Update promise

To update your code; you basically have to disable the promise manager, see what fails, update some code, and try again. To understand how your code will, fail, consider a test for our Google Search example:const {Builder, By, until} = require('selenium-webdriver');const test = require('selenium-webdriver/testing');describe('Google Search', function() { let driver; test.before(function() { driver = new Builder().forBrowser('firefox').build(); }); test.it('example', function theTestFunction() { driver.get(' // (1) driver.findElement(By.name('q')).sendKeys('webdriver'); // (2) driver.findElement(By.name('btnK')).click(); // (3) driver.wait(until.titleIs('webdriver - Google Search'), 1000); // (4) }); test.after(function() { driver.quit(); });});Inside theTestFunction, when the promise manager is enabled, it will capture every WebDriver command and block its execution until those before it have completed. Thus, even though driver.findElement() on line (2) is immediately scheduled, it will not start execution until the command on line (1) completes.When you disable the promise manager, every command will start executing as soon as its scheduled. The exact behavior depends on the specific browser, but essentially, the command to find an element on line (2) will start executing before the page requested on line (1) has loaded.You will need to update your code to explicitly link each action so it does not start until previous commands have finished. Presented below are three options for how to update your code.Option 1: Use classic promise chainingYour first option is to adopt classic promise chaining (yes, the very thing the promise manager was created to avoid). This will make your code far more verbose, but it will work with and without the promise manager and you won't need

Restoration, or can use window.scrollTo() or similar APIs to take full control.For "traverse" and "reload", the navigateEvent.scroll() API performs the browser's scroll restoration logic at the specified time. This allows cases that require precise control over scroll restoration timing, such as a non-broken version of the demo referenced above, to be written like so:if (navigateEvent.navigationType === "traverse" || navigateEvent.navigationType === "reload") { navigateEvent.intercept({ scroll: "manual", async handler() { await fetchDataAndSetUpDOM(); navigateEvent.scroll(); await measureLayoutAndDoTransition(); }, });}Some more details on how the navigation API handles scrolling with "traverse" and "reload" navigations:navigateEvent.scroll() will silently do nothing if called after the user has started scrolling the document.navigateEvent.scroll() doesn't actually perform a single update of the scroll position. Rather, it puts the page in scroll-position-restoring mode. The scroll position could update several times as more elements load and scroll anchoring kicks in.By default, any navigations which are intercepted with navigateEvent.intercept() will ignore the value of history.scrollRestoration from the classic history API. This allows developers to use history.scrollRestoration for controlling cross-document scroll restoration, while using the more-granular option to intercept() to control individual same-document navigations.Deferred commitThe default behavior of immediately "committing" (i.e., updating location.href and navigation.currentEntry) works well for most situations, but some developers may find they do not want to immediately update the URL, and may want to retain the option of aborting the navigation without needing to rollback a URL update or cancel-and-restart. This behavior can be customized using intercept()'s commit option:e.intercept({ handler, commit: "immediate" }): the default behavior, immediately commit the navigation and update location.href and navigation.currentEntry.e.intercept({ handler, commit: "after-transition" }): start the navigation (e.g., show a loading spinner if the UI has one), but do not immediately commit.When deferred commit is used, the navigation will commit (and a committed promise will resolve if present) when e.commit() is called. If any handler(s) passed to intercept() fulfill, and e.commit() has not yet been called, we will fallback to committing just before any finish promise resolves and navigatesuccess is fired.If a handler passed to intercept() rejects before e.commit() is called, then the navigation will be treated as canceled (both committed and finished promises will reject, and no URL update will occur). If a handler passed to intercept() rejects after e.commit() is called, the behavior will match a rejected promise in immediate commit mode (i.e., the committed promise will fulfill, the finished promise will reject, and the URL will update).Because deferred commit can be used to

August 13 was a great day for Google and Pixel fans globally as the curtains were finally open on the Pixel 9 series. While the new Pixels bring pretty decent improvements and new AI features over the previous-gen Pixels, one of the odd things about this launch is that unlike Pixel launches each year, the Pixel 9 series doesn’t come with the latest Android version – Android 15. Does this mean Google is already backtracking on its 7-year update promise? Let’s shed some light on it.Update: added an Editor’s Note explaining how I see the situation and how Google breaks the promise of the number of OS updates. Pixel 9: Did Google Just Break Its Own Update Promise?Google’s 7-year update announcement came during the launch of the Pixel 8 series, and it took the Android community by storm. Beating Apple in the updates game was a huge deal, after all. While most people were happy with the announcement, some questioned if Google would actually adhere to its promise. That’s because the firm isn’t exactly known for keeping and fulfilling them.Image Courtesy: GoogleFast-forward a year, and Google might have started backtracking on its promise. The Pixel 9 series comes with Android 14 out of the box instead of Android 15, which was extremely shocking for a new Pixel device. Now, before we get ahead of ourselves, there might’ve been many factors at play in the firm internally. These could be reasons why Android 15 didn’t release alongside the Pixel 9 series.However, our counter question to this is that Android 15 Beta 4 rolled out a month ago and had already reached platform stability. While the release timeline on the official website doesn’t mention stable Android 15’s release date, new Pixels have always received the latest Android update a month or two after the final beta. Hence, had Google willed, they could’ve released Android 15 alongside Pixel 9. But again, it is possible that they wanted to do it, but the stable builds weren’t ready.Pixel 9 and 8 Series Get The Same Number of Android UpdatesThe last reason could be that Google deliberately wanted to deduct an update early from the 7-year update quota because they just don’t want to support the Pixel 9 series till Android 22. This means the Pixel 9 technically still gets 7 years of updates, but it’s actually only 6 Android updates after Android 15 and feature

Drops till August 2031.Editor’s Note: I have read all the comments and discussions around this post online and would like to add another piece of evidence to justify the title. Pixel phones usually launch with the latest Android versions. The Pixel 9 series didn’t, which is a shame. After the announcement, it made me question the “7 years of OS updates” promise too, so I went looking for the Pixel 9 update support page, which validates our statement.As per the Google support page, the Pixel 9 series will receive ‘guaranteed Android version updates’ until at least August 2031. That means if Google doesn’t change the timeline for the release of new Android updates then the Pixel 9 series will only get up to the Android 21 update; while all phones should’ve gotten up to Android 22 if it followed the usual release cycle.Image Courtesy: Google supportThis breaks the 7-year OS update promise in my mind as new Pixels should launch with the new Android version. Pixel 9 series launching with Android 14 (and not Android 15) essentially discounts one year of OS updates from that promise. So, that’s my two cents on this topic.Now, as complex as this situation is, it’s quite common in the Android world. When a manufacturer launches a phone with, say, Android 14 and promises three major updates, users assume that the phone will get updates till Android 17.As a result, many manufacturers use a tactic where they release a phone when a new Android version is just around the corner. This is so that they could count the new “soon to release” Android version update in the update quota. Google has now done the same with the Pixel 9 series.Google’s 7 Years promise states all the major Android versions and feature drops released during those years. Considering a new Android version is usually released in September or October and the Pixel 9 is supported till August 13, 2031, unless Android 22 is released before August 14 (which is unlikely), it’s safe to say that Pixel 9 won’t get Android 22.Ultimately, the reason behind this mess is due to Google launching the Pixel 9 series one month prior than usual. This could be because Google thought it would be better to launch the phones before the iPhone 16 series which is scheduled to launch in September, or it could be because Google didn’t want to launch