Bump v11.0.0-nightly.20200612

This reverts commit b809d104d0.

.github/PULL_REQUEST_TEMPLATE.md

@@ -15,6 +15,7 @@ Contributors guide: https://github.com/electron/electron/blob/master/CONTRIBUTIN
 - [ ] relevant documentation is changed or added
 - [ ] PR title follows semantic [commit guidelines](https://github.com/electron/electron/blob/master/docs/development/pull-requests.md#commit-message-guidelines)
 - [ ] [PR release notes](https://github.com/electron/clerk/blob/master/README.md) describe the change in a way relevant to app developers, and are [capitalized, punctuated, and past tense](https://github.com/electron/clerk/blob/master/README.md#examples).
+- [ ] This is **NOT A BREAKING CHANGE**. Breaking changes may not be merged to master until 11-x-y is branched.
 
 #### Release Notes
 

BUILD.gn

@@ -322,6 +322,7 @@ source_set("electron_lib") {
     "shell/common/api:mojo",
     "//base:base_static",
     "//base/allocator:buildflags",
+    "//chrome/app:command_ids",
     "//chrome/app/resources:platform_locale_settings",
     "//chrome/services/printing/public/mojom",
     "//components/certificate_transparency",
@@ -347,6 +348,7 @@ source_set("electron_lib") {
     "//device/bluetooth",
     "//device/bluetooth/public/cpp",
     "//gin",
+    "//media/blink:blink",
     "//media/capture/mojom:video_capture",
     "//media/mojo/mojom",
     "//net:extras",
@@ -523,6 +525,16 @@ source_set("electron_lib") {
 
     sources += filenames.lib_sources_nss
     sources += [
+      "shell/browser/ui/gtk/app_indicator_icon.cc",
+      "shell/browser/ui/gtk/app_indicator_icon.h",
+      "shell/browser/ui/gtk/app_indicator_icon_menu.cc",
+      "shell/browser/ui/gtk/app_indicator_icon_menu.h",
+      "shell/browser/ui/gtk/gtk_status_icon.cc",
+      "shell/browser/ui/gtk/gtk_status_icon.h",
+      "shell/browser/ui/gtk/menu_util.cc",
+      "shell/browser/ui/gtk/menu_util.h",
+      "shell/browser/ui/gtk/status_icon.cc",
+      "shell/browser/ui/gtk/status_icon.h",
       "shell/browser/ui/gtk_util.cc",
       "shell/browser/ui/gtk_util.h",
     ]

DEPS

@@ -5,6 +5,7 @@ gclient_gn_args = [
   'checkout_android_native_support',
   'checkout_libaom',
   'checkout_nacl',
+  'checkout_pgo_profiles',
   'checkout_oculus_sdk',
   'checkout_openxr',
   'checkout_google_benchmark'
@@ -12,7 +13,7 @@ gclient_gn_args = [
 
 vars = {
   'chromium_version':
-    '17da1064b910f4170320ff37e971064916aed1dc',
+    'ff6c4f4b826d66c2e32380bf5d1eb5e1fe37faef',
   'node_version':
     'v12.16.3',
   'nan_version':
@@ -42,6 +43,7 @@ vars = {
   'checkout_chromium': True,
   'checkout_node': True,
   'checkout_nan': True,
+  'checkout_pgo_profiles': True,
 
   # It's only needed to parse the native tests configurations.
   'checkout_pyyaml': False,

ELECTRON_VERSION

@@ -1 +1 @@
-10.0.0-nightly.20200521
+11.0.0-nightly.20200612

azure-pipelines-woa.yml

@@ -71,7 +71,6 @@ steps:
     ELECTRON_TEST_RESULTS_DIR: junit
     MOCHA_MULTI_REPORTERS: 'mocha-junit-reporter, tap'
     MOCHA_REPORTER: mocha-multi-reporters
-    MOCHA_TIMEOUT: 120000
 
 - task: PublishTestResults@2
   displayName: 'Publish Test Results'

build/webpack/run-compiler.js

@@ -1,3 +1,4 @@
+const fs = require('fs');
 const path = require('path')
 const webpack = require('webpack')
 
@@ -9,6 +10,9 @@ config.output = {
   filename: path.basename(outPath)
 }
 
+const { wrapInitWithProfilingTimeout } = config;
+delete config.wrapInitWithProfilingTimeout;
+
 webpack(config, (err, stats) => {
   if (err) {
     console.error(err)
@@ -17,6 +21,18 @@ webpack(config, (err, stats) => {
     console.error(stats.toString('normal'))
     process.exit(1)
   } else {
+    if (wrapInitWithProfilingTimeout) {
+      const contents = fs.readFileSync(outPath, 'utf8');
+      const newContents = `function ___electron_webpack_init__() {
+${contents}
+};
+if ((globalThis.process || binding.process).argv.includes("--profile-electron-init")) {
+  setTimeout(___electron_webpack_init__, 0);
+} else {
+  ___electron_webpack_init__();
+}`;
+      fs.writeFileSync(outPath, newContents);
+    }
     process.exit(0)
   }
 })

build/webpack/webpack.config.base.js

@@ -21,7 +21,7 @@ class AccessDependenciesPlugin {
 }
 
 const defines = {
-  BUILDFLAG: ''
+  BUILDFLAG: onlyPrintingGraph ? '(a => a)' : ''
 }
 
 const buildFlagsPrefix = '--buildflags='
@@ -34,8 +34,7 @@ if (buildFlagArg) {
   for (const line of flagFile.split(/(\r\n|\r|\n)/g)) {
     const flagMatch = line.match(/#define BUILDFLAG_INTERNAL_(.+?)\(\) \(([01])\)/)
     if (flagMatch) {
-      const flagName = flagMatch[1];
-      const flagValue = flagMatch[2];
+      const [, flagName, flagValue] = flagMatch;
       defines[flagName] = JSON.stringify(Boolean(parseInt(flagValue, 10)));
     }
   }
@@ -64,16 +63,12 @@ if (defines['ENABLE_VIEWS_API'] === 'false') {
   )
 }
 
-const alias = {}
-for (const ignoredModule of ignoredModules) {
-  alias[ignoredModule] = path.resolve(electronRoot, 'lib/common/dummy.js')
-}
-
 module.exports = ({
   alwaysHasNode,
   loadElectronFromAlternateTarget,
   targetDeletesNodeGlobals,
-  target
+  target,
+  wrapInitWithProfilingTimeout
 }) => {
   let entry = path.resolve(electronRoot, 'lib', target, 'init.ts')
   if (!fs.existsSync(entry)) {
@@ -88,24 +83,30 @@ module.exports = ({
     output: {
       filename: `${target}.bundle.js`
     },
+    wrapInitWithProfilingTimeout,
     resolve: {
       alias: {
-        ...alias,
         '@electron/internal': path.resolve(electronRoot, 'lib'),
         'electron': path.resolve(electronRoot, 'lib', loadElectronFromAlternateTarget || target, 'api', 'exports', 'electron.ts'),
-        // Force timers to resolve to our dependency that doens't use window.postMessage
+        // Force timers to resolve to our dependency that doesn't use window.postMessage
         'timers': path.resolve(electronRoot, 'node_modules', 'timers-browserify', 'main.js')
       },
       extensions: ['.ts', '.js']
     },
     module: {
       rules: [{
+        test: (moduleName) => !onlyPrintingGraph && ignoredModules.includes(moduleName),
+        loader: 'null-loader',
+      }, {
         test: /\.ts$/,
         loader: 'ts-loader',
         options: {
           configFile: path.resolve(electronRoot, 'tsconfig.electron.json'),
           transpileOnly: onlyPrintingGraph,
-          ignoreDiagnostics: [6059]
+          ignoreDiagnostics: [
+            // File '{0}' is not under 'rootDir' '{1}'.
+            6059,
+          ]
         }
       }]
     },

build/webpack/webpack.config.renderer.js

@@ -1,5 +1,6 @@
 module.exports = require('./webpack.config.base')({
   target: 'renderer',
   alwaysHasNode: true,
-  targetDeletesNodeGlobals: true
+  targetDeletesNodeGlobals: true,
+  wrapInitWithProfilingTimeout: true
 })

build/webpack/webpack.config.sandboxed_renderer.js

@@ -1,4 +1,5 @@
 module.exports = require('./webpack.config.base')({
   target: 'sandboxed_renderer',
-  alwaysHasNode: false
+  alwaysHasNode: false,
+  wrapInitWithProfilingTimeout: true,
 })

build/webpack/webpack.gni

@@ -16,6 +16,7 @@ template("webpack_build") {
     inputs = [
                invoker.config_file,
                "//electron/build/webpack/webpack.config.base.js",
+               "//electron/build/webpack/run-compiler.js",
                "//electron/tsconfig.json",
                "//electron/yarn.lock",
                "//electron/typings/internal-ambient.d.ts",

chromium_src/BUILD.gn

@@ -72,6 +72,7 @@ static_library("chrome") {
   ]
   deps = [
     "//chrome/browser:resource_prefetch_predictor_proto",
+    "//chrome/services/speech:buildflags",
     "//components/feature_engagement:buildflags",
     "//components/optimization_guide/proto:optimization_guide_proto",
   ]

docs/README.md

@@ -92,7 +92,6 @@ These individual tutorials expand on topics discussed in the guide above.
 * Electron Releases & Developer Feedback
   * [Versioning Policy](tutorial/electron-versioning.md)
   * [Release Timelines](tutorial/electron-timelines.md)
-  * [App Feedback Program](tutorial/app-feedback-program.md)
 * [Packaging App Source Code with asar](tutorial/application-packaging.md)
   * [Generating asar Archives](tutorial/application-packaging.md#generating-asar-archives)
   * [Using asar Archives](tutorial/application-packaging.md#using-asar-archives)

docs/api/app.md

@@ -1222,7 +1222,7 @@ Show the app's about panel options. These options can be overridden with `app.se
   * `credits` String (optional) _macOS_ _Windows_ - Credit information.
   * `authors` String[] (optional) _Linux_ - List of app authors.
   * `website` String (optional) _Linux_ - The app's website.
-  * `iconPath` String (optional) _Linux_ _Windows_ - Path to the app's icon. On Linux, will be shown as 64x64 pixels while retaining aspect ratio.
+  * `iconPath` String (optional) _Linux_ _Windows_ - Path to the app's icon in a JPEG or PNG file format. On Linux, will be shown as 64x64 pixels while retaining aspect ratio.
 
 Set the about panel options. This will override the values defined in the app's `.plist` file on macOS. See the [Apple docs][about-panel-options] for more details. On Linux, values must be set in order to be shown; there are no defaults.
 
@@ -1403,7 +1403,7 @@ in your app's initialization to ensure that your overridden value is used.
 
 A `Boolean` which when `true` disables the overrides that Electron has in place
 to ensure renderer processes are restarted on every navigation.  The current
-default value for this property is `false`.
+default value for this property is `true`.
 
 The intention is for these overrides to become disabled by default and then at
 some point in the future this property will be removed.  This property impacts

docs/api/browser-window.md

@@ -387,6 +387,13 @@ It creates a new `BrowserWindow` with native properties as set by the `options`.
       Default is `true`.
     * `enableWebSQL` Boolean (optional) - Whether to enable the [WebSQL api](https://www.w3.org/TR/webdatabase/).
       Default is `true`.
+    * `v8CacheOptions` String (optional) - Enforces the v8 code caching policy
+      used by blink. Accepted values are
+      * `none` - Disables code caching
+      * `code` - Heuristic based code caching
+      * `bypassHeatCheck` - Bypass code caching heuristics but with lazy compilation
+      * `bypassHeatCheckAndEagerCompile` - Same as above except compilation is eager.
+      Default policy is `code`.
 
 When setting minimum or maximum window size with `minWidth`/`maxWidth`/
 `minHeight`/`maxHeight`, it only constrains the users. It won't prevent you from

docs/api/command-line-switches.md

@@ -36,6 +36,10 @@ for integrated authentication. Without `*` prefix the URL has to match exactly.
 A comma-separated list of servers for which delegation of user credentials is required.
 Without `*` prefix the URL has to match exactly.
 
+### --disable-ntlm-v2
+
+Disables NTLM v2 for posix platforms, no effect elsewhere.
+
 ### --disable-http-cache
 
 Disables the disk cache for HTTP requests.

docs/api/desktop-capturer.md

@@ -72,6 +72,50 @@ const constraints = {
 }
 ```
 
+This example shows how to capture a video from a [WebContents](web-contents.md)
+
+```javascript
+// In the renderer process.
+const { desktopCapturer, remote } = require('electron')
+
+desktopCapturer.getMediaSourceIdForWebContents(remote.getCurrentWebContents().id).then(async mediaSourceId => {
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        mandatory: {
+          chromeMediaSource: 'tab',
+          chromeMediaSourceId: mediaSourceId
+        }
+      },
+      video: {
+        mandatory: {
+          chromeMediaSource: 'tab',
+          chromeMediaSourceId: mediaSourceId,
+          minWidth: 1280,
+          maxWidth: 1280,
+          minHeight: 720,
+          maxHeight: 720
+        }
+      }
+    })
+    handleStream(stream)
+  } catch (e) {
+    handleError(e)
+  }
+})
+
+function handleStream (stream) {
+  const video = document.querySelector('video')
+  video.srcObject = stream
+  video.onloadedmetadata = (e) => video.play()
+}
+
+function handleError (e) {
+  console.log(e)
+}
+```
+
+
 ## Methods
 
 The `desktopCapturer` module has the following methods:
@@ -94,6 +138,15 @@ Returns `Promise<DesktopCapturerSource[]>` - Resolves with an array of [`Desktop
 **Note** Capturing the screen contents requires user consent on macOS 10.15 Catalina or higher,
 which can detected by [`systemPreferences.getMediaAccessStatus`].
 
+### `desktopCapturer.getMediaSourceIdForWebContents(webContentsId)`
+
+* `webContentsId` number - Id of the WebContents to get stream of
+
+Returns `Promise<string>` - Resolves with the identifier of a WebContents stream, this identifier can be
+used with [`navigator.mediaDevices.getUserMedia`].
+The identifier is **only valid for 10 seconds**.
+The identifier may be empty if not requested from a renderer process.
+
 [`navigator.mediaDevices.getUserMedia`]: https://developer.mozilla.org/en/docs/Web/API/MediaDevices/getUserMedia
 [`systemPreferences.getMediaAccessStatus`]: system-preferences.md#systempreferencesgetmediaaccessstatusmediatype-macos
 

docs/api/menu-item.md

@@ -69,6 +69,7 @@ a `type`.
 The `role` property can have following values:
 
 * `undo`
+* `about` - Trigger a native about panel (custom message box on Window, which does not provide its own).
 * `redo`
 * `cut`
 * `copy`
@@ -94,7 +95,6 @@ The `role` property can have following values:
 The following additional roles are available on _macOS_:
 
 * `appMenu` - Whole default "App" menu (About, Services, etc.)
-* `about` - Map to the `orderFrontStandardAboutPanel` action.
 * `hide` - Map to the `hide` action.
 * `hideOthers` - Map to the `hideOtherApplications` action.
 * `unhide` - Map to the `unhideAllApplications` action.

docs/api/protocol-ns.md

@@ -1,309 +0,0 @@
-# protocol (NetworkService) (Draft)
-
-This document describes the new protocol APIs based on the [NetworkService](https://www.chromium.org/servicification).
-
-We don't currently have an estimate of when we will enable the `NetworkService` by
-default in Electron, but as Chromium is already removing non-`NetworkService`
-code, we will probably switch before Electron 10.
-
-The content of this document should be moved to `protocol.md` after we have
-enabled the `NetworkService` by default in Electron.
-
-> Register a custom protocol and intercept existing protocol requests.
-
-Process: [Main](../glossary.md#main-process)
-
-An example of implementing a protocol that has the same effect as the
-`file://` protocol:
-
-```javascript
-const { app, protocol } = require('electron')
-const path = require('path')
-
-app.whenReady().then(() => {
-  protocol.registerFileProtocol('atom', (request, callback) => {
-    const url = request.url.substr(7)
-    callback({ path: path.normalize(`${__dirname}/${url}`) })
-  })
-})
-```
-
-**Note:** All methods unless specified can only be used after the `ready` event
-of the `app` module gets emitted.
-
-## Using `protocol` with a custom `partition` or `session`
-
-A protocol is registered to a specific Electron [`session`](./session.md)
-object. If you don't specify a session, then your `protocol` will be applied to
-the default session that Electron uses. However, if you define a `partition` or
-`session` on your `browserWindow`'s `webPreferences`, then that window will use
-a different session and your custom protocol will not work if you just use
-`electron.protocol.XXX`.
-
-To have your custom protocol work in combination with a custom session, you need
-to register it to that session explicitly.
-
-```javascript
-const { session, app, protocol } = require('electron')
-const path = require('path')
-
-app.whenReady().then(() => {
-  const partition = 'persist:example'
-  const ses = session.fromPartition(partition)
-
-  ses.protocol.registerFileProtocol('atom', (request, callback) => {
-    const url = request.url.substr(7)
-    callback({ path: path.normalize(`${__dirname}/${url}`) })
-  })
-
-  mainWindow = new BrowserWindow({ webPreferences: { partition } })
-})
-```
-
-## Methods
-
-The `protocol` module has the following methods:
-
-### `protocol.registerSchemesAsPrivileged(customSchemes)`
-
-* `customSchemes` [CustomScheme[]](structures/custom-scheme.md)
-
-**Note:** This method can only be used before the `ready` event of the `app`
-module gets emitted and can be called only once.
-
-Registers the `scheme` as standard, secure, bypasses content security policy for
-resources, allows registering ServiceWorker and supports fetch API. Specify a
-privilege with the value of `true` to enable the capability.
-
-An example of registering a privileged scheme, that bypasses Content Security
-Policy:
-
-```javascript
-const { protocol } = require('electron')
-protocol.registerSchemesAsPrivileged([
-  { scheme: 'foo', privileges: { bypassCSP: true } }
-])
-```
-
-A standard scheme adheres to what RFC 3986 calls [generic URI
-syntax](https://tools.ietf.org/html/rfc3986#section-3). For example `http` and
-`https` are standard schemes, while `file` is not.
-
-Registering a scheme as standard allows relative and absolute resources to
-be resolved correctly when served. Otherwise the scheme will behave like the
-`file` protocol, but without the ability to resolve relative URLs.
-
-For example when you load following page with custom protocol without
-registering it as standard scheme, the image will not be loaded because
-non-standard schemes can not recognize relative URLs:
-
-```html
-<body>
-  <img src='test.png'>
-</body>
-```
-
-Registering a scheme as standard will allow access to files through the
-[FileSystem API][file-system-api]. Otherwise the renderer will throw a security
-error for the scheme.
-
-By default web storage apis (localStorage, sessionStorage, webSQL, indexedDB,
-cookies) are disabled for non standard schemes. So in general if you want to
-register a custom protocol to replace the `http` protocol, you have to register
-it as a standard scheme.
-
-### `protocol.registerFileProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` (String | [ProtocolResponse](structures/protocol-response.md))
-
-Registers a protocol of `scheme` that will send a file as the response. The
-`handler` will be called with `request` and `callback` where `request` is
-an incoming request for the `scheme`.
-
-To handle the `request`, the `callback` should be called with either the file's
-path or an object that has a `path` property, e.g. `callback(filePath)` or
-`callback({ path: filePath })`. The `filePath` must be an absolute path.
-
-By default the `scheme` is treated like `http:`, which is parsed differently
-from protocols that follow the "generic URI syntax" like `file:`.
-
-### `protocol.registerBufferProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` (Buffer | [ProtocolResponse](structures/protocol-response.md))
-
-Registers a protocol of `scheme` that will send a `Buffer` as a response.
-
-The usage is the same with `registerFileProtocol`, except that the `callback`
-should be called with either a `Buffer` object or an object that has the `data`
-property.
-
-Example:
-
-```javascript
-protocol.registerBufferProtocol('atom', (request, callback) => {
-  callback({ mimeType: 'text/html', data: Buffer.from('<h5>Response</h5>') })
-})
-```
-
-### `protocol.registerStringProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` (String | [ProtocolResponse](structures/protocol-response.md))
-
-Registers a protocol of `scheme` that will send a `String` as a response.
-
-The usage is the same with `registerFileProtocol`, except that the `callback`
-should be called with either a `String` or an object that has the `data`
-property.
-
-### `protocol.registerHttpProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` ProtocolResponse
-
-Registers a protocol of `scheme` that will send an HTTP request as a response.
-
-The usage is the same with `registerFileProtocol`, except that the `callback`
-should be called with an object that has the `url` property.
-
-### `protocol.registerStreamProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` (ReadableStream | [ProtocolResponse](structures/protocol-response.md))
-
-Registers a protocol of `scheme` that will send a stream as a response.
-
-The usage is the same with `registerFileProtocol`, except that the
-`callback` should be called with either a [`ReadableStream`](https://nodejs.org/api/stream.html#stream_class_stream_readable) object or an object that
-has the `data` property.
-
-Example:
-
-```javascript
-const { protocol } = require('electron')
-const { PassThrough } = require('stream')
-
-function createStream (text) {
-  const rv = new PassThrough() // PassThrough is also a Readable stream
-  rv.push(text)
-  rv.push(null)
-  return rv
-}
-
-protocol.registerStreamProtocol('atom', (request, callback) => {
-  callback({
-    statusCode: 200,
-    headers: {
-      'content-type': 'text/html'
-    },
-    data: createStream('<h5>Response</h5>')
-  })
-})
-```
-
-It is possible to pass any object that implements the readable stream API (emits
-`data`/`end`/`error` events). For example, here's how a file could be returned:
-
-```javascript
-protocol.registerStreamProtocol('atom', (request, callback) => {
-  callback(fs.createReadStream('index.html'))
-})
-```
-
-### `protocol.unregisterProtocol(scheme)`
-
-* `scheme` String
-
-Unregisters the custom protocol of `scheme`.
-
-### `protocol.isProtocolRegistered(scheme)`
-
-* `scheme` String
-
-Returns `Boolean` - Whether `scheme` is already registered.
-
-### `protocol.interceptFileProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` (String | [ProtocolResponse](structures/protocol-response.md))
-
-Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
-which sends a file as a response.
-
-### `protocol.interceptStringProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` (String | [ProtocolResponse](structures/protocol-response.md))
-
-Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
-which sends a `String` as a response.
-
-### `protocol.interceptBufferProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` (Buffer | [ProtocolResponse](structures/protocol-response.md))
-
-Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
-which sends a `Buffer` as a response.
-
-### `protocol.interceptHttpProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` ProtocolResponse
-
-Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
-which sends a new HTTP request as a response.
-
-### `protocol.interceptStreamProtocol(scheme, handler)`
-
-* `scheme` String
-* `handler` Function
-  * `request` ProtocolRequest
-  * `callback` Function
-    * `response` (ReadableStream | [ProtocolResponse](structures/protocol-response.md))
-
-Same as `protocol.registerStreamProtocol`, except that it replaces an existing
-protocol handler.
-
-### `protocol.uninterceptProtocol(scheme)`
-
-* `scheme` String
-
-Remove the interceptor installed for `scheme` and restore its original handler.
-
-### `protocol.isProtocolIntercepted(scheme)`
-
-* `scheme` String
-
-Returns `Boolean` - Whether `scheme` is already intercepted.
-
-[file-system-api]: https://developer.mozilla.org/en-US/docs/Web/API/LocalFileSystem

docs/api/protocol.md

@@ -15,8 +15,6 @@ app.whenReady().then(() => {
   protocol.registerFileProtocol('atom', (request, callback) => {
     const url = request.url.substr(7)
     callback({ path: path.normalize(`${__dirname}/${url}`) })
-  }, (error) => {
-    if (error) console.error('Failed to register protocol')
   })
 })
 ```
@@ -26,9 +24,15 @@ of the `app` module gets emitted.
 
 ## Using `protocol` with a custom `partition` or `session`
 
-A protocol is registered to a specific Electron [`session`](./session.md) object. If you don't specify a session, then your `protocol` will be applied to the default session that Electron uses. However, if you define a `partition` or `session` on your `browserWindow`'s `webPreferences`, then that window will use a different session and your custom protocol will not work if you just use `electron.protocol.XXX`.
+A protocol is registered to a specific Electron [`session`](./session.md)
+object. If you don't specify a session, then your `protocol` will be applied to
+the default session that Electron uses. However, if you define a `partition` or
+`session` on your `browserWindow`'s `webPreferences`, then that window will use
+a different session and your custom protocol will not work if you just use
+`electron.protocol.XXX`.
 
-To have your custom protocol work in combination with a custom session, you need to register it to that session explicitly.
+To have your custom protocol work in combination with a custom session, you need
+to register it to that session explicitly.
 
 ```javascript
 const { session, app, protocol } = require('electron')
@@ -41,17 +45,9 @@ app.whenReady().then(() => {
   ses.protocol.registerFileProtocol('atom', (request, callback) => {
     const url = request.url.substr(7)
     callback({ path: path.normalize(`${__dirname}/${url}`) })
-  }, (error) => {
-    if (error) console.error('Failed to register protocol')
   })
 
-  mainWindow = new BrowserWindow({
-    width: 800,
-    height: 600,
-    webPreferences: {
-      partition: partition
-    }
-  })
+  mainWindow = new BrowserWindow({ webPreferences: { partition } })
 })
 ```
 
@@ -63,15 +59,15 @@ The `protocol` module has the following methods:
 
 * `customSchemes` [CustomScheme[]](structures/custom-scheme.md)
 
-
 **Note:** This method can only be used before the `ready` event of the `app`
 module gets emitted and can be called only once.
 
-Registers the `scheme` as standard, secure, bypasses content security policy for resources,
-allows registering ServiceWorker and supports fetch API.
+Registers the `scheme` as standard, secure, bypasses content security policy for
+resources, allows registering ServiceWorker, supports fetch API, and streaming
+video/audio. Specify a privilege with the value of `true` to enable the capability.
 
-Specify a privilege with the value of `true` to enable the capability.
-An example of registering a privileged scheme, with bypassing Content Security Policy:
+An example of registering a privileged scheme, that bypasses Content Security
+Policy:
 
 ```javascript
 const { protocol } = require('electron')
@@ -84,7 +80,7 @@ A standard scheme adheres to what RFC 3986 calls [generic URI
 syntax](https://tools.ietf.org/html/rfc3986#section-3). For example `http` and
 `https` are standard schemes, while `file` is not.
 
-Registering a scheme as standard, will allow relative and absolute resources to
+Registering a scheme as standard allows relative and absolute resources to
 be resolved correctly when served. Otherwise the scheme will behave like the
 `file` protocol, but without the ability to resolve relative URLs.
 
@@ -102,168 +98,107 @@ Registering a scheme as standard will allow access to files through the
 [FileSystem API][file-system-api]. Otherwise the renderer will throw a security
 error for the scheme.
 
-By default web storage apis (localStorage, sessionStorage, webSQL, indexedDB, cookies)
-are disabled for non standard schemes. So in general if you want to register a
-custom protocol to replace the `http` protocol, you have to register it as a standard scheme.
+By default web storage apis (localStorage, sessionStorage, webSQL, indexedDB,
+cookies) are disabled for non standard schemes. So in general if you want to
+register a custom protocol to replace the `http` protocol, you have to register
+it as a standard scheme.
 
-`protocol.registerSchemesAsPrivileged` can be used to replicate the functionality of the previous `protocol.registerStandardSchemes`, `webFrame.registerURLSchemeAs*` and `protocol.registerServiceWorkerSchemes` functions that existed prior to Electron 5.0.0, for example:
+Protocols that use streams (http and stream protocols) should set `stream: true`.
+The `<video>` and `<audio>` HTML elements expect protocols to buffer their
+responses by default. The `stream` flag configures those elements to correctly
+expect streaming responses.
 
-**before (<= v4.x)**
-```javascript
-// Main
-protocol.registerStandardSchemes(['scheme1', 'scheme2'], { secure: true })
-// Renderer
-webFrame.registerURLSchemeAsPrivileged('scheme1', { secure: true })
-webFrame.registerURLSchemeAsPrivileged('scheme2', { secure: true })
-```
-
-**after (>= v5.x)**
-```javascript
-protocol.registerSchemesAsPrivileged([
-  { scheme: 'scheme1', privileges: { standard: true, secure: true } },
-  { scheme: 'scheme2', privileges: { standard: true, secure: true } }
-])
-```
-
-### `protocol.registerFileProtocol(scheme, handler[, completion])`
+### `protocol.registerFileProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `filePath` String | [FilePathWithHeaders](structures/file-path-with-headers.md) (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` (String | [ProtocolResponse](structures/protocol-response.md))
 
-Registers a protocol of `scheme` that will send the file as a response. The
-`handler` will be called with `handler(request, callback)` when a `request` is
-going to be created with `scheme`. `completion` will be called with
-`completion(null)` when `scheme` is successfully registered or
-`completion(error)` when failed.
+Returns `Boolean` - Whether the protocol was successfully registered
+
+Registers a protocol of `scheme` that will send a file as the response. The
+`handler` will be called with `request` and `callback` where `request` is
+an incoming request for the `scheme`.
 
 To handle the `request`, the `callback` should be called with either the file's
 path or an object that has a `path` property, e.g. `callback(filePath)` or
-`callback({ path: filePath })`. The object may also have a `headers` property
-which gives a map of headers to values for the response headers, e.g.
-`callback({ path: filePath, headers: {"Content-Security-Policy": "default-src 'none'"]})`.
-
-When `callback` is called with nothing, a number, or an object that has an
-`error` property, the `request` will fail with the `error` number you
-specified. For the available error numbers you can use, please see the
-[net error list][net-error].
+`callback({ path: filePath })`. The `filePath` must be an absolute path.
 
 By default the `scheme` is treated like `http:`, which is parsed differently
-than protocols that follow the "generic URI syntax" like `file:`.
+from protocols that follow the "generic URI syntax" like `file:`.
 
-### `protocol.registerBufferProtocol(scheme, handler[, completion])`
+### `protocol.registerBufferProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `buffer` (Buffer | [MimeTypedBuffer](structures/mime-typed-buffer.md)) (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` (Buffer | [ProtocolResponse](structures/protocol-response.md))
+
+Returns `Boolean` - Whether the protocol was successfully registered
 
 Registers a protocol of `scheme` that will send a `Buffer` as a response.
 
 The usage is the same with `registerFileProtocol`, except that the `callback`
-should be called with either a `Buffer` object or an object that has the `data`,
-`mimeType`, and `charset` properties.
+should be called with either a `Buffer` object or an object that has the `data`
+property.
 
 Example:
 
 ```javascript
-const { protocol } = require('electron')
-
 protocol.registerBufferProtocol('atom', (request, callback) => {
   callback({ mimeType: 'text/html', data: Buffer.from('<h5>Response</h5>') })
-}, (error) => {
-  if (error) console.error('Failed to register protocol')
 })
 ```
 
-### `protocol.registerStringProtocol(scheme, handler[, completion])`
+### `protocol.registerStringProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `data` (String | [StringProtocolResponse](structures/string-protocol-response.md)) (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` (String | [ProtocolResponse](structures/protocol-response.md))
+
+Returns `Boolean` - Whether the protocol was successfully registered
 
 Registers a protocol of `scheme` that will send a `String` as a response.
 
 The usage is the same with `registerFileProtocol`, except that the `callback`
-should be called with either a `String` or an object that has the `data`,
-`mimeType`, and `charset` properties.
+should be called with either a `String` or an object that has the `data`
+property.
 
-### `protocol.registerHttpProtocol(scheme, handler[, completion])`
+### `protocol.registerHttpProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `redirectRequest` Object
-      * `url` String
-      * `method` String (optional)
-      * `session` Session | null (optional)
-      * `uploadData` [ProtocolResponseUploadData](structures/protocol-response-upload-data.md) (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` ProtocolResponse
+
+Returns `Boolean` - Whether the protocol was successfully registered
 
 Registers a protocol of `scheme` that will send an HTTP request as a response.
 
 The usage is the same with `registerFileProtocol`, except that the `callback`
-should be called with a `redirectRequest` object that has the `url`, `method`,
-`referrer`, `uploadData` and `session` properties.
+should be called with an object that has the `url` property.
 
-By default the HTTP request will reuse the current session. If you want the
-request to have a different session you should set `session` to `null`.
-
-For POST requests the `uploadData` object must be provided.
-
-### `protocol.registerStreamProtocol(scheme, handler[, completion])`
+### `protocol.registerStreamProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `stream` (ReadableStream | [StreamProtocolResponse](structures/stream-protocol-response.md)) (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` (ReadableStream | [ProtocolResponse](structures/protocol-response.md))
 
-Registers a protocol of `scheme` that will send a `Readable` as a response.
+Returns `Boolean` - Whether the protocol was successfully registered
 
-The usage is similar to the other `register{Any}Protocol`, except that the
-`callback` should be called with either a `Readable` object or an object that
-has the `data`, `statusCode`, and `headers` properties.
+Registers a protocol of `scheme` that will send a stream as a response.
+
+The usage is the same with `registerFileProtocol`, except that the
+`callback` should be called with either a [`ReadableStream`](https://nodejs.org/api/stream.html#stream_class_stream_readable) object or an object that
+has the `data` property.
 
 Example:
 
@@ -286,8 +221,6 @@ protocol.registerStreamProtocol('atom', (request, callback) => {
     },
     data: createStream('<h5>Response</h5>')
   })
-}, (error) => {
-  if (error) console.error('Failed to register protocol')
 })
 ```
 
@@ -295,132 +228,102 @@ It is possible to pass any object that implements the readable stream API (emits
 `data`/`end`/`error` events). For example, here's how a file could be returned:
 
 ```javascript
-const { protocol } = require('electron')
-const fs = require('fs')
-
 protocol.registerStreamProtocol('atom', (request, callback) => {
   callback(fs.createReadStream('index.html'))
-}, (error) => {
-  if (error) console.error('Failed to register protocol')
 })
 ```
 
-### `protocol.unregisterProtocol(scheme[, completion])`
+### `protocol.unregisterProtocol(scheme)`
 
 * `scheme` String
-* `completion` Function (optional)
-  * `error` Error
+
+Returns `Boolean` - Whether the protocol was successfully unregistered
 
 Unregisters the custom protocol of `scheme`.
 
-### `protocol.isProtocolHandled(scheme)`
+### `protocol.isProtocolRegistered(scheme)`
 
 * `scheme` String
 
-Returns `Promise<Boolean>` - fulfilled with a boolean that indicates whether there is
-already a handler for `scheme`.
+Returns `Boolean` - Whether `scheme` is already registered.
 
-### `protocol.interceptFileProtocol(scheme, handler[, completion])`
+### `protocol.interceptFileProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `filePath` String
-* `completion` Function (optional)
-  * `error` Error
+    * `response` (String | [ProtocolResponse](structures/protocol-response.md))
+
+Returns `Boolean` - Whether the protocol was successfully intercepted
 
 Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
 which sends a file as a response.
 
-### `protocol.interceptStringProtocol(scheme, handler[, completion])`
+### `protocol.interceptStringProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `data` (String | [StringProtocolResponse](structures/string-protocol-response.md)) (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` (String | [ProtocolResponse](structures/protocol-response.md))
+
+Returns `Boolean` - Whether the protocol was successfully intercepted
 
 Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
 which sends a `String` as a response.
 
-### `protocol.interceptBufferProtocol(scheme, handler[, completion])`
+### `protocol.interceptBufferProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `buffer` Buffer (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` (Buffer | [ProtocolResponse](structures/protocol-response.md))
+
+Returns `Boolean` - Whether the protocol was successfully intercepted
 
 Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
 which sends a `Buffer` as a response.
 
-### `protocol.interceptHttpProtocol(scheme, handler[, completion])`
+### `protocol.interceptHttpProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `redirectRequest` Object
-      * `url` String
-      * `method` String (optional)
-      * `session` Session | null (optional)
-      * `uploadData` [ProtocolResponseUploadData](structures/protocol-response-upload-data.md) (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` [ProtocolResponse](structures/protocol-response.md)
+
+Returns `Boolean` - Whether the protocol was successfully intercepted
 
 Intercepts `scheme` protocol and uses `handler` as the protocol's new handler
 which sends a new HTTP request as a response.
 
-### `protocol.interceptStreamProtocol(scheme, handler[, completion])`
+### `protocol.interceptStreamProtocol(scheme, handler)`
 
 * `scheme` String
 * `handler` Function
-  * `request` Object
-    * `url` String
-    * `headers` Record<String, String>
-    * `referrer` String
-    * `method` String
-    * `uploadData` [UploadData[]](structures/upload-data.md)
+  * `request` ProtocolRequest
   * `callback` Function
-    * `stream` (ReadableStream | [StreamProtocolResponse](structures/stream-protocol-response.md)) (optional)
-* `completion` Function (optional)
-  * `error` Error
+    * `response` (ReadableStream | [ProtocolResponse](structures/protocol-response.md))
+
+Returns `Boolean` - Whether the protocol was successfully intercepted
 
 Same as `protocol.registerStreamProtocol`, except that it replaces an existing
 protocol handler.
 
-### `protocol.uninterceptProtocol(scheme[, completion])`
+### `protocol.uninterceptProtocol(scheme)`
 
 * `scheme` String
-* `completion` Function (optional)
-  * `error` Error
+
+Returns `Boolean` - Whether the protocol was successfully unintercepted
 
 Remove the interceptor installed for `scheme` and restore its original handler.
 
-[net-error]: https://code.google.com/p/chromium/codesearch#chromium/src/net/base/net_error_list.h
+### `protocol.isProtocolIntercepted(scheme)`
+
+* `scheme` String
+
+Returns `Boolean` - Whether `scheme` is already intercepted.
+
 [file-system-api]: https://developer.mozilla.org/en-US/docs/Web/API/LocalFileSystem

docs/api/service-workers.md

@@ -39,7 +39,7 @@ Returns:
   * `message` String - The actual console message
   * `versionId` Number - The version ID of the service worker that sent the log message
   * `source` String - The type of source for this message.  Can be `javascript`, `xml`, `network`, `console-api`, `storage`, `app-cache`, `rendering`, `security`, `deprecation`, `worker`, `violation`, `intervention`, `recommendation` or `other`.
-  * `level` Number - The log level, from 0 to 3.  In order it matches `verbose`, `info`, `warning` and `error`.
+  * `level` Number - The log level, from 0 to 3. In order it matches `verbose`, `info`, `warning` and `error`.
   * `sourceUrl` String - The URL the message came from
   * `lineNumber` Number - The line number of the source that triggered this console message
 

docs/api/structures/custom-scheme.md

@@ -8,3 +8,4 @@
   * `allowServiceWorkers` Boolean (optional) - Default false.
   * `supportFetchAPI` Boolean (optional) - Default false.
   * `corsEnabled` Boolean (optional) - Default false.
+  * `stream` Boolean (optional) - Default false.

docs/api/structures/protocol-request.md

@@ -4,3 +4,4 @@
 * `referrer` String
 * `method` String
 * `uploadData` [UploadData[]](upload-data.md) (optional)
+* `headers` Record<String, String>

docs/api/structures/trace-config.md

@@ -6,7 +6,7 @@
 * `trace_buffer_size_in_events` number (optional) - maximum size of the trace
   recording buffer in events.
 * `enable_argument_filter` boolean (optional) - if true, filter event data
-  according to a whitelist of events that have been manually vetted to not
+  according to a specific list of events that have been manually vetted to not
   include any PII. See [the implementation in
   Chromium][trace_event_args_whitelist.cc] for specifics.
 * `included_categories` String[] (optional) - a list of tracing categories to

docs/api/web-contents.md

@@ -402,6 +402,7 @@ Returns:
   * `key` String - Equivalent to [KeyboardEvent.key][keyboardevent].
   * `code` String - Equivalent to [KeyboardEvent.code][keyboardevent].
   * `isAutoRepeat` Boolean - Equivalent to [KeyboardEvent.repeat][keyboardevent].
+  * `isComposing` Boolean - Equivalent to [KeyboardEvent.isComposing][keyboardevent].
   * `shift` Boolean - Equivalent to [KeyboardEvent.shiftKey][keyboardevent].
   * `control` Boolean - Equivalent to [KeyboardEvent.controlKey][keyboardevent].
   * `alt` Boolean - Equivalent to [KeyboardEvent.altKey][keyboardevent].
@@ -737,9 +738,9 @@ Emitted when a `<webview>` has been attached to this web contents.
 Returns:
 
 * `event` Event
-* `level` Integer
-* `message` String
-* `line` Integer
+* `level` Integer - The log level, from 0 to 3. In order it matches `verbose`, `info`, `warning` and `error`.
+* `message` String - The actual console message
+* `line` Integer - The line number of the source that triggered this console message
 * `sourceId` String
 
 Emitted when the associated window logs a console message.
@@ -907,10 +908,10 @@ Returns `String` - The URL of the current web page.
 ```javascript
 const { BrowserWindow } = require('electron')
 let win = new BrowserWindow({ width: 800, height: 600 })
-win.loadURL('http://github.com')
-
-let currentURL = win.webContents.getURL()
-console.log(currentURL)
+win.loadURL('http://github.com').then(() => {
+  const currentURL = win.webContents.getURL()
+  console.log(currentURL)
+})
 ```
 
 #### `contents.getTitle()`

docs/api/webview-tag.md

@@ -755,9 +755,9 @@ Fired when page leaves fullscreen triggered by HTML API.
 
 Returns:
 
-* `level` Integer
-* `message` String
-* `line` Integer
+* `level` Integer - The log level, from 0 to 3. In order it matches `verbose`, `info`, `warning` and `error`.
+* `message` String - The actual console message
+* `line` Integer - The line number of the source that triggered this console message
 * `sourceId` String
 
 Fired when the guest window logs a console message.

docs/development/README.md

@@ -23,4 +23,3 @@ For guides on Electron app development, see
 * [Debugging on macOS](debugging-instructions-macos.md)
 * [Setting Up Symbol Server in Debugger](setting-up-symbol-server.md)
 * [Patches](patches.md)
-* [Upgrading Node](upgrading-node.md)

docs/development/build-instructions-gn.md

@@ -10,6 +10,10 @@ Check the build prerequisites for your platform before proceeding
   * [Linux](build-instructions-linux.md#prerequisites)
   * [Windows](build-instructions-windows.md#prerequisites)
 
+## Build Tools
+
+[Electron's Build Tools](https://github.com/electron/build-tools) automate much of the setup for compiling Electron from source with different configurations and build targets. If you wish to set up the environment manually, the instructions are listed below.
+
 ## GN prerequisites
 
 You'll need to install [`depot_tools`][depot-tools], the toolset

docs/development/upgrading-node.md

@@ -1,121 +0,0 @@
-# Upgrading Node
-
-## Discussion
-
-Chromium and Node.js both depend on V8, and Electron contains
-only a single copy of V8, so it's important to ensure that the
-version of V8 chosen is compatible with the build's version of
-Node.js and Chromium.
-
-Upgrading Node is much easier than upgrading Chromium, so fewer
-conflicts arise if one upgrades Chromium first, then chooses the
-upstream Node release whose version of V8 is closest to the one
-Chromium contains.
-
-Electron has its own [Node fork](https://github.com/electron/node)
-with modifications for the V8 build details mentioned above
-and for exposing API needed by Electron. Once an upstream Node
-release is chosen, it's placed in a branch in Electron's Node fork
-and any Electron Node patches are applied there.
-
-Another factor is that the Node project patches its version of V8.
-As mentioned above, Electron builds everything with a single copy
-of V8, so Node's V8 patches must be ported to that copy.
-
-Once all of Electron's dependencies are building and using the same
-copy of V8, the next step is to fix any Electron code issues caused
-by the Node upgrade.
-
-[FIXME] something about a Node debugger in Atom that we (e.g. deepak)
-use and need to confirm doesn't break with the Node upgrade?
-
-So in short, the primary steps are:
-
-1. Update Electron's Node fork to the desired version
-2. Backport Node's V8 patches to our copy of V8
-3. Update the GN build files, porting changes from node's GYP files
-4. Update Electron's DEPS to use new version of Node
-
-## Updating Electron's Node [fork](https://github.com/electron/node)
-
-1. Ensure that `master` on `electron/node` has updated release tags from `nodejs/node`
-2. Create a branch in https://github.com/electron/node: `electron-node-vX.X.X` where the base that you're branching from is the tag for the desired update
-  - `vX.X.X` Must use a version of Node compatible with our current version of Chromium
-3. Re-apply our commits from the previous version of Node we were using (`vY.Y.Y`) to `v.X.X.X`
-  - Check release tag and select the range of commits we need to re-apply
-  - Cherry-pick commit range:
-    1. Checkout both `vY.Y.Y` & `v.X.X.X`
-    2. `git cherry-pick FIRST_COMMIT_HASH..LAST_COMMIT_HASH`
-  - Resolve merge conflicts in each file encountered, then:
-    1. `git add <conflict-file>`
-    2. `git cherry-pick --continue`
-    3. Repeat until finished
-
-
-## Updating [V8](https://github.com/electron/node/src/V8) Patches
-
-We need to generate a patch file from each patch that Node
-applies to V8.
-
-```sh
-$ cd third_party/electron_node
-$ CURRENT_NODE_VERSION=vX.Y.Z
-# Find the last commit with the message "deps: update V8 to <some version>"
-# This commit corresponds to Node resetting V8 to its pristine upstream
-# state at the stated version.
-$ LAST_V8_UPDATE="$(git log --grep='^deps: update V8' --format='%H' -1 deps/v8)"
-# This creates a patch file containing all changes in deps/v8 from
-# $LAST_V8_UPDATE up to the current Node version, formatted in a way that
-# it will apply cleanly to the V8 repository (i.e. with `deps/v8`
-# stripped off the path and excluding the v8/gypfiles directory, which
-# isn't present in V8.
-$ git format-patch \
-    --relative=deps/v8 \
-    $LAST_V8_UPDATE..$CURRENT_NODE_VERSION \
-    deps/v8 \
-    ':(exclude)deps/v8/gypfiles' \
-    --stdout \
-    > ../../electron/common/patches/v8/node_v8_patches.patch
-```
-
-This list of patches will probably include one that claims to
-make the V8 API backwards-compatible with a previous version of
-V8. Unfortunately, those patches almost always change the V8 API
-in a way that is incompatible with Chromium.
-
-It's usually easier to update Node to work without the
-compatibility patch than to update Chromium to work with the
-compatibility patch, so it's recommended to revert the
-compatibility patch and fix any errors that arise when compiling
-Node.
-
-## Update Electron's `DEPS` file
-
-Update the `DEPS` file in the root of
-[electron/electron](https://github.com/electron/electron) to
-point to the git hash of the updated Node.
-
-## Notes
-
-- Node maintains its own fork of V8
-  - They backport a small amount of things as needed
-  - Documentation in Node about how [they work with V8](https://nodejs.org/api/v8.html)
-- We update code such that we only use one copy of V8 across all of Electron
-  - E.g Electron, Chromium, and Node.js
-- We don’t track upstream closely due to logistics:
-   - Upstream uses multiple repos and so merging into a single repo
-   would result in lost history. So we only update when we’re planning
-   a Node version bump in Electron.
-- Chromium is large and time-consuming to update, so we typically
-  choose the Node version based on which of its releases has a version
-  of V8 that’s closest to the version in Chromium that we’re using.
-  - We sometimes have to wait for the next periodic Node release
-   because it will sync more closely with the version of V8 in the new Chromium
- - Electron keeps all its patches in the repo because it’s simpler than
-   maintaining different repos for patches for each upstream project.
-   - Crashpad, Node.js, Chromium, Skia etc. patches are all kept in the same place
- - Building Node:
-   - We maintain our own GN build files for Node.js to make it easier to ensure
-     that eevrything is built with the same compiler flags.
-     This means that every time we upgrade Node.js we have to do a modest amount of
-     work to synchronize the GN files with the upstream GYP files.

docs/tutorial/app-feedback-program.md

@@ -1,3 +0,0 @@
-# Electron App Feedback Program
-
-Electron is working on building a streamlined release process and having faster releases. To help with that, we have the App Feedback Program for large-scale Electron apps to test our beta releases and report app-specific issues to the Electron team. We use this program to help us prioritize work and get applications upgraded to the next stable release as soon as possible. There are a few requirements we expect from participants, such as attending short, online weekly check-ins. Please visit the [blog post](https://electronjs.org/blog/app-feedback-program) for details and sign-up.

docs/tutorial/first-app.md

@@ -44,23 +44,10 @@ run the main process. An example of your `package.json` might look like this:
 ```
 
 __Note__: If the `main` field is not present in `package.json`, Electron will
-attempt to load an `index.js` (as Node.js does). If this was actually
-a simple Node application, you would add a `start` script that instructs `node`
-to execute the current package:
+attempt to load an `index.js` (as Node.js does).
 
-```json
-{
-  "name": "your-app",
-  "version": "0.1.0",
-  "main": "main.js",
-  "scripts": {
-    "start": "node ."
-  }
-}
-```
-
-Turning this Node application into an Electron application is quite simple - we
-merely replace the `node` runtime with the `electron` runtime.
+By default, `npm start` would run the main script with Node.js. in order to make
+it run with Electron, you can add a `start` script:
 
 ```json
 {
@@ -154,10 +141,10 @@ function createWindow () {
 // Some APIs can only be used after this event occurs.
 app.whenReady().then(createWindow)
 
-// Quit when all windows are closed.
+// Quit when all windows are closed, except on macOS. There, it's common
+// for applications and their menu bar to stay active until the user quits
+// explicitly with Cmd + Q.
 app.on('window-all-closed', () => {
-  // On macOS it is common for applications and their menu bar
-  // to stay active until the user quits explicitly with Cmd + Q
   if (process.platform !== 'darwin') {
     app.quit()
   }

electron_paks.gni

@@ -55,7 +55,9 @@ template("electron_extra_paks") {
     output = "${invoker.output_dir}/resources.pak"
     sources = [
       "$root_gen_dir/components/components_resources.pak",
+      "$root_gen_dir/content/browser/resources/media/media_internals_resources.pak",
       "$root_gen_dir/content/browser/tracing/tracing_resources.pak",
+      "$root_gen_dir/content/browser/webrtc/resources/webrtc_internals_resources.pak",
       "$root_gen_dir/content/content_resources.pak",
       "$root_gen_dir/content/dev_ui_content_resources.pak",
       "$root_gen_dir/mojo/public/js/mojo_bindings_resources.pak",
@@ -68,7 +70,9 @@ template("electron_extra_paks") {
       "//components/resources",
       "//content:content_resources",
       "//content:dev_ui_content_resources",
+      "//content/browser/resources/media:media_internals_resources",
       "//content/browser/tracing:resources",
+      "//content/browser/webrtc/resources",
       "//electron:resources",
       "//mojo/public/js:resources",
       "//net:net_resources",

filenames.auto.gni

@@ -43,7 +43,6 @@ auto_filenames = {
     "docs/api/power-monitor.md",
     "docs/api/power-save-blocker.md",
     "docs/api/process.md",
-    "docs/api/protocol-ns.md",
     "docs/api/protocol.md",
     "docs/api/remote.md",
     "docs/api/sandbox-option.md",
@@ -136,11 +135,11 @@ auto_filenames = {
 
   sandbox_bundle_deps = [
     "lib/browser/api/module-names.ts",
-    "lib/common/api/clipboard.js",
+    "lib/common/api/clipboard.ts",
     "lib/common/api/deprecate.ts",
     "lib/common/api/module-list.ts",
-    "lib/common/api/native-image.js",
-    "lib/common/api/shell.js",
+    "lib/common/api/native-image.ts",
+    "lib/common/api/shell.ts",
     "lib/common/define-properties.ts",
     "lib/common/electron-binding-setup.ts",
     "lib/common/type-utils.ts",
@@ -150,7 +149,7 @@ auto_filenames = {
     "lib/renderer/api/crash-reporter.ts",
     "lib/renderer/api/desktop-capturer.ts",
     "lib/renderer/api/ipc-renderer.ts",
-    "lib/renderer/api/remote.js",
+    "lib/renderer/api/remote.ts",
     "lib/renderer/api/web-frame.ts",
     "lib/renderer/inspector.ts",
     "lib/renderer/ipc-renderer-internal-utils.ts",
@@ -167,10 +166,12 @@ auto_filenames = {
     "lib/renderer/window-setup.ts",
     "lib/sandboxed_renderer/api/exports/electron.ts",
     "lib/sandboxed_renderer/api/module-list.ts",
-    "lib/sandboxed_renderer/init.js",
+    "lib/sandboxed_renderer/init.ts",
     "package.json",
     "tsconfig.electron.json",
     "tsconfig.json",
+    "typings/internal-ambient.d.ts",
+    "typings/internal-electron.d.ts",
   ]
 
   isolated_bundle_deps = [
@@ -181,6 +182,8 @@ auto_filenames = {
     "package.json",
     "tsconfig.electron.json",
     "tsconfig.json",
+    "typings/internal-ambient.d.ts",
+    "typings/internal-electron.d.ts",
   ]
 
   browser_bundle_deps = [
@@ -189,15 +192,15 @@ auto_filenames = {
     "lib/browser/api/auto-updater/auto-updater-native.js",
     "lib/browser/api/auto-updater/auto-updater-win.js",
     "lib/browser/api/auto-updater/squirrel-update-win.js",
-    "lib/browser/api/browser-view.js",
+    "lib/browser/api/browser-view.ts",
     "lib/browser/api/browser-window.js",
-    "lib/browser/api/content-tracing.js",
+    "lib/browser/api/content-tracing.ts",
     "lib/browser/api/crash-reporter.ts",
     "lib/browser/api/desktop-capturer.ts",
     "lib/browser/api/dialog.js",
     "lib/browser/api/exports/electron.ts",
-    "lib/browser/api/global-shortcut.js",
-    "lib/browser/api/in-app-purchase.js",
+    "lib/browser/api/global-shortcut.ts",
+    "lib/browser/api/in-app-purchase.ts",
     "lib/browser/api/ipc-main.ts",
     "lib/browser/api/menu-item-roles.js",
     "lib/browser/api/menu-item.js",
@@ -208,19 +211,19 @@ auto_filenames = {
     "lib/browser/api/native-theme.ts",
     "lib/browser/api/net-log.js",
     "lib/browser/api/net.ts",
-    "lib/browser/api/notification.js",
+    "lib/browser/api/notification.ts",
     "lib/browser/api/power-monitor.ts",
-    "lib/browser/api/power-save-blocker.js",
+    "lib/browser/api/power-save-blocker.ts",
     "lib/browser/api/protocol.ts",
     "lib/browser/api/screen.ts",
-    "lib/browser/api/session.js",
+    "lib/browser/api/session.ts",
     "lib/browser/api/system-preferences.ts",
     "lib/browser/api/top-level-window.js",
     "lib/browser/api/touch-bar.js",
-    "lib/browser/api/tray.js",
-    "lib/browser/api/view.js",
-    "lib/browser/api/views/image-view.js",
-    "lib/browser/api/web-contents-view.js",
+    "lib/browser/api/tray.ts",
+    "lib/browser/api/view.ts",
+    "lib/browser/api/views/image-view.ts",
+    "lib/browser/api/web-contents-view.ts",
     "lib/browser/api/web-contents.js",
     "lib/browser/chrome-extension-shim.js",
     "lib/browser/default-menu.ts",
@@ -238,11 +241,11 @@ auto_filenames = {
     "lib/browser/remote/server.ts",
     "lib/browser/rpc-server.js",
     "lib/browser/utils.ts",
-    "lib/common/api/clipboard.js",
+    "lib/common/api/clipboard.ts",
     "lib/common/api/deprecate.ts",
     "lib/common/api/module-list.ts",
-    "lib/common/api/native-image.js",
-    "lib/common/api/shell.js",
+    "lib/common/api/native-image.ts",
+    "lib/common/api/shell.ts",
     "lib/common/define-properties.ts",
     "lib/common/electron-binding-setup.ts",
     "lib/common/init.ts",
@@ -256,15 +259,17 @@ auto_filenames = {
     "package.json",
     "tsconfig.electron.json",
     "tsconfig.json",
+    "typings/internal-ambient.d.ts",
+    "typings/internal-electron.d.ts",
   ]
 
   renderer_bundle_deps = [
     "lib/browser/api/module-names.ts",
-    "lib/common/api/clipboard.js",
+    "lib/common/api/clipboard.ts",
     "lib/common/api/deprecate.ts",
     "lib/common/api/module-list.ts",
-    "lib/common/api/native-image.js",
-    "lib/common/api/shell.js",
+    "lib/common/api/native-image.ts",
+    "lib/common/api/shell.ts",
     "lib/common/define-properties.ts",
     "lib/common/electron-binding-setup.ts",
     "lib/common/init.ts",
@@ -278,7 +283,7 @@ auto_filenames = {
     "lib/renderer/api/exports/electron.ts",
     "lib/renderer/api/ipc-renderer.ts",
     "lib/renderer/api/module-list.ts",
-    "lib/renderer/api/remote.js",
+    "lib/renderer/api/remote.ts",
     "lib/renderer/api/web-frame.ts",
     "lib/renderer/init.ts",
     "lib/renderer/inspector.ts",
@@ -298,15 +303,17 @@ auto_filenames = {
     "package.json",
     "tsconfig.electron.json",
     "tsconfig.json",
+    "typings/internal-ambient.d.ts",
+    "typings/internal-electron.d.ts",
   ]
 
   worker_bundle_deps = [
     "lib/browser/api/module-names.ts",
-    "lib/common/api/clipboard.js",
+    "lib/common/api/clipboard.ts",
     "lib/common/api/deprecate.ts",
     "lib/common/api/module-list.ts",
-    "lib/common/api/native-image.js",
-    "lib/common/api/shell.js",
+    "lib/common/api/native-image.ts",
+    "lib/common/api/shell.ts",
     "lib/common/define-properties.ts",
     "lib/common/electron-binding-setup.ts",
     "lib/common/init.ts",
@@ -319,7 +326,7 @@ auto_filenames = {
     "lib/renderer/api/exports/electron.ts",
     "lib/renderer/api/ipc-renderer.ts",
     "lib/renderer/api/module-list.ts",
-    "lib/renderer/api/remote.js",
+    "lib/renderer/api/remote.ts",
     "lib/renderer/api/web-frame.ts",
     "lib/renderer/ipc-renderer-internal-utils.ts",
     "lib/renderer/ipc-renderer-internal.ts",
@@ -329,5 +336,7 @@ auto_filenames = {
     "package.json",
     "tsconfig.electron.json",
     "tsconfig.json",
+    "typings/internal-ambient.d.ts",
+    "typings/internal-electron.d.ts",
   ]
 }

lib/browser/api/browser-view.ts

@@ -1,11 +1,10 @@
-'use strict';
+import { EventEmitter } from 'events';
 
-const { EventEmitter } = require('events');
 const { BrowserView } = process.electronBinding('browser_view');
 
 Object.setPrototypeOf(BrowserView.prototype, EventEmitter.prototype);
 
-BrowserView.fromWebContents = (webContents) => {
+BrowserView.fromWebContents = (webContents: Electron.WebContents) => {
   for (const view of BrowserView.getAllViews()) {
     if (view.webContents.equal(webContents)) return view;
   }
@@ -13,4 +12,4 @@ BrowserView.fromWebContents = (webContents) => {
   return null;
 };
 
-module.exports = BrowserView;
+export default BrowserView;

lib/browser/api/content-tracing.js

@@ -1,2 +0,0 @@
-'use strict';
-module.exports = process.electronBinding('content_tracing');

lib/browser/api/content-tracing.ts

@@ -0,0 +1 @@
+export default process.electronBinding('content_tracing');

lib/browser/api/global-shortcut.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = process.electronBinding('global_shortcut').globalShortcut;

lib/browser/api/global-shortcut.ts

@@ -0,0 +1 @@
+export default process.electronBinding('global_shortcut').globalShortcut;

lib/browser/api/in-app-purchase.ts

@@ -1,22 +1,24 @@
-'use strict';
+import { EventEmitter } from 'events';
 
-const { deprecate } = require('electron');
+let _inAppPurchase;
 
 if (process.platform === 'darwin') {
-  const { EventEmitter } = require('events');
   const { inAppPurchase, InAppPurchase } = process.electronBinding('in_app_purchase');
 
   // inAppPurchase is an EventEmitter.
   Object.setPrototypeOf(InAppPurchase.prototype, EventEmitter.prototype);
   EventEmitter.call(inAppPurchase);
 
-  module.exports = inAppPurchase;
+  _inAppPurchase = inAppPurchase;
 } else {
-  module.exports = {
-    purchaseProduct: (productID, quantity, callback) => {
+  _inAppPurchase = new EventEmitter();
+  Object.assign(_inAppPurchase, {
+    purchaseProduct: () => {
       throw new Error('The inAppPurchase module can only be used on macOS');
     },
     canMakePayments: () => false,
     getReceiptURL: () => ''
-  };
+  });
 }
+
+export default _inAppPurchase;

lib/browser/api/menu-item-roles.js

@@ -10,7 +10,8 @@ const roles = {
   about: {
     get label () {
       return isLinux ? 'About' : `About ${app.name}`;
-    }
+    },
+    ...(isWindows && { appMethod: 'showAboutPanel' })
   },
   close: {
     label: isMac ? 'Close Window' : 'Close',

lib/browser/api/notification.js

@@ -1,7 +0,0 @@
-'use strict';
-
-const { Notification, isSupported } = process.electronBinding('notification');
-
-Notification.isSupported = isSupported;
-
-module.exports = Notification;

lib/browser/api/notification.ts

@@ -0,0 +1,5 @@
+const { Notification: ElectronNotification, isSupported } = process.electronBinding('notification');
+
+ElectronNotification.isSupported = isSupported;
+
+export default ElectronNotification;

lib/browser/api/power-save-blocker.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = process.electronBinding('power_save_blocker').powerSaveBlocker;

lib/browser/api/power-save-blocker.ts

@@ -0,0 +1 @@
+export default process.electronBinding('power_save_blocker').powerSaveBlocker;

lib/browser/api/session.js

@@ -1,17 +0,0 @@
-'use strict';
-
-const { EventEmitter } = require('events');
-const { app, deprecate } = require('electron');
-const { fromPartition } = process.electronBinding('session');
-
-// Public API.
-Object.defineProperties(exports, {
-  defaultSession: {
-    enumerable: true,
-    get () { return fromPartition(''); }
-  },
-  fromPartition: {
-    enumerable: true,
-    value: fromPartition
-  }
-});

lib/browser/api/session.ts

@@ -0,0 +1,8 @@
+const { fromPartition } = process.electronBinding('session');
+
+export default {
+  fromPartition,
+  get defaultSession () {
+    return fromPartition('');
+  }
+};

lib/browser/api/tray.ts

@@ -1,5 +1,3 @@
-'use strict';
-
 const { Tray } = process.electronBinding('tray');
 
-module.exports = Tray;
+export default Tray;

lib/browser/api/view.ts

@@ -1,5 +1,3 @@
-'use strict';
-
 const { View } = process.electronBinding('view');
 
-module.exports = View;
+export default View;

lib/browser/api/views/image-view.ts

@@ -1,8 +1,7 @@
-const electron = require('electron');
+import { View } from 'electron';
 
-const { View } = electron;
 const { ImageView } = process.electronBinding('image_view');
 
 Object.setPrototypeOf(ImageView.prototype, View.prototype);
 
-module.exports = ImageView;
+export default ImageView;

lib/browser/api/web-contents-view.ts

@@ -1,10 +1,7 @@
-'use strict';
+import { View } from 'electron';
 
-const electron = require('electron');
-
-const { View } = electron;
 const { WebContentsView } = process.electronBinding('web_contents_view');
 
 Object.setPrototypeOf(WebContentsView.prototype, View.prototype);
 
-module.exports = WebContentsView;
+export default WebContentsView;

lib/browser/desktop-capturer.ts

@@ -1,4 +1,4 @@
-const { createDesktopCapturer } = process.electronBinding('desktop_capturer');
+const { createDesktopCapturer, getMediaSourceIdForWebContents: getMediaSourceIdForWebContentsBinding } = process.electronBinding('desktop_capturer');
 
 const deepEqual = (a: ElectronInternal.GetSourcesOptions, b: ElectronInternal.GetSourcesOptions) => JSON.stringify(a) === JSON.stringify(b);
 
@@ -77,3 +77,7 @@ export const getSourcesImpl = (event: Electron.IpcMainEvent | null, args: Electr
 
   return getSources;
 };
+
+export const getMediaSourceIdForWebContents = (event: Electron.IpcMainEvent, webContentsId: number) => {
+  return getMediaSourceIdForWebContentsBinding(event.sender.id, webContentsId);
+};

lib/browser/remote/objects-registry.ts

@@ -51,19 +51,11 @@ class ObjectsRegistry {
   // Dereference an object according to its ID.
   // Note that an object may be double-freed (cleared when page is reloaded, and
   // then garbage collected in old page).
-  // rendererSideRefCount is the ref count that the renderer process reported
-  // at time of GC if this is different to the number of references we sent to
-  // the given owner then a GC occurred between a ref being sent and the value
-  // being pulled out of the weak map.
-  // In this case we decrement out ref count and do not delete the stored
-  // object
-  // For more details on why we do renderer side ref counting see
-  // https://github.com/electron/electron/pull/17464
-  remove (webContents: WebContents, contextId: string, id: number, rendererSideRefCount: number) {
+  remove (webContents: WebContents, contextId: string, id: number) {
     const ownerKey = getOwnerKey(webContents, contextId);
     const owner = this.owners[ownerKey];
     if (owner && owner.has(id)) {
-      const newRefCount = owner.get(id)! - rendererSideRefCount;
+      const newRefCount = owner.get(id)! - 1;
 
       // Only completely remove if the number of references GCed in the
       // renderer is the same as the number of references we sent them

lib/browser/remote/server.ts

@@ -1,15 +1,14 @@
-'use strict';
-
 import * as electron from 'electron';
 import { EventEmitter } from 'events';
 import objectsRegistry from './objects-registry';
 import { ipcMainInternal } from '../ipc-main-internal';
-import { isPromise, isSerializableObject } from '@electron/internal/common/type-utils';
-import { Size } from 'electron/main';
+import { isPromise, isSerializableObject, deserialize, serialize } from '../../common/type-utils';
+import type { MetaTypeFromRenderer, ObjectMember, MetaType, ObjProtoDescriptor } from '../../common/remote/types';
 
 const v8Util = process.electronBinding('v8_util');
 const eventBinding = process.electronBinding('event');
 const features = process.electronBinding('features');
+const { NativeImage } = process.electronBinding('native_image');
 
 if (!features.isRemoteModuleEnabled()) {
   throw new Error('remote module is disabled');
@@ -26,14 +25,6 @@ const FUNCTION_PROPERTIES = [
 // id => Function
 const rendererFunctions = v8Util.createDoubleIDWeakMap<(...args: any[]) => void>();
 
-type ObjectMember = {
-  name: string,
-  value?: any,
-  enumerable?: boolean,
-  writable?: boolean,
-  type?: 'method' | 'get'
-}
-
 // Return the description of object's members:
 const getObjectMembers = function (object: any): ObjectMember[] {
   let names = Object.getOwnPropertyNames(object);
@@ -59,11 +50,6 @@ const getObjectMembers = function (object: any): ObjectMember[] {
   });
 };
 
-type ObjProtoDescriptor = {
-  members: ObjectMember[],
-  proto: ObjProtoDescriptor
-} | null
-
 // Return the description of object's prototype.
 const getObjectPrototype = function (object: any): ObjProtoDescriptor {
   const proto = Object.getPrototypeOf(object);
@@ -74,71 +60,42 @@ const getObjectPrototype = function (object: any): ObjProtoDescriptor {
   };
 };
 
-type MetaType = {
-  type: 'number',
-  value: number
-} | {
-  type: 'boolean',
-  value: boolean
-} | {
-  type: 'string',
-  value: string
-} | {
-  type: 'bigint',
-  value: bigint
-} | {
-  type: 'symbol',
-  value: symbol
-} | {
-  type: 'undefined',
-  value: undefined
-} | {
-  type: 'object' | 'function',
-  name: string,
-  members: ObjectMember[],
-  proto: ObjProtoDescriptor,
-  id: number,
-} | {
-  type: 'value',
-  value: any,
-} | {
-  type: 'buffer',
-  value: Uint8Array,
-} | {
-  type: 'array',
-  members: MetaType[]
-} | {
-  type: 'error',
-  value: Error,
-  members: ObjectMember[]
-} | {
-  type: 'promise',
-  then: MetaType
-}
-
 // Convert a real value into meta data.
 const valueToMeta = function (sender: electron.WebContents, contextId: string, value: any, optimizeSimpleObject = false): MetaType {
   // Determine the type of value.
-  let type: MetaType['type'] = typeof value;
-  if (type === 'object') {
-    // Recognize certain types of objects.
-    if (value instanceof Buffer) {
-      type = 'buffer';
-    } else if (Array.isArray(value)) {
-      type = 'array';
-    } else if (value instanceof Error) {
-      type = 'error';
-    } else if (isSerializableObject(value)) {
+  let type: MetaType['type'];
+
+  switch (typeof value) {
+    case 'object':
+      // Recognize certain types of objects.
+      if (value instanceof Buffer) {
+        type = 'buffer';
+      } else if (value instanceof NativeImage) {
+        type = 'nativeimage';
+      } else if (Array.isArray(value)) {
+        type = 'array';
+      } else if (value instanceof Error) {
+        type = 'error';
+      } else if (isSerializableObject(value)) {
+        type = 'value';
+      } else if (isPromise(value)) {
+        type = 'promise';
+      } else if (hasProp.call(value, 'callee') && value.length != null) {
+        // Treat the arguments object as array.
+        type = 'array';
+      } else if (optimizeSimpleObject && v8Util.getHiddenValue(value, 'simple')) {
+        // Treat simple objects as value.
+        type = 'value';
+      } else {
+        type = 'object';
+      }
+      break;
+    case 'function':
+      type = 'function';
+      break;
+    default:
       type = 'value';
-    } else if (isPromise(value)) {
-      type = 'promise';
-    } else if (hasProp.call(value, 'callee') && value.length != null) {
-      // Treat the arguments object as array.
-      type = 'array';
-    } else if (optimizeSimpleObject && v8Util.getHiddenValue(value, 'simple')) {
-      // Treat simple objects as value.
-      type = 'value';
-    }
+      break;
   }
 
   // Fill the meta object according to value's type.
@@ -147,6 +104,8 @@ const valueToMeta = function (sender: electron.WebContents, contextId: string, v
       type,
       members: value.map((el: any) => valueToMeta(sender, contextId, el, optimizeSimpleObject))
     };
+  } else if (type === 'nativeimage') {
+    return { type, value: serialize(value) };
   } else if (type === 'object' || type === 'function') {
     return {
       type,
@@ -216,38 +175,6 @@ const removeRemoteListenersAndLogWarning = (sender: any, callIntoRenderer: (...a
   console.warn(message);
 };
 
-type MetaTypeFromRenderer = {
-  type: 'value',
-  value: any
-} | {
-  type: 'remote-object',
-  id: number
-} | {
-  type: 'array',
-  value: MetaTypeFromRenderer[]
-} | {
-  type: 'buffer',
-  value: Uint8Array
-} | {
-  type: 'promise',
-  then: MetaTypeFromRenderer
-} | {
-  type: 'object',
-  name: string,
-  members: { name: string, value: MetaTypeFromRenderer }[]
-} | {
-  type: 'function-with-return-value',
-  value: MetaTypeFromRenderer
-} | {
-  type: 'function',
-  id: number,
-  location: string,
-  length: number
-} | {
-  type: 'nativeimage',
-  value: { size: Size, buffer: Buffer, scaleFactor: number, dataURL: string }[]
-}
-
 const fakeConstructor = (constructor: Function, name: string) =>
   new Proxy(Object, {
     get (target, prop, receiver) {
@@ -263,15 +190,8 @@ const fakeConstructor = (constructor: Function, name: string) =>
 const unwrapArgs = function (sender: electron.WebContents, frameId: number, contextId: string, args: any[]) {
   const metaToValue = function (meta: MetaTypeFromRenderer): any {
     switch (meta.type) {
-      case 'nativeimage': {
-        const image = electron.nativeImage.createEmpty();
-        for (const rep of meta.value) {
-          const { size, scaleFactor, dataURL } = rep;
-          const { width, height } = size;
-          image.addRepresentation({ dataURL, scaleFactor, width, height });
-        }
-        return image;
-      }
+      case 'nativeimage':
+        return deserialize(meta.value);
       case 'value':
         return meta.value;
       case 'remote-object':
@@ -340,7 +260,7 @@ const isRemoteModuleEnabledImpl = function (contents: electron.WebContents) {
 
 const isRemoteModuleEnabledCache = new WeakMap();
 
-const isRemoteModuleEnabled = function (contents: electron.WebContents) {
+export const isRemoteModuleEnabled = function (contents: electron.WebContents) {
   if (!isRemoteModuleEnabledCache.has(contents)) {
     isRemoteModuleEnabledCache.set(contents, isRemoteModuleEnabledImpl(contents));
   }
@@ -548,14 +468,10 @@ handleRemoteCommand('ELECTRON_BROWSER_MEMBER_GET', function (event, contextId, i
   return valueToMeta(event.sender, contextId, obj[name]);
 });
 
-handleRemoteCommand('ELECTRON_BROWSER_DEREFERENCE', function (event, contextId, id, rendererSideRefCount) {
-  objectsRegistry.remove(event.sender, contextId, id, rendererSideRefCount);
+handleRemoteCommand('ELECTRON_BROWSER_DEREFERENCE', function (event, contextId, id) {
+  objectsRegistry.remove(event.sender, contextId, id);
 });
 
 handleRemoteCommand('ELECTRON_BROWSER_CONTEXT_RELEASE', (event, contextId) => {
   objectsRegistry.clear(event.sender, contextId);
 });
-
-module.exports = {
-  isRemoteModuleEnabled
-};

lib/browser/rpc-server.js

@@ -73,6 +73,10 @@ if (BUILDFLAG(ENABLE_DESKTOP_CAPTURER)) {
 
     return typeUtils.serialize(await desktopCapturer.getSourcesImpl(event, options));
   });
+
+  ipcMainInternal.handle('ELECTRON_BROWSER_DESKTOP_CAPTURER_GET_MEDIA_SOURCE_ID_FOR_WEB_CONTENTS', function (event, webContentsId, stack) {
+    return desktopCapturer.getMediaSourceIdForWebContents(event, webContentsId);
+  });
 }
 
 const isRemoteModuleEnabled = BUILDFLAG(ENABLE_REMOTE_MODULE)

lib/common/api/clipboard.ts

@@ -1,13 +1,11 @@
-'use strict';
-
 const clipboard = process.electronBinding('clipboard');
 
 if (process.type === 'renderer') {
   const ipcRendererUtils = require('@electron/internal/renderer/ipc-renderer-internal-utils');
   const typeUtils = require('@electron/internal/common/type-utils');
 
-  const makeRemoteMethod = function (method) {
-    return (...args) => {
+  const makeRemoteMethod = function (method: keyof Electron.Clipboard) {
+    return (...args: any[]) => {
       args = typeUtils.serialize(args);
       const result = ipcRendererUtils.invokeSync('ELECTRON_BROWSER_CLIPBOARD_SYNC', method, ...args);
       return typeUtils.deserialize(result);
@@ -16,7 +14,7 @@ if (process.type === 'renderer') {
 
   if (process.platform === 'linux') {
     // On Linux we could not access clipboard in renderer process.
-    for (const method of Object.keys(clipboard)) {
+    for (const method of Object.keys(clipboard) as (keyof Electron.Clipboard)[]) {
       clipboard[method] = makeRemoteMethod(method);
     }
   } else if (process.platform === 'darwin') {
@@ -26,4 +24,4 @@ if (process.type === 'renderer') {
   }
 }
 
-module.exports = clipboard;
+export default clipboard;

lib/common/api/native-image.ts

@@ -1,5 +1,3 @@
-'use strict';
-
 const { nativeImage } = process.electronBinding('native_image');
 
-module.exports = nativeImage;
+export default nativeImage;

lib/common/api/shell.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = process.electronBinding('shell');

lib/common/api/shell.ts

@@ -0,0 +1 @@
+export default process.electronBinding('shell');

lib/common/remote/types.ts

@@ -0,0 +1,85 @@
+import type { Size } from 'electron/main';
+import type { NativeImage } from 'electron/common';
+
+export type ObjectMember = {
+  name: string,
+  value?: any,
+  enumerable?: boolean,
+  writable?: boolean,
+  type?: 'method' | 'get'
+}
+
+export type ObjProtoDescriptor = {
+  members: ObjectMember[],
+  proto: ObjProtoDescriptor
+} | null
+
+export type MetaType = {
+  type: 'object' | 'function',
+  name: string,
+  members: ObjectMember[],
+  proto: ObjProtoDescriptor,
+  id: number,
+} | {
+  type: 'value',
+  value: any,
+} | {
+  type: 'buffer',
+  value: Uint8Array,
+} | {
+  type: 'array',
+  members: MetaType[]
+} | {
+  type: 'error',
+  value: Error,
+  members: ObjectMember[]
+} | {
+  type: 'exception',
+  value: MetaType,
+} | {
+  type: 'promise',
+  then: MetaType
+} | {
+  type: 'nativeimage'
+  value: NativeImage
+}
+
+export type MetaTypeFromRenderer = {
+  type: 'value',
+  value: any
+} | {
+  type: 'remote-object',
+  id: number
+} | {
+  type: 'array',
+  value: MetaTypeFromRenderer[]
+} | {
+  type: 'buffer',
+  value: Uint8Array
+} | {
+  type: 'promise',
+  then: MetaTypeFromRenderer
+} | {
+  type: 'object',
+  name: string,
+  members: {
+    name: string,
+    value: MetaTypeFromRenderer
+  }[]
+} | {
+  type: 'function-with-return-value',
+  value: MetaTypeFromRenderer
+} | {
+  type: 'function',
+  id: number,
+  location: string,
+  length: number
+} | {
+  type: 'nativeimage',
+  value: {
+    size: Size,
+    buffer: Buffer,
+    scaleFactor: number,
+    dataURL: string
+  }[]
+}

lib/common/type-utils.ts

@@ -20,10 +20,10 @@ const serializableTypes = [
   Date,
   Error,
   RegExp,
-  ArrayBuffer,
-  NativeImage
+  ArrayBuffer
 ];
 
+// https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm#Supported_types
 export function isSerializableObject (value: any) {
   return value === null || ArrayBuffer.isView(value) || serializableTypes.some(type => value instanceof type);
 }
@@ -34,18 +34,55 @@ const objectMap = function (source: Object, mapper: (value: any) => any) {
   return Object.fromEntries(targetEntries);
 };
 
-export function serialize (value: any): any {
-  if (value instanceof NativeImage) {
-    const representations = [];
-    for (const scaleFactor of value.getScaleFactors()) {
-      const size = value.getSize(scaleFactor);
-      const dataURL = value.toDataURL({ scaleFactor });
+function serializeNativeImage (image: any) {
+  const representations = [];
+  const scaleFactors = image.getScaleFactors();
+
+  // Use Buffer when there's only one representation for better perf.
+  // This avoids compressing to/from PNG where it's not necessary to
+  // ensure uniqueness of dataURLs (since there's only one).
+  if (scaleFactors.length === 1) {
+    const scaleFactor = scaleFactors[0];
+    const size = image.getSize(scaleFactor);
+    const buffer = image.toBitmap({ scaleFactor });
+    representations.push({ scaleFactor, size, buffer });
+  } else {
+    // Construct from dataURLs to ensure that they are not lost in creation.
+    for (const scaleFactor of scaleFactors) {
+      const size = image.getSize(scaleFactor);
+      const dataURL = image.toDataURL({ scaleFactor });
       representations.push({ scaleFactor, size, dataURL });
     }
-    return { __ELECTRON_SERIALIZED_NativeImage__: true, representations };
-  } else if (value instanceof Buffer) {
-    return { __ELECTRON_SERIALIZED_Buffer__: true, data: value };
-  } else if (Array.isArray(value)) {
+  }
+  return { __ELECTRON_SERIALIZED_NativeImage__: true, representations };
+}
+
+function deserializeNativeImage (value: any) {
+  const image = nativeImage.createEmpty();
+
+  // Use Buffer when there's only one representation for better perf.
+  // This avoids compressing to/from PNG where it's not necessary to
+  // ensure uniqueness of dataURLs (since there's only one).
+  if (value.representations.length === 1) {
+    const { buffer, size, scaleFactor } = value.representations[0];
+    const { width, height } = size;
+    image.addRepresentation({ buffer, scaleFactor, width, height });
+  } else {
+    // Construct from dataURLs to ensure that they are not lost in creation.
+    for (const rep of value.representations) {
+      const { dataURL, size, scaleFactor } = rep;
+      const { width, height } = size;
+      image.addRepresentation({ dataURL, scaleFactor, width, height });
+    }
+  }
+
+  return image;
+}
+
+export function serialize (value: any): any {
+  if (value instanceof NativeImage) {
+    return serializeNativeImage(value);
+  } if (Array.isArray(value)) {
     return value.map(serialize);
   } else if (isSerializableObject(value)) {
     return value;
@@ -58,16 +95,7 @@ export function serialize (value: any): any {
 
 export function deserialize (value: any): any {
   if (value && value.__ELECTRON_SERIALIZED_NativeImage__) {
-    const image = nativeImage.createEmpty();
-    for (const rep of value.representations) {
-      const { size, scaleFactor, dataURL } = rep;
-      const { width, height } = size;
-      image.addRepresentation({ dataURL, scaleFactor, width, height });
-    }
-    return image;
-  } else if (value && value.__ELECTRON_SERIALIZED_Buffer__) {
-    const { buffer, byteOffset, byteLength } = value.data;
-    return Buffer.from(buffer, byteOffset, byteLength);
+    return deserializeNativeImage(value);
   } else if (Array.isArray(value)) {
     return value.map(deserialize);
   } else if (isSerializableObject(value)) {

lib/renderer/api/desktop-capturer.ts

@@ -16,3 +16,7 @@ function getCurrentStack () {
 export async function getSources (options: Electron.SourcesOptions) {
   return deserialize(await ipcRendererInternal.invoke('ELECTRON_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', options, getCurrentStack()));
 }
+
+export function getMediaSourceIdForWebContents (webContentsId: number) {
+  return ipcRendererInternal.invoke<string>('ELECTRON_BROWSER_DESKTOP_CAPTURER_GET_MEDIA_SOURCE_ID_FOR_WEB_CONTENTS', webContentsId, getCurrentStack());
+}

lib/renderer/api/ipc-renderer.ts

@@ -1,39 +1,36 @@
-const { ipc } = process.electronBinding('ipc');
-const v8Util = process.electronBinding('v8_util');
+import { EventEmitter } from 'events';
+
+const { ipc } = process.electronBinding('ipc');
 
-// Created by init.js.
-const ipcRenderer = v8Util.getHiddenValue<Electron.IpcRenderer>(global, 'ipc');
 const internal = false;
 
-// TODO(MarshallOfSound): Remove if statement when isolated_bundle and content_script_bundle are gone
-if (!ipcRenderer.send) {
-  ipcRenderer.send = function (channel, ...args) {
-    return ipc.send(internal, channel, args);
-  };
+const ipcRenderer = new EventEmitter() as Electron.IpcRenderer;
+ipcRenderer.send = function (channel, ...args) {
+  return ipc.send(internal, channel, args);
+};
 
-  ipcRenderer.sendSync = function (channel, ...args) {
-    return ipc.sendSync(internal, channel, args)[0];
-  };
+ipcRenderer.sendSync = function (channel, ...args) {
+  return ipc.sendSync(internal, channel, args)[0];
+};
 
-  ipcRenderer.sendToHost = function (channel, ...args) {
-    return ipc.sendToHost(channel, args);
-  };
+ipcRenderer.sendToHost = function (channel, ...args) {
+  return ipc.sendToHost(channel, args);
+};
 
-  ipcRenderer.sendTo = function (webContentsId, channel, ...args) {
-    return ipc.sendTo(internal, false, webContentsId, channel, args);
-  };
+ipcRenderer.sendTo = function (webContentsId, channel, ...args) {
+  return ipc.sendTo(internal, false, webContentsId, channel, args);
+};
 
-  ipcRenderer.invoke = async function (channel, ...args) {
-    const { error, result } = await ipc.invoke(internal, channel, args);
-    if (error) {
-      throw new Error(`Error invoking remote method '${channel}': ${error}`);
-    }
-    return result;
-  };
+ipcRenderer.invoke = async function (channel, ...args) {
+  const { error, result } = await ipc.invoke(internal, channel, args);
+  if (error) {
+    throw new Error(`Error invoking remote method '${channel}': ${error}`);
+  }
+  return result;
+};
 
-  ipcRenderer.postMessage = function (channel: string, message: any, transferables: any) {
-    return ipc.postMessage(channel, message, transferables);
-  };
-}
+ipcRenderer.postMessage = function (channel: string, message: any, transferables: any) {
+  return ipc.postMessage(channel, message, transferables);
+};
 
 export default ipcRenderer;

lib/renderer/api/remote.ts

@@ -1,18 +1,20 @@
-'use strict';
+import { CallbacksRegistry } from '../remote/callbacks-registry';
+import { isPromise, isSerializableObject, serialize, deserialize } from '../../common/type-utils';
+import { MetaTypeFromRenderer, ObjectMember, ObjProtoDescriptor, MetaType } from '../../common/remote/types';
+import { ipcRendererInternal } from '../ipc-renderer-internal';
+import type { BrowserWindow, WebContents } from 'electron/main';
+import { browserModuleNames } from '@electron/internal/browser/api/module-names';
+import { commonModuleList } from '@electron/internal/common/api/module-list';
 
 const v8Util = process.electronBinding('v8_util');
 const { hasSwitch } = process.electronBinding('command_line');
 const { NativeImage } = process.electronBinding('native_image');
 
-const { CallbacksRegistry } = require('@electron/internal/renderer/remote/callbacks-registry');
-const { isPromise, isSerializableObject } = require('@electron/internal/common/type-utils');
-const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal');
-
 const callbacksRegistry = new CallbacksRegistry();
 const remoteObjectCache = v8Util.createIDWeakMap();
 
 // An unique ID that can represent current context.
-const contextId = v8Util.getHiddenValue(global, 'contextId');
+const contextId = v8Util.getHiddenValue<string>(global, 'contextId');
 
 // Notify the main process when current context is going to be released.
 // Note that when the renderer process is destroyed, the message may not be
@@ -26,8 +28,8 @@ process.on('exit', () => {
 const IS_REMOTE_PROXY = Symbol('is-remote-proxy');
 
 // Convert the arguments object into an array of meta data.
-function wrapArgs (args, visited = new Set()) {
-  const valueToMeta = (value) => {
+function wrapArgs (args: any[], visited = new Set()): any {
+  const valueToMeta = (value: any): any => {
     // Check for circular reference.
     if (visited.has(value)) {
       return {
@@ -37,14 +39,7 @@ function wrapArgs (args, visited = new Set()) {
     }
 
     if (value instanceof NativeImage) {
-      const images = [];
-      for (const scaleFactor of value.getScaleFactors()) {
-        const size = value.getSize(scaleFactor);
-        const buffer = value.toBitmap({ scaleFactor });
-        const dataURL = value.toDataURL({ scaleFactor });
-        images.push({ buffer, scaleFactor, size, dataURL });
-      }
-      return { type: 'nativeimage', value: images };
+      return { type: 'nativeimage', value: serialize(value) };
     } else if (Array.isArray(value)) {
       visited.add(value);
       const meta = {
@@ -67,7 +62,7 @@ function wrapArgs (args, visited = new Set()) {
       if (isPromise(value)) {
         return {
           type: 'promise',
-          then: valueToMeta(function (onFulfilled, onRejected) {
+          then: valueToMeta(function (onFulfilled: Function, onRejected: Function) {
             value.then(onFulfilled, onRejected);
           })
         };
@@ -78,7 +73,7 @@ function wrapArgs (args, visited = new Set()) {
         };
       }
 
-      const meta = {
+      const meta: MetaTypeFromRenderer = {
         type: 'object',
         name: value.constructor ? value.constructor.name : '',
         members: []
@@ -117,15 +112,15 @@ function wrapArgs (args, visited = new Set()) {
 // Populate object's members from descriptors.
 // The |ref| will be kept referenced by |members|.
 // This matches |getObjectMemebers| in rpc-server.
-function setObjectMembers (ref, object, metaId, members) {
+function setObjectMembers (ref: any, object: any, metaId: number, members: ObjectMember[]) {
   if (!Array.isArray(members)) return;
 
   for (const member of members) {
     if (Object.prototype.hasOwnProperty.call(object, member.name)) continue;
 
-    const descriptor = { enumerable: member.enumerable };
+    const descriptor: PropertyDescriptor = { enumerable: member.enumerable };
     if (member.type === 'method') {
-      const remoteMemberFunction = function (...args) {
+      const remoteMemberFunction = function (this: any, ...args: any[]) {
         let command;
         if (this && this.constructor === remoteMemberFunction) {
           command = 'ELECTRON_BROWSER_MEMBER_CONSTRUCTOR';
@@ -172,7 +167,7 @@ function setObjectMembers (ref, object, metaId, members) {
 
 // Populate object's prototype from descriptor.
 // This matches |getObjectPrototype| in rpc-server.
-function setObjectPrototype (ref, object, metaId, descriptor) {
+function setObjectPrototype (ref: any, object: any, metaId: number, descriptor: ObjProtoDescriptor) {
   if (descriptor === null) return;
   const proto = {};
   setObjectMembers(ref, proto, metaId, descriptor.members);
@@ -181,7 +176,7 @@ function setObjectPrototype (ref, object, metaId, descriptor) {
 }
 
 // Wrap function in Proxy for accessing remote properties
-function proxyFunctionProperties (remoteMemberFunction, metaId, name) {
+function proxyFunctionProperties (remoteMemberFunction: Function, metaId: number, name: string) {
   let loaded = false;
 
   // Lazily load function properties
@@ -193,13 +188,13 @@ function proxyFunctionProperties (remoteMemberFunction, metaId, name) {
     setObjectMembers(remoteMemberFunction, remoteMemberFunction, meta.id, meta.members);
   };
 
-  return new Proxy(remoteMemberFunction, {
-    set: (target, property, value, receiver) => {
+  return new Proxy(remoteMemberFunction as any, {
+    set: (target, property, value) => {
       if (property !== 'ref') loadRemoteProperties();
       target[property] = value;
       return true;
     },
-    get: (target, property, receiver) => {
+    get: (target, property) => {
       if (property === IS_REMOTE_PROXY) return true;
       if (!Object.prototype.hasOwnProperty.call(target, property)) loadRemoteProperties();
       const value = target[property];
@@ -222,28 +217,30 @@ function proxyFunctionProperties (remoteMemberFunction, metaId, name) {
 }
 
 // Convert meta data from browser into real value.
-function metaToValue (meta) {
-  const types = {
-    value: () => meta.value,
-    array: () => meta.members.map((member) => metaToValue(member)),
-    buffer: () => Buffer.from(meta.value.buffer, meta.value.byteOffset, meta.value.byteLength),
-    promise: () => Promise.resolve({ then: metaToValue(meta.then) }),
-    error: () => metaToError(meta),
-    exception: () => { throw metaToError(meta.value); }
-  };
-
-  if (Object.prototype.hasOwnProperty.call(types, meta.type)) {
-    return types[meta.type]();
+function metaToValue (meta: MetaType): any {
+  if (meta.type === 'value') {
+    return meta.value;
+  } else if (meta.type === 'array') {
+    return meta.members.map((member) => metaToValue(member));
+  } else if (meta.type === 'nativeimage') {
+    return deserialize(meta.value);
+  } else if (meta.type === 'buffer') {
+    return Buffer.from(meta.value.buffer, meta.value.byteOffset, meta.value.byteLength);
+  } else if (meta.type === 'promise') {
+    return Promise.resolve({ then: metaToValue(meta.then) });
+  } else if (meta.type === 'error') {
+    return metaToError(meta);
+  } else if (meta.type === 'exception') {
+    if (meta.value.type === 'error') { throw metaToError(meta.value); } else { throw new Error(`Unexpected value type in exception: ${meta.value.type}`); }
   } else {
     let ret;
-    if (remoteObjectCache.has(meta.id)) {
-      v8Util.addRemoteObjectRef(contextId, meta.id);
+    if ('id' in meta && remoteObjectCache.has(meta.id)) {
       return remoteObjectCache.get(meta.id);
     }
 
     // A shadow class to represent the remote function object.
     if (meta.type === 'function') {
-      const remoteFunction = function (...args) {
+      const remoteFunction = function (this: any, ...args: any[]) {
         let command;
         if (this && this.constructor === remoteFunction) {
           command = 'ELECTRON_BROWSER_CONSTRUCTOR';
@@ -260,20 +257,19 @@ function metaToValue (meta) {
 
     setObjectMembers(ret, ret, meta.id, meta.members);
     setObjectPrototype(ret, ret, meta.id, meta.proto);
-    if (ret.constructor && ret.constructor[IS_REMOTE_PROXY]) {
+    if (ret.constructor && (ret.constructor as any)[IS_REMOTE_PROXY]) {
       Object.defineProperty(ret.constructor, 'name', { value: meta.name });
     }
 
     // Track delegate obj's lifetime & tell browser to clean up when object is GCed.
     v8Util.setRemoteObjectFreer(ret, contextId, meta.id);
     v8Util.setHiddenValue(ret, 'electronId', meta.id);
-    v8Util.addRemoteObjectRef(contextId, meta.id);
     remoteObjectCache.set(meta.id, ret);
     return ret;
   }
 }
 
-function metaToError (meta) {
+function metaToError (meta: { type: 'error', value: any, members: ObjectMember[] }) {
   const obj = meta.value;
   for (const { name, value } of meta.members) {
     obj[name] = metaToValue(value);
@@ -281,7 +277,7 @@ function metaToError (meta) {
   return obj;
 }
 
-function handleMessage (channel, handler) {
+function handleMessage (channel: string, handler: Function) {
   ipcRendererInternal.on(channel, (event, passedContextId, id, ...args) => {
     if (passedContextId === contextId) {
       handler(id, ...args);
@@ -294,8 +290,8 @@ function handleMessage (channel, handler) {
 
 const enableStacks = hasSwitch('enable-api-filtering-logging');
 
-function getCurrentStack () {
-  const target = {};
+function getCurrentStack (): string | undefined {
+  const target = { stack: undefined as string | undefined };
   if (enableStacks) {
     Error.captureStackTrace(target, getCurrentStack);
   }
@@ -303,47 +299,47 @@ function getCurrentStack () {
 }
 
 // Browser calls a callback in renderer.
-handleMessage('ELECTRON_RENDERER_CALLBACK', (id, args) => {
+handleMessage('ELECTRON_RENDERER_CALLBACK', (id: number, args: any) => {
   callbacksRegistry.apply(id, metaToValue(args));
 });
 
 // A callback in browser is released.
-handleMessage('ELECTRON_RENDERER_RELEASE_CALLBACK', (id) => {
+handleMessage('ELECTRON_RENDERER_RELEASE_CALLBACK', (id: number) => {
   callbacksRegistry.remove(id);
 });
 
-exports.require = (module) => {
+exports.require = (module: string) => {
   const command = 'ELECTRON_BROWSER_REQUIRE';
   const meta = ipcRendererInternal.sendSync(command, contextId, module, getCurrentStack());
   return metaToValue(meta);
 };
 
 // Alias to remote.require('electron').xxx.
-exports.getBuiltin = (module) => {
+export function getBuiltin (module: string) {
   const command = 'ELECTRON_BROWSER_GET_BUILTIN';
   const meta = ipcRendererInternal.sendSync(command, contextId, module, getCurrentStack());
   return metaToValue(meta);
-};
+}
 
-exports.getCurrentWindow = () => {
+export function getCurrentWindow (): BrowserWindow {
   const command = 'ELECTRON_BROWSER_CURRENT_WINDOW';
   const meta = ipcRendererInternal.sendSync(command, contextId, getCurrentStack());
   return metaToValue(meta);
-};
+}
 
 // Get current WebContents object.
-exports.getCurrentWebContents = () => {
+export function getCurrentWebContents (): WebContents {
   const command = 'ELECTRON_BROWSER_CURRENT_WEB_CONTENTS';
   const meta = ipcRendererInternal.sendSync(command, contextId, getCurrentStack());
   return metaToValue(meta);
-};
+}
 
 // Get a global object in browser.
-exports.getGlobal = (name) => {
+export function getGlobal<T = any> (name: string): T {
   const command = 'ELECTRON_BROWSER_GLOBAL';
   const meta = ipcRendererInternal.sendSync(command, contextId, name, getCurrentStack());
   return metaToValue(meta);
-};
+}
 
 // Get the process object in browser.
 Object.defineProperty(exports, 'process', {
@@ -351,22 +347,19 @@ Object.defineProperty(exports, 'process', {
 });
 
 // Create a function that will return the specified value when called in browser.
-exports.createFunctionWithReturnValue = (returnValue) => {
+export function createFunctionWithReturnValue<T> (returnValue: T): () => T {
   const func = () => returnValue;
   v8Util.setHiddenValue(func, 'returnValue', true);
   return func;
-};
+}
 
-const addBuiltinProperty = (name) => {
+const addBuiltinProperty = (name: string) => {
   Object.defineProperty(exports, name, {
     get: () => exports.getBuiltin(name)
   });
 };
 
-const { commonModuleList } = require('@electron/internal/common/api/module-list');
-const { browserModuleNames } = require('@electron/internal/browser/api/module-names');
-
-const browserModules = commonModuleList.concat(browserModuleNames.map(name => ({ name })));
+const browserModules = commonModuleList.concat(browserModuleNames.map(name => ({ name, loader: () => {} })));
 
 // And add a helper receiver for each one.
 browserModules

lib/renderer/init.ts

@@ -1,4 +1,3 @@
-import { EventEmitter } from 'events';
 import * as path from 'path';
 
 const Module = require('module');
@@ -39,20 +38,17 @@ require('@electron/internal/common/init');
 // The global variable will be used by ipc for event dispatching
 const v8Util = process.electronBinding('v8_util');
 
-const ipcEmitter = new EventEmitter();
-const ipcInternalEmitter = new EventEmitter();
-v8Util.setHiddenValue(global, 'ipc', ipcEmitter);
-v8Util.setHiddenValue(global, 'ipc-internal', ipcInternalEmitter);
+const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal');
+const ipcRenderer = require('@electron/internal/renderer/api/ipc-renderer').default;
 
 v8Util.setHiddenValue(global, 'ipcNative', {
   onMessage (internal: boolean, channel: string, ports: any[], args: any[], senderId: number) {
-    const sender = internal ? ipcInternalEmitter : ipcEmitter;
+    const sender = internal ? ipcRendererInternal : ipcRenderer;
     sender.emit(channel, { sender, senderId, ports }, ...args);
   }
 });
 
 // Use electron module after everything is ready.
-const { ipcRendererInternal } = require('@electron/internal/renderer/ipc-renderer-internal');
 const { webFrameInit } = require('@electron/internal/renderer/web-frame-init');
 webFrameInit();
 
@@ -84,9 +80,6 @@ const appPath = parseOption('app-path', null);
 const guestInstanceId = parseOption('guest-instance-id', null, value => parseInt(value));
 const openerId = parseOption('opener-id', null, value => parseInt(value));
 
-// The arguments to be passed to isolated world.
-const isolatedWorldArgs = { ipcRendererInternal, guestInstanceId, isHiddenPage, openerId, usesNativeWindowOpen, rendererProcessReuseEnabled };
-
 // The webContents preload script is loaded after the session preload scripts.
 if (preloadScript) {
   preloadScripts.push(preloadScript);
@@ -116,11 +109,6 @@ if (process.isMainFrame) {
   webViewInit(contextIsolation, webviewTag, guestInstanceId);
 }
 
-// Pass the arguments to isolatedWorld.
-if (contextIsolation) {
-  v8Util.setHiddenValue(global, 'isolated-world-args', isolatedWorldArgs);
-}
-
 if (nodeIntegration) {
   // Export node bindings to global.
   const { makeRequireFunction } = __non_webpack_require__('internal/modules/cjs/helpers') // eslint-disable-line

lib/renderer/ipc-renderer-internal.ts

@@ -1,33 +1,32 @@
-const { ipc } = process.electronBinding('ipc');
-const v8Util = process.electronBinding('v8_util');
+import { EventEmitter } from 'events';
+
+const { ipc } = process.electronBinding('ipc');
 
-// Created by init.js.
-export const ipcRendererInternal = v8Util.getHiddenValue<Electron.IpcRendererInternal>(global, 'ipc-internal');
 const internal = true;
 
-// TODO(MarshallOfSound): Remove if statement when isolated_bundle and content_script_bundle are gone
-if (!ipcRendererInternal.send) {
-  ipcRendererInternal.send = function (channel, ...args) {
-    return ipc.send(internal, channel, args);
-  };
+const ipcRendererInternal = new EventEmitter() as any as Electron.IpcRendererInternal;
+ipcRendererInternal.send = function (channel, ...args) {
+  return ipc.send(internal, channel, args);
+};
 
-  ipcRendererInternal.sendSync = function (channel, ...args) {
-    return ipc.sendSync(internal, channel, args)[0];
-  };
+ipcRendererInternal.sendSync = function (channel, ...args) {
+  return ipc.sendSync(internal, channel, args)[0];
+};
 
-  ipcRendererInternal.sendTo = function (webContentsId, channel, ...args) {
-    return ipc.sendTo(internal, false, webContentsId, channel, args);
-  };
+ipcRendererInternal.sendTo = function (webContentsId, channel, ...args) {
+  return ipc.sendTo(internal, false, webContentsId, channel, args);
+};
 
-  ipcRendererInternal.sendToAll = function (webContentsId, channel, ...args) {
-    return ipc.sendTo(internal, true, webContentsId, channel, args);
-  };
+ipcRendererInternal.sendToAll = function (webContentsId, channel, ...args) {
+  return ipc.sendTo(internal, true, webContentsId, channel, args);
+};
 
-  ipcRendererInternal.invoke = async function<T> (channel: string, ...args: any[]) {
-    const { error, result } = await ipc.invoke<T>(internal, channel, args);
-    if (error) {
-      throw new Error(`Error invoking remote method '${channel}': ${error}`);
-    }
-    return result;
-  };
-}
+ipcRendererInternal.invoke = async function<T> (channel: string, ...args: any[]) {
+  const { error, result } = await ipc.invoke<T>(internal, channel, args);
+  if (error) {
+    throw new Error(`Error invoking remote method '${channel}': ${error}`);
+  }
+  return result;
+};
+
+export { ipcRendererInternal };

lib/renderer/window-setup.ts

@@ -125,7 +125,11 @@ class LocationProxy {
   }
 
   private getGuestURL (): URL | null {
-    const urlString = this._invokeWebContentsMethodSync('getURL') as string;
+    const maybeURL = this._invokeWebContentsMethodSync('getURL') as string;
+
+    // When there's no previous frame the url will be blank, so accountfor that here
+    // to prevent url parsing errors on an empty string.
+    const urlString = maybeURL !== '' ? maybeURL : 'about:blank';
     try {
       return new URL(urlString);
     } catch (e) {

lib/sandboxed_renderer/init.ts

@@ -1,25 +1,19 @@
-'use strict';
-
 /* eslint no-eval: "off" */
 /* global binding, Buffer */
-const events = require('events');
+import { electronBindingSetup } from '@electron/internal/common/electron-binding-setup';
+import * as events from 'events';
+
 const { EventEmitter } = events;
 
-process.electronBinding = require('@electron/internal/common/electron-binding-setup').electronBindingSetup(binding.get, 'renderer');
+process.electronBinding = electronBindingSetup(binding.get, 'renderer');
 
 const v8Util = process.electronBinding('v8_util');
 // Expose Buffer shim as a hidden value. This is used by C++ code to
 // deserialize Buffer instances sent from browser process.
 v8Util.setHiddenValue(global, 'Buffer', Buffer);
-// The `lib/renderer/api/ipc-renderer.ts` module looks for the ipc object in the
-// "ipc" hidden value
-v8Util.setHiddenValue(global, 'ipc', new EventEmitter());
-// The `lib/renderer/ipc-renderer-internal.ts` module looks for the ipc object in the
-// "ipc-internal" hidden value
-v8Util.setHiddenValue(global, 'ipc-internal', new EventEmitter());
 // The process object created by webpack is not an event emitter, fix it so
 // the API is more compatible with non-sandboxed renderers.
-for (const prop of Object.keys(EventEmitter.prototype)) {
+for (const prop of Object.keys(EventEmitter.prototype) as (keyof typeof process)[]) {
   if (Object.prototype.hasOwnProperty.call(process, prop)) {
     delete process[prop];
   }
@@ -43,17 +37,22 @@ process.isRemoteModuleEnabled = isRemoteModuleEnabled;
 // The electron module depends on process.electronBinding
 const electron = require('electron');
 
-const loadedModules = new Map([
+const loadedModules = new Map<string, any>([
   ['electron', electron],
-  ['events', events],
-  ['timers', require('timers')],
-  ['url', require('url')]
+  ['electron/common', electron],
+  ['electron/renderer', electron],
+  ['events', events]
+]);
+
+const loadableModules = new Map<string, Function>([
+  ['timers', () => require('timers')],
+  ['url', () => require('url')]
 ]);
 
 // ElectronApiServiceImpl will look for the "ipcNative" hidden object when
 // invoking the 'onMessage' callback.
 v8Util.setHiddenValue(global, 'ipcNative', {
-  onMessage (internal, channel, ports, args, senderId) {
+  onMessage (internal: boolean, channel: string, ports: MessagePort[], args: any[], senderId: number) {
     const sender = internal ? ipcRendererInternal : electron.ipcRenderer;
     sender.emit(channel, { sender, senderId, ports }, ...args);
   }
@@ -62,16 +61,16 @@ v8Util.setHiddenValue(global, 'ipcNative', {
 // ElectronSandboxedRendererClient will look for the "lifecycle" hidden object when
 v8Util.setHiddenValue(global, 'lifecycle', {
   onLoaded () {
-    process.emit('loaded');
+    (process as events.EventEmitter).emit('loaded');
   },
   onExit () {
-    process.emit('exit');
+    (process as events.EventEmitter).emit('exit');
   },
   onDocumentStart () {
-    process.emit('document-start');
+    (process as events.EventEmitter).emit('document-start');
   },
   onDocumentEnd () {
-    process.emit('document-end');
+    (process as events.EventEmitter).emit('document-end');
   }
 });
 
@@ -80,7 +79,7 @@ webFrameInit();
 
 // Pass different process object to the preload script(which should not have
 // access to things like `process.electronBinding`).
-const preloadProcess = new EventEmitter();
+const preloadProcess: NodeJS.Process = new EventEmitter() as any;
 
 Object.assign(preloadProcess, binding.process);
 Object.assign(preloadProcess, processProps);
@@ -97,16 +96,21 @@ Object.defineProperty(preloadProcess, 'noDeprecation', {
   }
 });
 
-process.on('loaded', () => preloadProcess.emit('loaded'));
-process.on('exit', () => preloadProcess.emit('exit'));
-process.on('document-start', () => preloadProcess.emit('document-start'));
-process.on('document-end', () => preloadProcess.emit('document-end'));
+process.on('loaded', () => (preloadProcess as events.EventEmitter).emit('loaded'));
+process.on('exit', () => (preloadProcess as events.EventEmitter).emit('exit'));
+(process as events.EventEmitter).on('document-start', () => (preloadProcess as events.EventEmitter).emit('document-start'));
+(process as events.EventEmitter).on('document-end', () => (preloadProcess as events.EventEmitter).emit('document-end'));
 
 // This is the `require` function that will be visible to the preload script
-function preloadRequire (module) {
+function preloadRequire (module: string) {
   if (loadedModules.has(module)) {
     return loadedModules.get(module);
   }
+  if (loadableModules.has(module)) {
+    const loadedModule = loadableModules.get(module)!();
+    loadedModules.set(module, loadedModule);
+    return loadedModule;
+  }
   throw new Error(`module not found: ${module}`);
 }
 
@@ -124,9 +128,6 @@ const isHiddenPage = hasSwitch('hidden-page');
 const rendererProcessReuseEnabled = hasSwitch('disable-electron-site-instance-overrides');
 const usesNativeWindowOpen = true;
 
-// The arguments to be passed to isolated world.
-const isolatedWorldArgs = { ipcRendererInternal, guestInstanceId, isHiddenPage, openerId, usesNativeWindowOpen, rendererProcessReuseEnabled };
-
 switch (window.location.protocol) {
   case 'devtools:': {
     // Override some inspector APIs.
@@ -152,11 +153,6 @@ if (process.isMainFrame) {
   webViewInit(contextIsolation, isWebViewTagEnabled, guestInstanceId);
 }
 
-// Pass the arguments to isolatedWorld.
-if (contextIsolation) {
-  v8Util.setHiddenValue(global, 'isolated-world-args', isolatedWorldArgs);
-}
-
 // Wrap the script into a function executed in global scope. It won't have
 // access to the current scope, so we'll expose a few objects as arguments:
 //
@@ -164,7 +160,7 @@ if (contextIsolation) {
 // - `process`: The `preloadProcess` object
 // - `Buffer`: Shim of `Buffer` implementation
 // - `global`: The window object, which is aliased to `global` by webpack.
-function runPreloadScript (preloadSrc) {
+function runPreloadScript (preloadSrc: string) {
   const preloadWrapperSrc = `(function(require, process, Buffer, global, setImmediate, clearImmediate, exports) {
   ${preloadSrc}
   })`;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron",
-  "version": "10.0.0-nightly.20200521",
+  "version": "11.0.0-nightly.20200612",
   "repository": "https://github.com/electron/electron",
   "description": "Build cross platform desktop apps with JavaScript, HTML, and CSS",
   "devDependencies": {
@@ -46,6 +46,7 @@
     "lint-staged": "^8.1.0",
     "minimist": "^1.2.0",
     "nugget": "^2.0.1",
+    "null-loader": "^4.0.0",
     "pre-flight": "^1.1.0",
     "remark-cli": "^4.0.0",
     "remark-preset-lint-markdown-style-guide": "^2.1.1",
@@ -133,7 +134,8 @@
       "git add filenames.auto.gni"
     ],
     "{*.patch,.patches}": [
-      "node script/lint.js --patches --only --"
+      "node script/lint.js --patches --only --",
+      "node script/check-patch-diff.js"
     ],
     "DEPS": [
       "node script/gen-hunspell-filenames.js"

patches/chromium/.patches

@@ -66,7 +66,6 @@ disable_compositor_recycling.patch
 allow_new_privileges_in_unsandboxed_child_processes.patch
 expose_setuseragent_on_networkcontext.patch
 feat_add_set_theme_source_to_allow_apps_to.patch
-revert_cleanup_remove_menu_subtitles_sublabels.patch
 add_webmessageportconverter_entangleandinjectmessageportchannel.patch
 revert_remove_contentrendererclient_shouldfork.patch
 ignore_rc_check.patch
@@ -89,10 +88,16 @@ feat_add_onclose_to_messageport.patch
 fix_account_for_print_preview_disabled_when_printing_to_pdf.patch
 web_contents.patch
 ui_gtk_public_header.patch
-crash_allow_embedder_to_set_crash_upload_url.patch
+refactor_expose_cursor_changes_to_the_webcontentsobserver.patch
 crash_allow_setting_more_options.patch
 breakpad_treat_node_processes_as_browser_processes.patch
 upload_list_add_loadsync_method.patch
 breakpad_allow_getting_string_values_for_crash_keys.patch
 crash_allow_disabling_compression_on_linux.patch
-fix_hunspell_crash.patch
+allow_setting_secondary_label_via_simplemenumodel.patch
+disable_unnecessary_ischromefirstrun_check.patch
+disable_dcheck_that_fails_with_software_compositing.patch
+fix_swap_global_proxies_before_initializing_the_windows_proxies.patch
+fix_default_to_ntlm_v2_in_network_service.patch
+feat_add_streaming-protocol_registry_to_multibuffer_data_source.patch
+fix_handling_non_client_pointer_events_from_pen_on_windows_10.patch

patches/chromium/accelerator.patch

@@ -10,18 +10,18 @@ This patch makes three changes to Accelerator::GetShortcutText to improve shortc
 3. Ctrl-Shift-= should show as Ctrl-+
 
 diff --git a/ui/base/accelerators/accelerator.cc b/ui/base/accelerators/accelerator.cc
-index 291bdeec97bec510f7c86a8e8bccab22b7d5d8ac..926a705c23bd5adbfc0fe178c44617086b946a80 100644
+index 7f26ef86fe967663a50bb556b49a37e1d10d5462..c83431034b9ddf0084f2ee2fc2538e4fb5aa0f0c 100644
 --- a/ui/base/accelerators/accelerator.cc
 +++ b/ui/base/accelerators/accelerator.cc
-@@ -11,6 +11,7 @@
- #include "base/logging.h"
+@@ -12,6 +12,7 @@
+ #include "base/notreached.h"
  #include "base/strings/strcat.h"
  #include "base/strings/string_util.h"
 +#include "base/strings/stringprintf.h"
  #include "base/strings/utf_string_conversions.h"
  #include "build/build_config.h"
  #include "ui/base/l10n/l10n_util.h"
-@@ -22,9 +23,7 @@
+@@ -23,9 +24,7 @@
  #include <windows.h>
  #endif
  
@@ -31,7 +31,7 @@ index 291bdeec97bec510f7c86a8e8bccab22b7d5d8ac..926a705c23bd5adbfc0fe178c4461708
  
  #if defined(OS_CHROMEOS)
  #include "ui/base/ui_base_features.h"
-@@ -220,7 +219,15 @@ base::string16 Accelerator::GetShortcutText() const {
+@@ -204,7 +203,15 @@ base::string16 Accelerator::GetShortcutText() const {
    shortcut = KeyCodeToName();
  #endif
  
@@ -47,7 +47,7 @@ index 291bdeec97bec510f7c86a8e8bccab22b7d5d8ac..926a705c23bd5adbfc0fe178c4461708
  #if defined(OS_WIN)
      // Our fallback is to try translate the key code to a regular character
      // unless it is one of digits (VK_0 to VK_9). Some keyboard
-@@ -229,21 +236,14 @@ base::string16 Accelerator::GetShortcutText() const {
+@@ -213,21 +220,14 @@ base::string16 Accelerator::GetShortcutText() const {
      // accent' for '0'). For display in the menu (e.g. Ctrl-0 for the
      // default zoom level), we leave VK_[0-9] alone without translation.
      wchar_t key;
@@ -75,7 +75,7 @@ index 291bdeec97bec510f7c86a8e8bccab22b7d5d8ac..926a705c23bd5adbfc0fe178c4461708
    }
  
  #if defined(OS_MACOSX)
-@@ -426,7 +426,7 @@ base::string16 Accelerator::ApplyLongFormModifiers(
+@@ -410,7 +410,7 @@ base::string16 Accelerator::ApplyLongFormModifiers(
    // more information.
    if (IsCtrlDown())
      shortcut = ApplyModifierToAcceleratorString(shortcut, IDS_APP_CTRL_KEY);

patches/chromium/add_contentgpuclient_precreatemessageloop_callback.patch

@@ -10,10 +10,10 @@ Allows Electron to restore WER when ELECTRON_DEFAULT_ERROR_MODE is set.
 This should be upstreamed.
 
 diff --git a/content/gpu/gpu_main.cc b/content/gpu/gpu_main.cc
-index 4ba4a1505651f9e63c4476322a12762e46ac9c6b..39e81a63d549c690a040dd463d0300de01abf419 100644
+index b502af8bb93dd45b5de046850f69ef34f9d04732..a6c84cd7909c6a1c70f3f4b5bd65531bf26f1a94 100644
 --- a/content/gpu/gpu_main.cc
 +++ b/content/gpu/gpu_main.cc
-@@ -247,6 +247,10 @@ int GpuMain(const MainFunctionParams& parameters) {
+@@ -255,6 +255,10 @@ int GpuMain(const MainFunctionParams& parameters) {
    // to the GpuProcessHost once the GpuServiceImpl has started.
    viz::GpuServiceImpl::InstallPreInitializeLogHandler();
  
@@ -24,8 +24,8 @@ index 4ba4a1505651f9e63c4476322a12762e46ac9c6b..39e81a63d549c690a040dd463d0300de
    // We are experiencing what appear to be memory-stomp issues in the GPU
    // process. These issues seem to be impacting the task executor and listeners
    // registered to it. Create the task executor on the heap to guard against
-@@ -363,7 +367,6 @@ int GpuMain(const MainFunctionParams& parameters) {
-       }));
+@@ -373,7 +377,6 @@ int GpuMain(const MainFunctionParams& parameters) {
+   }
  #endif
  
 -  auto* client = GetContentClient()->gpu();

patches/chromium/add_didinstallconditionalfeatures.patch

@@ -10,7 +10,7 @@ DidCreateScriptContext is called, not all JS APIs are available in the
 context, which can cause some preload scripts to trip.
 
 diff --git a/content/public/renderer/render_frame_observer.h b/content/public/renderer/render_frame_observer.h
-index 68822e9c91633d9433c52bdf3484f6c660eb7917..c14a7b2a1897f805f072d8156765f909f1410001 100644
+index 831a3574055881f31a3e7dbc98c0525b47af5dcb..9626f181ee471fec68af7ddfc968f2d852698b74 100644
 --- a/content/public/renderer/render_frame_observer.h
 +++ b/content/public/renderer/render_frame_observer.h
 @@ -114,6 +114,8 @@ class CONTENT_EXPORT RenderFrameObserver : public IPC::Listener,
@@ -23,10 +23,10 @@ index 68822e9c91633d9433c52bdf3484f6c660eb7917..c14a7b2a1897f805f072d8156765f909
                                          int32_t world_id) {}
    virtual void DidClearWindowObject() {}
 diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc
-index 1ca9dc1dab20fb1ca4d461fbe3068323ee6b9b44..95e9039217f44dcaf770ffea2979976e79d276ab 100644
+index 0fe316e4d949bf2c0e64a2374a8f639e3afee104..cb612a7002a4ae808ca488e2aa2adbb759310964 100644
 --- a/content/renderer/render_frame_impl.cc
 +++ b/content/renderer/render_frame_impl.cc
-@@ -4865,6 +4865,12 @@ void RenderFrameImpl::DidCreateScriptContext(v8::Local<v8::Context> context,
+@@ -4729,6 +4729,12 @@ void RenderFrameImpl::DidCreateScriptContext(v8::Local<v8::Context> context,
      observer.DidCreateScriptContext(context, world_id);
  }
  
@@ -40,10 +40,10 @@ index 1ca9dc1dab20fb1ca4d461fbe3068323ee6b9b44..95e9039217f44dcaf770ffea2979976e
                                                 int world_id) {
    for (auto& observer : observers_)
 diff --git a/content/renderer/render_frame_impl.h b/content/renderer/render_frame_impl.h
-index b839ead18e704d6e3cbb9ee62882438ca91d4823..f54218f24522ee2d28462e127b52d8ba4d529330 100644
+index c8772a65b238f52855a6634dbe1722491a663354..c856fb03735e3a46135492513e71daf3b1dc6c1a 100644
 --- a/content/renderer/render_frame_impl.h
 +++ b/content/renderer/render_frame_impl.h
-@@ -751,6 +751,8 @@ class CONTENT_EXPORT RenderFrameImpl
+@@ -724,6 +724,8 @@ class CONTENT_EXPORT RenderFrameImpl
    bool ShouldTrackUseCounter(const blink::WebURL& url) override;
    void DidCreateScriptContext(v8::Local<v8::Context> context,
                                int world_id) override;
@@ -53,10 +53,10 @@ index b839ead18e704d6e3cbb9ee62882438ca91d4823..f54218f24522ee2d28462e127b52d8ba
                                  int world_id) override;
    void DidChangeScrollOffset() override;
 diff --git a/third_party/blink/public/web/web_local_frame_client.h b/third_party/blink/public/web/web_local_frame_client.h
-index e07795d6a2726738e743f38dff795a98663eb71c..d7be6078425928c0e9577d8401e328e5ed2bef0c 100644
+index e8286b37ae00d2cbfea0f9138ecb6532c36324fc..1c5aae1c07e0c730a0cab28dccaa5a793d41d6ac 100644
 --- a/third_party/blink/public/web/web_local_frame_client.h
 +++ b/third_party/blink/public/web/web_local_frame_client.h
-@@ -551,6 +551,9 @@ class BLINK_EXPORT WebLocalFrameClient {
+@@ -547,6 +547,9 @@ class BLINK_EXPORT WebLocalFrameClient {
    virtual void DidCreateScriptContext(v8::Local<v8::Context>,
                                        int32_t world_id) {}
  
@@ -67,7 +67,7 @@ index e07795d6a2726738e743f38dff795a98663eb71c..d7be6078425928c0e9577d8401e328e5
    virtual void WillReleaseScriptContext(v8::Local<v8::Context>,
                                          int32_t world_id) {}
 diff --git a/third_party/blink/renderer/bindings/core/v8/local_window_proxy.cc b/third_party/blink/renderer/bindings/core/v8/local_window_proxy.cc
-index 81457a2e2b5723aa2ff218b4e410d55d7b7f14f8..a62f6c58bb0aaac836edfd87ab2a6f61045059dc 100644
+index 1841d4bea144e2fe0fb69839d52ff2ba4aa6b551..64c5eb7d0da7684531b044de9d6d114fc897786e 100644
 --- a/third_party/blink/renderer/bindings/core/v8/local_window_proxy.cc
 +++ b/third_party/blink/renderer/bindings/core/v8/local_window_proxy.cc
 @@ -201,6 +201,7 @@ void LocalWindowProxy::Initialize() {
@@ -79,10 +79,10 @@ index 81457a2e2b5723aa2ff218b4e410d55d7b7f14f8..a62f6c58bb0aaac836edfd87ab2a6f61
    if (World().IsMainWorld()) {
      GetFrame()->Loader().DispatchDidClearWindowObjectInMainWorld();
 diff --git a/third_party/blink/renderer/core/exported/local_frame_client_impl.cc b/third_party/blink/renderer/core/exported/local_frame_client_impl.cc
-index 9bcd5333f0a097a2fcfec60152cfbaace0e3c1da..21bd2c2c05fa32de9442877dbb0261066d2d59a3 100644
+index eae1fafbaab524e590f414b54b366a6d709fad47..97da1b1639618dded697eb72d5959926ce725e24 100644
 --- a/third_party/blink/renderer/core/exported/local_frame_client_impl.cc
 +++ b/third_party/blink/renderer/core/exported/local_frame_client_impl.cc
-@@ -345,6 +345,13 @@ void LocalFrameClientImpl::DidCreateScriptContext(
+@@ -348,6 +348,13 @@ void LocalFrameClientImpl::DidCreateScriptContext(
      web_frame_->Client()->DidCreateScriptContext(context, world_id);
  }
  
@@ -97,7 +97,7 @@ index 9bcd5333f0a097a2fcfec60152cfbaace0e3c1da..21bd2c2c05fa32de9442877dbb026106
      v8::Local<v8::Context> context,
      int32_t world_id) {
 diff --git a/third_party/blink/renderer/core/exported/local_frame_client_impl.h b/third_party/blink/renderer/core/exported/local_frame_client_impl.h
-index 5c554a74f4d3aca91d5a1428f0b1e871764a98b3..aeb930d769c9dbfeb97ca42b4e000ca5c79c49a6 100644
+index 7494f29aebe486454f35209a4a72d42dd46431a0..89f4129124b7fb01c449c51f767f4fe0dcc9c299 100644
 --- a/third_party/blink/renderer/core/exported/local_frame_client_impl.h
 +++ b/third_party/blink/renderer/core/exported/local_frame_client_impl.h
 @@ -78,6 +78,8 @@ class LocalFrameClientImpl final : public LocalFrameClient {
@@ -110,10 +110,10 @@ index 5c554a74f4d3aca91d5a1428f0b1e871764a98b3..aeb930d769c9dbfeb97ca42b4e000ca5
                                  int32_t world_id) override;
  
 diff --git a/third_party/blink/renderer/core/frame/local_frame_client.h b/third_party/blink/renderer/core/frame/local_frame_client.h
-index f7cbcbc3ded7362a5fa19b0b50808e88d23838e0..cbcc0996690c63c0e0af500ac229cccbdf047b7c 100644
+index a8443a8bfc2542ffad472206214279c1223d493f..8c7a4dec19d6fbca615b7bc282b0388189eef886 100644
 --- a/third_party/blink/renderer/core/frame/local_frame_client.h
 +++ b/third_party/blink/renderer/core/frame/local_frame_client.h
-@@ -291,6 +291,8 @@ class CORE_EXPORT LocalFrameClient : public FrameClient {
+@@ -297,6 +297,8 @@ class CORE_EXPORT LocalFrameClient : public FrameClient {
  
    virtual void DidCreateScriptContext(v8::Local<v8::Context>,
                                        int32_t world_id) = 0;
@@ -123,10 +123,10 @@ index f7cbcbc3ded7362a5fa19b0b50808e88d23838e0..cbcc0996690c63c0e0af500ac229cccb
                                          int32_t world_id) = 0;
    virtual bool AllowScriptExtensions() = 0;
 diff --git a/third_party/blink/renderer/core/loader/empty_clients.h b/third_party/blink/renderer/core/loader/empty_clients.h
-index 605166b7950a37f7d85d9a71af8c042bcbcefc8d..a1ac286dd231436e86c24c9aa65300a534d641de 100644
+index 7f060dbe946a6df2d4e4f376512679390edadc07..435882fafb3e08b94424e812ee825e7a042dfef3 100644
 --- a/third_party/blink/renderer/core/loader/empty_clients.h
 +++ b/third_party/blink/renderer/core/loader/empty_clients.h
-@@ -336,6 +336,8 @@ class CORE_EXPORT EmptyLocalFrameClient : public LocalFrameClient {
+@@ -334,6 +334,8 @@ class CORE_EXPORT EmptyLocalFrameClient : public LocalFrameClient {
  
    void DidCreateScriptContext(v8::Local<v8::Context>,
                                int32_t world_id) override {}

patches/chromium/add_realloc.patch

@@ -12,7 +12,7 @@ when we override ReallocateBufferMemory, so we therefore need to implement
 Realloc on the v8 side and correspondingly in gin.
 
 diff --git a/gin/array_buffer.cc b/gin/array_buffer.cc
-index b94a71ef856f92404e16544e22ebbadf57cff363..b15685f6907bcafeb1acd62bfe76f0713dea27f3 100644
+index 891a2e316f6c9eeda9670aaf5201ed57e5f7ba49..00ea3682f491175c6f9bea727de120f5f0de3dac 100644
 --- a/gin/array_buffer.cc
 +++ b/gin/array_buffer.cc
 @@ -43,6 +43,10 @@ void* ArrayBufferAllocator::AllocateUninitialized(size_t length) {
@@ -39,10 +39,10 @@ index 2aef366ac8194aa261cbca6abc051f7da8a988d3..3c7d66c81032636abcca4f1538ce9b7f
  
    GIN_EXPORT static ArrayBufferAllocator* SharedInstance();
 diff --git a/third_party/blink/renderer/bindings/core/v8/v8_initializer.cc b/third_party/blink/renderer/bindings/core/v8/v8_initializer.cc
-index 696a6170a584c1bb71c8ad253963d9f64395a13e..9677aa931cd543adfc1e9844d6afee8dcb0f4c2d 100644
+index fa88b2bd0233a4c5ff35a26d10e20fa1b91e33b2..21504ce01403d20067c8439c0c61ee0d71de84a5 100644
 --- a/third_party/blink/renderer/bindings/core/v8/v8_initializer.cc
 +++ b/third_party/blink/renderer/bindings/core/v8/v8_initializer.cc
-@@ -661,6 +661,10 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
+@@ -672,6 +672,10 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
          size, ArrayBufferContents::kDontInitialize);
    }
  

patches/chromium/add_trustedauthclient_to_urlloaderfactory.patch

@@ -10,11 +10,11 @@ WebContents, and cancels the authentication if there's no WebContents
 available, which there isn't in the case of the 'net' module.
 
 diff --git a/services/network/public/mojom/network_context.mojom b/services/network/public/mojom/network_context.mojom
-index 18c3c5312be05333e6ed19ad53bb6296be5db4b7..21299b9959c3f9f44c419d769b0aaff59b1d89f7 100644
+index 2001e6202cf61d1c70bf81334b62d0502ea8c9ba..9dad884c877ae77d1a2460361112903c06023021 100644
 --- a/services/network/public/mojom/network_context.mojom
 +++ b/services/network/public/mojom/network_context.mojom
-@@ -161,6 +161,25 @@ struct HttpAuthStaticNetworkContextParams {
-      = DefaultCredentials.ALLOW_DEFAULT_CREDENTIALS;
+@@ -198,6 +198,25 @@ struct CTPolicy {
+   array<string> excluded_legacy_spkis;
  };
  
 +interface TrustedAuthClient {
@@ -39,7 +39,7 @@ index 18c3c5312be05333e6ed19ad53bb6296be5db4b7..21299b9959c3f9f44c419d769b0aaff5
  interface CertVerifierClient {
    Verify(
      int32 default_error,
-@@ -605,6 +624,8 @@ struct URLLoaderFactoryParams {
+@@ -627,6 +646,8 @@ struct URLLoaderFactoryParams {
    // impact because of the extra process hops, so use should be minimized.
    pending_remote<TrustedURLLoaderHeaderClient>? header_client;
  
@@ -49,18 +49,18 @@ index 18c3c5312be05333e6ed19ad53bb6296be5db4b7..21299b9959c3f9f44c419d769b0aaff5
    // the per-context allow patterns that is managed via NetworkContext
    // interface. This still respects the per-context block lists.
 diff --git a/services/network/url_loader.cc b/services/network/url_loader.cc
-index a180f3fe9af9411dec7a6e49da5ee4ef3f7b00f5..92ecdeca6962697d6ca13ff3ad4de8c2d7d1aa8a 100644
+index 5d984482a2e5e18216bfc2229a18a513558dbcf4..1662f0878df16639ad585694be428058ab5a6c92 100644
 --- a/services/network/url_loader.cc
 +++ b/services/network/url_loader.cc
-@@ -442,6 +442,7 @@ URLLoader::URLLoader(
+@@ -437,6 +437,7 @@ URLLoader::URLLoader(
      base::WeakPtr<KeepaliveStatisticsRecorder> keepalive_statistics_recorder,
      base::WeakPtr<NetworkUsageAccumulator> network_usage_accumulator,
      mojom::TrustedURLLoaderHeaderClient* url_loader_header_client,
 +    mojom::TrustedURLLoaderAuthClient* url_loader_auth_client,
      mojom::OriginPolicyManager* origin_policy_manager,
-     std::unique_ptr<TrustTokenRequestHelperFactory> trust_token_helper_factory)
-     : url_request_context_(url_request_context),
-@@ -498,6 +499,11 @@ URLLoader::URLLoader(
+     std::unique_ptr<TrustTokenRequestHelperFactory> trust_token_helper_factory,
+     mojo::PendingRemote<mojom::CookieAccessObserver> cookie_observer)
+@@ -496,6 +497,11 @@ URLLoader::URLLoader(
      header_client_.set_disconnect_handler(
          base::BindOnce(&URLLoader::OnMojoDisconnect, base::Unretained(this)));
    }
@@ -72,7 +72,7 @@ index a180f3fe9af9411dec7a6e49da5ee4ef3f7b00f5..92ecdeca6962697d6ca13ff3ad4de8c2
    if (want_raw_headers_) {
      options_ |= mojom::kURLLoadOptionSendSSLInfoWithResponse |
                  mojom::kURLLoadOptionSendSSLInfoForCertificateError;
-@@ -978,7 +984,7 @@ void URLLoader::OnReceivedRedirect(net::URLRequest* url_request,
+@@ -994,7 +1000,7 @@ void URLLoader::OnReceivedRedirect(net::URLRequest* url_request,
  
  void URLLoader::OnAuthRequired(net::URLRequest* url_request,
                                 const net::AuthChallengeInfo& auth_info) {
@@ -81,7 +81,7 @@ index a180f3fe9af9411dec7a6e49da5ee4ef3f7b00f5..92ecdeca6962697d6ca13ff3ad4de8c2
      OnAuthCredentials(base::nullopt);
      return;
    }
-@@ -994,11 +1000,20 @@ void URLLoader::OnAuthRequired(net::URLRequest* url_request,
+@@ -1010,11 +1016,20 @@ void URLLoader::OnAuthRequired(net::URLRequest* url_request,
    if (url_request->response_headers())
      head->headers = url_request->response_headers();
    head->auth_challenge_info = auth_info;
@@ -108,18 +108,18 @@ index a180f3fe9af9411dec7a6e49da5ee4ef3f7b00f5..92ecdeca6962697d6ca13ff3ad4de8c2
    auth_challenge_responder_receiver_.set_disconnect_handler(
        base::BindOnce(&URLLoader::DeleteSelf, base::Unretained(this)));
 diff --git a/services/network/url_loader.h b/services/network/url_loader.h
-index 4e95817834afd7b9d3a3284a5924646ff784e636..e26a90754565a548d72a74b2936f15ab5c71debb 100644
+index 077344d12f001b00590598bccbba2d614c8c1af2..d9c8a41c9c4fe11277392dd428c71f022f22063b 100644
 --- a/services/network/url_loader.h
 +++ b/services/network/url_loader.h
-@@ -112,6 +112,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) URLLoader
+@@ -115,6 +115,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) URLLoader
        base::WeakPtr<KeepaliveStatisticsRecorder> keepalive_statistics_recorder,
        base::WeakPtr<NetworkUsageAccumulator> network_usage_accumulator,
        mojom::TrustedURLLoaderHeaderClient* url_loader_header_client,
 +      mojom::TrustedURLLoaderAuthClient* url_loader_auth_client,
        mojom::OriginPolicyManager* origin_policy_manager,
        std::unique_ptr<TrustTokenRequestHelperFactory>
-           trust_token_helper_factory);
-@@ -443,6 +444,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) URLLoader
+           trust_token_helper_factory,
+@@ -454,6 +455,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) URLLoader
    base::Optional<base::UnguessableToken> fetch_window_id_;
  
    mojo::Remote<mojom::TrustedHeaderClient> header_client_;
@@ -128,30 +128,30 @@ index 4e95817834afd7b9d3a3284a5924646ff784e636..e26a90754565a548d72a74b2936f15ab
    std::unique_ptr<FileOpenerForUpload> file_opener_for_upload_;
  
 diff --git a/services/network/url_loader_factory.cc b/services/network/url_loader_factory.cc
-index 1c43785d9b2c19dd4129f030e3ec9475a9bb4b31..730635d7f18bf95100558c37a1d38304a22f650d 100644
+index c8f02a3760f938c772c9e81afff8b37e49a73cbd..7e5bb5d1384488de2dee3672f933eba643dc14f7 100644
 --- a/services/network/url_loader_factory.cc
 +++ b/services/network/url_loader_factory.cc
-@@ -68,6 +68,7 @@ URLLoaderFactory::URLLoaderFactory(
+@@ -75,6 +75,7 @@ URLLoaderFactory::URLLoaderFactory(
        resource_scheduler_client_(std::move(resource_scheduler_client)),
        header_client_(std::move(params_->header_client)),
        coep_reporter_(std::move(params_->coep_reporter)),
 +      auth_client_(std::move(params_->auth_client)),
-       cors_url_loader_factory_(cors_url_loader_factory) {
+       cors_url_loader_factory_(cors_url_loader_factory),
+       cookie_observer_(std::move(params_->cookie_observer)) {
    DCHECK(context);
-   DCHECK_NE(mojom::kInvalidProcessId, params_->process_id);
-@@ -230,6 +231,7 @@ void URLLoaderFactory::CreateLoaderAndStart(
+@@ -270,6 +271,7 @@ void URLLoaderFactory::CreateLoaderAndStart(
        std::move(keepalive_statistics_recorder),
        std::move(network_usage_accumulator),
        header_client_.is_bound() ? header_client_.get() : nullptr,
 +      auth_client_.is_bound() ? auth_client_.get() : nullptr,
-       context_->origin_policy_manager(),
-       url_request.trust_token_params
-           ? std::make_unique<TrustTokenRequestHelperFactory>(
+       context_->origin_policy_manager(), std::move(trust_token_factory),
+       std::move(cookie_observer));
+ 
 diff --git a/services/network/url_loader_factory.h b/services/network/url_loader_factory.h
-index 1a623585035487de061ba6476914992ea2f7ac88..caa19dcd4b99296e50f8e22bfc92a70ba14473d1 100644
+index 8b29b67a5b0663778df3169e09bf818e6bbcec3f..e504fa3d41066907a3fbc41e69daac968415dfa6 100644
 --- a/services/network/url_loader_factory.h
 +++ b/services/network/url_loader_factory.h
-@@ -74,6 +74,7 @@ class URLLoaderFactory : public mojom::URLLoaderFactory {
+@@ -75,6 +75,7 @@ class URLLoaderFactory : public mojom::URLLoaderFactory {
    scoped_refptr<ResourceSchedulerClient> resource_scheduler_client_;
    mojo::Remote<mojom::TrustedURLLoaderHeaderClient> header_client_;
    mojo::Remote<mojom::CrossOriginEmbedderPolicyReporter> coep_reporter_;

patches/chromium/allow_nested_error_trackers.patch

@@ -20,15 +20,15 @@ least harm in the interim by removing the check that prevents more than
 one tracker from existing at a time.
 
 diff --git a/ui/gfx/x/x11_error_tracker.cc b/ui/gfx/x/x11_error_tracker.cc
-index af031de356c5e0938fd3b84a494e48dc9a0e0476..2a5c18dc473a4f88fc0427bec69142917159bbd9 100644
+index 6592ae0483884815697358040123eed5ee657816..d6862673c0b5a61db550c084291787ad1549db69 100644
 --- a/ui/gfx/x/x11_error_tracker.cc
 +++ b/ui/gfx/x/x11_error_tracker.cc
 @@ -24,7 +24,7 @@ namespace gfx {
  X11ErrorTracker::X11ErrorTracker() {
    // This is a non-exhaustive check for incorrect usage. It disallows nested
    // X11ErrorTracker instances on the same thread.
--  DCHECK(g_handler == NULL);
-+  // DCHECK(g_handler == NULL);
+-  DCHECK(g_handler == nullptr);
++  // DCHECK(g_handler == nullptr);
    g_handler = this;
    XSync(GetXDisplay(), False);
    old_handler_ = XSetErrorHandler(X11ErrorHandler);

patches/chromium/allow_setting_secondary_label_via_simplemenumodel.patch

@@ -0,0 +1,86 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: deepak1556 <hop2deep@gmail.com>
+Date: Thu, 21 May 2020 13:58:01 -0700
+Subject: Allow setting secondary label via SimpleMenuModel
+
+Builds on https://chromium-review.googlesource.com/c/chromium/src/+/2208976
+
+diff --git a/ui/base/models/simple_menu_model.cc b/ui/base/models/simple_menu_model.cc
+index 88053e9d501413d18b6a6ae36b76668431db7ee9..481a04c4835d246cfa20edfc4f1dd10ce93fcdb8 100644
+--- a/ui/base/models/simple_menu_model.cc
++++ b/ui/base/models/simple_menu_model.cc
+@@ -49,6 +49,11 @@ base::string16 SimpleMenuModel::Delegate::GetLabelForCommandId(
+   return base::string16();
+ }
+ 
++base::string16 SimpleMenuModel::Delegate::GetSecondaryLabelForCommandId(
++    int command_id) const {
++  return base::string16();
++}
++
+ ImageModel SimpleMenuModel::Delegate::GetIconForCommandId(
+     int command_id) const {
+   return ImageModel();
+@@ -291,6 +296,11 @@ void SimpleMenuModel::SetLabel(int index, const base::string16& label) {
+   MenuItemsChanged();
+ }
+ 
++void SimpleMenuModel::SetSecondaryLabel(int index, const base::string16& secondary_label) {
++  items_[ValidateItemIndex(index)].secondary_label = secondary_label;
++  MenuItemsChanged();
++}
++
+ void SimpleMenuModel::SetMinorText(int index,
+                                    const base::string16& minor_text) {
+   items_[ValidateItemIndex(index)].minor_text = minor_text;
+@@ -364,6 +374,12 @@ base::string16 SimpleMenuModel::GetLabelAt(int index) const {
+   return items_[ValidateItemIndex(index)].label;
+ }
+ 
++base::string16 SimpleMenuModel::GetSecondaryLabelAt(int index) const {
++  if (IsItemDynamicAt(index))
++    return delegate_->GetSecondaryLabelForCommandId(GetCommandIdAt(index));
++  return items_[ValidateItemIndex(index)].secondary_label;
++}
++
+ base::string16 SimpleMenuModel::GetMinorTextAt(int index) const {
+   return items_[ValidateItemIndex(index)].minor_text;
+ }
+diff --git a/ui/base/models/simple_menu_model.h b/ui/base/models/simple_menu_model.h
+index 92975ff7dc5c5ca217717da6faa0042467076005..84cf58456cd8a879dbf5940737713027057546cd 100644
+--- a/ui/base/models/simple_menu_model.h
++++ b/ui/base/models/simple_menu_model.h
+@@ -44,6 +44,7 @@ class COMPONENT_EXPORT(UI_BASE) SimpleMenuModel : public MenuModel {
+     // Some command ids have labels and icons that change over time.
+     virtual bool IsItemForCommandIdDynamic(int command_id) const;
+     virtual base::string16 GetLabelForCommandId(int command_id) const;
++    virtual base::string16 GetSecondaryLabelForCommandId(int command_id) const;
+     // Gets the icon for the item with the specified id.
+     virtual ImageModel GetIconForCommandId(int command_id) const;
+ 
+@@ -147,6 +148,9 @@ class COMPONENT_EXPORT(UI_BASE) SimpleMenuModel : public MenuModel {
+   // Sets the label for the item at |index|.
+   void SetLabel(int index, const base::string16& label);
+ 
++  // Sets the secondary_label for the item at |index|.
++  void SetSecondaryLabel(int index, const base::string16& secondary_label);
++
+   // Sets the minor text for the item at |index|.
+   void SetMinorText(int index, const base::string16& minor_text);
+ 
+@@ -173,6 +177,7 @@ class COMPONENT_EXPORT(UI_BASE) SimpleMenuModel : public MenuModel {
+   ui::MenuSeparatorType GetSeparatorTypeAt(int index) const override;
+   int GetCommandIdAt(int index) const override;
+   base::string16 GetLabelAt(int index) const override;
++  base::string16 GetSecondaryLabelAt(int index) const override;
+   base::string16 GetMinorTextAt(int index) const override;
+   ImageModel GetMinorIconAt(int index) const override;
+   bool IsItemDynamicAt(int index) const override;
+@@ -207,6 +212,7 @@ class COMPONENT_EXPORT(UI_BASE) SimpleMenuModel : public MenuModel {
+     int command_id = 0;
+     ItemType type = TYPE_COMMAND;
+     base::string16 label;
++    base::string16 secondary_label;
+     base::string16 minor_text;
+     ImageModel minor_icon;
+     ImageModel icon;

patches/chromium/blink-worker-enable-csp-in-file-scheme.patch

@@ -6,7 +6,7 @@ Subject: blink-worker-enable-csp-in-file-scheme.patch
 This allows file:// URLs in workers to have a CSP.
 
 diff --git a/third_party/blink/renderer/core/workers/worker_classic_script_loader.cc b/third_party/blink/renderer/core/workers/worker_classic_script_loader.cc
-index dc1858e41ce77fcb3cd9f828cc70ef9e09a23d15..8e1ffef4b630b4981cd37bd669b1187240bca280 100644
+index c8a4f02e69491345a6353e557b6bbdc34bb2999a..982995c8bf4632a2970c90780f3c2da3f244634e 100644
 --- a/third_party/blink/renderer/core/workers/worker_classic_script_loader.cc
 +++ b/third_party/blink/renderer/core/workers/worker_classic_script_loader.cc
 @@ -323,7 +323,6 @@ void WorkerClassicScriptLoader::ProcessContentSecurityPolicy(

patches/chromium/blink_local_frame.patch

@@ -14,10 +14,10 @@ when there is code doing that.
 This patch reverts the change to fix the crash in Electron.
 
 diff --git a/third_party/blink/renderer/core/frame/local_frame.cc b/third_party/blink/renderer/core/frame/local_frame.cc
-index 89028fddac1f32a619a3d0b9216932515ef0ed86..c1ba8ffd313256001c99ad605906c11cd06274e9 100644
+index c04ca5b367d6a5b0de3adb9e63d2b79ecee1c83d..10d113e0d15a6379d31f2d44df7bc42b339e963e 100644
 --- a/third_party/blink/renderer/core/frame/local_frame.cc
 +++ b/third_party/blink/renderer/core/frame/local_frame.cc
-@@ -469,10 +469,6 @@ void LocalFrame::DetachImpl(FrameDetachType type) {
+@@ -533,10 +533,6 @@ void LocalFrame::DetachImpl(FrameDetachType type) {
    }
    CHECK(!view_ || !view_->IsAttached());
  
@@ -28,7 +28,7 @@ index 89028fddac1f32a619a3d0b9216932515ef0ed86..c1ba8ffd313256001c99ad605906c11c
    if (!Client())
      return;
  
-@@ -490,6 +486,10 @@ void LocalFrame::DetachImpl(FrameDetachType type) {
+@@ -554,6 +550,10 @@ void LocalFrame::DetachImpl(FrameDetachType type) {
    // Notify ScriptController that the frame is closing, since its cleanup ends
    // up calling back to LocalFrameClient via WindowProxy.
    GetScriptController().ClearForClose();

patches/chromium/blink_world_context.patch

@@ -7,24 +7,23 @@ This exposes a method for obtaining a reference to an isolated world, which is
 otherwise not available in the Blink API.
 
 diff --git a/third_party/blink/public/web/web_local_frame.h b/third_party/blink/public/web/web_local_frame.h
-index 8231ed74df9c031a594eb1be607b171a78531010..c5621d9e7dc4f1c2a0c79a1d07e833874378b950 100644
+index 282839542f03317b919a300aa5b00efbc1045ede..3b22d8712a0437a760d6b0d822f97b01a3a08d22 100644
 --- a/third_party/blink/public/web/web_local_frame.h
 +++ b/third_party/blink/public/web/web_local_frame.h
-@@ -335,6 +335,9 @@ class WebLocalFrame : public WebFrame {
-   // be calling this API.
-   virtual v8::Local<v8::Context> MainWorldScriptContext() const = 0;
- 
+@@ -341,6 +341,8 @@ class WebLocalFrame : public WebFrame {
+   // Returns the world ID associated with |script_context|.
+   virtual int32_t GetScriptContextWorldId(
+       v8::Local<v8::Context> script_context) const = 0;
 +  virtual v8::Local<v8::Context> WorldScriptContext(
 +      v8::Isolate* isolate, int world_id) const = 0;
-+
+ 
    // Executes script in the context of the current page and returns the value
    // that the script evaluated to with callback. Script execution can be
-   // suspend.
 diff --git a/third_party/blink/renderer/core/frame/web_local_frame_impl.cc b/third_party/blink/renderer/core/frame/web_local_frame_impl.cc
-index f8e90a17ca7cec06613b396a4e8351381772b692..008737d979c82bd1b07144a21f1c39de48c210a2 100644
+index 73aa50d81c4acf066e31b44614f7bdb375e9a159..37bc11b20b4b0944ac75dc96109980c8cfc13b0b 100644
 --- a/third_party/blink/renderer/core/frame/web_local_frame_impl.cc
 +++ b/third_party/blink/renderer/core/frame/web_local_frame_impl.cc
-@@ -923,6 +923,13 @@ v8::Local<v8::Object> WebLocalFrameImpl::GlobalProxy() const {
+@@ -952,6 +952,13 @@ v8::Local<v8::Object> WebLocalFrameImpl::GlobalProxy() const {
    return MainWorldScriptContext()->Global();
  }
  
@@ -39,13 +38,13 @@ index f8e90a17ca7cec06613b396a4e8351381772b692..008737d979c82bd1b07144a21f1c39de
    return BindingSecurity::ShouldAllowAccessToFrame(
        CurrentDOMWindow(V8PerIsolateData::MainThreadIsolate()),
 diff --git a/third_party/blink/renderer/core/frame/web_local_frame_impl.h b/third_party/blink/renderer/core/frame/web_local_frame_impl.h
-index c80168558ff46553667f70f9fa82bf19ce5ecbce..1bc72e14acd253615c73571ac82e9970f5b91196 100644
+index 44f6172f65c45e46bd686d2135d09e3dc6844976..5f6a6bc7aad3acb5eb2640aabf029001fbeea267 100644
 --- a/third_party/blink/renderer/core/frame/web_local_frame_impl.h
 +++ b/third_party/blink/renderer/core/frame/web_local_frame_impl.h
 @@ -161,6 +161,8 @@ class CORE_EXPORT WebLocalFrameImpl final
-       int argc,
-       v8::Local<v8::Value> argv[]) override;
    v8::Local<v8::Context> MainWorldScriptContext() const override;
+   int32_t GetScriptContextWorldId(
+       v8::Local<v8::Context> script_context) const override;
 +  v8::Local<v8::Context> WorldScriptContext(
 +      v8::Isolate* isolate, int world_id) const override;
    void RequestExecuteScriptAndReturnValue(const WebScriptSource&,

patches/chromium/build_add_electron_tracing_category.patch

@@ -8,13 +8,13 @@ categories in use are known / declared.  This patch is required for us
 to introduce a new Electron category for Electron-specific tracing.
 
 diff --git a/base/trace_event/builtin_categories.h b/base/trace_event/builtin_categories.h
-index 97fe778a121a1fd3658db8c00d621a72c12e82d2..661a0ee2deff4dc1c4180ade161c9ff17cfc0226 100644
+index 8f6f08406e743cfabd653c7f9e4bf32802e0cf65..5dfd3cc573d6c56c53f608c4258d7f0abc9f639a 100644
 --- a/base/trace_event/builtin_categories.h
 +++ b/base/trace_event/builtin_categories.h
-@@ -74,6 +74,7 @@
+@@ -73,6 +73,7 @@
+   X("drmcursor")                                                         \
    X("dwrite")                                                            \
    X("DXVA Decoding")                                                     \
-   X("EarlyJava")                                                         \
 +  X("electron")                                                          \
    X("evdev")                                                             \
    X("event")                                                             \

patches/chromium/build_gn.patch

@@ -14,7 +14,7 @@ tradeoff is that switching from MAS_BUILD to !MAS_BUILD or vice-versa will
 rebuild the entire tree.
 
 diff --git a/build/config/BUILDCONFIG.gn b/build/config/BUILDCONFIG.gn
-index 6f5d5f123f89c5ef4dd601eddb6025bd4dc3b9ab..b39aa4b3181489e5ea270c6cd3f30adfbb9847a0 100644
+index 33416d571f2d2a672daf62be21bfb97dfc998b51..a1f21871c1806857723d3a421e5ef3917d7f1ef0 100644
 --- a/build/config/BUILDCONFIG.gn
 +++ b/build/config/BUILDCONFIG.gn
 @@ -123,6 +123,9 @@ if (current_os == "") {

patches/chromium/can_create_window.patch

@@ -9,10 +9,10 @@ potentially prevent a window from being created.
 TODO(loc): this patch is currently broken.
 
 diff --git a/content/browser/frame_host/render_frame_host_impl.cc b/content/browser/frame_host/render_frame_host_impl.cc
-index baee2af78cd679e458c336786326957b6ea32440..5aa26ca8eb3d5128cc217950fe8bba27b44c26b6 100644
+index 21ff33131e62938ab04399a70d392ccbe5282034..79abda0cc919e3a79b49ebd417bf86368934bbd1 100644
 --- a/content/browser/frame_host/render_frame_host_impl.cc
 +++ b/content/browser/frame_host/render_frame_host_impl.cc
-@@ -4363,6 +4363,7 @@ void RenderFrameHostImpl::CreateNewWindow(
+@@ -4691,6 +4691,7 @@ void RenderFrameHostImpl::CreateNewWindow(
            last_committed_origin_, params->window_container_type,
            params->target_url, params->referrer.To<Referrer>(),
            params->frame_name, params->disposition, *params->features,
@@ -21,10 +21,10 @@ index baee2af78cd679e458c336786326957b6ea32440..5aa26ca8eb3d5128cc217950fe8bba27
            &no_javascript_access);
  
 diff --git a/content/browser/web_contents/web_contents_impl.cc b/content/browser/web_contents/web_contents_impl.cc
-index 6883f29361bab9a78ba93da92e7bd234f62e2f8f..6a18c7085f102d475bd36925106e86c56812accc 100644
+index d2b8edd094a8585fe14e144e881feafd0917199a..e282718ec461f6c7bcb1fe36d5bb73359f04a30a 100644
 --- a/content/browser/web_contents/web_contents_impl.cc
 +++ b/content/browser/web_contents/web_contents_impl.cc
-@@ -2962,9 +2962,9 @@ RenderFrameHostDelegate* WebContentsImpl::CreateNewWindow(
+@@ -2969,9 +2969,9 @@ RenderFrameHostDelegate* WebContentsImpl::CreateNewWindow(
    }
  
    if (delegate_) {
@@ -38,10 +38,10 @@ index 6883f29361bab9a78ba93da92e7bd234f62e2f8f..6a18c7085f102d475bd36925106e86c5
  
    for (auto& observer : observers_) {
 diff --git a/content/common/frame.mojom b/content/common/frame.mojom
-index ce836b666eaca4312b01dec1cb012bbcb23b9050..9009a8b7a23e170ab0fbf81a6d157e18fa4e1769 100644
+index 21811c17c9ffc37ccae543a7f5d2181987e144ab..697acddd922caa5f5df27219b0e109a1c72b6b2b 100644
 --- a/content/common/frame.mojom
 +++ b/content/common/frame.mojom
-@@ -305,6 +305,10 @@ struct CreateNewWindowParams {
+@@ -256,6 +256,10 @@ struct CreateNewWindowParams {
  
    // The window features to use for the new window.
    blink.mojom.WindowFeatures features;
@@ -53,10 +53,10 @@ index ce836b666eaca4312b01dec1cb012bbcb23b9050..9009a8b7a23e170ab0fbf81a6d157e18
  
  // Operation result when the renderer asks the browser to create a new window.
 diff --git a/content/public/browser/content_browser_client.cc b/content/public/browser/content_browser_client.cc
-index 5990228237b99f382ba235a4bc59068ab12168de..c9fc489ded15dc3cfcdd71c86707e6e86a7e6ba3 100644
+index 8cfe2bfebd69be8aa4ed4fd1a8b846e7237be68f..8f36f7277a59d297a0700d1dfd5d8120f6a0ffa1 100644
 --- a/content/public/browser/content_browser_client.cc
 +++ b/content/public/browser/content_browser_client.cc
-@@ -508,6 +508,8 @@ bool ContentBrowserClient::CanCreateWindow(
+@@ -530,6 +530,8 @@ bool ContentBrowserClient::CanCreateWindow(
      const std::string& frame_name,
      WindowOpenDisposition disposition,
      const blink::mojom::WindowFeatures& features,
@@ -66,10 +66,10 @@ index 5990228237b99f382ba235a4bc59068ab12168de..c9fc489ded15dc3cfcdd71c86707e6e8
      bool opener_suppressed,
      bool* no_javascript_access) {
 diff --git a/content/public/browser/content_browser_client.h b/content/public/browser/content_browser_client.h
-index 7c7a70b95873ed089e311cc0917ad32d8e465a4e..2d8d316f948fbc25fd4b1aa899b38ba2607e24a1 100644
+index 21c7cfe08903cf92948af5fe069d7b25035c23fe..463fcc56d05a2e18c1d3752b5e7e275c8797eca8 100644
 --- a/content/public/browser/content_browser_client.h
 +++ b/content/public/browser/content_browser_client.h
-@@ -144,6 +144,7 @@ class NetworkService;
+@@ -146,6 +146,7 @@ class NetworkService;
  class TrustedURLLoaderHeaderClient;
  }  // namespace mojom
  struct ResourceRequest;
@@ -77,7 +77,7 @@ index 7c7a70b95873ed089e311cc0917ad32d8e465a4e..2d8d316f948fbc25fd4b1aa899b38ba2
  }  // namespace network
  
  namespace rappor {
-@@ -831,6 +832,8 @@ class CONTENT_EXPORT ContentBrowserClient {
+@@ -851,6 +852,8 @@ class CONTENT_EXPORT ContentBrowserClient {
        const std::string& frame_name,
        WindowOpenDisposition disposition,
        const blink::mojom::WindowFeatures& features,
@@ -87,7 +87,7 @@ index 7c7a70b95873ed089e311cc0917ad32d8e465a4e..2d8d316f948fbc25fd4b1aa899b38ba2
        bool opener_suppressed,
        bool* no_javascript_access);
 diff --git a/content/public/browser/web_contents_delegate.cc b/content/public/browser/web_contents_delegate.cc
-index 17281521f8109279fe68e11abc2fcec41cfdf9c0..83b951dcf55b54661c8f855a8e10984d262c91b2 100644
+index 6017278cc0fa8d029477e7ef46a9c0cacae438be..18161c8f836134e470333381a16425e3347ea867 100644
 --- a/content/public/browser/web_contents_delegate.cc
 +++ b/content/public/browser/web_contents_delegate.cc
 @@ -26,6 +26,17 @@ namespace content {
@@ -109,7 +109,7 @@ index 17281521f8109279fe68e11abc2fcec41cfdf9c0..83b951dcf55b54661c8f855a8e10984d
                                                   const OpenURLParams& params) {
    return nullptr;
 diff --git a/content/public/browser/web_contents_delegate.h b/content/public/browser/web_contents_delegate.h
-index d10b0f458416044f0b5eaeac4160ac26a2857d94..4e3a846a3825216e1a77e17fd8e03331c6fb927b 100644
+index 3844c78d8e56c43e08786af3128a1bcda3fc5839..089291f17512d24697ace85c93d1b3d4e024edf2 100644
 --- a/content/public/browser/web_contents_delegate.h
 +++ b/content/public/browser/web_contents_delegate.h
 @@ -16,6 +16,7 @@
@@ -119,8 +119,8 @@ index d10b0f458416044f0b5eaeac4160ac26a2857d94..4e3a846a3825216e1a77e17fd8e03331
 +#include "content/common/frame.mojom.h"
  #include "content/public/browser/bluetooth_chooser.h"
  #include "content/public/browser/bluetooth_scanning_prompt.h"
- #include "content/public/browser/invalidate_type.h"
-@@ -327,6 +328,13 @@ class CONTENT_EXPORT WebContentsDelegate {
+ #include "content/public/browser/eye_dropper.h"
+@@ -331,6 +332,13 @@ class CONTENT_EXPORT WebContentsDelegate {
        const std::string& partition_id,
        SessionStorageNamespace* session_storage_namespace);
  
@@ -135,7 +135,7 @@ index d10b0f458416044f0b5eaeac4160ac26a2857d94..4e3a846a3825216e1a77e17fd8e03331
    // typically happens when popups are created.
    virtual void WebContentsCreated(WebContents* source_contents,
 diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
-index 2a33016a5e54bbabfa8c534b954f6c72822ca70d..ea7084056f13c60bcc3ba8bd4991a924b6153ee2 100644
+index 0d7c504ce1fb7cbd72e7b176f6d88d1734034cc0..80278388015825fee05771aff7af3376d327058a 100644
 --- a/content/renderer/render_view_impl.cc
 +++ b/content/renderer/render_view_impl.cc
 @@ -68,6 +68,7 @@
@@ -158,10 +158,10 @@ index 2a33016a5e54bbabfa8c534b954f6c72822ca70d..ea7084056f13c60bcc3ba8bd4991a924
    // moved on send.
    bool is_background_tab =
 diff --git a/content/shell/browser/web_test/web_test_content_browser_client.cc b/content/shell/browser/web_test/web_test_content_browser_client.cc
-index a10476afec548da09e44c1ea565c0ca7c9f902db..2b9d7fe3f57fa50036e8fc2e33daaae94ccbdcda 100644
+index c69a7f463fbf629320c88f65a9c0f6ce9c3bf0db..6d7f47624414c4e9e77680e415facd8f3e2130ee 100644
 --- a/content/shell/browser/web_test/web_test_content_browser_client.cc
 +++ b/content/shell/browser/web_test/web_test_content_browser_client.cc
-@@ -395,6 +395,8 @@ bool WebTestContentBrowserClient::CanCreateWindow(
+@@ -400,6 +400,8 @@ bool WebTestContentBrowserClient::CanCreateWindow(
      const std::string& frame_name,
      WindowOpenDisposition disposition,
      const blink::mojom::WindowFeatures& features,
@@ -171,10 +171,10 @@ index a10476afec548da09e44c1ea565c0ca7c9f902db..2b9d7fe3f57fa50036e8fc2e33daaae9
      bool opener_suppressed,
      bool* no_javascript_access) {
 diff --git a/content/shell/browser/web_test/web_test_content_browser_client.h b/content/shell/browser/web_test/web_test_content_browser_client.h
-index b59e7c255d90996dec1f02170ffa4e1d3ec2a0c6..56db656bd2b19ca2ae90ace6c813a719a6266217 100644
+index 45b6bbbd41bbe19a39edb83b6ced844cb4c97244..90b5c696f4cc6b77d1377a628c9d8166c773bb60 100644
 --- a/content/shell/browser/web_test/web_test_content_browser_client.h
 +++ b/content/shell/browser/web_test/web_test_content_browser_client.h
-@@ -78,6 +78,8 @@ class WebTestContentBrowserClient : public ShellContentBrowserClient {
+@@ -79,6 +79,8 @@ class WebTestContentBrowserClient : public ShellContentBrowserClient {
                         const std::string& frame_name,
                         WindowOpenDisposition disposition,
                         const blink::mojom::WindowFeatures& features,
@@ -206,10 +206,10 @@ index 4f735ad0d97eaac9a57dad137e479f8a7ec33a36..0a3c5821962c85609b64b3625fa6b8d6
  
  }  // namespace blink
 diff --git a/third_party/blink/renderer/core/frame/local_dom_window.cc b/third_party/blink/renderer/core/frame/local_dom_window.cc
-index 8029e46e91697d6a8c1349519d2c6e68bfb443a5..4b75b3e28938e092bc575117bc6ed5c7607baf74 100644
+index 5137d99c8e94b8f2dfb903b3de87d2dfcfd14380..5859fa66f7878b77ccea0c41f22845f617123684 100644
 --- a/third_party/blink/renderer/core/frame/local_dom_window.cc
 +++ b/third_party/blink/renderer/core/frame/local_dom_window.cc
-@@ -1768,6 +1768,7 @@ DOMWindow* LocalDOMWindow::open(v8::Isolate* isolate,
+@@ -1837,6 +1837,7 @@ DOMWindow* LocalDOMWindow::open(v8::Isolate* isolate,
    }
  
    WebWindowFeatures window_features = GetWindowFeaturesFromString(features);

patches/chromium/chore_use_electron_resources_not_chrome_for_spellchecker.patch

@@ -7,10 +7,10 @@ spellchecker uses a few IDS_ resources.  We need to load these from
 Electrons grit header instead of Chromes
 
 diff --git a/chrome/browser/BUILD.gn b/chrome/browser/BUILD.gn
-index f853ba4924c5730cc9b0eafc2d15dbf3c1341542..9bb35ad9a3918d5fea8d66eb7f29c50058c87afc 100644
+index c2b29ac310b445a9544bc7d81d3e54003f327c90..8740a49e0c3cf822da7cda504052ee7b93826bb8 100644
 --- a/chrome/browser/BUILD.gn
 +++ b/chrome/browser/BUILD.gn
-@@ -5313,6 +5313,7 @@ jumbo_static_library("browser") {
+@@ -5403,6 +5403,7 @@ static_library("browser") {
      deps += [
        "//components/spellcheck/browser",
        "//components/spellcheck/common",

patches/chromium/command-ismediakey.patch

@@ -3,17 +3,8 @@ From: Jeremy Apthorp <jeremya@chromium.org>
 Date: Wed, 10 Oct 2018 15:07:34 -0700
 Subject: command-ismediakey.patch
 
-Override MediaKeysListener::IsMediaKeycode to also listen for Volume Up, Volume Down,
-and Mute. We also need to patch out Chromium's usage of RemoteCommandCenterDelegate, as
-it uses MPRemoteCommandCenter. MPRemoteCommandCenter makes it such that GlobalShortcuts
-in Electron will not work as intended, because by design an app does not receive remote
-control events until it begins playing audio. This means that a media shortcut would not kick
-into effect until you, for example, began playing a YouTube video which sort of defeats the
-purpose of GlobalShortcuts.
-
-At the moment there is no upstream possibility for this; but perhaps Chromium may
-consider some kind of switch, enabled by default, which would conditionally choose to avoid usage of
-RemoteCommandCenterDelegate on macOS.
+Override MediaKeysListener::IsMediaKeycode and associated functions to also listen for
+Volume Up, Volume Down, and Mute.
 
 Also apply electron/electron@0f67b1866a9f00b852370e721affa4efda623f3a
 and electron/electron@d2368d2d3b3de9eec4cc32b6aaf035cc89921bf1 as
@@ -95,3 +86,31 @@ index 85378bb565de617b1bd611d28c8714361747a357..36de4c0b0353be2418dacd388e92d7c3
      return event;
    }
  
+diff --git a/ui/base/accelerators/system_media_controls_media_keys_listener.cc b/ui/base/accelerators/system_media_controls_media_keys_listener.cc
+index 9d6084ceaccfd071549e63e3015f55ef292312ec..846210b04d6e2e193413c643296938ec550f6d25 100644
+--- a/ui/base/accelerators/system_media_controls_media_keys_listener.cc
++++ b/ui/base/accelerators/system_media_controls_media_keys_listener.cc
+@@ -65,6 +65,11 @@ bool SystemMediaControlsMediaKeysListener::StartWatchingMediaKey(
+     case VKEY_MEDIA_STOP:
+       service_->SetIsStopEnabled(true);
+       break;
++    case VKEY_VOLUME_DOWN:
++    case VKEY_VOLUME_UP:
++    case VKEY_VOLUME_MUTE:
++      // Do nothing.
++      break;
+     default:
+       NOTREACHED();
+   }
+@@ -97,6 +102,11 @@ void SystemMediaControlsMediaKeysListener::StopWatchingMediaKey(
+     case VKEY_MEDIA_STOP:
+       service_->SetIsStopEnabled(false);
+       break;
++    case VKEY_VOLUME_DOWN:
++    case VKEY_VOLUME_UP:
++    case VKEY_VOLUME_MUTE:
++      // Do nothing.
++      break;
+     default:
+       NOTREACHED();
+   }

patches/chromium/content_browser_main_loop.patch

@@ -8,10 +8,10 @@ run before shutdown. This is required to cleanup WebContents asynchronously
 in atom::CommonWebContentsDelegate::ResetManageWebContents.
 
 diff --git a/content/browser/browser_main_loop.cc b/content/browser/browser_main_loop.cc
-index a4044d94e4cd420edecc98482f0d1cb4b8707039..036b9b5001d053bc8dab781b9c30c37a019f7a1e 100644
+index d01f1fcfd6259c82b0fab35345b05b771c6a933b..554170ffdb2f9f852ade0be8173a2c306840401d 100644
 --- a/content/browser/browser_main_loop.cc
 +++ b/content/browser/browser_main_loop.cc
-@@ -1491,7 +1491,7 @@ void BrowserMainLoop::MainMessageLoopRun() {
+@@ -1482,7 +1482,7 @@ void BrowserMainLoop::MainMessageLoopRun() {
    NOTREACHED();
  #else
    base::RunLoop run_loop;

patches/chromium/crash_allow_embedder_to_set_crash_upload_url.patch

@@ -1,192 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jeremy Apthorp <jeremya@chromium.org>
-Date: Wed, 13 May 2020 19:06:23 +0000
-Subject: allow embedder to set crash upload url
-
-Currently //components/crash hard-codes the crash report URL to be a
-Google-specific target. This CL adds a hook which allows embedders to override
-this URL. Without it, this module isn't usable for non-Google embedders.
-
-Change-Id: I1251c3ef164f04de63cf8c66165180e897a91d78
-Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2194585
-Commit-Queue: Jeremy Apthorp <jeremya@chromium.org>
-Reviewed-by: Robert Sesek <rsesek@chromium.org>
-Cr-Commit-Position: refs/heads/master@{#768385}
-
-diff --git a/components/crash/core/app/BUILD.gn b/components/crash/core/app/BUILD.gn
-index bb11c401ca7939ca04e90fd13f1b335bf5b60598..af031a027ee3e19e57e9c4d9a133127a3a637003 100644
---- a/components/crash/core/app/BUILD.gn
-+++ b/components/crash/core/app/BUILD.gn
-@@ -22,7 +22,10 @@ source_set("lib") {
-     "crash_reporter_client.h",
-   ]
- 
--  deps = [ "//base" ]
-+  deps = [
-+    "//base",
-+    "//build:branding_buildflags",
-+  ]
- }
- 
- source_set("crashpad_handler_main") {
-diff --git a/components/crash/core/app/breakpad_linux.cc b/components/crash/core/app/breakpad_linux.cc
-index 192b0a7f137f311abb6a991f997e11f5eba52256..8ca43e2a8a104c3edf4087df5490fd47cd18f9a4 100644
---- a/components/crash/core/app/breakpad_linux.cc
-+++ b/components/crash/core/app/breakpad_linux.cc
-@@ -103,7 +103,11 @@ namespace {
- // while we do have functions to deal with uint64_t's.
- uint64_t g_crash_loop_before_time = 0;
- #else
--const char kUploadURL[] = "https://clients2.google.com/cr/report";
-+char* g_upload_url = nullptr;
-+void SetUploadURL(const std::string& url) {
-+  DCHECK(!g_upload_url);
-+  g_upload_url = strdup(url.c_str());
-+}
- #endif
- 
- bool g_is_crash_reporter_enabled = false;
-@@ -1400,16 +1404,16 @@ void ExecUploadProcessOrTerminate(const BreakpadInfo& info,
- 
-   static const char kWgetBinary[] = "/usr/bin/wget";
-   const char* args[] = {
--    kWgetBinary,
--    header_content_encoding,
--    header_content_type,
--    post_file,
--    kUploadURL,
--    "--timeout=10",  // Set a timeout so we don't hang forever.
--    "--tries=1",     // Don't retry if the upload fails.
--    "-O",  // Output reply to the file descriptor path.
--    status_fd_path,
--    nullptr,
-+      kWgetBinary,
-+      header_content_encoding,
-+      header_content_type,
-+      post_file,
-+      g_upload_url,
-+      "--timeout=10",  // Set a timeout so we don't hang forever.
-+      "--tries=1",     // Don't retry if the upload fails.
-+      "-O",            // Output reply to the file descriptor path.
-+      status_fd_path,
-+      nullptr,
-   };
-   static const char msg[] = "Cannot upload crash dump: cannot exec "
-                             "/usr/bin/wget\n";
-@@ -2037,6 +2041,10 @@ void InitCrashReporter(const std::string& process_type) {
- #endif
-       process_type.empty();
- 
-+#if !defined(OS_CHROMEOS)
-+  SetUploadURL(GetCrashReporterClient()->GetUploadUrl());
-+#endif
-+
-   if (is_browser_process) {
-     bool enable_breakpad = GetCrashReporterClient()->GetCollectStatsConsent() ||
-                            GetCrashReporterClient()->IsRunningUnattended();
-diff --git a/components/crash/core/app/crash_reporter_client.cc b/components/crash/core/app/crash_reporter_client.cc
-index e778f68af30f8c071d1360d06b553cc957160c5b..0ef0f00e4320b2ab1584621df5b3b8081c65a788 100644
---- a/components/crash/core/app/crash_reporter_client.cc
-+++ b/components/crash/core/app/crash_reporter_client.cc
-@@ -4,6 +4,7 @@
- 
- #include "components/crash/core/app/crash_reporter_client.h"
- 
-+#include "build/branding_buildflags.h"
- #include "build/build_config.h"
- 
- // On Windows don't use FilePath and logging.h.
-@@ -22,6 +23,10 @@ namespace {
- 
- CrashReporterClient* g_client = nullptr;
- 
-+#if BUILDFLAG(GOOGLE_CHROME_BRANDING) && defined(OFFICIAL_BUILD)
-+const char kDefaultUploadURL[] = "https://clients2.google.com/cr/report";
-+#endif
-+
- }  // namespace
- 
- void SetCrashReporterClient(CrashReporterClient* client) {
-@@ -196,6 +201,16 @@ void CrashReporterClient::GetSanitizationInformation(
- }
- #endif
- 
-+std::string CrashReporterClient::GetUploadUrl() {
-+#if BUILDFLAG(GOOGLE_CHROME_BRANDING) && defined(OFFICIAL_BUILD)
-+  // Only allow the possibility of report upload in official builds. This
-+  // crash server won't have symbols for any other build types.
-+  return kDefaultUploadURL;
-+#else
-+  return std::string();
-+#endif
-+}
-+
- bool CrashReporterClient::ShouldMonitorCrashHandlerExpensively() {
-   return false;
- }
-diff --git a/components/crash/core/app/crash_reporter_client.h b/components/crash/core/app/crash_reporter_client.h
-index 9cc78fc2584061d26fd1e83b3ebf5ada0a12c138..ad4bbbc5de3feb8441ba613009452c920d925820 100644
---- a/components/crash/core/app/crash_reporter_client.h
-+++ b/components/crash/core/app/crash_reporter_client.h
-@@ -194,6 +194,9 @@ class CrashReporterClient {
-       bool* sanitize_stacks);
- #endif
- 
-+  // Returns the URL target for crash report uploads.
-+  virtual std::string GetUploadUrl();
-+
-   // This method should return true to configure a crash reporter capable of
-   // monitoring itself for its own crashes to do so, even if self-monitoring
-   // would be expensive. "Expensive" self-monitoring dedicates an additional
-diff --git a/components/crash/core/app/crashpad_linux.cc b/components/crash/core/app/crashpad_linux.cc
-index 5d31d0926cd1732bdd1808c232c18fc6ff550c05..56a79e28dece162210613c842df0a34aaa66f91c 100644
---- a/components/crash/core/app/crashpad_linux.cc
-+++ b/components/crash/core/app/crashpad_linux.cc
-@@ -120,9 +120,8 @@ base::FilePath PlatformCrashpadInitialization(
-     // to ChromeOS's /sbin/crash_reporter which in turn passes the dump to
-     // crash_sender which handles the upload.
-     std::string url;
--#if BUILDFLAG(GOOGLE_CHROME_BRANDING) && defined(OFFICIAL_BUILD) && \
--    !defined(OS_CHROMEOS)
--    url = "https://clients2.google.com/cr/report";
-+#if !defined(OS_CHROMEOS)
-+    url = crash_reporter_client->GetUploadUrl();
- #else
-     url = std::string();
- #endif
-diff --git a/components/crash/core/app/crashpad_mac.mm b/components/crash/core/app/crashpad_mac.mm
-index b579521d55860823722df2ee849f6b1628b3c950..c49d38082c41c7eb71ed2c701b06ed5b7eaa514a 100644
---- a/components/crash/core/app/crashpad_mac.mm
-+++ b/components/crash/core/app/crashpad_mac.mm
-@@ -133,13 +133,7 @@ base::FilePath PlatformCrashpadInitialization(
-       crash_reporter_client->GetCrashDumpLocation(&database_path);
-       crash_reporter_client->GetCrashMetricsLocation(&metrics_path);
- 
--#if BUILDFLAG(GOOGLE_CHROME_BRANDING) && defined(OFFICIAL_BUILD)
--      // Only allow the possibility of report upload in official builds. This
--      // crash server won't have symbols for any other build types.
--      std::string url = "https://clients2.google.com/cr/report";
--#else
--      std::string url;
--#endif
-+      std::string url = crash_reporter_client->GetUploadUrl();
- 
-       std::vector<std::string> arguments;
- 
-diff --git a/components/crash/core/app/crashpad_win.cc b/components/crash/core/app/crashpad_win.cc
-index 669f5bea844d75f0e5c34b58994f4cfb8e856af0..c199b467ffeb007f3098ccde6879fbd71e9ec9fd 100644
---- a/components/crash/core/app/crashpad_win.cc
-+++ b/components/crash/core/app/crashpad_win.cc
-@@ -85,11 +85,7 @@ base::FilePath PlatformCrashpadInitialization(
-     std::map<std::string, std::string> process_annotations;
-     GetPlatformCrashpadAnnotations(&process_annotations);
- 
--#if BUILDFLAG(GOOGLE_CHROME_BRANDING)
--    std::string url = "https://clients2.google.com/cr/report";
--#else
--    std::string url;
--#endif
-+    std::string url = crash_reporter_client->GetUploadUrl();
- 
-     // Allow the crash server to be overridden for testing. If the variable
-     // isn't present in the environment then the default URL will remain.

patches/chromium/crash_allow_setting_more_options.patch

@@ -21,10 +21,10 @@ index 8ca43e2a8a104c3edf4087df5490fd47cd18f9a4..bb0c6aebb4fdb9b24de8292a3f1c8dc7
  uint64_t g_process_start_time = 0;
  pid_t g_pid = 0;
 diff --git a/components/crash/core/app/crash_reporter_client.cc b/components/crash/core/app/crash_reporter_client.cc
-index 0ef0f00e4320b2ab1584621df5b3b8081c65a788..bb30a0fdd797b80a345212828060a38f25d78e67 100644
+index 44e81b2f95f6332df16cfa00bdd26c7abbc733dc..9b3db694b920048735789d4db0f8670addd22b40 100644
 --- a/components/crash/core/app/crash_reporter_client.cc
 +++ b/components/crash/core/app/crash_reporter_client.cc
-@@ -153,6 +153,17 @@ bool CrashReporterClient::ReportingIsEnforcedByPolicy(bool* breakpad_enabled) {
+@@ -148,6 +148,17 @@ bool CrashReporterClient::ReportingIsEnforcedByPolicy(bool* breakpad_enabled) {
    return false;
  }
  
@@ -43,7 +43,7 @@ index 0ef0f00e4320b2ab1584621df5b3b8081c65a788..bb30a0fdd797b80a345212828060a38f
  unsigned int CrashReporterClient::GetCrashDumpPercentage() {
    return 100;
 diff --git a/components/crash/core/app/crash_reporter_client.h b/components/crash/core/app/crash_reporter_client.h
-index ad4bbbc5de3feb8441ba613009452c920d925820..c2dfc8fc897d901d237670e7c305fd263606bee7 100644
+index 05538423d0b9ad0d83e9326a58f8856e0403fed2..06d9f1e3b57db5cf33555eb5ad837f8d66aa8b3d 100644
 --- a/components/crash/core/app/crash_reporter_client.h
 +++ b/components/crash/core/app/crash_reporter_client.h
 @@ -5,6 +5,7 @@
@@ -54,7 +54,7 @@ index ad4bbbc5de3feb8441ba613009452c920d925820..c2dfc8fc897d901d237670e7c305fd26
  #include <string>
  
  #include "base/strings/string16.h"
-@@ -153,6 +154,19 @@ class CrashReporterClient {
+@@ -150,6 +151,19 @@ class CrashReporterClient {
    // that case, |breakpad_enabled| is set to the value enforced by policies.
    virtual bool ReportingIsEnforcedByPolicy(bool* breakpad_enabled);
  
@@ -75,7 +75,7 @@ index ad4bbbc5de3feb8441ba613009452c920d925820..c2dfc8fc897d901d237670e7c305fd26
    // Used by WebView to sample crashes without generating the unwanted dumps. If
    // the returned value is less than 100, crash dumping will be sampled to that
 diff --git a/components/crash/core/app/crashpad_mac.mm b/components/crash/core/app/crashpad_mac.mm
-index c49d38082c41c7eb71ed2c701b06ed5b7eaa514a..7d3a52951ac525640974e03b13f8827d465adf1d 100644
+index 0b594d053d7c7f2a8eae9a15e62daacab52ffa64..96210530f699a2331f57415beddc20ed19b9cb4b 100644
 --- a/components/crash/core/app/crashpad_mac.mm
 +++ b/components/crash/core/app/crashpad_mac.mm
 @@ -67,6 +67,8 @@ std::map<std::string, std::string> GetProcessSimpleAnnotations() {

patches/chromium/dcheck.patch

@@ -17,10 +17,10 @@ only one or two specific checks fail. Then it's better to simply comment out the
 failing checks and allow the rest of the target to have them enabled.
 
 diff --git a/content/browser/frame_host/navigation_controller_impl.cc b/content/browser/frame_host/navigation_controller_impl.cc
-index 16b7768fab7a43cf6ddf089fd9590bd333a766e3..b41519865e6babc829085880aadaaaea7e086e45 100644
+index 86a9e8c358ca6c70b07e17cf8dbcdb013472a3be..633f93d28840c350e8cda3dde96b98ac019bc9e7 100644
 --- a/content/browser/frame_host/navigation_controller_impl.cc
 +++ b/content/browser/frame_host/navigation_controller_impl.cc
-@@ -1262,8 +1262,10 @@ NavigationType NavigationControllerImpl::ClassifyNavigation(
+@@ -1253,8 +1253,10 @@ NavigationType NavigationControllerImpl::ClassifyNavigation(
      return NAVIGATION_TYPE_NEW_SUBFRAME;
    }
  
@@ -33,7 +33,7 @@ index 16b7768fab7a43cf6ddf089fd9590bd333a766e3..b41519865e6babc829085880aadaaaea
  
    if (rfh->GetParent()) {
      // All manual subframes would be did_create_new_entry and handled above, so
-@@ -1518,7 +1520,10 @@ void NavigationControllerImpl::RendererDidNavigateToNewPage(
+@@ -1510,7 +1512,10 @@ void NavigationControllerImpl::RendererDidNavigateToNewPage(
      new_entry->GetFavicon() = GetLastCommittedEntry()->GetFavicon();
    }
  
@@ -46,10 +46,10 @@ index 16b7768fab7a43cf6ddf089fd9590bd333a766e3..b41519865e6babc829085880aadaaaea
    // navigation. Now we know that the renderer has updated its state accordingly
    // and it is safe to also clear the browser side history.
 diff --git a/ui/base/clipboard/clipboard_win.cc b/ui/base/clipboard/clipboard_win.cc
-index 4362daa04e89ca8f47c5e07e998fc9f1ad4f4c5b..9ecdb2e13235396aee11ae1be7e539f8e932e3f6 100644
+index 9bfabd34eabcaf893b674e74e540f9258f1730bb..ea6e9f7b7161f9e3afa463fb8114479d3d10eb6b 100644
 --- a/ui/base/clipboard/clipboard_win.cc
 +++ b/ui/base/clipboard/clipboard_win.cc
-@@ -776,10 +776,10 @@ SkBitmap ClipboardWin::ReadImageInternal(ClipboardBuffer buffer) const {
+@@ -773,10 +773,10 @@ SkBitmap ClipboardWin::ReadImageInternal(ClipboardBuffer buffer) const {
  
  void ClipboardWin::WriteToClipboard(ClipboardFormatType format, HANDLE handle) {
    UINT cf_format = format.ToFormatEtc().cfFormat;

patches/chromium/delay_lock_the_protocol_scheme_registry.patch

@@ -19,10 +19,10 @@ https://chromium-review.googlesource.com/c/chromium/src/+/1901591, we should try
 re-submitting the patch.
 
 diff --git a/content/app/content_main_runner_impl.cc b/content/app/content_main_runner_impl.cc
-index 67d7e8e69d8a9b8b34b82b83bdf688df4c17ed59..9f6b797ea0489fc87b33a36bbcaae84a2cbf05f3 100644
+index 0d752de291c071e9a6054d7ced3ac1930fa38471..05e1e711e1a4abc1aab79fdbb4cda63cbf282e94 100644
 --- a/content/app/content_main_runner_impl.cc
 +++ b/content/app/content_main_runner_impl.cc
-@@ -640,7 +640,7 @@ int ContentMainRunnerImpl::Initialize(const ContentMainParams& params) {
+@@ -656,7 +656,7 @@ int ContentMainRunnerImpl::Initialize(const ContentMainParams& params) {
    }
  #endif
  
@@ -68,7 +68,7 @@ index 3038f9d25798f36811b6398f8cc0e7d83ecc41b0..68189c36c47ef85b345b0ccc40c456f8
  // Re-initializes schemes for tests.
  CONTENT_EXPORT void ReRegisterContentSchemesForTests();
 diff --git a/content/public/app/content_main_delegate.cc b/content/public/app/content_main_delegate.cc
-index 6c27d324e6235051875b88c4bc5bd362d3907f3c..06c17d6673d280fabf5b47244e7f7f7ab374f9a3 100644
+index ed5b0e2c0b4d453560ee9e2e4a55780b409eeea9..46e29dca5d13691bcf9494c0f90b68d6219a75ef 100644
 --- a/content/public/app/content_main_delegate.cc
 +++ b/content/public/app/content_main_delegate.cc
 @@ -37,6 +37,10 @@ int ContentMainDelegate::TerminateForFatalInitializationError() {
@@ -83,7 +83,7 @@ index 6c27d324e6235051875b88c4bc5bd362d3907f3c..06c17d6673d280fabf5b47244e7f7f7a
    return service_manager::ProcessType::kDefault;
  }
 diff --git a/content/public/app/content_main_delegate.h b/content/public/app/content_main_delegate.h
-index f8590642a8d6807a15746e9e7673b5e76cbe0e14..7d8df731b6dd18a42ec4fc2b1bb08a6198da8ff8 100644
+index 2d9ee9fa20a9aba1de168cc86bfeea5eab71e6d3..4b163c3fa2ddd258b5527e0ccaf9fc9d2621ef75 100644
 --- a/content/public/app/content_main_delegate.h
 +++ b/content/public/app/content_main_delegate.h
 @@ -77,6 +77,20 @@ class CONTENT_EXPORT ContentMainDelegate {

patches/chromium/desktop_media_list.patch

@@ -29,10 +29,10 @@ index a489bf6ea2179059f53e53563e993db9c7cd123b..93e237569fe94ec8526f67d915e1a735
    virtual content::DesktopMediaID::Type GetMediaListType() const = 0;
  };
 diff --git a/chrome/browser/media/webrtc/desktop_media_list_base.cc b/chrome/browser/media/webrtc/desktop_media_list_base.cc
-index ba64a40697c7bb91d6e944ad9ea8fa50dd970633..d2600791197082c8c2e179ee4df66965234c4542 100644
+index 147d5be9f7f56fb71468b56e86eb33b59d51cd66..5930fe95e33a9e5a3108c31e8c34daa9c724511c 100644
 --- a/chrome/browser/media/webrtc/desktop_media_list_base.cc
 +++ b/chrome/browser/media/webrtc/desktop_media_list_base.cc
-@@ -22,6 +22,11 @@ DesktopMediaListBase::DesktopMediaListBase(base::TimeDelta update_period)
+@@ -20,6 +20,11 @@ DesktopMediaListBase::DesktopMediaListBase(base::TimeDelta update_period)
  
  DesktopMediaListBase::~DesktopMediaListBase() {}
  
@@ -44,7 +44,7 @@ index ba64a40697c7bb91d6e944ad9ea8fa50dd970633..d2600791197082c8c2e179ee4df66965
  void DesktopMediaListBase::SetUpdatePeriod(base::TimeDelta period) {
    DCHECK(!observer_);
    update_period_ = period;
-@@ -56,7 +61,7 @@ void DesktopMediaListBase::Update(UpdateCallback callback) {
+@@ -54,7 +59,7 @@ void DesktopMediaListBase::Update(UpdateCallback callback) {
    DCHECK(sources_.empty());
    DCHECK(!refresh_callback_);
    refresh_callback_ = std::move(callback);
@@ -53,7 +53,7 @@ index ba64a40697c7bb91d6e944ad9ea8fa50dd970633..d2600791197082c8c2e179ee4df66965
  }
  
  int DesktopMediaListBase::GetSourceCount() const {
-@@ -70,6 +75,11 @@ const DesktopMediaList::Source& DesktopMediaListBase::GetSource(
+@@ -68,6 +73,11 @@ const DesktopMediaList::Source& DesktopMediaListBase::GetSource(
    return sources_[index];
  }
  
@@ -65,7 +65,7 @@ index ba64a40697c7bb91d6e944ad9ea8fa50dd970633..d2600791197082c8c2e179ee4df66965
  DesktopMediaID::Type DesktopMediaListBase::GetMediaListType() const {
    return type_;
  }
-@@ -81,6 +91,12 @@ DesktopMediaListBase::SourceDescription::SourceDescription(
+@@ -79,6 +89,12 @@ DesktopMediaListBase::SourceDescription::SourceDescription(
  
  void DesktopMediaListBase::UpdateSourcesList(
      const std::vector<SourceDescription>& new_sources) {
@@ -111,16 +111,15 @@ index ad7f766a36b1b6b2a8bc0f96369f1aaadf6681f7..f6c6c14a0937430df62c9b9c1132c591
   protected:
    virtual ~DesktopMediaListObserver() {}
 diff --git a/chrome/browser/media/webrtc/native_desktop_media_list.cc b/chrome/browser/media/webrtc/native_desktop_media_list.cc
-index 224d52b83533543398757ca487f99b3e59897e21..eb50b0393ba532766867aeec5ddeab1a6acd0bc2 100644
+index 622d9a22c8e53ba13f00c078a8240c0449c0900a..a190f487c7c388631e83bb951420d699b913bdea 100644
 --- a/chrome/browser/media/webrtc/native_desktop_media_list.cc
 +++ b/chrome/browser/media/webrtc/native_desktop_media_list.cc
-@@ -10,14 +10,15 @@
+@@ -10,13 +10,14 @@
  #include "base/hash/hash.h"
  #include "base/message_loop/message_pump_type.h"
  #include "base/single_thread_task_runner.h"
 +#include "base/strings/string_number_conversions.h"
  #include "base/strings/utf_string_conversions.h"
- #include "base/task/post_task.h"
  #include "base/threading/thread_restrictions.h"
  #include "build/build_config.h"
  #include "chrome/browser/media/webrtc/desktop_media_list.h"
@@ -132,11 +131,11 @@ index 224d52b83533543398757ca487f99b3e59897e21..eb50b0393ba532766867aeec5ddeab1a
  #include "third_party/libyuv/include/libyuv/scale_argb.h"
  #include "third_party/skia/include/core/SkBitmap.h"
 @@ -221,6 +222,8 @@ void NativeDesktopMediaList::Worker::RefreshThumbnails(
-       FROM_HERE, {BrowserThread::UI},
+       FROM_HERE,
        base::BindOnce(&NativeDesktopMediaList::UpdateNativeThumbnailsFinished,
                       media_list_));
 +
 +  capturer_.reset();
  }
  
- void NativeDesktopMediaList::Worker::OnCaptureResult(
+ bool NativeDesktopMediaList::Worker::IsCurrentFrameValid() const {

patches/chromium/disable-redraw-lock.patch

@@ -15,7 +15,7 @@ the redraw locking mechanism, which fixes these issues. The electron issue
 can be found at https://github.com/electron/electron/issues/1821
 
 diff --git a/ui/views/win/hwnd_message_handler.cc b/ui/views/win/hwnd_message_handler.cc
-index 0328f536a10de1ff4b6fd0a70c1b80c260aa7b87..2bb93842c74feb1d3f33d4589b7a75ceff8858ef 100644
+index c981cfc6b0ace5a0c60aa04af05f9a9e3158231d..eb43285dfacd700451dacb3a04546790298026ea 100644
 --- a/ui/views/win/hwnd_message_handler.cc
 +++ b/ui/views/win/hwnd_message_handler.cc
 @@ -306,6 +306,10 @@ constexpr int kSynthesizedMouseMessagesTimeDifference = 500;
@@ -49,7 +49,7 @@ index 0328f536a10de1ff4b6fd0a70c1b80c260aa7b87..2bb93842c74feb1d3f33d4589b7a75ce
  // HWNDMessageHandler, gfx::WindowImpl overrides:
  
 diff --git a/ui/views/win/hwnd_message_handler.h b/ui/views/win/hwnd_message_handler.h
-index 4da6edd086c9df20af7cdcb5c6020cd61166fbea..81b300c2533a3aaa6e0c343405a6040351061e27 100644
+index a84076658b4e8e6817938fa889bcb11d5c68b354..fa1052eec362f090c59b98e7d6158b3849657afa 100644
 --- a/ui/views/win/hwnd_message_handler.h
 +++ b/ui/views/win/hwnd_message_handler.h
 @@ -203,6 +203,8 @@ class VIEWS_EXPORT HWNDMessageHandler : public gfx::WindowImpl,

patches/chromium/disable_color_correct_rendering.patch

@@ -19,8 +19,23 @@ This can be removed once web content (including WebGL) learn how
 to deal with color spaces. That is being tracked at
 https://crbug.com/634542 and https://crbug.com/711107.
 
+diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
+index f2beaa8238c66b942620e053f4abae32441f2851..82aa964e34a966e3e2300c2b951d6431d294d111 100644
+--- a/cc/trees/layer_tree_host_impl.cc
++++ b/cc/trees/layer_tree_host_impl.cc
+@@ -1859,6 +1859,10 @@ void LayerTreeHostImpl::SetIsLikelyToRequireADraw(
+ 
+ gfx::ColorSpace LayerTreeHostImpl::GetRasterColorSpace(
+     gfx::ContentColorUsage content_color_usage) const {
++  if (!settings_.enable_color_correct_rendering) {
++    return {};
++  }
++
+   constexpr gfx::ColorSpace srgb = gfx::ColorSpace::CreateSRGB();
+ 
+   if (settings_.prefer_raster_in_srgb &&
 diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
-index 95a901678c215220b9e88db768444d48e32f6dbd..841c809b0b50c8c34a9d9c972c511bd4fd57a7b0 100644
+index c2684645484c7e1b6a555ba31f6634496a4fec76..9250d3b772fdeb6eb943f6cddeb96200e0f819f4 100644
 --- a/cc/trees/layer_tree_settings.h
 +++ b/cc/trees/layer_tree_settings.h
 @@ -100,6 +100,8 @@ class CC_EXPORT LayerTreeSettings {
@@ -66,10 +81,10 @@ index 0fc4813b2f76fe6154ebdc60ffabd278bed75653..7423c91d661adcf9e761b93ddbfa4ea8
        !command_line->HasSwitch(switches::kUIDisablePartialSwap);
  #if defined(OS_MACOSX)
 diff --git a/components/viz/service/display/gl_renderer.cc b/components/viz/service/display/gl_renderer.cc
-index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f00bfe2d8d 100644
+index 1efef99651721d7cdb159ef9fe1aea6c5fb299f0..efcdc1dbe7207f66862a7ab93f0f226c8d27ba2e 100644
 --- a/components/viz/service/display/gl_renderer.cc
 +++ b/components/viz/service/display/gl_renderer.cc
-@@ -84,6 +84,9 @@
+@@ -85,6 +85,9 @@
  
  using gpu::gles2::GLES2Interface;
  
@@ -79,7 +94,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  namespace viz {
  namespace {
  
-@@ -582,8 +585,9 @@ void GLRenderer::DoDrawQuad(const DrawQuad* quad,
+@@ -583,8 +586,9 @@ void GLRenderer::DoDrawQuad(const DrawQuad* quad,
  void GLRenderer::DrawDebugBorderQuad(const DebugBorderDrawQuad* quad) {
    SetBlendEnabled(quad->ShouldDrawWithBlending());
  
@@ -91,7 +106,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  
    // Use the full quad_rect for debug quads to not move the edges based on
    // partial swaps.
-@@ -1553,7 +1557,8 @@ void GLRenderer::ChooseRPDQProgram(DrawRenderPassDrawQuadParams* params,
+@@ -1554,7 +1558,8 @@ void GLRenderer::ChooseRPDQProgram(DrawRenderPassDrawQuadParams* params,
            params->use_color_matrix, tint_gl_composited_content_,
            params->apply_shader_based_rounded_corner &&
                ShouldApplyRoundedCorner(params->quad)),
@@ -101,7 +116,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  }
  
  void GLRenderer::UpdateRPDQUniforms(DrawRenderPassDrawQuadParams* params) {
-@@ -2024,7 +2029,8 @@ void GLRenderer::DrawSolidColorQuad(const SolidColorDrawQuad* quad,
+@@ -2025,7 +2030,8 @@ void GLRenderer::DrawSolidColorQuad(const SolidColorDrawQuad* quad,
    SetUseProgram(ProgramKey::SolidColor(use_aa ? USE_AA : NO_AA,
                                         tint_gl_composited_content_,
                                         ShouldApplyRoundedCorner(quad)),
@@ -111,7 +126,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
    SetShaderColor(color, opacity);
    if (current_program_->rounded_corner_rect_location() != -1) {
      SetShaderRoundedCorner(
-@@ -2179,7 +2185,8 @@ void GLRenderer::DrawContentQuadAA(const ContentDrawQuadBase* quad,
+@@ -2180,7 +2186,8 @@ void GLRenderer::DrawContentQuadAA(const ContentDrawQuadBase* quad,
                                                : NON_PREMULTIPLIED_ALPHA,
                         false, false, tint_gl_composited_content_,
                         ShouldApplyRoundedCorner(quad)),
@@ -121,7 +136,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  
    if (current_program_->tint_color_matrix_location() != -1) {
      auto matrix = cc::DebugColors::TintCompositedContentColorTransformMatrix();
-@@ -2275,7 +2282,8 @@ void GLRenderer::DrawContentQuadNoAA(const ContentDrawQuadBase* quad,
+@@ -2276,7 +2283,8 @@ void GLRenderer::DrawContentQuadNoAA(const ContentDrawQuadBase* quad,
                         !quad->ShouldDrawWithBlending(), has_tex_clamp_rect,
                         tint_gl_composited_content_,
                         ShouldApplyRoundedCorner(quad)),
@@ -131,7 +146,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  
    if (current_program_->tint_color_matrix_location() != -1) {
      auto matrix = cc::DebugColors::TintCompositedContentColorTransformMatrix();
-@@ -2377,7 +2385,8 @@ void GLRenderer::DrawYUVVideoQuad(const YUVVideoDrawQuad* quad,
+@@ -2378,7 +2386,8 @@ void GLRenderer::DrawYUVVideoQuad(const YUVVideoDrawQuad* quad,
    // The source color space should never be RGB.
    DCHECK_NE(src_color_space, src_color_space.GetAsFullRangeRGB());
  
@@ -141,7 +156,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  
  #if defined(OS_WIN)
    // Force sRGB output on Windows for overlay candidate video quads to match
-@@ -2541,7 +2550,8 @@ void GLRenderer::DrawStreamVideoQuad(const StreamVideoDrawQuad* quad,
+@@ -2542,7 +2551,8 @@ void GLRenderer::DrawStreamVideoQuad(const StreamVideoDrawQuad* quad,
  
    SetUseProgram(ProgramKey::VideoStream(tex_coord_precision,
                                          ShouldApplyRoundedCorner(quad)),
@@ -151,7 +166,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  
    DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
    gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
-@@ -2606,8 +2616,8 @@ void GLRenderer::FlushTextureQuadCache(BoundGeometry flush_binding) {
+@@ -2607,8 +2617,8 @@ void GLRenderer::FlushTextureQuadCache(BoundGeometry flush_binding) {
        draw_cache_.nearest_neighbor ? GL_NEAREST : GL_LINEAR);
  
    // Bind the program to the GL state.
@@ -162,7 +177,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  
    if (current_program_->rounded_corner_rect_location() != -1) {
      SetShaderRoundedCorner(
-@@ -3346,7 +3356,9 @@ void GLRenderer::PrepareGeometry(BoundGeometry binding) {
+@@ -3347,7 +3357,9 @@ void GLRenderer::PrepareGeometry(BoundGeometry binding) {
  void GLRenderer::SetUseProgram(const ProgramKey& program_key_no_color,
                                 const gfx::ColorSpace& src_color_space,
                                 const gfx::ColorSpace& dst_color_space) {
@@ -173,7 +188,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  
    // If the input color space is PQ, and it did not specify a white level,
    // override it with the frame's white level.
-@@ -3728,9 +3740,9 @@ void GLRenderer::CopyRenderPassDrawQuadToOverlayResource(
+@@ -3729,9 +3741,9 @@ void GLRenderer::CopyRenderPassDrawQuadToOverlayResource(
          cc::MathUtil::CheckedRoundUp(iosurface_height, iosurface_multiple);
    }
  
@@ -186,7 +201,7 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
    *new_bounds = gfx::RectF(updated_dst_rect.origin(),
                             gfx::SizeF((*overlay_texture)->texture.size()));
  
-@@ -3949,8 +3961,8 @@ void GLRenderer::FlushOverdrawFeedback(const gfx::Rect& output_rect) {
+@@ -3950,8 +3962,8 @@ void GLRenderer::FlushOverdrawFeedback(const gfx::Rect& output_rect) {
  
    PrepareGeometry(SHARED_BINDING);
  
@@ -197,14 +212,14 @@ index 085dbe8d7a92e541cbb92f08e9c01967b38262e0..31007e113e695ca9736d4927d088d2f0
  
    gfx::Transform render_matrix;
    render_matrix.Translate(0.5 * output_rect.width() + output_rect.x(),
-@@ -4064,3 +4076,5 @@ gfx::Size GLRenderer::GetRenderPassBackingPixelSize(
+@@ -4065,3 +4077,5 @@ gfx::Size GLRenderer::GetRenderPassBackingPixelSize(
  }
  
  }  // namespace viz
 +
 +#undef PATCH_CS
 diff --git a/content/browser/gpu/gpu_process_host.cc b/content/browser/gpu/gpu_process_host.cc
-index d47312d5f89939eab55cfa94bd3fbd41a4bd7d2a..da2f5e9fdc0fda37c82357a12f4fa28f5c556273 100644
+index 2ed4bf758cdc24de04b1cd37d5b0c0c195e5561d..f87824a4d6cf0f724f4b86c66f9d2a1c7f60b7ca 100644
 --- a/content/browser/gpu/gpu_process_host.cc
 +++ b/content/browser/gpu/gpu_process_host.cc
 @@ -209,6 +209,7 @@ GpuTerminationStatus ConvertToGpuTerminationStatus(
@@ -216,10 +231,10 @@ index d47312d5f89939eab55cfa94bd3fbd41a4bd7d2a..da2f5e9fdc0fda37c82357a12f4fa28f
      service_manager::switches::kGpuSandboxAllowSysVShm,
      service_manager::switches::kGpuSandboxFailuresFatal,
 diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
-index 618700cc99de3174b9de9bc26abcaac5880ec21e..aac0c3e5e19ee7bcf0de68a4f9f45c1cf46f9fad 100644
+index 0e84525e677131b3428e5fe73dfb7b48bf65a692..c473f13efc218c98942166715504006d56f9a862 100644
 --- a/content/browser/renderer_host/render_process_host_impl.cc
 +++ b/content/browser/renderer_host/render_process_host_impl.cc
-@@ -230,6 +230,7 @@
+@@ -226,6 +226,7 @@
  #include "ui/accessibility/accessibility_switches.h"
  #include "ui/base/ui_base_switches.h"
  #include "ui/display/display_switches.h"
@@ -227,7 +242,7 @@ index 618700cc99de3174b9de9bc26abcaac5880ec21e..aac0c3e5e19ee7bcf0de68a4f9f45c1c
  #include "ui/gl/gl_switches.h"
  #include "ui/native_theme/native_theme_features.h"
  #include "url/origin.h"
-@@ -3213,6 +3214,7 @@ void RenderProcessHostImpl::PropagateBrowserCommandLineToRenderer(
+@@ -3246,6 +3247,7 @@ void RenderProcessHostImpl::PropagateBrowserCommandLineToRenderer(
    // Propagate the following switches to the renderer command line (along
    // with any associated values) if present in the browser command line.
    static const char* const kSwitchNames[] = {
@@ -236,10 +251,10 @@ index 618700cc99de3174b9de9bc26abcaac5880ec21e..aac0c3e5e19ee7bcf0de68a4f9f45c1c
      service_manager::switches::kDisableInProcessStackTraces,
      service_manager::switches::kDisableSeccompFilterSandbox,
 diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
-index 75558f0658a3760ce9dcf550b1ac134e30c686d8..40dc39bdcd08032e7af821beeb13373fd1c613e9 100644
+index 85dae05a77b3189dac8d506705555dd96eea07a7..523a971c8e2c7a52eb8b7857cc8aa17e5bb9bf85 100644
 --- a/content/renderer/render_widget.cc
 +++ b/content/renderer/render_widget.cc
-@@ -2586,6 +2586,9 @@ cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
+@@ -2548,6 +2548,9 @@ cc::LayerTreeSettings RenderWidget::GenerateLayerTreeSettings(
    settings.main_frame_before_activation_enabled =
        cmd.HasSwitch(cc::switches::kEnableMainFrameBeforeActivation);
  
@@ -250,7 +265,7 @@ index 75558f0658a3760ce9dcf550b1ac134e30c686d8..40dc39bdcd08032e7af821beeb13373f
    // is what the renderer uses if its not threaded.
    settings.enable_checker_imaging =
 diff --git a/third_party/blink/renderer/platform/graphics/canvas_color_params.cc b/third_party/blink/renderer/platform/graphics/canvas_color_params.cc
-index d88680239152858689121d134559765fb8fae1b7..073ed8a8f84ebf994a2b9d9fa7e78f75f1177cb9 100644
+index 6bf7541499dd849439f191cfddae92dded99ef85..a023ddd9f8311bff998bb6655445bb44baa96cfc 100644
 --- a/third_party/blink/renderer/platform/graphics/canvas_color_params.cc
 +++ b/third_party/blink/renderer/platform/graphics/canvas_color_params.cc
 @@ -4,6 +4,7 @@
@@ -269,7 +284,7 @@ index d88680239152858689121d134559765fb8fae1b7..073ed8a8f84ebf994a2b9d9fa7e78f75
  
  namespace blink {
  
-@@ -89,6 +91,11 @@ uint8_t CanvasColorParams::BytesPerPixel() const {
+@@ -88,6 +90,11 @@ uint8_t CanvasColorParams::BytesPerPixel() const {
  }
  
  gfx::ColorSpace CanvasColorParams::GetSamplerGfxColorSpace() const {
@@ -281,7 +296,7 @@ index d88680239152858689121d134559765fb8fae1b7..073ed8a8f84ebf994a2b9d9fa7e78f75
    gfx::ColorSpace::PrimaryID primary_id = GetPrimaryID(color_space_);
  
    // TODO(ccameron): This needs to take into account whether or not this texture
-@@ -102,6 +109,11 @@ gfx::ColorSpace CanvasColorParams::GetSamplerGfxColorSpace() const {
+@@ -101,6 +108,11 @@ gfx::ColorSpace CanvasColorParams::GetSamplerGfxColorSpace() const {
  }
  
  gfx::ColorSpace CanvasColorParams::GetStorageGfxColorSpace() const {
@@ -294,7 +309,7 @@ index d88680239152858689121d134559765fb8fae1b7..073ed8a8f84ebf994a2b9d9fa7e78f75
  
    gfx::ColorSpace::TransferID transfer_id =
 diff --git a/ui/gfx/mac/io_surface.cc b/ui/gfx/mac/io_surface.cc
-index 2674784dca1ed12b2f5afc7b728e0c6e8cd6ca4a..5b661c70c9c89883a1aaaf1a29a9ec9fe7f16da6 100644
+index 2674784dca1ed12b2f5afc7b728e0c6e8cd6ca4a..93a9652b71d86441e15b87aafd7a6b1a13f45830 100644
 --- a/ui/gfx/mac/io_surface.cc
 +++ b/ui/gfx/mac/io_surface.cc
 @@ -16,6 +16,7 @@
@@ -305,33 +320,37 @@ index 2674784dca1ed12b2f5afc7b728e0c6e8cd6ca4a..5b661c70c9c89883a1aaaf1a29a9ec9f
  
  namespace gfx {
  
-@@ -258,6 +259,11 @@ IOSurfaceRef CreateIOSurface(const gfx::Size& size,
-     IOSurfaceSetValue(surface, CFSTR("IOSurfaceColorSpace"), kCGColorSpaceSRGB);
-   } else {
-     CGColorSpaceRef color_space = base::mac::GetSRGBColorSpace();
-+    auto* cmd_line = base::CommandLine::ForCurrentProcess();
-+    if (cmd_line->HasSwitch(switches::kDisableColorCorrectRendering)) {
-+      color_space = base::mac::GetSystemColorSpace();
-+    }
-+
-     base::ScopedCFTypeRef<CFDataRef> color_space_icc(
-         CGColorSpaceCopyICCProfile(color_space));
-     IOSurfaceSetValue(surface, CFSTR("IOSurfaceColorSpace"), color_space_icc);
-@@ -274,6 +280,14 @@ bool IOSurfaceCanSetColorSpace(const ColorSpace& color_space) {
- 
- void IOSurfaceSetColorSpace(IOSurfaceRef io_surface,
+@@ -119,6 +120,14 @@ void IOSurfaceMachPortTraits::Release(mach_port_t port) {
+ // Common method used by IOSurfaceSetColorSpace and IOSurfaceCanSetColorSpace.
+ bool IOSurfaceSetColorSpace(IOSurfaceRef io_surface,
                              const ColorSpace& color_space) {
 +  auto* cmd_line = base::CommandLine::ForCurrentProcess();
 +  if (cmd_line->HasSwitch(switches::kDisableColorCorrectRendering)) {
 +    base::ScopedCFTypeRef<CFDataRef> system_icc(
 +        CGColorSpaceCopyICCProfile(base::mac::GetSystemColorSpace()));
 +    IOSurfaceSetValue(io_surface, CFSTR("IOSurfaceColorSpace"), system_icc);
-+    return;
++    return true;
 +  }
 +
-   if (!internal::IOSurfaceSetColorSpace(io_surface, color_space)) {
-     DLOG(ERROR) << "Failed to set color space for IOSurface: "
-                 << color_space.ToString();
+   // Allow but ignore invalid color spaces.
+   if (!color_space.IsValid())
+     return true;
+@@ -253,6 +262,15 @@ IOSurfaceRef CreateIOSurface(const gfx::Size& size,
+     DCHECK_EQ(kIOReturnSuccess, r);
+   }
+ 
++  auto* cmd_line = base::CommandLine::ForCurrentProcess();
++  if (cmd_line->HasSwitch(switches::kDisableColorCorrectRendering)) {
++    CGColorSpaceRef color_space = base::mac::GetSystemColorSpace();
++    base::ScopedCFTypeRef<CFDataRef> color_space_icc(
++        CGColorSpaceCopyICCProfile(color_space));
++    IOSurfaceSetValue(surface, CFSTR("IOSurfaceColorSpace"), color_space_icc);
++    return surface;
++  }
++
+   // Ensure that all IOSurfaces start as sRGB.
+   if (__builtin_available(macos 10.12, *)) {
+     IOSurfaceSetValue(surface, CFSTR("IOSurfaceColorSpace"), kCGColorSpaceSRGB);
 diff --git a/ui/gfx/switches.cc b/ui/gfx/switches.cc
 index 0f746ead72a2c195321384c9c4ced96d0608fb7b..a9cc7b6d93cdb42c5a9a177e8a09edeb36db8122 100644
 --- a/ui/gfx/switches.cc

patches/chromium/disable_compositor_recycling.patch

@@ -6,7 +6,7 @@ Subject: fix: disabling compositor recycling
 Compositor recycling is useful for Chrome because there can be many tabs and spinning up a compositor for each one would be costly. In practice, Chrome uses the parent compositor code path of browser_compositor_view_mac.mm; the NSView of each tab is detached when it's hidden and attached when it's shown. For Electron, there is no parent compositor, so we're forced into the "own compositor" code path, which seems to be non-optimal and pretty ruthless in terms of the release of resources. Electron has no real concept of multiple tabs per window, so it should be okay to disable this ruthless recycling altogether in Electron.
 
 diff --git a/content/browser/renderer_host/render_widget_host_view_mac.mm b/content/browser/renderer_host/render_widget_host_view_mac.mm
-index 385b0dbeb7cbfb31ad0726051dc2e8fb4d7b16b2..9fe6d55cc0dbcc504cdf0eebe71899887de31b19 100644
+index 1cf61e86d97c5735836d7d0211b179300b46b454..1fc038fa999702c91a9126df61567ba4c8601dad 100644
 --- a/content/browser/renderer_host/render_widget_host_view_mac.mm
 +++ b/content/browser/renderer_host/render_widget_host_view_mac.mm
 @@ -472,7 +472,11 @@ void RenderWidgetHostViewMac::WasOccluded() {

patches/chromium/disable_dcheck_that_fails_with_software_compositing.patch

@@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Deepak Mohan <hop2deep@gmail.com>
+Date: Fri, 22 May 2020 17:58:16 -0700
+Subject: Disable DCHECK that fails with software compositing
+
+Should be removed once https://bugs.chromium.org/p/chromium/issues/detail?id=1084625
+is addressed.
+
+diff --git a/ui/views/win/hwnd_message_handler.cc b/ui/views/win/hwnd_message_handler.cc
+index eb43285dfacd700451dacb3a04546790298026ea..faa47e9ef7f388dc0bfa5cd3efb961e6339ce390 100644
+--- a/ui/views/win/hwnd_message_handler.cc
++++ b/ui/views/win/hwnd_message_handler.cc
+@@ -2407,13 +2407,13 @@ void HWNDMessageHandler::OnPaint(HDC dc) {
+       RECT cr;
+       if (GetClientRect(hwnd(), &cr)) {
+         if (exposed_pixels_.height() > 0) {
+-          DCHECK_GE(cr.bottom, exposed_pixels_.height());
++          //DCHECK_GE(cr.bottom, exposed_pixels_.height());
+           RECT rect = {cr.left, cr.bottom - exposed_pixels_.height(), cr.right,
+                        cr.bottom};
+           FillRect(ps.hdc, &rect, brush);
+         }
+         if (exposed_pixels_.width() > 0) {
+-          DCHECK_GE(cr.right, exposed_pixels_.width());
++          //DCHECK_GE(cr.right, exposed_pixels_.width());
+           RECT rect = {cr.right - exposed_pixels_.width(), cr.top, cr.right,
+                        cr.bottom - exposed_pixels_.height()};
+           FillRect(ps.hdc, &rect, brush);

patches/chromium/disable_hidden.patch

@@ -6,10 +6,10 @@ Subject: disable_hidden.patch
 Electron uses this to disable background throttling for hidden windows.
 
 diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
-index a0bb67b269f03ed6fa322fd156e9eb358eed1437..8c2d75c20afd5832371b04f50c9fb1ec5d9e8dc5 100644
+index a60ee2a3568046caa1a35ad0430d3c244c6e49a3..e660c0e072a6fa855102ec7e4d8a883a923e46ae 100644
 --- a/content/browser/renderer_host/render_widget_host_impl.cc
 +++ b/content/browser/renderer_host/render_widget_host_impl.cc
-@@ -653,6 +653,9 @@ void RenderWidgetHostImpl::WasHidden() {
+@@ -645,6 +645,9 @@ void RenderWidgetHostImpl::WasHidden() {
    if (is_hidden_)
      return;
  
@@ -20,10 +20,10 @@ index a0bb67b269f03ed6fa322fd156e9eb358eed1437..8c2d75c20afd5832371b04f50c9fb1ec
        blink::mojom::PointerLockResult::kWrongDocument);
  
 diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h
-index 947fb6ba02cde74da8787ccec689cd184f98aefd..67722b63693d28c828435d60ca167b5cda0a57b4 100644
+index 34be0a2ee98bcfc46acc9a9c7202451c72ea9631..294964841b1d3be15ca87c74da27fa4cdc0a8da3 100644
 --- a/content/browser/renderer_host/render_widget_host_impl.h
 +++ b/content/browser/renderer_host/render_widget_host_impl.h
-@@ -179,6 +179,9 @@ class CONTENT_EXPORT RenderWidgetHostImpl
+@@ -181,6 +181,9 @@ class CONTENT_EXPORT RenderWidgetHostImpl
    // RenderWidgetHostImpl.
    static RenderWidgetHostImpl* From(RenderWidgetHost* rwh);
  
@@ -34,10 +34,10 @@ index 947fb6ba02cde74da8787ccec689cd184f98aefd..67722b63693d28c828435d60ca167b5c
        const base::TimeDelta& delay) {
      new_content_rendering_delay_ = delay;
 diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc
-index 12e1923fd2943af92aaf6f691d28212bdd2a73dd..3b66abb180df5f3da7c4fa8de77279620cbc4aa3 100644
+index 4802fcfbccc628d186c30f9941e5a6a7eeea06a0..099ac6cccd9d7b46d41c3356423f82d863fcca66 100644
 --- a/content/browser/renderer_host/render_widget_host_view_aura.cc
 +++ b/content/browser/renderer_host/render_widget_host_view_aura.cc
-@@ -692,7 +692,7 @@ void RenderWidgetHostViewAura::HideImpl() {
+@@ -641,7 +641,7 @@ void RenderWidgetHostViewAura::HideImpl() {
    DCHECK(visibility_ == Visibility::HIDDEN ||
           visibility_ == Visibility::OCCLUDED);
  

patches/chromium/disable_unnecessary_ischromefirstrun_check.patch

@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Deepak Mohan <hop2deep@gmail.com>
+Date: Fri, 22 May 2020 17:40:47 -0700
+Subject: Disable unnecessary IsChromeFirstRun check
+
+Patch can be removed once https://bugs.chromium.org/p/chromium/issues/detail?id=1090030 is fixed.
+
+diff --git a/chrome/browser/spellchecker/spellcheck_service.cc b/chrome/browser/spellchecker/spellcheck_service.cc
+index d353a024b8f18e8a02edd7bb9c8cdc76e1af1963..8aef24d488365398161a75790ad306e4b1fecb72 100644
+--- a/chrome/browser/spellchecker/spellcheck_service.cc
++++ b/chrome/browser/spellchecker/spellcheck_service.cc
+@@ -18,7 +18,9 @@
+ #include "base/synchronization/waitable_event.h"
+ #include "base/values.h"
+ #include "build/build_config.h"
++#if 0
+ #include "chrome/browser/first_run/first_run.h"
++#endif
+ #include "chrome/browser/spellchecker/spellcheck_factory.h"
+ #include "chrome/browser/spellchecker/spellcheck_hunspell_dictionary.h"
+ #include "components/language/core/browser/pref_names.h"
+@@ -566,7 +568,7 @@ void SpellcheckService::InitWindowsDictionaryLanguages(
+                 .empty());
+   });
+ 
+-  if (first_run::IsChromeFirstRun()) {
++  //if (first_run::IsChromeFirstRun()) {
+     // Ensure that spellcheck is enabled for the first dialect of the
+     // accepted languages if there is a Windows dictionary installed for
+     // that dialect.
+@@ -606,7 +608,7 @@ void SpellcheckService::InitWindowsDictionaryLanguages(
+                                base::Value(first_user_language));
+       prefs->Set(spellcheck::prefs::kSpellCheckDictionaries, user_dictionaries);
+     }
+-  }
++  //}
+ 
+   // No need to call LoadHunspellDictionaries() as when the ListPrefUpdate
+   // object goes out of scope, the preference change handler will do this.

patches/chromium/expose_setuseragent_on_networkcontext.patch

@@ -33,10 +33,10 @@ index 0ccfe130f00ec3b6c75cd8ee04d5a2777e1fd00c..653829457d58bf92057cc36aa8a28970
    DISALLOW_COPY_AND_ASSIGN(StaticHttpUserAgentSettings);
  };
 diff --git a/services/network/network_context.cc b/services/network/network_context.cc
-index b7c83cceb2297eddcb345e75a95b7744b08d2e6b..7dda5ce275aef7670406e3cb3b08bd6d14d188ef 100644
+index 5f2feba6f09327088badc56d76872d2c3920866f..803315067b4ceccd3ceb3c97ea186b5de7f64f1f 100644
 --- a/services/network/network_context.cc
 +++ b/services/network/network_context.cc
-@@ -1044,6 +1044,13 @@ void NetworkContext::SetNetworkConditions(
+@@ -1009,6 +1009,13 @@ void NetworkContext::SetNetworkConditions(
                                        std::move(network_conditions));
  }
  
@@ -51,10 +51,10 @@ index b7c83cceb2297eddcb345e75a95b7744b08d2e6b..7dda5ce275aef7670406e3cb3b08bd6d
    // This may only be called on NetworkContexts created with the constructor
    // that calls MakeURLRequestContext().
 diff --git a/services/network/network_context.h b/services/network/network_context.h
-index cff8a36b7703df31d0823efb2549f57d7c6c6907..ae9c7a0d6cd98f59892fd5b0fcb6a0307cd842fc 100644
+index 0bc906026e988819f66554749c8d6aa2f2accc49..b76ab13a2c02b5d61ff931564af743260fbeeae8 100644
 --- a/services/network/network_context.h
 +++ b/services/network/network_context.h
-@@ -242,6 +242,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkContext
+@@ -235,6 +235,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) NetworkContext
    void CloseIdleConnections(CloseIdleConnectionsCallback callback) override;
    void SetNetworkConditions(const base::UnguessableToken& throttling_profile_id,
                              mojom::NetworkConditionsPtr conditions) override;
@@ -63,10 +63,10 @@ index cff8a36b7703df31d0823efb2549f57d7c6c6907..ae9c7a0d6cd98f59892fd5b0fcb6a030
    void SetEnableReferrers(bool enable_referrers) override;
  #if defined(OS_CHROMEOS)
 diff --git a/services/network/public/mojom/network_context.mojom b/services/network/public/mojom/network_context.mojom
-index e834a5f9a4b6c698ad20e3b9cdc99e871e4035df..18c3c5312be05333e6ed19ad53bb6296be5db4b7 100644
+index 248108042a5be07a3ddf6a11880ddbf04470d673..2001e6202cf61d1c70bf81334b62d0502ea8c9ba 100644
 --- a/services/network/public/mojom/network_context.mojom
 +++ b/services/network/public/mojom/network_context.mojom
-@@ -1026,6 +1026,9 @@ interface NetworkContext {
+@@ -1031,6 +1031,9 @@ interface NetworkContext {
    SetNetworkConditions(mojo_base.mojom.UnguessableToken throttling_profile_id,
                         NetworkConditions? conditions);
  
@@ -77,10 +77,10 @@ index e834a5f9a4b6c698ad20e3b9cdc99e871e4035df..18c3c5312be05333e6ed19ad53bb6296
    SetAcceptLanguage(string new_accept_language);
  
 diff --git a/services/network/test/test_network_context.h b/services/network/test/test_network_context.h
-index b2be49a841af089adb1c85eb87aa6c198a522001..eee74c88beffafcfba75bb76ad7c54154a57aa39 100644
+index eff66d994c5c416a672405226172e640b65278ff..34e8182ad2b33598d7c91a63202516c5b7e42257 100644
 --- a/services/network/test/test_network_context.h
 +++ b/services/network/test/test_network_context.h
-@@ -104,6 +104,7 @@ class TestNetworkContext : public mojom::NetworkContext {
+@@ -105,6 +105,7 @@ class TestNetworkContext : public mojom::NetworkContext {
    void CloseIdleConnections(CloseIdleConnectionsCallback callback) override {}
    void SetNetworkConditions(const base::UnguessableToken& throttling_profile_id,
                              mojom::NetworkConditionsPtr conditions) override {}

patches/chromium/feat_add_onclose_to_messageport.patch

@@ -10,22 +10,22 @@ get this standardised, but in lieu of that, this makes MessagePort a
 whole bunch more useful!
 
 diff --git a/third_party/blink/renderer/core/messaging/message_port.cc b/third_party/blink/renderer/core/messaging/message_port.cc
-index 3e71122bfbc87b481d620d67d01926690ae5270a..cd1abc51fa216215b5ab00d0a8b63638c24cbd57 100644
+index 9e9de51e37ee46266c647bd9c0c27e02a42bf5f1..d16727bed1a99b8171d0c7c5c5b7f38289ae9e55 100644
 --- a/third_party/blink/renderer/core/messaging/message_port.cc
 +++ b/third_party/blink/renderer/core/messaging/message_port.cc
-@@ -149,6 +149,7 @@ void MessagePort::close() {
-     Entangle(mojo::MessagePipe().handle0);
+@@ -158,6 +158,7 @@ void MessagePort::close() {
+     Entangle(pipe.TakePort0());
    }
    closed_ = true;
 +  DispatchEvent(*Event::Create(event_type_names::kClose));
  }
  
- void MessagePort::Entangle(mojo::ScopedMessagePipeHandle handle) {
+ void MessagePort::Entangle(MessagePortDescriptor port) {
 diff --git a/third_party/blink/renderer/core/messaging/message_port.h b/third_party/blink/renderer/core/messaging/message_port.h
-index d24804499949c237462ee455e7cec93836debca9..53e61229e73e2343414aa1ac5c5ac1ff2d3db439 100644
+index d30195fc3cf96279426c7c23fa6f99f7cd193b26..95dc5b61a01452e64e5008e772367897445ca312 100644
 --- a/third_party/blink/renderer/core/messaging/message_port.h
 +++ b/third_party/blink/renderer/core/messaging/message_port.h
-@@ -119,6 +119,13 @@ class CORE_EXPORT MessagePort : public EventTargetWithInlineData,
+@@ -121,6 +121,13 @@ class CORE_EXPORT MessagePort : public EventTargetWithInlineData,
      return GetAttributeEventListener(event_type_names::kMessageerror);
    }
  

patches/chromium/feat_add_set_theme_source_to_allow_apps_to.patch

@@ -13,7 +13,7 @@ uses internally for things like menus and devtools.
 We can remove this patch once it has in some shape been upstreamed.
 
 diff --git a/ui/native_theme/native_theme.cc b/ui/native_theme/native_theme.cc
-index c0c55286676df02d1aae3afd15de745e9756dd3e..c791beb29543b84bcc0e1d7b464a0e0f4bc39cd4 100644
+index 1d9716fc42193fce05418817ab259e55c8c08cc9..90d8fea6dffef7f0f12ae7fe2cb23b5517794765 100644
 --- a/ui/native_theme/native_theme.cc
 +++ b/ui/native_theme/native_theme.cc
 @@ -247,6 +247,8 @@ NativeTheme::NativeTheme(bool should_use_dark_colors)
@@ -26,10 +26,10 @@ index c0c55286676df02d1aae3afd15de745e9756dd3e..c791beb29543b84bcc0e1d7b464a0e0f
  }
  
 diff --git a/ui/native_theme/native_theme.h b/ui/native_theme/native_theme.h
-index 8c60a3f7ba7cd3caec127028422be32024ff586b..7bffe0caa4a55728e45f2371bb594c96855d1bc5 100644
+index fce4c73af25eea6a917031202ada54a62aca2545..8e54a2975b1e0eea49e0583fb2966d00c78aa747 100644
 --- a/ui/native_theme/native_theme.h
 +++ b/ui/native_theme/native_theme.h
-@@ -363,6 +363,22 @@ class NATIVE_THEME_EXPORT NativeTheme {
+@@ -393,6 +393,22 @@ class NATIVE_THEME_EXPORT NativeTheme {
        ColorId color_id,
        ColorScheme color_scheme = ColorScheme::kDefault) const;
  
@@ -52,7 +52,7 @@ index 8c60a3f7ba7cd3caec127028422be32024ff586b..7bffe0caa4a55728e45f2371bb594c96
    // Returns a shared instance of the native theme that should be used for web
    // rendering. Do not use it in a normal application context (i.e. browser).
    // The returned object should not be deleted by the caller. This function is
-@@ -497,6 +513,8 @@ class NATIVE_THEME_EXPORT NativeTheme {
+@@ -531,6 +547,8 @@ class NATIVE_THEME_EXPORT NativeTheme {
    PreferredColorScheme preferred_color_scheme_ =
        PreferredColorScheme::kNoPreference;
  
@@ -62,10 +62,10 @@ index 8c60a3f7ba7cd3caec127028422be32024ff586b..7bffe0caa4a55728e45f2371bb594c96
  };
  
 diff --git a/ui/native_theme/native_theme_win.cc b/ui/native_theme/native_theme_win.cc
-index f94a3ed2098d5f32ea0eb881be28d7a589b359a5..1bb8445ef2f68bdf1f2fc8a7a6f1cd0f4e0357d0 100644
+index 54730260ccb2ca56fd3fa26db631821de0e7d796..f94097fb5be82f7e9a3e09d2446c17534c513832 100644
 --- a/ui/native_theme/native_theme_win.cc
 +++ b/ui/native_theme/native_theme_win.cc
-@@ -733,6 +733,8 @@ bool NativeThemeWin::ShouldUseDarkColors() const {
+@@ -734,6 +734,8 @@ bool NativeThemeWin::ShouldUseDarkColors() const {
    // ...unless --force-dark-mode was specified in which case caveat emptor.
    if (UsesHighContrastColors() && !IsForcedDarkMode())
      return false;

patches/chromium/feat_add_streaming-protocol_registry_to_multibuffer_data_source.patch

@@ -0,0 +1,82 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Paul Frazee <pfrazee@gmail.com>
+Date: Sat, 6 Jun 2020 10:30:45 -0500
+Subject: feat: add streaming-protocol registry to multibuffer_data_source
+
+blink::WebMediaPlayerImpl - which provides the <video> and <audio> behaviors - needs to know
+whether a data source will stream or fully buffer the response. It determines this behavior
+with MultibufferDataSource::AssumeFullyBuffered() which has http/s hardwired. An incorrect
+determination will cause the video/audio to fail playing.
+
+This patch adds a list of "streaming protocols" to the MultibufferDataSource in order to allow
+other protocols to register their streaming behavior. MultibufferDataSource::AssumeFullyBuffered()
+then refers to the list so that it can correctly determine the data source's settings.
+
+diff --git a/media/blink/multibuffer_data_source.cc b/media/blink/multibuffer_data_source.cc
+index 0f6ae1fb8b4ff9f24ce3f407b7359e016fc6de5f..947812e1d877ad0c9434ea958598dd9a38227d46 100644
+--- a/media/blink/multibuffer_data_source.cc
++++ b/media/blink/multibuffer_data_source.cc
+@@ -10,9 +10,11 @@
+ #include "base/callback_helpers.h"
+ #include "base/location.h"
+ #include "base/macros.h"
++#include "base/no_destructor.h"
+ #include "base/numerics/ranges.h"
+ #include "base/numerics/safe_conversions.h"
+ #include "base/single_thread_task_runner.h"
++#include "base/strings/string_util.h"
+ #include "media/base/media_log.h"
+ #include "media/blink/buffered_data_source_host_impl.h"
+ #include "media/blink/multibuffer_reader.h"
+@@ -65,10 +67,22 @@ const int kUpdateBufferSizeFrequency = 32;
+ // How long to we delay a seek after a read?
+ constexpr base::TimeDelta kSeekDelay = base::TimeDelta::FromMilliseconds(20);
+ 
++std::vector<std::string>* GetStreamingSchemes() {
++  static base::NoDestructor<std::vector<std::string>> streaming_schemes({
++    url::kHttpsScheme,
++    url::kHttpScheme
++  });
++  return streaming_schemes.get();
++}
++
+ }  // namespace
+ 
+ namespace media {
+ 
++void AddStreamingScheme(const char* new_scheme) {
++  GetStreamingSchemes()->push_back(new_scheme);
++}
++
+ class MultibufferDataSource::ReadOperation {
+  public:
+   ReadOperation(int64_t position,
+@@ -158,7 +172,14 @@ bool MultibufferDataSource::media_has_played() const {
+ 
+ bool MultibufferDataSource::AssumeFullyBuffered() const {
+   DCHECK(url_data_);
+-  return !url_data_->url().SchemeIsHTTPOrHTTPS();
++
++  const std::string scheme = url_data_->url().scheme();
++  for (const std::string& streaming_scheme : *GetStreamingSchemes()) {
++    if (base::LowerCaseEqualsASCII(scheme, streaming_scheme)) {
++      return false;
++    }
++  }
++  return true;
+ }
+ 
+ void MultibufferDataSource::SetReader(MultiBufferReader* reader) {
+diff --git a/media/blink/multibuffer_data_source.h b/media/blink/multibuffer_data_source.h
+index 3da5a7bba5e7cc0f54998a81649f4dd9d78aa7be..938ae6ebc92315b3a75019c3bc8c9058106f7695 100644
+--- a/media/blink/multibuffer_data_source.h
++++ b/media/blink/multibuffer_data_source.h
+@@ -30,6 +30,8 @@ class BufferedDataSourceHost;
+ class MediaLog;
+ class MultiBufferReader;
+ 
++void MEDIA_BLINK_EXPORT AddStreamingScheme(const char* new_scheme);
++
+ // A data source capable of loading URLs and buffering the data using an
+ // in-memory sliding window.
+ //