diff --git a/docs/api.md b/docs/api.md
index ee41958aec..119d790b74 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -280,7 +280,7 @@ await context.close();
 - [browserContext.clearCookies()](#browsercontextclearcookies)
 - [browserContext.clearPermissions()](#browsercontextclearpermissions)
 - [browserContext.close()](#browsercontextclose)
-- [browserContext.cookies([...urls])](#browsercontextcookiesurls)
+- [browserContext.cookies([urls])](#browsercontextcookiesurls)
 - [browserContext.exposeFunction(name, playwrightFunction)](#browsercontextexposefunctionname-playwrightfunction)
 - [browserContext.newPage()](#browsercontextnewpage)
 - [browserContext.pages()](#browsercontextpages)
@@ -365,8 +365,8 @@ will be closed.
 
 > **NOTE** the default browser context cannot be closed.
 
-#### browserContext.cookies([...urls])
-- `...urls` <...[string]>
+#### browserContext.cookies([urls])
+- `urls` <[string]|[Array]<[string]>>
 - returns: <[Promise]<[Array]<[Object]>>>
   - `name` <[string]>
   - `value` <[string]>
@@ -653,7 +653,7 @@ page.removeListener('request', logRequest);
 - [page.reload([options])](#pagereloadoptions)
 - [page.route(url, handler)](#pagerouteurl-handler)
 - [page.screenshot([options])](#pagescreenshotoptions)
-- [page.select(selector, value[, options])](#pageselectselector-value-options)
+- [page.select(selector, values[, options])](#pageselectselector-values-options)
 - [page.setContent(html[, options])](#pagesetcontenthtml-options)
 - [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout)
 - [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout)
@@ -907,6 +907,12 @@ To disable authentication, pass `null`.
 - `selector` <[string]> A selector to search for checkbox or radio button to check. If there are multiple elements satisfying the selector, the first will be checked.
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully checked. The Promise will be rejected if there is no element matching `selector`.
 
@@ -926,20 +932,18 @@ Shortcut for [page.mainFrame().check(selector[, options])](#framecheckselector-o
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully clicked. The Promise will be rejected if there is no element matching `selector`.
 
 This method fetches an element with `selector`, scrolls it into view if needed, and then uses [page.mouse](#pagemouse) to click in the center of the element.
 If there's no element matching `selector`, the method throws an error.
 
-Bear in mind that if `click()` triggers a navigation event and there's a separate `page.waitForNavigation()` promise to be resolved, you may end up with a race condition that yields unexpected results. The correct pattern for click and wait for navigation is the following:
-
-```javascript
-const [response] = await Promise.all([
-  page.waitForNavigation(waitOptions),
-  page.click(selector, clickOptions),
-]);
-```
 
 Shortcut for [page.mainFrame().click(selector[, options])](#frameclickselector-options).
 
@@ -982,6 +986,12 @@ Browser-specific Coverage implementation, only available for Chromium atm. See [
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the double click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.  
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully double clicked. The Promise will be rejected if there is no element matching `selector`.
 
@@ -1154,6 +1164,12 @@ const fs = require('fs');
 - `value` <[string]> Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom. Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully filled. The promise will be rejected if there is no element matching `selector`.
 
@@ -1190,7 +1206,8 @@ Returns frame matching the specified criteria. Either `name` or `url` must be sp
 #### page.goBack([options])
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">> When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -1203,7 +1220,8 @@ Navigate to the previous page in history.
 #### page.goForward([options])
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">> When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -1217,7 +1235,8 @@ Navigate to the next page in history.
 - `url` <[string]> URL to navigate page to. The url should include scheme, e.g. `https://`.
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">> When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -1350,7 +1369,8 @@ The `format` options are:
 #### page.reload([options])
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">> When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -1403,14 +1423,20 @@ await browser.close();
 
 > **NOTE** Screenshots take at least 1/6 second on Chromium OS X and Chromium Windows. See https://crbug.com/741689 for discussion.
 
-#### page.select(selector, value[, options])
+#### page.select(selector, values[, options])
 - `selector` <[string]> A selector to query frame for.
-- `value` <[string]|[ElementHandle]|[Object]|[Array]<[string]>|[Array]<[ElementHandle]>|[Array]<[Object]>> Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise only the first option matching one of the passed options is selected. String values are equivalent to `{value:'string'}`. Option is considered matching if all specified properties match.
+- `values` <[string]|[ElementHandle]|[Object]|[Array]<[string]>|[Array]<[ElementHandle]>|[Array]<[Object]>> Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise only the first option matching one of the passed options is selected. String values are equivalent to `{value:'string'}`. Option is considered matching if all specified properties match.
   - `value` <[string]> Matches by `option.value`.
   - `label` <[string]> Matches by `option.label`.
   - `index` <[number]> Matches by the index.
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom. Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]<[Array]<[string]>>> An array of option values that have been successfully selected.
 
@@ -1437,7 +1463,7 @@ Shortcut for [page.mainFrame().select()](#frameselectselector-values)
 - `html` <[string]> HTML markup to assign to the page.
 - `options` <[Object]> Parameters which might have the following properties:
   - `timeout` <[number]> Maximum time in milliseconds for resources to load, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">>  When to consider setting markup succeeded, defaults to `load`. Given an array of event strings, setting content is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2">  When to consider setting markup succeeded, defaults to `load`. Given an array of event strings, setting content is considered to be successful after all events have been fired. Events can be either:
     - `'load'` - consider setting content to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider setting content to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider setting content to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -1508,6 +1534,12 @@ Shortcut for [page.mainFrame().title()](#frametitle).
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the triple click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully triple clicked. The Promise will be rejected if there is no element matching `selector`.
 
@@ -1526,6 +1558,12 @@ Shortcut for [page.mainFrame().tripleclick(selector[, options])](#frametriplecli
 - `options` <[Object]>
   - `delay` <[number]> Time to wait between key presses in milliseconds. Defaults to 0.
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom. Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]>
 
@@ -1544,6 +1582,12 @@ Shortcut for [page.mainFrame().type(selector, text[, options])](#frametypeselect
 - `selector` <[string]> A selector to search for uncheckbox to check. If there are multiple elements satisfying the selector, the first will be checked.
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully unchecked. The Promise will be rejected if there is no element matching `selector`.
 
@@ -1671,7 +1715,8 @@ Shortcut for [page.mainFrame().waitForFunction(pageFunction[, options[, ...args]
 #### page.waitForLoadState([options])
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">>  When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2">  When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -1692,7 +1737,8 @@ Shortcut for [page.mainFrame().waitForLoadState([options])](#framewaitforloadsta
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
   - `url` <[string]|[RegExp]|[Function]> A glob pattern, regex pattern or predicate receiving [URL] to match while waiting for the navigation.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">>  When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2">  When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -1814,7 +1860,7 @@ An example of getting text from an iframe element:
 - [frame.isDetached()](#frameisdetached)
 - [frame.name()](#framename)
 - [frame.parentFrame()](#frameparentframe)
-- [frame.select(selector, value[, options])](#frameselectselector-value-options)
+- [frame.select(selector, values[, options])](#frameselectselector-values-options)
 - [frame.setContent(html[, options])](#framesetcontenthtml-options)
 - [frame.title()](#frametitle)
 - [frame.tripleclick(selector[, options])](#frametripleclickselector-options)
@@ -1895,6 +1941,12 @@ Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<s
 - `selector` <[string]> A selector to search for checkbox to check. If there are multiple elements satisfying the selector, the first will be checked.
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully checked. The Promise will be rejected if there is no element matching `selector`.
 
@@ -1915,21 +1967,18 @@ If there's no element matching `selector`, the method throws an error.
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully clicked. The Promise will be rejected if there is no element matching `selector`.
 
 This method fetches an element with `selector`, scrolls it into view if needed, and then uses [page.mouse](#pagemouse) to click in the center of the element.
 If there's no element matching `selector`, the method throws an error.
 
-Bear in mind that if `click()` triggers a navigation event and there's a separate `page.waitForNavigation()` promise to be resolved, you may end up with a race condition that yields unexpected results. The correct pattern for click and wait for navigation is the following:
-
-```javascript
-const [response] = await Promise.all([
-  page.waitForNavigation(waitOptions),
-  frame.click(selector, clickOptions),
-]);
-```
-
 #### frame.content()
 - returns: <[Promise]<[string]>>
 
@@ -1945,6 +1994,12 @@ Gets the full HTML contents of the frame, including the doctype.
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the double click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully double clicked. The Promise will be rejected if there is no element matching `selector`.
 
@@ -2017,6 +2072,12 @@ await resultHandle.dispose();
 - `value` <[string]> Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom. Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully filled. The promise will be rejected if there is no element matching `selector`.
 
@@ -2050,7 +2111,8 @@ console.log(frame === contentFrame);  // -> true
 - `url` <[string]> URL to navigate frame to. The url should include scheme, e.g. `https://`.
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">>  When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2">  When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -2103,14 +2165,20 @@ If the name is empty, returns the id attribute instead.
 #### frame.parentFrame()
 - returns: <?[Frame]> Parent frame, if any. Detached frames and main frames return `null`.
 
-#### frame.select(selector, value[, options])
+#### frame.select(selector, values[, options])
 - `selector` <[string]> A selector to query frame for.
-- `value` <[string]|[ElementHandle]|[Object]|[Array]<[string]>|[Array]<[ElementHandle]>|[Array]<[Object]>> Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise only the first option matching one of the passed options is selected. String values are equivalent to `{value:'string'}`. Option is considered matching if all specified properties match.
+- `values` <[string]|[ElementHandle]|[Object]|[Array]<[string]>|[Array]<[ElementHandle]>|[Array]<[Object]>> Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise only the first option matching one of the passed options is selected. String values are equivalent to `{value:'string'}`. Option is considered matching if all specified properties match.
   - `value` <[string]> Matches by `option.value`.
   - `label` <[string]> Matches by `option.label`.
   - `index` <[number]> Matches by the index.
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom. Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]<[Array]<[string]>>> An array of option values that have been successfully selected.
 
@@ -2135,7 +2203,8 @@ frame.select('select#colors', { value: 'blue' }, { index: 2 }, 'red');
 - `html` <[string]> HTML markup to assign to the page.
 - `options` <[Object]> Parameters which might have the following properties:
   - `timeout` <[number]> Maximum time in milliseconds for resources to load, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">>  When to consider setting markup succeeded, defaults to `load`. Given an array of event strings, setting content is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2">  When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider setting content to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider setting content to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider setting content to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -2155,6 +2224,12 @@ frame.select('select#colors', { value: 'blue' }, { index: 2 }, 'red');
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the triple click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully triple clicked. The Promise will be rejected if there is no element matching `selector`.
 
@@ -2171,6 +2246,12 @@ Bear in mind that if the first or second click of the `tripleclick()` triggers a
 - `options` <[Object]>
   - `delay` <[number]> Time to wait between key presses in milliseconds. Defaults to 0.
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom. Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]>
 
@@ -2187,6 +2268,12 @@ await frame.type('#mytextarea', 'World', {delay: 100}); // Types slower, like a
 - `selector` <[string]> A selector to search for uncheckbox to check. If there are multiple elements satisfying the selector, the first will be checked.
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to be present in the dom and displayed (for example, no `display:none`), stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element matching `selector` is successfully unchecked. The Promise will be rejected if there is no element matching `selector`.
 
@@ -2292,7 +2379,8 @@ await page.waitForFunction(selector => !!document.querySelector(selector), {}, s
 #### frame.waitForLoadState([options])
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">>  When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+   - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2">  When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -2311,7 +2399,8 @@ await frame.waitForLoadState(); // The promise resolves after navigation has fin
 - `options` <[Object]> Navigation parameters which might have the following properties:
   - `timeout` <[number]> Maximum navigation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultNavigationTimeout(timeout)](#browsercontextsetdefaultnavigationtimeouttimeout), [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout), [page.setDefaultNavigationTimeout(timeout)](#pagesetdefaultnavigationtimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
   - `url` <[string]|[RegExp]|[Function]> URL string, URL regex pattern or predicate receiving [URL] to match while waiting for the navigation.
-  - `waitUntil` <"load"|"domcontentloaded"|"networkidle0"|"networkidle2"|[Array]<"load"|"domcontentloaded"|"networkidle0"|"networkidle2">>  When to consider navigation succeeded, defaults to `load`. Given an array of event strings, navigation is considered to be successful after all events have been fired. Events can be either:
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2">  When to consider navigation succeeded, defaults to `load`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
     - `'load'` - consider navigation to be finished when the `load` event is fired.
     - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
     - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
@@ -2363,15 +2452,15 @@ ElementHandle instances can be used as arguments in [`page.$eval()`](#pageevalse
 - [elementHandle.click([options])](#elementhandleclickoptions)
 - [elementHandle.contentFrame()](#elementhandlecontentframe)
 - [elementHandle.dblclick([options])](#elementhandledblclickoptions)
-- [elementHandle.fill(value)](#elementhandlefillvalue)
+- [elementHandle.fill(value[, options])](#elementhandlefillvalue-options)
 - [elementHandle.focus()](#elementhandlefocus)
 - [elementHandle.hover([options])](#elementhandlehoveroptions)
 - [elementHandle.ownerFrame()](#elementhandleownerframe)
 - [elementHandle.press(key[, options])](#elementhandlepresskey-options)
 - [elementHandle.screenshot([options])](#elementhandlescreenshotoptions)
 - [elementHandle.scrollIntoViewIfNeeded()](#elementhandlescrollintoviewifneeded)
-- [elementHandle.select(...values)](#elementhandleselectvalues)
-- [elementHandle.setInputFiles(...files)](#elementhandlesetinputfilesfiles)
+- [elementHandle.select(values[, options])](#elementhandleselectvalues-options)
+- [elementHandle.setInputFiles(files)](#elementhandlesetinputfilesfiles)
 - [elementHandle.toString()](#elementhandletostring)
 - [elementHandle.tripleclick([options])](#elementhandletripleclickoptions)
 - [elementHandle.type(text[, options])](#elementhandletypetext-options)
@@ -2450,6 +2539,12 @@ This method returns the bounding box of the element (relative to the main frame)
 #### elementHandle.check([options])
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element is successfully checked. Promise gets rejected if the operation fails.
 
@@ -2465,6 +2560,12 @@ If element is not already checked, it scrolls it into view if needed, and then u
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element is successfully clicked. Promise gets rejected if the element is detached from DOM.
 
@@ -2483,6 +2584,12 @@ If the element is detached from DOM, the method throws an error.
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the double click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element is successfully double clicked. Promise gets rejected if the element is detached from DOM.
 
@@ -2493,8 +2600,16 @@ Bear in mind that if the first click of the `dblclick()` triggers a navigation e
 
 > **NOTE** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
 
-#### elementHandle.fill(value)
+#### elementHandle.fill(value[, options])
 - `value` <[string]> Value to set for the `<input>`, `<textarea>` or `[contenteditable]` element.
+- `options` <[Object]>
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
+  - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element is successfully filled.
 
 This method focuses the element and triggers an `input` event after filling.
@@ -2526,6 +2641,13 @@ If the element is detached from DOM, the method throws an error.
 - `options` <[Object]>
   - `text` <[string]> If specified, generates an input event with this text.
   - `delay` <[number]> Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
+  - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]>
 
 Focuses the element, and then uses [`keyboard.down`](#keyboarddownkey-options) and [`keyboard.up`](#keyboardupkey).
@@ -2553,11 +2675,19 @@ Throws when ```elementHandle``` does not point to an element [connected](https:/
 
 > **NOTE** If javascript is disabled, element is scrolled into view even when already completely visible.
 
-#### elementHandle.select(...values)
-- `...values` <...[string]|[ElementHandle]|[Object]> Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise only the first option matching one of the passed options is selected. String values are equivalent to `{value:'string'}`. Option is considered matching if all specified properties match.
+#### elementHandle.select(values[, options])
+- `values` <[string]|[ElementHandle]|[Object]|[Array]<[string]>|[Array]<[ElementHandle]>|[Array]<[Object]>> Options to select. If the `<select>` has the `multiple` attribute, all matching options are selected, otherwise only the first option matching one of the passed options is selected. String values are equivalent to `{value:'string'}`. Option is considered matching if all specified properties match.
   - `value` <[string]> Matches by `option.value`.
   - `label` <[string]> Matches by `option.label`.
   - `index` <[number]> Matches by the index.
+- `options` <[Object]>
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
+  - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]<[Array]<[string]>>> An array of option values that have been successfully selected.
 
 Triggers a `change` and `input` event once all the provided options have been selected.
@@ -2577,8 +2707,8 @@ handle.select('red', 'green', 'blue');
 handle.select({ value: 'blue' }, { index: 2 }, 'red');
 ```
 
-#### elementHandle.setInputFiles(...files)
-- `...files` <...[string]|[Object]> Sets the value of the file input to these file paths or files. If some of the  `filePaths` are relative paths, then they are resolved relative to the [current working directory](https://nodejs.org/api/process.html#process_process_cwd).
+#### elementHandle.setInputFiles(files)
+- `files` <[string]|[Array]<[string]>|[Object]|[Array]<[Object]>>
   - `name` <[string]> <[File]> name
   - `type` <[string]> <[File]> type
   - `data` <[string]> Base64-encoded data
@@ -2586,6 +2716,8 @@ handle.select({ value: 'blue' }, { index: 2 }, 'red');
 
 This method expects `elementHandle` to point to an [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input).
 
+Sets the value of the file input to these file paths or files. If some of the  `filePaths` are relative paths, then they are resolved relative to the [current working directory](https://nodejs.org/api/process.html#process_process_cwd). For empty array, clears the selected files.
+
 #### elementHandle.toString()
 - returns: <[string]>
 
@@ -2598,6 +2730,12 @@ This method expects `elementHandle` to point to an [input element](https://devel
     - y <[number]>
   - `modifiers` <[Array]<"Alt"|"Control"|"Meta"|"Shift">> Modifier keys to press. Ensures that only these modifiers are pressed during the triple click, and then restores current modifiers back. If not specified, currently pressed modifiers are used.
   - `waitFor` <[boolean]> Whether to wait for the element to stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element is successfully triple clicked. Promise gets rejected if the element is detached from DOM.
 
@@ -2612,6 +2750,13 @@ Bear in mind that if the first or second click of the `tripleclick()` triggers a
 - `text` <[string]> A text to type into a focused element.
 - `options` <[Object]>
   - `delay` <[number]> Time to wait between key presses in milliseconds. Defaults to 0.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
+  - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]>
 
 Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
@@ -2633,6 +2778,12 @@ await elementHandle.press('Enter');
 #### elementHandle.uncheck([options])
 - `options` <[Object]>
   - `waitFor` <[boolean]> Whether to wait for the element to stop moving (for example, wait until css transition finishes) and potentially receive pointer events at the click point (for example, wait until element becomes non-obscured by other elements). Defaults to `true`.
+  - `waitUntil` <"commit"|"load"|"domcontentloaded"|"networkidle0"|"networkidle2"> When to consider navigation succeeded, defaults to `commit`. Events can be either:
+    - `'commit'` - navigation is committed, new url is displayed in the browser address bar.
+    - `'load'` - consider navigation to be finished when the `load` event is fired.
+    - `'domcontentloaded'` - consider navigation to be finished when the `DOMContentLoaded` event is fired.
+    - `'networkidle0'` - consider navigation to be finished when there are no more than 0 network connections for at least `500` ms.
+    - `'networkidle2'` - consider navigation to be finished when there are no more than 2 network connections for at least `500` ms.
   - `timeout` <[number]> Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the [browserContext.setDefaultTimeout(timeout)](#browsercontextsetdefaulttimeouttimeout) or [page.setDefaultTimeout(timeout)](#pagesetdefaulttimeouttimeout) methods.
 - returns: <[Promise]> Promise which resolves when the element is successfully unchecked. Promise gets rejected if the operation fails.
 
@@ -3681,7 +3832,7 @@ const backgroundPage = await backroundPageTarget.page();
 - [browserContext.clearCookies()](#browsercontextclearcookies)
 - [browserContext.clearPermissions()](#browsercontextclearpermissions)
 - [browserContext.close()](#browsercontextclose)
-- [browserContext.cookies([...urls])](#browsercontextcookiesurls)
+- [browserContext.cookies([urls])](#browsercontextcookiesurls)
 - [browserContext.exposeFunction(name, playwrightFunction)](#browsercontextexposefunctionname-playwrightfunction)
 - [browserContext.newPage()](#browsercontextnewpage)
 - [browserContext.pages()](#browsercontextpages)
diff --git a/src/browserContext.ts b/src/browserContext.ts
index 0a34f0c07c..7bca57a2eb 100644
--- a/src/browserContext.ts
+++ b/src/browserContext.ts
@@ -42,7 +42,7 @@ export interface BrowserContext {
   setDefaultTimeout(timeout: number): void;
   pages(): Promise<Page[]>;
   newPage(): Promise<Page>;
-  cookies(...urls: string[]): Promise<network.NetworkCookie[]>;
+  cookies(urls?: string | string[]): Promise<network.NetworkCookie[]>;
   setCookies(cookies: network.SetNetworkCookieParam[]): Promise<void>;
   clearCookies(): Promise<void>;
   setPermissions(origin: string, permissions: string[]): Promise<void>;
diff --git a/src/chromium/crBrowser.ts b/src/chromium/crBrowser.ts
index b31b239e98..3b2102298a 100644
--- a/src/chromium/crBrowser.ts
+++ b/src/chromium/crBrowser.ts
@@ -274,7 +274,7 @@ export class CRBrowserContext extends BrowserContextBase {
     throw result;
   }
 
-  async cookies(...urls: string[]): Promise<network.NetworkCookie[]> {
+  async cookies(urls?: string | string[]): Promise<network.NetworkCookie[]> {
     const { cookies } = await this._browser._client.send('Storage.getCookies', { browserContextId: this._browserContextId || undefined });
     return network.filterCookies(cookies.map(c => {
       const copy: any = { sameSite: 'None', ...c };
diff --git a/src/dom.ts b/src/dom.ts
index 818592723f..81f950ad46 100644
--- a/src/dom.ts
+++ b/src/dom.ts
@@ -241,7 +241,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
     return point;
   }
 
-  async _performPointerAction(action: (point: types.Point) => Promise<void>, options?: PointerActionOptions & types.WaitForOptions): Promise<void> {
+  async _performPointerAction(action: (point: types.Point) => Promise<void>, options?: PointerActionOptions & types.WaitForOptions & types.NavigateOptions): Promise<void> {
     const { waitFor = true } = (options || {});
     if (!helper.isBoolean(waitFor))
       throw new Error('waitFor option should be a boolean, got "' + (typeof waitFor) + '"');
@@ -260,28 +260,33 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
       await action(point);
       if (restoreModifiers)
         await this._page.keyboard._ensureModifiers(restoreModifiers);
-    });
+    }, options);
   }
 
   hover(options?: PointerActionOptions & types.WaitForOptions): Promise<void> {
     return this._performPointerAction(point => this._page.mouse.move(point.x, point.y), options);
   }
 
-  click(options?: ClickOptions & types.WaitForOptions): Promise<void> {
+  click(options?: ClickOptions & types.WaitForOptions & types.NavigateOptions): Promise<void> {
     return this._performPointerAction(point => this._page.mouse.click(point.x, point.y, options), options);
   }
 
-  dblclick(options?: MultiClickOptions & types.WaitForOptions): Promise<void> {
+  dblclick(options?: MultiClickOptions & types.WaitForOptions & types.NavigateOptions): Promise<void> {
     return this._performPointerAction(point => this._page.mouse.dblclick(point.x, point.y, options), options);
   }
 
-  tripleclick(options?: MultiClickOptions & types.WaitForOptions): Promise<void> {
+  tripleclick(options?: MultiClickOptions & types.WaitForOptions & types.NavigateOptions): Promise<void> {
     return this._performPointerAction(point => this._page.mouse.tripleclick(point.x, point.y, options), options);
   }
 
-  async select(...values: (string | ElementHandle | types.SelectOption)[]): Promise<string[]> {
-    const options = values.map(value => typeof value === 'object' ? value : { value });
-    for (const option of options) {
+  async select(values: string | ElementHandle | types.SelectOption | string[] | ElementHandle[] | types.SelectOption[], options?: types.NavigateOptions): Promise<string[]> {
+    let vals: string[] | ElementHandle[] | types.SelectOption[];
+    if (!Array.isArray(values))
+      vals = [ values ] as (string[] | ElementHandle[] | types.SelectOption[]);
+    else
+      vals = values;
+    const selectOptions = (vals as any).map((value: any) => typeof value === 'object' ? value : { value });
+    for (const option of selectOptions) {
       if (option instanceof ElementHandle)
         continue;
       if (option.value !== undefined)
@@ -292,11 +297,11 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
         assert(helper.isNumber(option.index), 'Indices must be numbers. Found index "' + option.index + '" of type "' + (typeof option.index) + '"');
     }
     return await this._page._frameManager.waitForNavigationsCreatedBy<string[]>(async () => {
-      return this._evaluateInUtility((injected, node, ...optionsToSelect) => injected.selectOptions(node, optionsToSelect), ...options);
-    });
+      return this._evaluateInUtility((injected, node, ...optionsToSelect) => injected.selectOptions(node, optionsToSelect), ...selectOptions);
+    }, options);
   }
 
-  async fill(value: string): Promise<void> {
+  async fill(value: string, options?: types.NavigateOptions): Promise<void> {
     assert(helper.isString(value), 'Value must be string. Found value "' + value + '" of type "' + (typeof value) + '"');
     await this._page._frameManager.waitForNavigationsCreatedBy(async () => {
       const error = await this._evaluateInUtility((injected, node, value) => injected.fill(node, value), value);
@@ -306,28 +311,35 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
         await this._page.keyboard.sendCharacters(value);
       else
         await this._page.keyboard.press('Delete');
-    });
+    }, options);
   }
 
-  async setInputFiles(...files: (string | types.FilePayload)[]) {
+  async setInputFiles(files: string | types.FilePayload | string[] | types.FilePayload[]) {
     const multiple = await this._evaluateInUtility((injected: Injected, node: Node) => {
       if (node.nodeType !== Node.ELEMENT_NODE || (node as Element).tagName !== 'INPUT')
         throw new Error('Node is not an HTMLInputElement');
       const input = node as HTMLInputElement;
       return input.multiple;
     });
-    assert(multiple || files.length <= 1, 'Non-multiple file input can only accept single file!');
-    const filePayloads = await Promise.all(files.map(async item => {
+    let ff: string[] | types.FilePayload[];
+    if (!Array.isArray(files))
+      ff = [ files ] as string[] | types.FilePayload[];
+    else
+      ff = files;
+    assert(multiple || ff.length <= 1, 'Non-multiple file input can only accept single file!');
+    const filePayloads: types.FilePayload[] = [];
+    for (const item of ff) {
       if (typeof item === 'string') {
         const file: types.FilePayload = {
           name: platform.basename(item),
           type: platform.getMimeType(item),
           data: await platform.readFileAsync(item, 'base64')
         };
-        return file;
+        filePayloads.push(file);
+      } else {
+        filePayloads.push(item);
       }
-      return item;
-    }));
+    }
     await this._page._frameManager.waitForNavigationsCreatedBy(async () => {
       await this._page._delegate.setInputFiles(this as any as ElementHandle<HTMLInputElement>, filePayloads);
     });
@@ -344,29 +356,29 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
       throw new Error(errorMessage);
   }
 
-  async type(text: string, options?: { delay?: number }) {
+  async type(text: string, options?: { delay?: number } & types.NavigateOptions) {
     await this._page._frameManager.waitForNavigationsCreatedBy(async () => {
       await this.focus();
       await this._page.keyboard.type(text, options);
-    });
+    }, options);
   }
 
-  async press(key: string, options?: { delay?: number, text?: string }) {
+  async press(key: string, options?: { delay?: number, text?: string } & types.NavigateOptions) {
     await this._page._frameManager.waitForNavigationsCreatedBy(async () => {
       await this.focus();
       await this._page.keyboard.press(key, options);
-    });
+    }, options);
   }
 
-  async check(options?: types.WaitForOptions) {
+  async check(options?: types.WaitForOptions & types.NavigateOptions) {
     await this._setChecked(true, options);
   }
 
-  async uncheck(options?: types.WaitForOptions) {
+  async uncheck(options?: types.WaitForOptions & types.NavigateOptions) {
     await this._setChecked(false, options);
   }
 
-  private async _setChecked(state: boolean, options?: types.WaitForOptions) {
+  private async _setChecked(state: boolean, options?: types.WaitForOptions & types.NavigateOptions) {
     if (await this._evaluateInUtility((injected, node) => injected.isCheckboxChecked(node)) === state)
       return;
     await this.click(options);
diff --git a/src/firefox/ffBrowser.ts b/src/firefox/ffBrowser.ts
index 542c21a1e7..0bca65ffe7 100644
--- a/src/firefox/ffBrowser.ts
+++ b/src/firefox/ffBrowser.ts
@@ -329,7 +329,7 @@ export class FFBrowserContext extends BrowserContextBase {
     throw result;
   }
 
-  async cookies(...urls: string[]): Promise<network.NetworkCookie[]> {
+  async cookies(urls?: string | string[]): Promise<network.NetworkCookie[]> {
     const { cookies } = await this._browser._connection.send('Browser.getCookies', { browserContextId: this._browserContextId || undefined });
     return network.filterCookies(cookies.map(c => {
       const copy: any = { ... c };
diff --git a/src/firefox/ffPage.ts b/src/firefox/ffPage.ts
index 82071fe66b..9da098d886 100644
--- a/src/firefox/ffPage.ts
+++ b/src/firefox/ffPage.ts
@@ -455,16 +455,6 @@ export class FFPage implements PageDelegate {
   }
 }
 
-export function normalizeWaitUntil(waitUntil: frames.LifecycleEvent | frames.LifecycleEvent[]): frames.LifecycleEvent[] {
-  if (!Array.isArray(waitUntil))
-    waitUntil = [waitUntil];
-  for (const condition of waitUntil) {
-    if (condition !== 'load' && condition !== 'domcontentloaded')
-      throw new Error('Unknown waitUntil condition: ' + condition);
-  }
-  return waitUntil;
-}
-
 function toRemoteObject(handle: dom.ElementHandle): Protocol.Runtime.RemoteObject {
   return handle._remoteObject;
 }
diff --git a/src/frames.ts b/src/frames.ts
index 49cd424763..2ca1519fa6 100644
--- a/src/frames.ts
+++ b/src/frames.ts
@@ -34,22 +34,14 @@ type ContextData = {
   rerunnableTasks: Set<RerunnableTask>;
 };
 
-export type NavigateOptions = {
-  timeout?: number,
-  waitUntil?: LifecycleEvent | LifecycleEvent[],
-};
-
-export type WaitForNavigationOptions = NavigateOptions & { url?: types.URLMatch };
-
-export type GotoOptions = NavigateOptions & {
+export type GotoOptions = types.NavigateOptions & {
   referer?: string,
 };
 export type GotoResult = {
   newDocumentId?: string,
 };
 
-export type LifecycleEvent = 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
-const kLifecycleEvents: Set<LifecycleEvent> = new Set(['load', 'domcontentloaded', 'networkidle0', 'networkidle2']);
+const kLifecycleEvents: Set<types.LifecycleEvent> = new Set(['commit', 'load', 'domcontentloaded', 'networkidle0', 'networkidle2']);
 
 type ConsoleTagHandler = () => void;
 
@@ -108,7 +100,7 @@ export class FrameManager {
     }
   }
 
-  async waitForNavigationsCreatedBy<T>(action: () => Promise<T>, options?: WaitForNavigationOptions): Promise<T> {
+  async waitForNavigationsCreatedBy<T>(action: () => Promise<T>, options?: types.WaitForNavigationOptions): Promise<T> {
     const barrier = new PendingNavigationBarrier(options);
     this._pendingNavigationBarriers.add(barrier);
     try {
@@ -176,6 +168,7 @@ export class FrameManager {
       return;
     const hasDOMContentLoaded = frame._firedLifecycleEvents.has('domcontentloaded');
     const hasLoad = frame._firedLifecycleEvents.has('load');
+    frame._firedLifecycleEvents.add('commit');
     frame._firedLifecycleEvents.add('domcontentloaded');
     frame._firedLifecycleEvents.add('load');
     for (const watcher of this._lifecycleWatchers)
@@ -186,7 +179,7 @@ export class FrameManager {
       this._page.emit(Events.Page.Load);
   }
 
-  frameLifecycleEvent(frameId: string, event: LifecycleEvent) {
+  frameLifecycleEvent(frameId: string, event: types.LifecycleEvent) {
     const frame = this._frames.get(frameId);
     if (!frame)
       return;
@@ -201,6 +194,7 @@ export class FrameManager {
 
   clearFrameLifecycle(frame: Frame) {
     frame._firedLifecycleEvents.clear();
+    frame._firedLifecycleEvents.add('commit');
     // Keep the current navigation request if any.
     frame._inflightRequests = new Set(Array.from(frame._inflightRequests).filter(request => request._documentId === frame._lastDocumentId));
     this._stopNetworkIdleTimer(frame, 'networkidle0');
@@ -287,7 +281,7 @@ export class FrameManager {
       this._stopNetworkIdleTimer(frame, 'networkidle2');
   }
 
-  private _startNetworkIdleTimer(frame: Frame, event: LifecycleEvent) {
+  private _startNetworkIdleTimer(frame: Frame, event: types.LifecycleEvent) {
     assert(!frame._networkIdleTimers.has(event));
     if (frame._firedLifecycleEvents.has(event))
       return;
@@ -296,7 +290,7 @@ export class FrameManager {
     }, 500));
   }
 
-  private _stopNetworkIdleTimer(frame: Frame, event: LifecycleEvent) {
+  private _stopNetworkIdleTimer(frame: Frame, event: types.LifecycleEvent) {
     const timeoutId = frame._networkIdleTimers.get(event);
     if (timeoutId)
       clearTimeout(timeoutId);
@@ -318,7 +312,7 @@ export class FrameManager {
 
 export class Frame {
   _id: string;
-  readonly _firedLifecycleEvents: Set<LifecycleEvent>;
+  readonly _firedLifecycleEvents: Set<types.LifecycleEvent>;
   _lastDocumentId = '';
   _requestWatchers = new Set<(request: network.Request) => void>();
   _documentWatchers = new Set<(documentId: string, error?: Error) => void>();
@@ -331,7 +325,7 @@ export class Frame {
   private _childFrames = new Set<Frame>();
   _name = '';
   _inflightRequests = new Set<network.Request>();
-  readonly _networkIdleTimers = new Map<LifecycleEvent, NodeJS.Timer>();
+  readonly _networkIdleTimers = new Map<types.LifecycleEvent, NodeJS.Timer>();
   private _setContentCounter = 0;
   private _detachedPromise: Promise<void>;
   private _detachedCallback = () => {};
@@ -410,7 +404,7 @@ export class Frame {
     }
   }
 
-  async waitForNavigation(options: WaitForNavigationOptions = {}): Promise<network.Response | null> {
+  async waitForNavigation(options: types.WaitForNavigationOptions = {}): Promise<network.Response | null> {
     const disposer = new Disposer();
     const requestWatcher = disposer.add(this._trackDocumentRequests());
     const {timeout = this._page._timeoutSettings.navigationTimeout()} = options;
@@ -443,7 +437,7 @@ export class Frame {
     return request ? request._finalRequest._waitForResponse() : null;
   }
 
-  async waitForLoadState(options: NavigateOptions = {}): Promise<void> {
+  async waitForLoadState(options: types.NavigateOptions = {}): Promise<void> {
     const {timeout = this._page._timeoutSettings.navigationTimeout()} = options;
     const disposer = new Disposer();
     const error = await Promise.race([
@@ -495,13 +489,10 @@ export class Frame {
     return {value: promise, dispose};
   }
 
-  _waitForLifecycle(waitUntil: LifecycleEvent|LifecycleEvent[] = 'load'): Disposable<Promise<void>> {
+  _waitForLifecycle(waitUntil: types.LifecycleEvent = 'load'): Disposable<Promise<void>> {
     let resolve: () => void;
-    const expectedLifecycle = typeof waitUntil === 'string' ? [waitUntil] : waitUntil;
-    for (const event of expectedLifecycle) {
-      if (!kLifecycleEvents.has(event))
-        throw new Error(`Unsupported waitUntil option ${String(event)}`);
-    }
+    if (!kLifecycleEvents.has(waitUntil))
+      throw new Error(`Unsupported waitUntil option ${String(waitUntil)}`);
 
     const checkLifecycleComplete = () => {
       if (!checkLifecycleRecursively(this))
@@ -516,10 +507,8 @@ export class Frame {
     return {value: promise, dispose};
 
     function checkLifecycleRecursively(frame: Frame): boolean {
-      for (const event of expectedLifecycle) {
-        if (!frame._firedLifecycleEvents.has(event))
-          return false;
-      }
+      if (!frame._firedLifecycleEvents.has(waitUntil))
+        return false;
       for (const child of frame.childFrames()) {
         if (!checkLifecycleRecursively(child))
           return false;
@@ -637,7 +626,7 @@ export class Frame {
     });
   }
 
-  async setContent(html: string, options?: NavigateOptions): Promise<void> {
+  async setContent(html: string, options?: types.NavigateOptions): Promise<void> {
     const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
     const context = await this._utilityContext();
     const lifecyclePromise = new Promise(resolve => {
@@ -810,27 +799,27 @@ export class Frame {
     return result!;
   }
 
-  async click(selector: string, options?: dom.ClickOptions & types.WaitForOptions) {
+  async click(selector: string, options?: dom.ClickOptions & types.WaitForOptions & types.NavigateOptions) {
     const handle = await this._optionallyWaitForSelectorInUtilityContext(selector, options);
     await handle.click(options);
     handle.dispose();
   }
 
-  async dblclick(selector: string, options?: dom.MultiClickOptions & types.WaitForOptions) {
+  async dblclick(selector: string, options?: dom.MultiClickOptions & types.WaitForOptions & types.NavigateOptions) {
     const handle = await this._optionallyWaitForSelectorInUtilityContext(selector, options);
     await handle.dblclick(options);
     handle.dispose();
   }
 
-  async tripleclick(selector: string, options?: dom.MultiClickOptions & types.WaitForOptions) {
+  async tripleclick(selector: string, options?: dom.MultiClickOptions & types.WaitForOptions & types.NavigateOptions) {
     const handle = await this._optionallyWaitForSelectorInUtilityContext(selector, options);
     await handle.tripleclick(options);
     handle.dispose();
   }
 
-  async fill(selector: string, value: string, options?: types.WaitForOptions) {
+  async fill(selector: string, value: string, options?: types.WaitForOptions & types.NavigateOptions) {
     const handle = await this._optionallyWaitForSelectorInUtilityContext(selector, options);
-    await handle.fill(value);
+    await handle.fill(value, options);
     handle.dispose();
   }
 
@@ -846,27 +835,26 @@ export class Frame {
     handle.dispose();
   }
 
-  async select(selector: string, value: string | dom.ElementHandle | types.SelectOption | string[] | dom.ElementHandle[] | types.SelectOption[], options?: types.WaitForOptions): Promise<string[]> {
+  async select(selector: string, values: string | dom.ElementHandle | types.SelectOption | string[] | dom.ElementHandle[] | types.SelectOption[], options?: types.WaitForOptions & types.NavigateOptions): Promise<string[]> {
     const handle = await this._optionallyWaitForSelectorInUtilityContext(selector, options);
-    const values = Array.isArray(value) ? value : [value];
-    const result = await handle.select(...values);
+    const result = await handle.select(values, options);
     handle.dispose();
     return result;
   }
 
-  async type(selector: string, text: string, options?: { delay?: number } & types.WaitForOptions) {
+  async type(selector: string, text: string, options?: { delay?: number } & types.WaitForOptions & types.NavigateOptions) {
     const handle = await this._optionallyWaitForSelectorInUtilityContext(selector, options);
     await handle.type(text, options);
     handle.dispose();
   }
 
-  async check(selector: string, options?: types.WaitForOptions) {
+  async check(selector: string, options?: types.WaitForOptions & types.NavigateOptions) {
     const handle = await this._optionallyWaitForSelectorInUtilityContext(selector, options);
     await handle.check(options);
     handle.dispose();
   }
 
-  async uncheck(selector: string, options?: types.WaitForOptions) {
+  async uncheck(selector: string, options?: types.WaitForOptions & types.NavigateOptions) {
     const handle = await this._optionallyWaitForSelectorInUtilityContext(selector, options);
     await handle.uncheck(options);
     handle.dispose();
@@ -1103,12 +1091,12 @@ function selectorToString(selector: string, waitFor: 'attached' | 'detached' | '
 
 class PendingNavigationBarrier {
   private _frameIds = new Map<string, number>();
-  private _waitOptions: WaitForNavigationOptions | undefined;
+  private _waitOptions: types.WaitForNavigationOptions | undefined;
   private _protectCount = 0;
   private _promise: Promise<void>;
   private _promiseCallback = () => {};
 
-  constructor(options?: WaitForNavigationOptions) {
+  constructor(options?: types.WaitForNavigationOptions) {
     this._waitOptions = options;
     this._promise = new Promise(f => this._promiseCallback = f);
     this.retain();
diff --git a/src/network.ts b/src/network.ts
index 8feb5683c4..cfc60dd6b5 100644
--- a/src/network.ts
+++ b/src/network.ts
@@ -42,7 +42,9 @@ export type SetNetworkCookieParam = {
   sameSite?: 'Strict' | 'Lax' | 'None'
 };
 
-export function filterCookies(cookies: NetworkCookie[], urls: string[]): NetworkCookie[] {
+export function filterCookies(cookies: NetworkCookie[], urls: string | string[] = []): NetworkCookie[] {
+  if (!Array.isArray(urls))
+    urls = [ urls ];
   const parsedURLs = urls.map(s => new URL(s));
   // Chromiums's cookies are missing sameSite when it is 'None'
   return cookies.filter(c => {
diff --git a/src/page.ts b/src/page.ts
index afde8c8d97..af980d2eb2 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -295,7 +295,7 @@ export class Page extends platform.EventEmitter {
     return this.mainFrame().content();
   }
 
-  async setContent(html: string, options?: frames.NavigateOptions): Promise<void> {
+  async setContent(html: string, options?: types.NavigateOptions): Promise<void> {
     return this.mainFrame().setContent(html, options);
   }
 
@@ -303,17 +303,17 @@ export class Page extends platform.EventEmitter {
     return this.mainFrame().goto(url, options);
   }
 
-  async reload(options?: frames.NavigateOptions): Promise<network.Response | null> {
+  async reload(options?: types.NavigateOptions): Promise<network.Response | null> {
     const waitPromise = this.waitForNavigation(options);
     await this._delegate.reload();
     return waitPromise;
   }
 
-  async waitForNavigation(options?: frames.WaitForNavigationOptions): Promise<network.Response | null> {
+  async waitForNavigation(options?: types.WaitForNavigationOptions): Promise<network.Response | null> {
     return this.mainFrame().waitForNavigation(options);
   }
 
-  async waitForLoadState(options?: frames.NavigateOptions): Promise<void> {
+  async waitForLoadState(options?: types.NavigateOptions): Promise<void> {
     return this.mainFrame().waitForLoadState(options);
   }
 
@@ -342,7 +342,7 @@ export class Page extends platform.EventEmitter {
     }, timeout, this._disconnectedPromise);
   }
 
-  async goBack(options?: frames.NavigateOptions): Promise<network.Response | null> {
+  async goBack(options?: types.NavigateOptions): Promise<network.Response | null> {
     const waitPromise = this.waitForNavigation(options);
     const result = await this._delegate.goBack();
     if (!result) {
@@ -352,7 +352,7 @@ export class Page extends platform.EventEmitter {
     return waitPromise;
   }
 
-  async goForward(options?: frames.NavigateOptions): Promise<network.Response | null> {
+  async goForward(options?: types.NavigateOptions): Promise<network.Response | null> {
     const waitPromise = this.waitForNavigation(options);
     const result = await this._delegate.goForward();
     if (!result) {
@@ -439,19 +439,19 @@ export class Page extends platform.EventEmitter {
     return this._closed;
   }
 
-  async click(selector: string, options?: dom.ClickOptions & types.WaitForOptions) {
+  async click(selector: string, options?: dom.ClickOptions & types.WaitForOptions & types.NavigateOptions) {
     return this.mainFrame().click(selector, options);
   }
 
-  async dblclick(selector: string, options?: dom.MultiClickOptions & types.WaitForOptions) {
+  async dblclick(selector: string, options?: dom.MultiClickOptions & types.WaitForOptions & types.NavigateOptions) {
     return this.mainFrame().dblclick(selector, options);
   }
 
-  async tripleclick(selector: string, options?: dom.MultiClickOptions & types.WaitForOptions) {
+  async tripleclick(selector: string, options?: dom.MultiClickOptions & types.WaitForOptions & types.NavigateOptions) {
     return this.mainFrame().tripleclick(selector, options);
   }
 
-  async fill(selector: string, value: string, options?: types.WaitForOptions) {
+  async fill(selector: string, value: string, options?: types.WaitForOptions & types.NavigateOptions) {
     return this.mainFrame().fill(selector, value, options);
   }
 
@@ -463,19 +463,19 @@ export class Page extends platform.EventEmitter {
     return this.mainFrame().hover(selector, options);
   }
 
-  async select(selector: string, value: string | dom.ElementHandle | types.SelectOption | string[] | dom.ElementHandle[] | types.SelectOption[], options?: types.WaitForOptions): Promise<string[]> {
-    return this.mainFrame().select(selector, value, options);
+  async select(selector: string, values: string | dom.ElementHandle | types.SelectOption | string[] | dom.ElementHandle[] | types.SelectOption[], options?: types.WaitForOptions & types.NavigateOptions): Promise<string[]> {
+    return this.mainFrame().select(selector, values, options);
   }
 
-  async type(selector: string, text: string, options?: { delay?: number } & types.WaitForOptions) {
+  async type(selector: string, text: string, options?: { delay?: number } & types.WaitForOptions & types.NavigateOptions) {
     return this.mainFrame().type(selector, text, options);
   }
 
-  async check(selector: string, options?: types.WaitForOptions) {
+  async check(selector: string, options?: types.WaitForOptions & types.NavigateOptions) {
     return this.mainFrame().check(selector, options);
   }
 
-  async uncheck(selector: string, options?: types.WaitForOptions) {
+  async uncheck(selector: string, options?: types.WaitForOptions & types.NavigateOptions) {
     return this.mainFrame().uncheck(selector, options);
   }
 
diff --git a/src/types.ts b/src/types.ts
index 67f371a661..856089dd08 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -46,6 +46,14 @@ export type WaitForElementOptions = TimeoutOptions & { waitFor?: 'attached' | 'd
 export type Polling = 'raf' | 'mutation' | number;
 export type WaitForFunctionOptions = TimeoutOptions & { polling?: Polling };
 
+export type LifecycleEvent = 'commit' | 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
+
+export type NavigateOptions = TimeoutOptions & {
+  waitUntil?: LifecycleEvent,
+};
+
+export type WaitForNavigationOptions = NavigateOptions & { url?: URLMatch };
+
 export type ElementScreenshotOptions = {
   type?: 'png' | 'jpeg',
   path?: string,
diff --git a/src/webkit/wkBrowser.ts b/src/webkit/wkBrowser.ts
index b3784d0bb7..30c19c7752 100644
--- a/src/webkit/wkBrowser.ts
+++ b/src/webkit/wkBrowser.ts
@@ -232,7 +232,7 @@ export class WKBrowserContext extends BrowserContextBase {
     throw result;
   }
 
-  async cookies(...urls: string[]): Promise<network.NetworkCookie[]> {
+  async cookies(urls?: string | string[]): Promise<network.NetworkCookie[]> {
     const { cookies } = await this._browser._browserSession.send('Browser.getAllCookies', { browserContextId: this._browserContextId });
     return network.filterCookies(cookies.map((c: network.NetworkCookie) => ({
       ...c,
diff --git a/src/webkit/wkPage.ts b/src/webkit/wkPage.ts
index fa9754fd49..8278faa39f 100644
--- a/src/webkit/wkPage.ts
+++ b/src/webkit/wkPage.ts
@@ -241,7 +241,7 @@ export class WKPage implements PageDelegate {
     this._page._frameManager.frameStoppedLoading(frameId);
   }
 
-  private _onLifecycleEvent(frameId: string, event: frames.LifecycleEvent) {
+  private _onLifecycleEvent(frameId: string, event: types.LifecycleEvent) {
     this._page._frameManager.frameLifecycleEvent(frameId, event);
   }
 
diff --git a/test/cookies.spec.js b/test/cookies.spec.js
index 1cdccdcb1f..c5439c6b84 100644
--- a/test/cookies.spec.js
+++ b/test/cookies.spec.js
@@ -121,7 +121,7 @@ module.exports.describe = function({testRunner, expect, playwright, defaultBrows
         name: 'birdo',
         value: 'tweets',
       }]);
-      const cookies = await context.cookies('https://foo.com', 'https://baz.com');
+      const cookies = await context.cookies(['https://foo.com', 'https://baz.com']);
       cookies.sort((a, b) => a.name.localeCompare(b.name));
       expect(cookies).toEqual([{
         name: 'birdo',
diff --git a/test/input.spec.js b/test/input.spec.js
index 6889632391..94757afd2f 100644
--- a/test/input.spec.js
+++ b/test/input.spec.js
@@ -174,7 +174,7 @@ module.exports.describe = function({testRunner, expect, playwright, FFOX, CHROMI
         await new Promise(x => picker.oninput = x);
         return picker.files.length;
       })).toBe(1);
-      page.waitForEvent('filechooser').then(({element}) => element.setInputFiles());
+      page.waitForEvent('filechooser').then(({element}) => element.setInputFiles([]));
       expect(await page.$eval('input', async picker => {
         picker.click();
         await new Promise(x => picker.oninput = x);
@@ -188,9 +188,10 @@ module.exports.describe = function({testRunner, expect, playwright, FFOX, CHROMI
         page.click('input'),
       ]);
       let error = null;
-      await element.setInputFiles(
+      await element.setInputFiles([
         path.relative(process.cwd(), __dirname + '/assets/file-to-upload.txt'),
-        path.relative(process.cwd(), __dirname + '/assets/pptr.png')).catch(e => error = e);
+        path.relative(process.cwd(), __dirname + '/assets/pptr.png')
+      ]).catch(e => error = e);
       expect(error).not.toBe(null);
     });
     it('should emit input and change events', async({page, server}) => {
diff --git a/test/navigation.spec.js b/test/navigation.spec.js
index b08ee74dd6..cd3f3dd856 100644
--- a/test/navigation.spec.js
+++ b/test/navigation.spec.js
@@ -259,7 +259,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
       let error = null;
       let loaded = false;
       page.once('load', () => loaded = true);
-      await page.goto(server.PREFIX + '/grid.html', {timeout: 0, waitUntil: ['load']}).catch(e => error = e);
+      await page.goto(server.PREFIX + '/grid.html', {timeout: 0, waitUntil: 'load'}).catch(e => error = e);
       expect(error).toBe(null);
       expect(loaded).toBe(true);
     });
@@ -635,9 +635,10 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
       });
 
       let bothFired = false;
-      const bothFiredPromise = page.waitForNavigation({
-        waitUntil: ['load', 'domcontentloaded']
-      }).then(() => bothFired = true);
+      const bothFiredPromise = Promise.all([
+        page.waitForNavigation({ waitUntil: 'load' }),
+        domContentLoadedPromise
+      ]).then(() => bothFired = true);
 
       await server.waitForRequest('/one-style.css');
       await domContentLoadedPromise;
@@ -789,7 +790,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
     });
     it('should work for cross-process navigations', async({page, server}) => {
       await page.goto(server.EMPTY_PAGE);
-      const waitPromise = page.waitForNavigation({waitUntil: []});
+      const waitPromise = page.waitForNavigation({waitUntil: 'commit'});
       const url = server.CROSS_PROCESS_PREFIX + '/empty.html';
       const gotoPromise = page.goto(url);
       const response = await waitPromise;
@@ -812,7 +813,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
 
       await Promise.all([
         page.click('a').then(() => messages.push('click')),
-        page.waitForNavigation({ waitUntil: [] }).then(() => messages.push('waitForNavigation'))
+        page.waitForNavigation({ waitUntil: 'commit' }).then(() => messages.push('waitForNavigation'))
       ]);
       expect(messages.join('|')).toBe('route|waitForNavigation|click');
     });
@@ -827,7 +828,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
 
       await Promise.all([
         page.click('a').then(() => messages.push('click')),
-        page.waitForNavigation({ waitUntil: [] }).then(() => messages.push('waitForNavigation'))
+        page.waitForNavigation({ waitUntil: 'commit' }).then(() => messages.push('waitForNavigation'))
       ]);
       expect(messages.join('|')).toBe('route|waitForNavigation|click');
     });
@@ -846,7 +847,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
 
       await Promise.all([
         page.click('input[type=submit]').then(() => messages.push('click')),
-        page.waitForNavigation({ waitUntil: [] }).then(() => messages.push('waitForNavigation'))
+        page.waitForNavigation({ waitUntil: 'commit' }).then(() => messages.push('waitForNavigation'))
       ]);
       expect(messages.join('|')).toBe('route|waitForNavigation|click');
     });
@@ -865,7 +866,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
 
       await Promise.all([
         page.click('input[type=submit]').then(() => messages.push('click')),
-        page.waitForNavigation({ waitUntil: [] }).then(() => messages.push('waitForNavigation'))
+        page.waitForNavigation({ waitUntil: 'commit' }).then(() => messages.push('waitForNavigation'))
       ]);
       expect(messages.join('|')).toBe('route|waitForNavigation|click');
     });
@@ -877,7 +878,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
       });
       await Promise.all([
         page.evaluate(`window.location.href = "${server.EMPTY_PAGE}"`).then(() => messages.push('evaluate')),
-        page.waitForNavigation({ waitUntil: [] }).then(() => messages.push('waitForNavigation')),
+        page.waitForNavigation({ waitUntil: 'commit' }).then(() => messages.push('waitForNavigation')),
       ]);
       expect(messages.join('|')).toBe('route|waitForNavigation|evaluate');
     });
@@ -900,7 +901,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
 
       await Promise.all([
         page.evaluate(`window.location.reload()`).then(() => messages.push('evaluate')),
-        page.waitForNavigation({ waitUntil: [] }).then(() => messages.push('waitForNavigation')),
+        page.waitForNavigation({ waitUntil: 'commit' }).then(() => messages.push('waitForNavigation')),
       ]);
       expect(messages.join('|')).toBe('route|waitForNavigation|evaluate');
     });
@@ -915,7 +916,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
       const frame = page.frame({ name: 'target' });
       await Promise.all([
         page.click('a').then(() => messages.push('click')),
-        frame.waitForNavigation({ waitUntil: [] }).then(() => messages.push('waitForNavigation'))
+        frame.waitForNavigation({ waitUntil: 'commit' }).then(() => messages.push('waitForNavigation'))
       ]);
       expect(frame.url()).toBe(server.EMPTY_PAGE);
       expect(messages.join('|')).toBe('route|waitForNavigation|click');
@@ -964,7 +965,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
       server.setRoute('/one-style.css', (req, res) => response = res);
       await Promise.all([
         server.waitForRequest('/one-style.css'),
-        page.goto(server.PREFIX + '/one-style.html', {waitUntil: []}),
+        page.goto(server.PREFIX + '/one-style.html', {waitUntil: 'commit'}),
       ]);
       const waitPromise = page.waitForLoadState();
       response.statusCode = 404;
@@ -973,7 +974,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
     });
     it('should respect timeout', async({page, server}) => {
       server.setRoute('/one-style.css', (req, res) => response = res);
-      await page.goto(server.PREFIX + '/one-style.html', {waitUntil: []});
+      await page.goto(server.PREFIX + '/one-style.html', {waitUntil: 'commit'});
       const error = await page.waitForLoadState({ timeout: 1 }).catch(e => e);
       expect(error.message).toBe('Navigation timeout of 1 ms exceeded');
     });
@@ -984,7 +985,7 @@ module.exports.describe = function({testRunner, expect, playwright, MAC, WIN, FF
     it('should resolve immediately if load state matches', async({page, server}) => {
       await page.goto(server.EMPTY_PAGE);
       server.setRoute('/one-style.css', (req, res) => response = res);
-      await page.goto(server.PREFIX + '/one-style.html', {waitUntil: []});
+      await page.goto(server.PREFIX + '/one-style.html', {waitUntil: 'commit'});
       await page.waitForLoadState({ waitUntil: 'domcontentloaded' });
     });
     it('should work with pages that have loaded before being connected to', async({page, context, server}) => {