To keep with our principle of simplicity, we decided to take a different approach. Chrome extensions would be simple and single-purpose in nature, and each would only be allowed a single visible UI "surface" in Chrome, a single browser action or page action button. Toolbars wouldn't be supported by design, and users would have more control over which features they added to their browser.
Unfortunately, in some cases, we couldn't enforce these design goals technically. With content scripts, extension developers have full control over the page, so they can put up as much UI as they want, even going as far as to create toolbars in the page. Others used content scripts to create extensions with more subtle features bundled together that were harder to attribute to specific extensions. In many cases, the Chrome Web Store helped by showing poor reviews when users had noticed bad behavior from a particular extension, but in other cases the connection wasn't clear.
Even worse, when extensions were sideloaded locally on their computer (perhaps bundled as part of another piece of software they installed) the user wouldn't have the benefit of the information in the Chrome Web Store at all, so they might not realize they were agreeing to install an extension with unwanted functionality or poor reviews.
It is for these reasons that we've updated the Chrome Web Store policy to enforce our original single-purpose design goal for extensions. We realize that this will require significant changes for some existing extensions. Some may need to be split into multiple separate extensions. Developers may need to switch to a different approach to monetization, which we've recently made easier by adding payment options to extensions. Since these changes may take some time to implement, we're not going to start enforcing the policy for existing extensions in the Web Store until June 2014. For new extensions, the policy will go into effect immediately.
Update May 16, 2014: This will begin being enforced for previously grandfathered extensions (those which were in the Web Store prior to Dec 19, 2013) on July 15, 2014.
But what if you need to test the actual web app's performance on a real device?
Chrome Beta – including ChromeOS – now supports native USB discovery of connected devices. Find them under Tools → Inspect Devices menu item, or visit the about:inspect page. There’s no configuration necessary and no need for the adb command line tool or extensions to see all instances of Chrome and WebView on the devices connected to your computer2.
While connected over USB, you can screencast the full viewport content from the device to DevTools. The corresponding icon will be shown next to the Elements tab if the inspected device is able to screencast.
Keyboard and mouse events are also sent from DevTools to your device, so you don't even need to touch it while you're testing your apps.
Posted by Pavel Feldman, Software Engineer and Viewport Teleporter
1 You need to check “Show 'Emulation' view in console drawer” in DevTool’s Settings→ Overrides to enable the emulation features
2 Windows users need to install the USB device drivers to enable device communication
Starting this release, responsive mobile websites will get a performance boost in Chrome for Android because we’ve disabled double-tap zoom. Previously, to support double-tap zoom, Chrome had to delay every touch event sent to the webpage by 300ms to allow the user to tap a second time. Now mobile-friendly sites that are already formatted to automatically fit in the page width will receive click events instantly and can respond to user input more quickly.
New in Chrome for Android, the Vibration API allows web developers to programmatically provide tactile feedback in the form of vibration. Use cases include improved accessibility and more engaging browser-based games.
Chrome Apps and Extensions APIs
signedInDevices API allows you retrieve a list of the user’s signed-in devices.
The above results were measured for Chrome version 29 and compare HTTPS vs. SPDY for each application across millions of real user sessions with various connectivity profiles. SPDY delivers significant latency savings for users with fast connections, at the median, and for the long tail users with high round-trip times.
In parallel with our contributions to the HTTP/2 standard, we continue to prototype further SPDY performance improvements through smarter compression, flow control, and prioritization. Our hope is that each of these will deliver better and faster SPDY and HTTP/2 protocols. We aren’t done yet—there are still many opportunities and ideas to explore to make the web faster!
Posted by Hasan Khalil, Roberto Peon, and Ilya Grigorik, SPeeDY Software Engineers
The experiment starts with an interactive map of Middle-earth. It may not feel like it, but this cinematic part of the experience was built with just HTML, CSS, and JavaScript. North Kingdom used the Touch Events API to support multi-touch pinch-to-zoom and the Full Screen API to allow users to hide the URL address bar. It looks natural on any screen size thanks to media queries and feels low-latency because of hardware-accelerated CSS Transitions.
Clicking or tapping a location in the map reveals a second layer with horizontal parallax scrolling, again built just with HTML, CSS, and JavaScript. Eventually users reach an immersive WebGL-based 3D environment optimized for Android phones and tablets with high-end GPUs. These environments also use the Web Audio API for interactive audio.
The multi-device web is evolving rapidly, and we’re looking forward to more sites like “A Journey Through Middle-earth” that show the potential of the platform’s latest mobile features. For a deeper technical case study, check out North Kingdom’s new HTML5 Rocks article about using WebGL in Chrome for Android. We’re also planning to host a Google Developers Live session with the team in early December; circle +Google Chrome Developers for details.
Posted by Max Heinritz, Product Manager and (Tolkien) Troll Evader
Today we’re releasing the Dart SDK 1.0, a cross-browser, open source toolkit for structured web applications. In the two years since we first announced Dart, we’ve been working closely with early adopters to mature the project and grow the community. This release marks Dart's transition to a production-ready option for web developers.
The Dart SDK 1.0 includes everything you need to write structured web applications: a simple yet powerful programming language, robust tools, and comprehensive core libraries. Together, these pieces can help make your development workflow simpler, faster, and more scalable as your projects grow from a few scripts to full-fledged web applications.
On the tools side, the SDK includes Dart Editor, a lightweight but powerful Dart development environment. We wanted to give developers the tools to manage a growing code base, so we added code completion, refactoring, jump to definition, a debugger, hints and warnings, and lots more. Dart also offers an instant edit/refresh cycle with Dartium, a custom version of Chromium with the native Dart VM. Outside the browser, the Dart VM can also be used for asynchronous server side computation.
For deployment, dart2js is a translator that allows your Dart code to run in modern browsers. The performance of generated JavaScript has improved dramatically since our initial release and is in many cases getting close to that of idiomatic JavaScript. In fact, the dart2js output of the DeltaBlue benchmark now runs even faster than idiomatic JavaScript. Similarly, dart2js output code size has been reduced substantially. The generated JavaScript for the game Pop, Pop, Win! is now 40% smaller than it was a year ago. Performance of the VM continues to improve as well; it’s now between 42% to 130% faster than idiomatic JavaScript running in V8, depending on the benchmark.
DeltaBlue benchmark results
The Dart SDK also features the Pub package manager, with more than 500 packages from the community. Fan favorites include AngularDart and polymer.dart, which provide higher-level frameworks for building web apps. Dart developers can continue using their favorite JavaScript libraries with Dart-JavaScript interop.
Going forward, the Dart team will focus on improving Dartium, increasing Dart performance, and ensuring the platform remains rock solid. In particular, changes to core technologies will be backward-compatible for the foreseeable future.
Today’s release marks the first time Dart is officially production-ready, and we’re seeing teams like Blossom, Montage, Soundtrap, Mandrill, Google's internal CRM app and Google Elections, already successfully using Dart in production. In addition, companies like Adobe, drone.io, and JetBrains have started to add Dart support to their products.
PNaCl unlocks the power of native performance for applications like Bullet physics simulators and Lua interpreters. For now PNaCl is Chrome only, but developers can make their PNaCl applications compatible with other browsers via pepper.js, which allows applications to use the Pepper API from JavaScript.
Portable Native Client provides a natively fast, secure option to meet the demands of a new generation of web applications. As always, we look forward to your questions and feedback on Stack Overflow or our discussion forum, and will host a Google Developers Live event on Thursday, November 14th to answer your questions. Visit gonacl.com for tutorials, documentation, and to get the SDK.
Posted by David Sehr, Summiting Engineer and Mountain Man
In addition to a much cleaner and easier-to-use layout, the new tool provides all of the same functionality as the chrome://extensions tab while streamlining the developer workflow:
Apps and extensions are now listed in separate tabs, reducing the potential for developer confusion and reinforcing the difference between the two item types. This also reduces the size of each list, making it faster to scroll through.
Unpacked items and installed items are now listed separately, which makes it much easier to quickly see and access your works-in-progress.
You can individually update specific apps and extensions with one click, instead of having to update all items at once like in the old tab.
The common actions for each item, such as reload, launch, view permissions, pack, and uninstall, are located right next to that item for fast access.
The list can now be live-filtered using the Search box at the top right of the page instead of having to use the regular “Find in page” feature of Chrome.
If you’re developing Chrome Apps or extensions and you have at least the latest version of Chrome Beta installed, get the new tool today and send us your feedback on our G+ Developers page or our developer forum.
Posted by Viet Hoa Dinh, Software Engineer and Tooling Taskmaster
Traditional benchmarks simply measure how quickly JavaScript can be executed. Octane 2.0 additionally measures latency, which is another important aspect of performance that is concerned with the smoothness of execution. In modern JavaScript engines like V8, latency comes from two main sources: compiling JavaScript to machine instructions so it can run faster, and garbage collecting memory that is no longer used. These tasks are computationally intensive and if they run for too long can be visible to users as small hiccups and freezes of JavaScript programs. We've added a modified version of our Mandreel and Splay benchmarks to measure how well JavaScript engines can minimize these pauses.
We’ve also added two new performance tests that target important use cases. One new test is based on the Typescript compiler from Microsoft, a heavy and complex JavaScript application. Its execution stresses raw execution speed, code parsing and the memory subsystem. We've also included the zlib benchmark, an asm.js test from the Mozilla Emscripten suite. Both new benchmarks help measure an engine’s ability to deal with heavy and complex workloads, which are increasingly common in today's web applications.
Finally, we fixed three existing benchmarks to help ensure that they measure what they were intended to:
Regexp: verify that regexp calculations give the correct results.
GameBoy Emulator: code that was supposed to run in strict mode now actually runs in strict mode.
CodeLoad: make sure the code loaded is different on every iteration.
Octane 2.0 represents one more step in our continuing quest to deliver the best possible performance for users. You can run Octane 2.0 in your browser or read the documentation for an in-depth look at the new benchmarks.
Posted by Hannes Payer, Software Engineer and Latency Buster
Best of all, it’s entirely open source, and is available in the Android 4.4 KitKat AOSP release built on a snapshot of the latest stable Chromium source tree. We're looking forward to working with the broader Chromium community to continue improving WebView. Watch dev.chromium.org/developers and the chromium-dev mailing list for future updates on getting involved in the Chromium WebView development. In the meantime, you can check out the Chromium WebView FAQ.
Happy developing from all of the Chromium WebView team!
Posted by Jonathan Dixon and Ben Murdoch, Ambassadors of Chocolate Treats
This feature will be rolling out to Beta users in Android, Windows, and Chrome OS in the coming days. A Mac version will be included in a future release.
PNaCl on desktop versions of Chrome
Over the last few years, web applications have benefited tremendously from more powerful processors and faster browsers. For developers looking to improve performance even further, Portable Native Client (PNaCl) now offers the ability to execute native code in the browser. Developers can compile C/C++ code--even complex existing code bases--into a single executable that runs across all desktop versions of Chrome and Chrome OS, no user installation required. PNaCl combines the portability of the web with the performance of native code. For more information, check out gonacl.com.
New Chrome Apps APIs
With URL handlers for apps, Chrome App developers can now specify URLs to be handled by a Chrome App. For example, a document link on a website could open a document editor Chrome App. This gives users more seamless entry points into their favorite Chrome Apps.
Directory access for Apps allows Chrome Apps to access and write to user-approved folders. This feature can be used to share files between a Chrome App and a native app. For example, a Chrome App code editor could modify files managed by a native Git client. Check out the demo to see it in action.
Other new features in this release
SCTP for WebRTC Data Channel allows P2P data transfers between browsers to be either best effort, reliable, or semi reliable, opening up use cases such as gaming.
Support for { alpha: false } in getContext('2d') lets you create an opaque canvas. This is similar to existing WebGL functionality and can improve the rendering performance of your app.
The Media Source API has been unprefixed and is now supported on Chrome for Android. It allows JavaScript to generate media streams for playback, addressing use cases like adaptive streaming and time shifting live streams.
Visit chromestatus.com for a complete overview of Chrome’s developer features, and circle +Google Chrome Developers for more frequent updates. We hope you enjoy this Beta release as much as we’ve enjoyed working on it!
Posted by Dan Alcantara, Software Engineer and Screen Real Estate Agent
To get the launcher, just install a Chrome App from the Chrome Web Store, such as this text editor or note-taking app. The first time you install an app, the launcher will show up as an icon in the Dock. Chrome Packaged Apps for the Mac are available in the dev channel of Chrome and will be launched to stable channel soon.
In the meantime, you can build your own packaged app, upload it to the Chrome Web Store and give all of your users access to it via a direct link. Have questions about this or any other Chrome Apps features? We always welcome your feedback on Stack Overflow, our G+ Developers page, or our developer forum.
Posted by Joe Marini, Chrome Developer Advocate and Apps Aficionado
These early results are encouraging but we’re still turning dials under the hood. While we work we’ll be expanding to a small set of people using the stable channel of Chrome on Windows, Mac and Chromebooks, who have Google set as default search engine. As this experimental feature includes open APIs, any search engine may integrate with the new ‘new tab’ page in Chrome. Keep the feedback coming.
This release introduces the device motion part of the Device Orientation API in Chrome for Android Beta. DeviceMotion events provide you information about device acceleration and rotation rates. Check out isthisanearthquake.com to see them in action.
Media Source Extension in Chrome for Android
The MediaSource API allows JavaScript to generate media streams for playback, which enables use cases such as adaptive streaming and time-shifting live streams. It is now enabled by default in Chrome for Android running on Jellybean or higher. This API is especially useful for streaming to mobile devices, where connectivity is often constrained and unpredictable. Play with it on this demo page.
Unless otherwise noted, the changes described below apply to desktop versions of Chrome and Chrome for Android:
Support for the WebRTC Device Enumeration API allows users to change their microphones and/or camera on the fly without having to restart the WebRTC call.
DevTools now supports CSS source maps (also known as preprocessors).
Chrome will now match the behavior of IE and not honor the Refresh header or tags when the URL to be refreshed to has a javascript: scheme. This is done to close down one more XSS vector against poorly constructed sites.
Two new experimental features landed behind a flag on Chrome for Android: Web Speech API (recognition) and the Vibration API.
The Sketchbot The Sketchbot was an electronic arm that received over 5,000 commands per second to etch an outline of your face in the sand. The Open Source project includes the code and the hardware designs to build a replica of the Web Lab. For developers like me who are soldering iron challenged, we have also included instructions and code to build a BergCloud LittlePrinter and a pure software only version.
If you’ve got the maker itch and want to build a Web Lab replica, integrate hardware that we had never envisaged, or are just curious about how we made the Web Lab, you can grab the code from Github.
Be sure to share what you do with the code in our G+ Community.
Paul Kinlan - Chrome Developer Advocate, Open Sourcerer and Wannabe Maker.
The dashboard is designed to encourage transparency and to consolidate web platform feature tracking. For each feature, it shows useful details such as:
A short description and owner email address
Implementation status in Chromium
Progress through the standards process
Our understanding of the opinion of other browser vendors
Values are associated with a shade of red, yellow, or green based on how they affect the likelihood that a feature will ship in other browsers. For example, the entry for CSS Flexbox is entirely green, indicating that the spec is stable and publicly endorsed by other browser vendors. In general, we like to see a lot of green because it indicates that we’re minimizing compatibility risk and preserving the interoperability that makes the web platform so powerful.
This is the first iteration of the new version, and we plan to explore different ways of exposing the data, including a better aggregate view. If you’re curious, the code is available on Github. We used a new framework called Polymer, which is built on the emerging Web Components standards. Although Polymer is in early development, we decided this was a perfect place to experiment with it.
Members of a given group can add, edit, and otherwise work with the store items and overall account-related properties that the particular group has responsibility for.
With the new Group Publishing capability, an organization’s engineering, marketing and product management teams can now collaborate much more effectively to better manage their Chrome Web Store presence. Have questions about this or any other Chrome Web Store Feature? We always welcome your feedback on our G+ Developers page or our developer forum.
Wei Zheng, Software Engineer and Google Group Maestro
CSS preprocessors like Sass make it easier to organize your CSS, but until now tweaking your styles required switching to another program and refreshing Chrome. CSS preprocessor mapping enables live-editing of these sources directly within the Sources panel. To see it in action, just map the .scss file, then Ctrl-click on a property or value to jump to the variable, mixin or function that defined it. Support for other pre-processors such as Less, Stylus and Compass is in the works. Refer to the improved DevTools css-preprocessor documentation for more details and setup instructions.
Snippets
There are times when you want to be able to save smaller scripts, bookmarklets and utilities so that you always have them available while debugging in the browser. Snippets is a new DevTools feature that makes it possible. It allows you to create, store and run JavaScript within the Sources tab. It gives you a multi-line console with syntax-highlight and persistence, making it convenient for prototyping code that is more than a one-liner. There's also a community-curated repository of snippets for developers that contains useful snippets such as color pickers, CSS prettyfiers, logging helpers and much more.
.png)
