[go: up one dir, main page]

Chrome is always looking for ways to speed up the web. Starting in Chrome 53, Chrome has started using Microsoft’s Profile Guided Optimization (PGO) technology to make Chrome up to 15% faster on Windows.

New tab page load time
14.8% faster
Page load (time to first paint)
5.9% faster
Startup time
16.8% faster
PGO impact on load and startup time

Chrome is a huge software project with more than a million functions in its source code. Not all functions are equal - some are called frequently, while others are rarely used.  PGO uses data from runtime execution that track which functions are most common to guide optimization.
To gather this data, the nightly build process now produces a special version of Chrome that tracks how often functions are used. PGO then optimizes those high-use functions for speed, in some cases increasing the binary size of those functions. To balance out that increase, PGO also optimizes less-used functions with smaller, though slightly slower code. These trade-offs result in higher overall performance, and a smaller overall code footprint.
PGO also optimizes the memory location of the code, moving rarely-used functions away from frequently-used ones in memory.  This results in more optimal use of the CPU instruction cache by avoiding caching of less-used code, increasing overall performance. There are many other tricks that PGO uses to make Chrome faster, and they add up to great results.
64-bit Chrome on Windows is using PGO as of version 53, and 32-bit Chrome is using it as of version 54.  Try out the latest version of Chrome to see the difference with PGO.
Posted by Sébastien Marchand, who is Pretty Good at Optimizing.


Unless otherwise noted, changes described below apply to the newest Chrome Beta channel release for Android, Chrome OS, Linux, Mac, and Windows.

Input handling improvements

As usage of the mobile web grows, it is increasingly important for sites to react well to touch input. Historically, this meant handling MouseEvent and TouchEvent separately, which can be difficult to maintain. Chrome now enables unified input handling by dispatching PointerEvents. PointerEvents lead to more responsive pages, as they don’t block scrolling by default. To achieve the same performance with TouchEvent, pages can use passive event listeners.


Chrome also now supports two new ways to respond to input. The touch-action CSS property enables sites to react to gestures such as panning. For mouse buttons, the new auxclick input event type allows sites to manage the click behavior of non-primary buttons.   

Async and await functions

Asynchronous JavaScript can be difficult to reason about. Promises help avoid the nesting problem of callbacks, but Promise-based code can still be difficult to read when a site has large chains of asynchronous dependencies. Chrome now supports the async and await JavaScript keywords, allowing developers to write Promise-based JavaScript that can be as structured and readable as synchronous code.


Fetching a URL and logging the response using Promises:

function logFetch(url) {
 return fetch(url)
   .then(response => response.text())
   .then(text => {
     console.log(text);
   }).catch(err => {
     console.error('fetch failed', err);
   });
}


The same code using async and await:

async function logFetch(url) {
 try {
   const response = await fetch(url);
   console.log(await response.text());
 }
 catch (err) {
   console.log('fetch failed', err);
 }
}

CSS automatic hyphenation

Formatting text to fill available space can be a challenge across devices and screen sizes. Chrome now supports CSS automatic hyphenation, one of Chrome’s most frequently requested layout features, on Android and Mac. CSS hyphenation allows the browser to hyphenate words when line-wrapping, improving the visual consistency of text blocks. Hyphenation support will be extended to other platforms in future releases.

hyphenation-gif-2.gif
A paragraph rendered with and without automatic hyphenation

Other features in this release

  • The once event listener option enables callbacks to be invoked only once before removing the event listener.
  • Sites can now mark web storage as persistent, preventing Chrome from automatically clearing storage for that site.
  • Cross-origin iframes now require a user gesture to start audio playback using the Web Audio API on Android, matching the behavior of the <audio> and <video> elements.
  • The TLS stack now implements GREASE, a mechanism to help prevent problems with buggy TLS servers.
  • Developers can create a MediaStreamTrackEvent in an alternative way with its new JavaScript constructor.
  • RSA-PSS signature algorithms have been added to TLS to prepare for TLS 1.3.
  • To improve load times and prevent failed navigations, cross-origin and parser-blocking scripts injected using document.write() will no longer load over 2G connections.
  • AudioNode constructors of the form new AudioNode(context, options) are now available, making it simpler to manage audio from scripts.
  • When the media player is too narrow to show every button, an overflow menu will appear to provide the hidden functionality to users.
  • Chrome media controls will now display a download button when the playback is associated with a file that can be downloaded.
  • The Web Share API is available for experimentation as an origin trial.

Deprecations and interoperability improvements

  • BaseAudioContext will replace AudioContext in the Web Audio API to conform to spec.
  • CSS Clipping Path properties no longer require the webkit prefix.
  • The MediaStream constructor is now available without prefix alongside the existing webkitMediaStream.
  • Non-script MIME types will no longer trigger script execution.
  • <textarea maxlength=""> and <textarea minlength=""> have been updated to count each line break as one character, instead of two.
  • The webkit prefix has been removed from the imageSmoothingEnabled property of CanvasRenderingContext2D.

Posted by Dan Ehrenberg, Asynchronous Adventurer
Labels:

Chrome supports multiple release channels with varying degrees of stability and support. The Canary channel ships the most bleeding edge version of Chrome possible. It is primarily intended to be used by developers and early adopters to test recent Chromium changes, but anyone can install it and give it a try. Previously the Canary channel was only available on Windows and Mac, and it is now available for Android as well.
Just like the Canary channel for other platforms, new versions are built from the most recent code available and often contain a variety of new features, enhancements, and bug fixes. These builds are shipped automatically with no manual testing, which means that the build can be unstable and may even stop working entirely for days at a time. However, the goal is for Canary to remain usable at all times, and the Chrome team prioritizes fixing major issues as quickly as possible.
Initially, builds will ship every weekday. In the future new builds may also be available on weekends. The frequency of builds means that keeping the app updated will consume a lot of data, typically more than 100MB per week. This is especially important for phones set to update native apps over cellular data.

We hope the Canary channel will be useful when developing and testing changes for Chrome on Android. If you encounter any bugs, please help us by reporting them.


Posted by Alex Mineer, APK Administrator & Bug Basher