Bump v7.0.0-nightly.20190602

* chore: allow conditional disable of the site instance override patches at runtime

* feat: add app.allowRendererProcessReuse property to allow runtime disable of site instance overrides

spec: add tests for the new allowRendererProcessReuse property

feat: add console warnings / errors for loading non context-aware native modules
  * Only error if the patch is disabled
  * Warn all the time, this will ship in Electron 7

.circleci/config.yml

@@ -35,6 +35,7 @@ env-debug-build: &env-debug-build
 
 env-testing-build: &env-testing-build
   GN_CONFIG: //electron/build/args/testing.gn
+  CHECK_DIST_MANIFEST: '1'
 
 env-release-build: &env-release-build
   GN_CONFIG: //electron/build/args/release.gn
@@ -143,13 +144,16 @@ step-gclient-sync: &step-gclient-sync
   run:
     name: Gclient sync
     command: |
-      gclient config \
-        --name "src/electron" \
-        --unmanaged \
-        $GCLIENT_EXTRA_ARGS \
-        "$CIRCLE_REPOSITORY_URL"
+      # If we did not restore a complete sync then we need to sync for realz
+      if [ ! -s "src/electron/.circle-sync-done" ]; then
+        gclient config \
+          --name "src/electron" \
+          --unmanaged \
+          $GCLIENT_EXTRA_ARGS \
+          "$CIRCLE_REPOSITORY_URL"
 
-      gclient sync --with_branch_heads --with_tags
+        gclient sync --with_branch_heads --with_tags
+      fi
 
 step-setup-env-for-build: &step-setup-env-for-build
   run:
@@ -176,6 +180,22 @@ step-restore-brew-cache: &step-restore-brew-cache
     keys:
       - v1-brew-cache-{{ arch }}
 
+step-get-more-space-on-mac: &step-get-more-space-on-mac
+  run:
+    name: Free up space on MacOS
+    command: |
+      if [ "`uname`" == "Darwin" ]; then
+        sudo rm -rf /Library/Developer/CoreSimulator
+      fi
+
+step-delete-git-directories: &step-delete-git-directories
+  run:
+    name: Delete src/.git directory on MacOS to free space
+    command: |
+      if [ "`uname`" == "Darwin" ]; then
+        sudo rm -rf src/.git
+      fi
+
 # On macOS the npm install command during gclient sync was run on a linux
 # machine and therefore installed a slightly different set of dependencies
 # Notably "fsevents" is a macOS only dependency, we rerun npm install once
@@ -263,6 +283,28 @@ step-electron-dist-build: &step-electron-dist-build
     command: |
       cd src
       ninja -C out/Default electron:electron_dist_zip
+      if [ "$CHECK_DIST_MANIFEST" == "1" ]; then
+        if [ "`uname`" == "Darwin" ]; then
+          target_os=mac
+          target_cpu=x64
+          if [ x"$MAS_BUILD" == x"true" ]; then
+            target_os=mac_mas
+          fi
+        elif [ "`uname`" == "Linux" ]; then
+          target_os=linux
+          if [ x"$TARGET_ARCH" == x ]; then
+            target_cpu=x64
+          elif [ "$TARGET_ARCH" == "ia32" ]; then
+            target_cpu=x86
+          else
+            target_cpu="$TARGET_ARCH"
+          fi
+        else
+          echo "Unknown system: `uname`"
+          exit 1
+        fi
+        electron/script/check-zip-manifest.py out/Default/dist.zip electron/script/dist_zip.$target_os.$target_cpu.manifest
+      fi
 
 step-electron-dist-store: &step-electron-dist-store
   store_artifacts:
@@ -535,36 +577,85 @@ steps-checkout: &steps-checkout
     - *step-depot-tools-get
     - *step-depot-tools-add-to-path
     - *step-restore-brew-cache
+    - *step-get-more-space-on-mac
     - *step-install-gnutar-on-mac
 
+    - run:
+        name: Generate DEPS Hash
+        command: node src/electron/script/generate-deps-hash.js
+    - run:
+        name: Touch Sync Done
+        command: touch src/electron/.circle-sync-done
+    # Restore exact src cache based on the hash of DEPS and patches/*
+    # If no cache is matched EXACTLY then the .circle-sync-done file is empty
+    # If a cache is matched EXACTLY then the .circle-sync-done file contains "done"
+    - restore_cache:
+        paths:
+          - ./src
+        keys:
+          - v5-src-cache-{{ arch }}-{{ checksum "src/electron/.depshash" }}
+        name: Restoring src cache
+    # Restore exact or closest git cache based on the hash of DEPS and .circle-sync-done
+    # If the src cache was restored above then this will match an empty cache
+    # If the src cache was not restored above then this will match a close git cache
     - restore_cache:
         paths:
           - ~/.gclient-cache
         keys:
-          - v1-gclient-cache-{{ arch }}-{{ checksum "src/electron/DEPS" }}
-          - v1-gclient-cache-{{ arch }}-
+          - v2-gclient-cache-{{ arch }}-{{ checksum "src/electron/.circle-sync-done" }}-{{ checksum "src/electron/DEPS" }}
+          - v2-gclient-cache-{{ arch }}-{{ checksum "src/electron/.circle-sync-done" }}
+        name: Conditionally restoring git cache
     - run:
         name: Set GIT_CACHE_PATH to make gclient to use the cache
         command: |
           # CircleCI does not support interpolation when setting environment variables.
           # https://circleci.com/docs/2.0/env-vars/#setting-an-environment-variable-in-a-shell-command
           echo 'export GIT_CACHE_PATH="$HOME/.gclient-cache"' >> $BASH_ENV
+    # This sync call only runs if .circle-sync-done is an EMPTY file
     - *step-gclient-sync
+    # Persist the git cache based on the hash of DEPS and .circle-sync-done
+    # If the src cache was restored above then this will persist an empty cache
     - save_cache:
         paths:
           - ~/.gclient-cache
-        key: v1-gclient-cache-{{ arch }}-{{ checksum "src/electron/DEPS" }}
+        key: v2-gclient-cache-{{ arch }}-{{ checksum "src/electron/.circle-sync-done" }}-{{ checksum "src/electron/DEPS" }}
+        name: Persisting git cache
+    # These next few steps reset Electron to the correct commit regardless of which cache was restored
+    - run:
+        name: Wipe Electron
+        command: rm -rf src/electron
+    - *step-checkout-electron
+    - run:
+        name: Run Electron Only Hooks
+        command: gclient runhooks --spec="solutions=[{'name':'src/electron','url':None,'deps_file':'DEPS','custom_vars':{'process_deps':False},'managed':False}]"
+    - run:
+        name: Generate DEPS Hash
+        command: (cd src/electron && git checkout .) && node src/electron/script/generate-deps-hash.js
+    # Mark the sync as done for future cache saving
+    - run:
+        name: Mark Sync Done
+        command: echo DONE > src/electron/.circle-sync-done
+    # Minimize the size of the cache
+    - run:
+        name: Remove some unused data to avoid storing it in the workspace/cache
+        command: |
+          rm -rf src/android_webview
+          rm -rf src/ios
+          rm -rf src/third_party/blink/web_tests
+          rm -rf src/third_party/blink/perf_tests
+          rm -rf src/third_party/hunspell_dictionaries
+          rm -rf src/third_party/WebKit/LayoutTests
+    # Save the src cache based on the deps hash
+    - save_cache:
+        paths:
+          - ./src
+        key: v5-src-cache-{{ arch }}-{{ checksum "src/electron/.depshash" }}
+        name: Persisting src cache
     - save_cache:
         paths:
           - /usr/local/Homebrew
         key: v1-brew-cache-{{ arch }}
-
-    - run:
-        name: Remove some unused data to avoid storing it in the workspace
-        command: |
-          rm -rf src/android_webview
-          rm -rf src/ios
-          rm -rf src/third_party/WebKit/LayoutTests
+        name: Persisting brew cache
     - persist_to_workspace:
         root: .
         paths:
@@ -651,9 +742,11 @@ steps-electron-build-for-publish: &steps-electron-build-for-publish
     - *step-depot-tools-get
     - *step-depot-tools-add-to-path
     - *step-restore-brew-cache
+    - *step-get-more-space-on-mac
     - *step-gclient-sync
     - *step-setup-env-for-build
     - *step-gn-gen-default
+    - *step-delete-git-directories
 
     # Electron app
     - *step-electron-build
@@ -801,6 +894,21 @@ steps-tests: &steps-tests
 
     - *step-maybe-notify-slack-failure
 
+steps-test-nan: &steps-test-nan
+  steps:
+    - attach_workspace:
+          at: .
+    - *step-depot-tools-add-to-path
+    - *step-electron-dist-unzip
+    - *step-setup-linux-for-headless-testing
+    - *step-fix-known-hosts-linux
+    - run:
+        name: Run Nan Tests
+        command: |
+          cd src
+          export ELECTRON_OUT_DIR=Default
+          node electron/script/nan-spec-runner.js
+
 chromium-upgrade-branches: &chromium-upgrade-branches
   /chromium\-upgrade\/[0-9]+/
 
@@ -1206,6 +1314,14 @@ jobs:
       <<: *env-stack-dumping
     <<: *steps-tests
 
+  linux-x64-testing-nan:
+    <<: *machine-linux-medium
+    environment:
+      <<: *env-linux-medium
+      <<: *env-headless-testing
+      <<: *env-stack-dumping
+    <<: *steps-test-nan
+
   linux-x64-release-tests:
     <<: *machine-linux-medium
     environment:
@@ -1239,6 +1355,15 @@ jobs:
       <<: *env-stack-dumping
     <<: *steps-tests
 
+  linux-ia32-testing-nan:
+    <<: *machine-linux-medium
+    environment:
+      <<: *env-linux-medium
+      <<: *env-ia32
+      <<: *env-headless-testing
+      <<: *env-stack-dumping
+    <<: *steps-test-nan
+
   linux-ia32-release-tests:
     <<: *machine-linux-medium
     environment:
@@ -1400,6 +1525,9 @@ workflows:
       - linux-x64-testing-tests:
           requires:
             - linux-x64-testing
+      - linux-x64-testing-nan:
+          requires:
+            - linux-x64-testing
 
       - linux-ia32-debug:
           requires:
@@ -1410,6 +1538,9 @@ workflows:
       - linux-ia32-testing-tests:
           requires:
             - linux-ia32-testing
+      - linux-ia32-testing-nan:
+          requires:
+            - linux-ia32-testing
 
       - linux-arm-debug:
           requires:

.env.example

@@ -1,7 +1,7 @@
 # These env vars are only necessary for creating Electron releases.
 # See docs/development/releasing.md
 
-APPVEYOR_TOKEN=
+APPVEYOR_CLOUD_TOKEN=
 CIRCLE_TOKEN=
 ELECTRON_GITHUB_TOKEN=
 VSTS_TOKEN=

.eslintrc.json

@@ -16,7 +16,8 @@
     }],
     "prefer-const": ["error", {
       "destructuring": "all"
-    }]
+    }],
+    "node/no-deprecated-api": 0
   },
   "parserOptions": {
     "ecmaVersion": 6,

.github/CODEOWNERS

@@ -4,17 +4,27 @@
 # https://git-scm.com/docs/gitignore
 
 # Most stuff in here is owned by the Community & Safety WG...
-/.github/* @electron/wg-community
+/.github/*                              @electron/wg-community
 
 # ...except the Admin WG maintains this file.
-/.github/CODEOWNERS @electron/wg-admin
+/.github/CODEOWNERS                     @electron/wg-admin
 
 # Upgrades WG
-/patches/ @electron/wg-upgrades
+/patches/                               @electron/wg-upgrades
 
 # Docs & Tooling WG
 /default_app/ @electron/wg-docs-tools
-/docs/ @electron/wg-docs-tools
+/docs/                                  @electron/wg-docs-tools
 
 # Releases WG
-/npm/ @electron/wg-releases
+/npm/                                   @electron/wg-releases
+/script/release-notes                   @electron/wg-releases
+/script/prepare-release.js              @electron/wg-releases
+/script/bump-version.js                 @electron/wg-releases
+/script/ci-release-build.js             @electron/wg-releases
+/script/release.js                      @electron/wg-releases
+/script/upload-to-github.js             @electron/wg-releases
+/script/release-artifact-cleanup.js     @electron/wg-releases
+/script/get-last-major-for-master.js    @electron/wg-releases
+/script/find-release.js                 @electron/wg-releases
+/script/download-circleci-artifacts.js  @electron/wg-releases

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -20,7 +20,7 @@ about: Create a report to help us improve Electron
   * <!-- (output of `node_modules/.bin/electron --version`) e.g. 4.0.3 -->
 * **Operating System:**
   * <!-- (Platform and Version) e.g. macOS 10.13.6 / Windows 10 (1803) / Ubuntu 18.04 x64 -->
-* **Last Known Working Electron version:**:
+* **Last Known Working Electron version:**
   * <!-- (if applicable) e.g. 3.1.0 -->
 
 ### Expected Behavior

.github/main.workflow

@@ -0,0 +1,10 @@
+workflow "Clerk" {
+  #TODO(codebytere): make this work properly on pull_request
+  on = "repository_dispatch"
+  resolves = "Check release notes"
+}
+
+action "Check release notes" {
+  uses = "electron/clerk@master"
+  secrets = [ "GITHUB_TOKEN" ]
+}

.gitignore

@@ -37,7 +37,7 @@
 /vendor/pyyaml
 node_modules/
 SHASUMS256.txt
-**/yarn.lock
+**/package-lock.json
 compile_commands.json
 .envrc
 
@@ -62,3 +62,6 @@ spec/.hash
 
 # If someone runs tsc this is where stuff will end up
 ts-gen
+
+# Used to accelerate CI builds
+.depshash

BUILD.gn

@@ -8,7 +8,7 @@ import("//tools/generate_library_loader/generate_library_loader.gni")
 import("//tools/grit/grit_rule.gni")
 import("//tools/grit/repack.gni")
 import("//tools/v8_context_snapshot/v8_context_snapshot.gni")
-import("//v8/snapshot_toolchain.gni")
+import("//v8/gni/snapshot_toolchain.gni")
 import("build/asar.gni")
 import("build/js_wrap.gni")
 import("build/npm.gni")
@@ -64,7 +64,7 @@ config("branding") {
 npm_action("build_electron_definitions") {
   script = "gn-typescript-definitions"
   args = [ rebase_path("$target_gen_dir/tsc/typings/electron.d.ts") ]
-  inputs = auto_filenames.api_docs + [ "package-lock.json" ]
+  inputs = auto_filenames.api_docs + [ "yarn.lock" ]
 
   outputs = [
     "$target_gen_dir/tsc/typings/electron.d.ts",
@@ -436,6 +436,7 @@ static_library("electron_lib") {
     "//content/public/browser",
     "//content/public/child",
     "//content/public/common:service_names",
+    "//content/public/gpu",
     "//content/public/renderer",
     "//content/public/utility",
     "//device/bluetooth",
@@ -545,6 +546,7 @@ static_library("electron_lib") {
 
   if (is_mac) {
     deps += [
+      "//components/remote_cocoa/app_shim",
       "//third_party/crashpad/crashpad/client",
       "//ui/accelerated_widget_mac",
     ]
@@ -1067,6 +1069,7 @@ template("dist_zip") {
                              "deps",
                              "data_deps",
                              "data",
+                             "testonly",
                            ])
     write_runtime_deps = _runtime_deps_file
   }
@@ -1076,7 +1079,11 @@ template("dist_zip") {
     deps = [
       ":$_runtime_deps_target",
     ]
-    forward_variables_from(invoker, [ "outputs" ])
+    forward_variables_from(invoker,
+                           [
+                             "outputs",
+                             "testonly",
+                           ])
     args = rebase_path(outputs + [ _runtime_deps_file ], root_build_dir) + [
              target_cpu,
              target_os,
@@ -1144,6 +1151,7 @@ dist_zip("electron_ffmpeg_zip") {
 }
 
 dist_zip("electron_chromedriver_zip") {
+  testonly = true
   data_deps = [
     "//chrome/test/chromedriver",
     ":licenses",

DEPS

@@ -10,9 +10,11 @@ gclient_gn_args = [
 
 vars = {
   'chromium_version':
-    '75.0.3740.3',
+    'ab588d36191964c4bca8de5c320534d95606c861',
   'node_version':
-    '2dc0f8811b2b295c08d797b8a11b030234c98502',
+    'dee0db9864a001ffc16440f725f4952a1a417069',
+  'nan_version':
+    '960dd6c70fc9eb136efdf37b4bef18fadbc3436f',
 
   'boto_version': 'f7574aa6cc2c819430c1f05e9a1a1a666ef8169b',
   'pyyaml_version': '3.12',
@@ -21,9 +23,14 @@ vars = {
   'boto_git': 'https://github.com/boto',
   'chromium_git': 'https://chromium.googlesource.com',
   'electron_git': 'https://github.com/electron',
+  # FIXME: Once https://github.com/nodejs/nan/pull/857 lands this should point at nodejs/nan
+  'nodejs_git': 'https://github.com/marshallofsound',
   'requests_git': 'https://github.com/kennethreitz',
   'yaml_git': 'https://github.com/yaml',
 
+  # KEEP IN SYNC WITH utils.js FILE
+  'yarn_version': '1.15.2',
+
   # To be able to build clean Chromium from sources.
   'apply_patches': True,
 
@@ -33,6 +40,7 @@ vars = {
   # To allow in-house builds to checkout those manually.
   'checkout_chromium': True,
   'checkout_node': True,
+  'checkout_nan': True,
 
   # It's only needed to parse the native tests configurations.
   'checkout_pyyaml': False,
@@ -40,6 +48,9 @@ vars = {
   # Python "requests" module is used for releases only.
   'checkout_requests': False,
 
+  # To allow running hooks without parsing the DEPS tree
+  'process_deps': True,
+
   # It is always needed for normal Electron builds,
   # but might be impossible for custom in-house builds.
   'download_external_binaries': True,
@@ -61,30 +72,34 @@ vars = {
 deps = {
   'src': {
     'url': (Var("chromium_git")) + '/chromium/src.git@' + (Var("chromium_version")),
-    'condition': 'checkout_chromium',
+    'condition': 'checkout_chromium and process_deps',
+  },
+  'src/third_party/nan': {
+    'url': (Var("nodejs_git")) + '/nan.git@' + (Var("nan_version")),
+    'condition': 'checkout_nan and process_deps',
   },
   'src/third_party/electron_node': {
     'url': (Var("electron_git")) + '/node.git@' + (Var("node_version")),
-    'condition': 'checkout_node',
+    'condition': 'checkout_node and process_deps',
   },
   'src/electron/vendor/pyyaml': {
     'url': (Var("yaml_git")) + '/pyyaml.git@' + (Var("pyyaml_version")),
-    'condition': 'checkout_pyyaml',
+    'condition': 'checkout_pyyaml and process_deps',
   },
   'src/electron/vendor/boto': {
     'url': Var('boto_git') + '/boto.git' + '@' +  Var('boto_version'),
-    'condition': 'checkout_boto',
+    'condition': 'checkout_boto and process_deps',
   },
   'src/electron/vendor/requests': {
     'url': Var('requests_git') + '/requests.git' + '@' +  Var('requests_version'),
-    'condition': 'checkout_requests',
+    'condition': 'checkout_requests and process_deps',
   },
 }
 
 hooks = [
   {
     'name': 'patch_chromium',
-    'condition': 'checkout_chromium and apply_patches',
+    'condition': '(checkout_chromium and apply_patches) and process_deps',
     'pattern': 'src/electron',
     'action': [
       'python',
@@ -107,13 +122,13 @@ hooks = [
     'action': [
       'python',
       '-c',
-      'import os, subprocess; os.chdir(os.path.join("src", "electron")); subprocess.check_call(["python", "script/lib/npm.py", "install"]);',
+      'import os, subprocess; os.chdir(os.path.join("src", "electron")); subprocess.check_call(["python", "script/lib/npx.py", "yarn@' + (Var("yarn_version")) + '", "install", "--frozen-lockfile"]);',
     ],
   },
   {
     'name': 'setup_boto',
     'pattern': 'src/electron',
-    'condition': 'checkout_boto',
+    'condition': 'checkout_boto and process_deps',
     'action': [
       'python',
       '-c',
@@ -123,7 +138,7 @@ hooks = [
   {
     'name': 'setup_requests',
     'pattern': 'src/electron',
-    'condition': 'checkout_requests',
+    'condition': 'checkout_requests and process_deps',
     'action': [
       'python',
       '-c',

ELECTRON_VERSION

@@ -1 +1 @@
-6.0.0-nightly.20190404
+7.0.0-nightly.20190602

README.md

@@ -93,6 +93,10 @@ const child = proc.spawn(electron)
 
 Find documentation translations in [electron/i18n](https://github.com/electron/i18n).
 
+## Contributing
+
+If you are interested in reporting/fixing issues and contributing directly to the code base, please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information on what we're looking for and how to get started.
+
 ## Community
 
 Info on reporting bugs, getting help, finding third-party tools and sample apps,

appveyor.yml

@@ -23,13 +23,28 @@
 # https://www.appveyor.com/docs/build-configuration/#secure-variables
 # https://www.appveyor.com/docs/build-configuration/#custom-environment-variables
 
+# Uncomment these lines to enable RDP
+#on_finish:
+#  - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
+
 version: 1.0.{build}
 build_cloud: libcc-20
-image: libcc-20-vs2017-15.7.4
+image: libcc-20-vs2017-15.9
 environment:
   GIT_CACHE_PATH: C:\Users\electron\libcc_cache
   DISABLE_CRASH_REPORTER_TESTS: true
   ELECTRON_OUT_DIR: Default
+  ELECTRON_ENABLE_STACK_DUMPING: 1
+notifications:
+  - provider: Webhook
+    url: https://electron-mission-control.herokuapp.com/rest/appveyor-hook
+    method: POST
+    headers:
+      x-mission-control-secret:
+        secure: 90BLVPcqhJPG7d24v0q/RRray6W3wDQ8uVQlQjOHaBWkw1i8FoA1lsjr2C/v1dVok+tS2Pi6KxDctPUkwIb4T27u4RhvmcPzQhVpfwVJAG9oNtq+yKN7vzHfg7k/pojEzVdJpQLzeJGcSrZu7VY39Q==
+    on_build_success: false
+    on_build_failure: true
+    on_build_status_changed: false
 build_script:
   - ps: >-
       if(($env:APPVEYOR_PULL_REQUEST_HEAD_REPO_NAME -split "/")[0] -eq ($env:APPVEYOR_REPO_NAME -split "/")[0]) {
@@ -38,7 +53,7 @@ build_script:
   - echo "Building $env:GN_CONFIG build"
   - git config --global core.longpaths true
   - cd ..
-  - md src
+  - ps: if (Test-Path src\electron) { Remove-Item src\electron -Recurse }
   - ps: Move-Item $env:APPVEYOR_BUILD_FOLDER -Destination src\electron
   - ps: $env:CHROMIUM_BUILDTOOLS_PATH="$pwd\src\buildtools"
   - ps: $env:SCCACHE_PATH="$pwd\src\electron\external_binaries\sccache.exe"
@@ -52,7 +67,7 @@ build_script:
       --unmanaged
       %GCLIENT_EXTRA_ARGS%
       "https://github.com/electron/electron"
-  - gclient sync --with_branch_heads --with_tags
+  - gclient sync --with_branch_heads --with_tags --reset
   - cd src
   - ps: $env:BUILD_CONFIG_PATH="//electron/build/args/%GN_CONFIG%.gn"
   - gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") %GN_EXTRA_ARGS%"

atom/app/atom_content_client.cc

@@ -268,4 +268,8 @@ void AtomContentClient::AddContentDecryptionModules(
   }
 }
 
+bool AtomContentClient::IsDataResourceGzipped(int resource_id) const {
+  return ui::ResourceBundle::GetSharedInstance().IsGzipped(resource_id);
+}
+
 }  // namespace atom

atom/app/atom_content_client.h

@@ -31,6 +31,7 @@ class AtomContentClient : public content::ContentClient {
   void AddContentDecryptionModules(
       std::vector<content::CdmInfo>* cdms,
       std::vector<media::CdmHostFilePath>* cdm_host_file_paths) override;
+  bool IsDataResourceGzipped(int resource_id) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AtomContentClient);

atom/app/atom_login_helper.mm

@@ -1,3 +1,7 @@
+// Copyright (c) 2017 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
 #import <Cocoa/Cocoa.h>
 
 int main(int argc, char* argv[]) {

atom/app/atom_main_delegate.cc

@@ -14,6 +14,8 @@
 
 #include "atom/app/atom_content_client.h"
 #include "atom/browser/atom_browser_client.h"
+#include "atom/browser/atom_gpu_client.h"
+#include "atom/browser/feature_list.h"
 #include "atom/browser/relauncher.h"
 #include "atom/common/options_switches.h"
 #include "atom/renderer/atom_renderer_client.h"
@@ -47,6 +49,10 @@
 #include "atom/app/atom_main_delegate_mac.h"
 #endif
 
+#if defined(OS_WIN)
+#include "base/win/win_util.h"
+#endif
+
 namespace atom {
 
 namespace {
@@ -136,14 +142,19 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 #if defined(DEBUG)
   // Print logging to debug.log on Windows
   settings.logging_dest = logging::LOG_TO_ALL;
-  settings.log_file = L"debug.log";
+  base::FilePath log_filename;
+  base::PathService::Get(base::DIR_EXE, &log_filename);
+  log_filename = log_filename.AppendASCII("debug.log");
+  settings.log_file = log_filename.value().c_str();
   settings.lock_log = logging::LOCK_LOG_FILE;
   settings.delete_old = logging::DELETE_OLD_LOG_FILE;
 #else
-  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+  settings.logging_dest =
+      logging::LOG_TO_SYSTEM_DEBUG_LOG | logging::LOG_TO_STDERR;
 #endif  // defined(DEBUG)
 #else   // defined(OS_WIN)
-  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+  settings.logging_dest =
+      logging::LOG_TO_SYSTEM_DEBUG_LOG | logging::LOG_TO_STDERR;
 #endif  // !defined(OS_WIN)
 
   // Only enable logging when --enable-logging is specified.
@@ -181,6 +192,9 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
   // Disable the ActiveVerifier, which is used by Chrome to track possible
   // bugs, but no use in Electron.
   base::win::DisableHandleVerifier();
+
+  if (IsBrowserProcess(command_line))
+    base::win::PinUser32();
 #endif
 
   content_client_ = std::make_unique<AtomContentClient>();
@@ -247,6 +261,10 @@ void AtomMainDelegate::PreSandboxStartup() {
 }
 
 void AtomMainDelegate::PreCreateMainMessageLoop() {
+  // This is initialized early because the service manager reads some feature
+  // flags and we need to make sure the feature list is initialized before the
+  // service manager reads the features.
+  InitializeFeatureList();
 #if defined(OS_MACOSX)
   RegisterAtomCrApp();
 #endif
@@ -257,6 +275,11 @@ content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
   return browser_client_.get();
 }
 
+content::ContentGpuClient* AtomMainDelegate::CreateContentGpuClient() {
+  gpu_client_.reset(new AtomGpuClient);
+  return gpu_client_.get();
+}
+
 content::ContentRendererClient*
 AtomMainDelegate::CreateContentRendererClient() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(

atom/app/atom_main_delegate.h

@@ -27,6 +27,7 @@ class AtomMainDelegate : public content::ContentMainDelegate {
   void PreCreateMainMessageLoop() override;
   void PostEarlyInitialization(bool is_running_tests) override;
   content::ContentBrowserClient* CreateContentBrowserClient() override;
+  content::ContentGpuClient* CreateContentGpuClient() override;
   content::ContentRendererClient* CreateContentRendererClient() override;
   content::ContentUtilityClient* CreateContentUtilityClient() override;
   int RunProcess(
@@ -48,6 +49,7 @@ class AtomMainDelegate : public content::ContentMainDelegate {
 
   std::unique_ptr<content::ContentBrowserClient> browser_client_;
   std::unique_ptr<content::ContentClient> content_client_;
+  std::unique_ptr<content::ContentGpuClient> gpu_client_;
   std::unique_ptr<content::ContentRendererClient> renderer_client_;
   std::unique_ptr<content::ContentUtilityClient> utility_client_;
 

atom/app/atom_main_delegate_mac.mm

@@ -4,6 +4,8 @@
 
 #include "atom/app/atom_main_delegate.h"
 
+#include <string>
+
 #include "atom/browser/mac/atom_application.h"
 #include "atom/common/application_info.h"
 #include "atom/common/mac/main_application_bundle.h"

atom/app/manifests.cc

@@ -18,6 +18,22 @@
 #include "chrome/services/printing/public/cpp/manifest.h"
 #endif
 
+namespace {
+
+// TODO(https://crbug.com/781334): Remove these helpers and just update the
+// manifest definitions to be marked out-of-process. This is here only to avoid
+// extra churn when transitioning away from content_packaged_services.
+service_manager::Manifest MakeOutOfProcess(
+    const service_manager::Manifest& manifest) {
+  // cpplint.py emits a false positive [build/include_what_you_use]
+  service_manager::Manifest copy(manifest);  // NOLINT
+  copy.options.execution_mode =
+      service_manager::Manifest::ExecutionMode::kOutOfProcessBuiltin;
+  return copy;
+}
+
+}  // namespace
+
 const service_manager::Manifest& GetElectronContentBrowserOverlayManifest() {
   static base::NoDestructor<service_manager::Manifest> manifest{
       service_manager::ManifestBuilder()
@@ -35,14 +51,14 @@ const service_manager::Manifest& GetElectronContentBrowserOverlayManifest() {
 }
 
 const std::vector<service_manager::Manifest>&
-GetElectronPackagedServicesOverlayManifest() {
+GetElectronBuiltinServiceManifests() {
   static base::NoDestructor<std::vector<service_manager::Manifest>> manifests{{
-      proxy_resolver::GetManifest(),
+      MakeOutOfProcess(proxy_resolver::GetManifest()),
 #if BUILDFLAG(ENABLE_PRINTING)
-      printing::GetPdfCompositorManifest(),
+      MakeOutOfProcess(printing::GetPdfCompositorManifest()),
 #endif
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
-      GetChromePrintingManifest(),
+      MakeOutOfProcess(GetChromePrintingManifest()),
 #endif
   }};
   return *manifests;

atom/app/manifests.h

@@ -11,6 +11,6 @@
 
 const service_manager::Manifest& GetElectronContentBrowserOverlayManifest();
 const std::vector<service_manager::Manifest>&
-GetElectronPackagedServicesOverlayManifest();
+GetElectronBuiltinServiceManifests();
 
 #endif  // ATOM_APP_MANIFESTS_H_

atom/app/node_main.cc

@@ -18,7 +18,7 @@
 #include "atom/common/node_includes.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
-#include "base/task/task_scheduler/task_scheduler.h"
+#include "base/task/thread_pool/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
@@ -48,7 +48,7 @@ int NodeMain(int argc, char* argv[]) {
     gin::V8Initializer::LoadV8Natives();
 
     // V8 requires a task scheduler apparently
-    base::TaskScheduler::CreateAndStartWithDefaultParams("Electron");
+    base::ThreadPool::CreateAndStartWithDefaultParams("Electron");
 
     // Initialize gin::IsolateHolder.
     JavascriptEnvironment gin_env(loop);
@@ -101,6 +101,7 @@ int NodeMain(int argc, char* argv[]) {
       }
     } while (more == true);
 
+    node_debugger.Stop();
     exit_code = node::EmitExit(env);
     node::RunAtExit(env);
     gin_env.platform()->DrainTasks(env->isolate());
@@ -112,10 +113,10 @@ int NodeMain(int argc, char* argv[]) {
 
   // According to "src/gin/shell/gin_main.cc":
   //
-  // gin::IsolateHolder waits for tasks running in TaskScheduler in its
-  // destructor and thus must be destroyed before TaskScheduler starts skipping
+  // gin::IsolateHolder waits for tasks running in ThreadPool in its
+  // destructor and thus must be destroyed before ThreadPool starts skipping
   // CONTINUE_ON_SHUTDOWN tasks.
-  base::TaskScheduler::GetInstance()->Shutdown();
+  base::ThreadPool::GetInstance()->Shutdown();
 
   v8::V8::Dispose();
 

atom/browser/api/atom_api_app.cc

@@ -24,6 +24,7 @@
 #include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/native_mate_converters/network_converter.h"
+#include "atom/common/native_mate_converters/once_callback.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
@@ -84,6 +85,7 @@ struct Converter<Browser::UserTask> {
       return false;
     dict.Get("arguments", &(out->arguments));
     dict.Get("description", &(out->description));
+    dict.Get("workingDirectory", &(out->working_dir));
     return true;
   }
 };
@@ -157,6 +159,7 @@ struct Converter<JumpListItem> {
 
         dict.Get("args", &(out->arguments));
         dict.Get("description", &(out->description));
+        dict.Get("workingDirectory", &(out->working_dir));
         return true;
 
       case JumpListItem::Type::SEPARATOR:
@@ -183,6 +186,7 @@ struct Converter<JumpListItem> {
         dict.Set("iconPath", val.icon_path);
         dict.Set("iconIndex", val.icon_index);
         dict.Set("description", val.description);
+        dict.Set("workingDirectory", val.working_dir);
         break;
 
       case JumpListItem::Type::SEPARATOR:
@@ -426,7 +430,7 @@ int GetPathConstant(const std::string& name) {
 }
 
 bool NotificationCallbackWrapper(
-    const base::Callback<
+    const base::RepeatingCallback<
         void(const base::CommandLine::StringVector& command_line,
              const base::FilePath& current_directory)>& callback,
     const base::CommandLine::StringVector& cmd,
@@ -485,7 +489,7 @@ void OnClientCertificateSelected(
       if (cert->EqualsExcludingChain((*identities)[i]->certificate())) {
         net::ClientCertIdentity::SelfOwningAcquirePrivateKey(
             std::move((*identities)[i]),
-            base::Bind(&GotPrivateKey, delegate, std::move(cert)));
+            base::BindRepeating(&GotPrivateKey, delegate, std::move(cert)));
         break;
       }
     }
@@ -529,9 +533,9 @@ int ImportIntoCertStore(CertificateManagerModel* model,
 }
 #endif
 
-void OnIconDataAvailable(util::Promise promise, gfx::Image* icon) {
-  if (icon && !icon->IsEmpty()) {
-    promise.Resolve(*icon);
+void OnIconDataAvailable(util::Promise promise, gfx::Image icon) {
+  if (!icon.IsEmpty()) {
+    promise.Resolve(icon);
   } else {
     promise.RejectWithErrorMessage("Failed to get file icon.");
   }
@@ -670,10 +674,11 @@ void App::OnLogin(scoped_refptr<LoginHandler> login_handler,
   bool prevent_default = false;
   content::WebContents* web_contents = login_handler->GetWebContents();
   if (web_contents) {
-    prevent_default = Emit(
-        "login", WebContents::FromOrCreate(isolate(), web_contents),
-        request_details, login_handler->auth_info(),
-        base::Bind(&PassLoginInformation, base::RetainedRef(login_handler)));
+    prevent_default =
+        Emit("login", WebContents::FromOrCreate(isolate(), web_contents),
+             request_details, *login_handler->auth_info(),
+             base::BindOnce(&PassLoginInformation,
+                            base::RetainedRef(login_handler)));
   }
 
   // Default behavior is to always cancel the auth.
@@ -718,10 +723,10 @@ void App::AllowCertificateError(
     int cert_error,
     const net::SSLInfo& ssl_info,
     const GURL& request_url,
-    content::ResourceType resource_type,
+    bool is_main_frame_request,
     bool strict_enforcement,
     bool expired_previous_decision,
-    const base::Callback<void(content::CertificateRequestResultType)>&
+    const base::RepeatingCallback<void(content::CertificateRequestResultType)>&
         callback) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
@@ -755,8 +760,8 @@ void App::SelectClientCertificate(
       Emit("select-client-certificate",
            WebContents::FromOrCreate(isolate(), web_contents),
            cert_request_info->host_and_port.ToString(), std::move(client_certs),
-           base::Bind(&OnClientCertificateSelected, isolate(), shared_delegate,
-                      shared_identities));
+           base::BindOnce(&OnClientCertificateSelected, isolate(),
+                          shared_delegate, shared_identities));
 
   // Default to first certificate from the platform store.
   if (!prevent_default) {
@@ -764,10 +769,14 @@ void App::SelectClientCertificate(
         (*shared_identities)[0]->certificate();
     net::ClientCertIdentity::SelfOwningAcquirePrivateKey(
         std::move((*shared_identities)[0]),
-        base::Bind(&GotPrivateKey, shared_delegate, std::move(cert)));
+        base::BindRepeating(&GotPrivateKey, shared_delegate, std::move(cert)));
   }
 }
 
+void App::OnGpuInfoUpdate() {
+  Emit("gpu-info-update");
+}
+
 void App::OnGpuProcessCrashed(base::TerminationStatus status) {
   Emit("gpu-process-crashed",
        status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED);
@@ -947,10 +956,10 @@ bool App::RequestSingleInstanceLock() {
   base::FilePath user_dir;
   base::PathService::Get(DIR_USER_DATA, &user_dir);
 
-  auto cb = base::Bind(&App::OnSecondInstance, base::Unretained(this));
+  auto cb = base::BindRepeating(&App::OnSecondInstance, base::Unretained(this));
 
   process_singleton_.reset(new ProcessSingleton(
-      user_dir, base::Bind(NotificationCallbackWrapper, cb)));
+      user_dir, base::BindRepeating(NotificationCallbackWrapper, cb)));
 
   switch (process_singleton_->NotifyOtherProcessOrCreate()) {
     case ProcessSingleton::NotifyResult::LOCK_ERROR:
@@ -1056,30 +1065,31 @@ Browser::LoginItemSettings App::GetLoginItemSettings(mate::Arguments* args) {
 
 #if defined(USE_NSS_CERTS)
 void App::ImportCertificate(const base::DictionaryValue& options,
-                            const net::CompletionCallback& callback) {
+                            net::CompletionRepeatingCallback callback) {
   auto browser_context = AtomBrowserContext::From("", false);
   if (!certificate_manager_model_) {
     auto copy = base::DictionaryValue::From(
         base::Value::ToUniquePtrValue(options.Clone()));
     CertificateManagerModel::Create(
         browser_context.get(),
-        base::Bind(&App::OnCertificateManagerModelCreated,
-                   base::Unretained(this), base::Passed(&copy), callback));
+        base::BindRepeating(&App::OnCertificateManagerModelCreated,
+                            base::Unretained(this), base::Passed(&copy),
+                            callback));
     return;
   }
 
   int rv = ImportIntoCertStore(certificate_manager_model_.get(), options);
-  callback.Run(rv);
+  std::move(callback).Run(rv);
 }
 
 void App::OnCertificateManagerModelCreated(
     std::unique_ptr<base::DictionaryValue> options,
-    const net::CompletionCallback& callback,
+    net::CompletionOnceCallback callback,
     std::unique_ptr<CertificateManagerModel> model) {
   certificate_manager_model_ = std::move(model);
   int rv =
       ImportIntoCertStore(certificate_manager_model_.get(), *(options.get()));
-  callback.Run(rv);
+  std::move(callback).Run(rv);
 }
 #endif
 
@@ -1268,6 +1278,21 @@ void App::EnableSandbox(mate::Arguments* args) {
   command_line->AppendSwitch(switches::kEnableSandbox);
 }
 
+void App::SetUserAgentFallback(const std::string& user_agent) {
+  AtomBrowserClient::Get()->SetUserAgent(user_agent);
+}
+
+std::string App::GetUserAgentFallback() {
+  return AtomBrowserClient::Get()->GetUserAgent();
+}
+
+void App::SetBrowserClientCanUseCustomSiteInstance(bool should_disable) {
+  AtomBrowserClient::Get()->SetCanUseCustomSiteInstance(should_disable);
+}
+bool App::CanBrowserClientUseCustomSiteInstance() {
+  return AtomBrowserClient::Get()->CanUseCustomSiteInstance();
+}
+
 #if defined(OS_MACOSX)
 bool App::MoveToApplicationsFolder(mate::Arguments* args) {
   return ui::cocoa::AtomBundleMover::Move(args);
@@ -1280,9 +1305,9 @@ bool App::IsInApplicationsFolder() {
 int DockBounce(const std::string& type) {
   int request_id = -1;
   if (type == "critical")
-    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_CRITICAL);
+    request_id = Browser::Get()->DockBounce(Browser::BounceType::CRITICAL);
   else if (type == "informational")
-    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_INFORMATIONAL);
+    request_id = Browser::Get()->DockBounce(Browser::BounceType::INFORMATIONAL);
   return request_id;
 }
 
@@ -1297,20 +1322,25 @@ v8::Local<v8::Value> App::GetDockAPI(v8::Isolate* isolate) {
     auto browser = base::Unretained(Browser::Get());
     mate::Dictionary dock_obj = mate::Dictionary::CreateEmpty(isolate);
     dock_obj.SetMethod("bounce", &DockBounce);
-    dock_obj.SetMethod("cancelBounce",
-                       base::Bind(&Browser::DockCancelBounce, browser));
-    dock_obj.SetMethod("downloadFinished",
-                       base::Bind(&Browser::DockDownloadFinished, browser));
-    dock_obj.SetMethod("setBadge",
-                       base::Bind(&Browser::DockSetBadgeText, browser));
-    dock_obj.SetMethod("getBadge",
-                       base::Bind(&Browser::DockGetBadgeText, browser));
-    dock_obj.SetMethod("hide", base::Bind(&Browser::DockHide, browser));
-    dock_obj.SetMethod("show", base::Bind(&Browser::DockShow, browser));
+    dock_obj.SetMethod(
+        "cancelBounce",
+        base::BindRepeating(&Browser::DockCancelBounce, browser));
+    dock_obj.SetMethod(
+        "downloadFinished",
+        base::BindRepeating(&Browser::DockDownloadFinished, browser));
+    dock_obj.SetMethod(
+        "setBadge", base::BindRepeating(&Browser::DockSetBadgeText, browser));
+    dock_obj.SetMethod(
+        "getBadge", base::BindRepeating(&Browser::DockGetBadgeText, browser));
+    dock_obj.SetMethod("hide",
+                       base::BindRepeating(&Browser::DockHide, browser));
+    dock_obj.SetMethod("show",
+                       base::BindRepeating(&Browser::DockShow, browser));
     dock_obj.SetMethod("isVisible",
-                       base::Bind(&Browser::DockIsVisible, browser));
+                       base::BindRepeating(&Browser::DockIsVisible, browser));
     dock_obj.SetMethod("setMenu", &DockSetMenu);
-    dock_obj.SetMethod("setIcon", base::Bind(&Browser::DockSetIcon, browser));
+    dock_obj.SetMethod("setIcon",
+                       base::BindRepeating(&Browser::DockSetIcon, browser));
 
     dock_.Reset(isolate, dock_obj.GetHandle());
   }
@@ -1329,70 +1359,84 @@ void App::BuildPrototype(v8::Isolate* isolate,
   prototype->SetClassName(mate::StringToV8(isolate, "App"));
   auto browser = base::Unretained(Browser::Get());
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
-      .SetMethod("quit", base::Bind(&Browser::Quit, browser))
-      .SetMethod("exit", base::Bind(&Browser::Exit, browser))
-      .SetMethod("focus", base::Bind(&Browser::Focus, browser))
-      .SetMethod("getVersion", base::Bind(&Browser::GetVersion, browser))
-      .SetMethod("setVersion", base::Bind(&Browser::SetVersion, browser))
-      .SetMethod("getName", base::Bind(&Browser::GetName, browser))
-      .SetMethod("setName", base::Bind(&Browser::SetName, browser))
-      .SetMethod("isReady", base::Bind(&Browser::is_ready, browser))
-      .SetMethod("whenReady", base::Bind(&Browser::WhenReady, browser))
+      .SetMethod("quit", base::BindRepeating(&Browser::Quit, browser))
+      .SetMethod("exit", base::BindRepeating(&Browser::Exit, browser))
+      .SetMethod("focus", base::BindRepeating(&Browser::Focus, browser))
+      .SetMethod("getVersion",
+                 base::BindRepeating(&Browser::GetVersion, browser))
+      .SetMethod("setVersion",
+                 base::BindRepeating(&Browser::SetVersion, browser))
+      .SetMethod("_getName", base::BindRepeating(&Browser::GetName, browser))
+      .SetMethod("_setName", base::BindRepeating(&Browser::SetName, browser))
+      .SetMethod("isReady", base::BindRepeating(&Browser::is_ready, browser))
+      .SetMethod("whenReady", base::BindRepeating(&Browser::WhenReady, browser))
       .SetMethod("addRecentDocument",
-                 base::Bind(&Browser::AddRecentDocument, browser))
+                 base::BindRepeating(&Browser::AddRecentDocument, browser))
       .SetMethod("clearRecentDocuments",
-                 base::Bind(&Browser::ClearRecentDocuments, browser))
+                 base::BindRepeating(&Browser::ClearRecentDocuments, browser))
       .SetMethod("setAppUserModelId",
-                 base::Bind(&Browser::SetAppUserModelID, browser))
-      .SetMethod("isDefaultProtocolClient",
-                 base::Bind(&Browser::IsDefaultProtocolClient, browser))
-      .SetMethod("setAsDefaultProtocolClient",
-                 base::Bind(&Browser::SetAsDefaultProtocolClient, browser))
-      .SetMethod("removeAsDefaultProtocolClient",
-                 base::Bind(&Browser::RemoveAsDefaultProtocolClient, browser))
-      .SetMethod("setBadgeCount", base::Bind(&Browser::SetBadgeCount, browser))
-      .SetMethod("getBadgeCount", base::Bind(&Browser::GetBadgeCount, browser))
+                 base::BindRepeating(&Browser::SetAppUserModelID, browser))
+      .SetMethod(
+          "isDefaultProtocolClient",
+          base::BindRepeating(&Browser::IsDefaultProtocolClient, browser))
+      .SetMethod(
+          "setAsDefaultProtocolClient",
+          base::BindRepeating(&Browser::SetAsDefaultProtocolClient, browser))
+      .SetMethod(
+          "removeAsDefaultProtocolClient",
+          base::BindRepeating(&Browser::RemoveAsDefaultProtocolClient, browser))
+      .SetMethod("_setBadgeCount",
+                 base::BindRepeating(&Browser::SetBadgeCount, browser))
+      .SetMethod("_getBadgeCount",
+                 base::BindRepeating(&Browser::GetBadgeCount, browser))
       .SetMethod("getLoginItemSettings", &App::GetLoginItemSettings)
       .SetMethod("setLoginItemSettings",
-                 base::Bind(&Browser::SetLoginItemSettings, browser))
+                 base::BindRepeating(&Browser::SetLoginItemSettings, browser))
       .SetMethod("isEmojiPanelSupported",
-                 base::Bind(&Browser::IsEmojiPanelSupported, browser))
+                 base::BindRepeating(&Browser::IsEmojiPanelSupported, browser))
+      .SetProperty("badgeCount",
+                   base::BindRepeating(&Browser::GetBadgeCount, browser),
+                   base::BindRepeating(&Browser::SetBadgeCount, browser))
+      .SetProperty("name", base::BindRepeating(&Browser::GetName, browser),
+                   base::BindRepeating(&Browser::SetName, browser))
 #if defined(OS_MACOSX)
-      .SetMethod("hide", base::Bind(&Browser::Hide, browser))
-      .SetMethod("show", base::Bind(&Browser::Show, browser))
+      .SetMethod("hide", base::BindRepeating(&Browser::Hide, browser))
+      .SetMethod("show", base::BindRepeating(&Browser::Show, browser))
       .SetMethod("setUserActivity",
-                 base::Bind(&Browser::SetUserActivity, browser))
+                 base::BindRepeating(&Browser::SetUserActivity, browser))
       .SetMethod("getCurrentActivityType",
-                 base::Bind(&Browser::GetCurrentActivityType, browser))
-      .SetMethod("invalidateCurrentActivity",
-                 base::Bind(&Browser::InvalidateCurrentActivity, browser))
+                 base::BindRepeating(&Browser::GetCurrentActivityType, browser))
+      .SetMethod(
+          "invalidateCurrentActivity",
+          base::BindRepeating(&Browser::InvalidateCurrentActivity, browser))
       .SetMethod("updateCurrentActivity",
-                 base::Bind(&Browser::UpdateCurrentActivity, browser))
+                 base::BindRepeating(&Browser::UpdateCurrentActivity, browser))
       // TODO(juturu): Remove in 2.0, deprecate before then with warnings
       .SetMethod("moveToApplicationsFolder", &App::MoveToApplicationsFolder)
       .SetMethod("isInApplicationsFolder", &App::IsInApplicationsFolder)
 #endif
 #if defined(OS_MACOSX) || defined(OS_LINUX)
       .SetMethod("setAboutPanelOptions",
-                 base::Bind(&Browser::SetAboutPanelOptions, browser))
+                 base::BindRepeating(&Browser::SetAboutPanelOptions, browser))
       .SetMethod("showAboutPanel",
-                 base::Bind(&Browser::ShowAboutPanel, browser))
+                 base::BindRepeating(&Browser::ShowAboutPanel, browser))
 #endif
 #if defined(OS_MACOSX) || defined(OS_WIN)
       .SetMethod("showEmojiPanel",
-                 base::Bind(&Browser::ShowEmojiPanel, browser))
+                 base::BindRepeating(&Browser::ShowEmojiPanel, browser))
       .SetProperty("accessibilitySupportEnabled",
                    &App::IsAccessibilitySupportEnabled,
                    &App::SetAccessibilitySupportEnabled)
 #endif
 #if defined(OS_WIN)
-      .SetMethod("setUserTasks", base::Bind(&Browser::SetUserTasks, browser))
+      .SetMethod("setUserTasks",
+                 base::BindRepeating(&Browser::SetUserTasks, browser))
       .SetMethod("getJumpListSettings", &App::GetJumpListSettings)
       .SetMethod("setJumpList", &App::SetJumpList)
 #endif
 #if defined(OS_LINUX)
       .SetMethod("isUnityRunning",
-                 base::Bind(&Browser::IsUnityRunning, browser))
+                 base::BindRepeating(&Browser::IsUnityRunning, browser))
 #endif
       .SetMethod("setAppPath", &App::SetAppPath)
       .SetMethod("getAppPath", &App::GetAppPath)
@@ -1428,7 +1472,12 @@ void App::BuildPrototype(v8::Isolate* isolate,
 #if defined(OS_MACOSX)
       .SetProperty("dock", &App::GetDockAPI)
 #endif
-      .SetMethod("enableSandbox", &App::EnableSandbox);
+      .SetProperty("userAgentFallback", &App::GetUserAgentFallback,
+                   &App::SetUserAgentFallback)
+      .SetMethod("enableSandbox", &App::EnableSandbox)
+      .SetProperty("allowRendererProcessReuse",
+                   &App::CanBrowserClientUseCustomSiteInstance,
+                   &App::SetBrowserClientCanUseCustomSiteInstance);
 }
 
 }  // namespace api

atom/browser/api/atom_api_app.h

@@ -27,7 +27,8 @@
 #include "content/public/browser/render_process_host.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/handle.h"
-#include "net/base/completion_callback.h"
+#include "net/base/completion_once_callback.h"
+#include "net/base/completion_repeating_callback.h"
 #include "net/ssl/client_cert_identity.h"
 
 #if defined(USE_NSS_CERTS)
@@ -68,7 +69,7 @@ class App : public AtomBrowserClient::Delegate,
             public content::BrowserChildProcessObserver {
  public:
   using FileIconCallback =
-      base::Callback<void(v8::Local<v8::Value>, const gfx::Image&)>;
+      base::RepeatingCallback<void(v8::Local<v8::Value>, const gfx::Image&)>;
 
   static mate::Handle<App> Create(v8::Isolate* isolate);
 
@@ -78,7 +79,7 @@ class App : public AtomBrowserClient::Delegate,
 #if defined(USE_NSS_CERTS)
   void OnCertificateManagerModelCreated(
       std::unique_ptr<base::DictionaryValue> options,
-      const net::CompletionCallback& callback,
+      net::CompletionOnceCallback callback,
       std::unique_ptr<CertificateManagerModel> model);
 #endif
 
@@ -129,11 +130,11 @@ class App : public AtomBrowserClient::Delegate,
       int cert_error,
       const net::SSLInfo& ssl_info,
       const GURL& request_url,
-      content::ResourceType resource_type,
+      bool is_main_frame_request,
       bool strict_enforcement,
       bool expired_previous_decision,
-      const base::Callback<void(content::CertificateRequestResultType)>&
-          callback) override;
+      const base::RepeatingCallback<
+          void(content::CertificateRequestResultType)>& callback) override;
   void SelectClientCertificate(
       content::WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
@@ -156,6 +157,7 @@ class App : public AtomBrowserClient::Delegate,
                        bool* no_javascript_access) override;
 
   // content::GpuDataManagerObserver:
+  void OnGpuInfoUpdate() override;
   void OnGpuProcessCrashed(base::TerminationStatus status) override;
 
   // content::BrowserChildProcessObserver:
@@ -199,7 +201,7 @@ class App : public AtomBrowserClient::Delegate,
   Browser::LoginItemSettings GetLoginItemSettings(mate::Arguments* args);
 #if defined(USE_NSS_CERTS)
   void ImportCertificate(const base::DictionaryValue& options,
-                         const net::CompletionCallback& callback);
+                         net::CompletionRepeatingCallback callback);
 #endif
   v8::Local<v8::Promise> GetFileIcon(const base::FilePath& path,
                                      mate::Arguments* args);
@@ -209,6 +211,10 @@ class App : public AtomBrowserClient::Delegate,
   v8::Local<v8::Promise> GetGPUInfo(v8::Isolate* isolate,
                                     const std::string& info_type);
   void EnableSandbox(mate::Arguments* args);
+  void SetUserAgentFallback(const std::string& user_agent);
+  std::string GetUserAgentFallback();
+  void SetBrowserClientCanUseCustomSiteInstance(bool should_disable);
+  bool CanBrowserClientUseCustomSiteInstance();
 
 #if defined(OS_MACOSX)
   bool MoveToApplicationsFolder(mate::Arguments* args);
@@ -218,7 +224,7 @@ class App : public AtomBrowserClient::Delegate,
 #endif
 
 #if defined(MAS_BUILD)
-  base::Callback<void()> StartAccessingSecurityScopedResource(
+  base::RepeatingCallback<void()> StartAccessingSecurityScopedResource(
       mate::Arguments* args);
 #endif
 

atom/browser/api/atom_api_app_mac.mm

@@ -33,6 +33,6 @@ void App::SetAppLogsPath(mate::Arguments* args) {
   }
 }
 
-}  // namespace atom
-
 }  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_app_mas.mm

@@ -4,6 +4,8 @@
 
 #include "atom/browser/api/atom_api_app.h"
 
+#include <string>
+
 #import <Cocoa/Cocoa.h>
 
 #include "base/strings/sys_string_conversions.h"
@@ -19,13 +21,13 @@ void OnStopAccessingSecurityScopedResource(NSURL* bookmarkUrl) {
 }
 
 // Get base64 encoded NSData, create a bookmark for it and start accessing it.
-base::Callback<void()> App::StartAccessingSecurityScopedResource(
+base::RepeatingCallback<void()> App::StartAccessingSecurityScopedResource(
     mate::Arguments* args) {
   std::string data;
   args->GetNext(&data);
   NSString* base64str = base::SysUTF8ToNSString(data);
-  NSData* bookmarkData =
-      [[NSData alloc] initWithBase64EncodedString:base64str options:0];
+  NSData* bookmarkData = [[NSData alloc] initWithBase64EncodedString:base64str
+                                                             options:0];
 
   // Create bookmarkUrl from NSData.
   BOOL isStale = false;
@@ -55,9 +57,10 @@ base::Callback<void()> App::StartAccessingSecurityScopedResource(
   [bookmarkUrl retain];
 
   // Return a js callback which will close the bookmark.
-  return base::Bind(&OnStopAccessingSecurityScopedResource, bookmarkUrl);
+  return base::BindRepeating(&OnStopAccessingSecurityScopedResource,
+                             bookmarkUrl);
 }
 
-}  // namespace atom
-
 }  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_auto_updater.cc

@@ -64,11 +64,17 @@ void AutoUpdater::OnError(const std::string& message,
   auto errorObject =
       error->ToObject(isolate()->GetCurrentContext()).ToLocalChecked();
 
+  auto context = isolate()->GetCurrentContext();
+
   // add two new params for better error handling
-  errorObject->Set(mate::StringToV8(isolate(), "code"),
-                   v8::Integer::New(isolate(), code));
-  errorObject->Set(mate::StringToV8(isolate(), "domain"),
-                   mate::StringToV8(isolate(), domain));
+  errorObject
+      ->Set(context, mate::StringToV8(isolate(), "code"),
+            v8::Integer::New(isolate(), code))
+      .Check();
+  errorObject
+      ->Set(context, mate::StringToV8(isolate(), "domain"),
+            mate::StringToV8(isolate(), domain))
+      .Check();
 
   mate::EmitEvent(isolate(), GetWrapper(), "error", errorObject, message);
 }
@@ -91,7 +97,8 @@ void AutoUpdater::OnUpdateDownloaded(const std::string& release_notes,
                                      const std::string& url) {
   Emit("update-downloaded", release_notes, release_name, release_date, url,
        // Keep compatibility with old APIs.
-       base::Bind(&AutoUpdater::QuitAndInstall, base::Unretained(this)));
+       base::BindRepeating(&AutoUpdater::QuitAndInstall,
+                           base::Unretained(this)));
 }
 
 void AutoUpdater::OnWindowAllClosed() {

atom/browser/api/atom_api_browser_view.cc

@@ -68,7 +68,7 @@ void BrowserView::Init(v8::Isolate* isolate,
                        const mate::Dictionary& options) {
   mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
   options.Get(options::kWebPreferences, &web_preferences);
-  web_preferences.Set("isBrowserView", true);
+  web_preferences.Set("type", "browserView");
   mate::Handle<class WebContents> web_contents =
       WebContents::Create(isolate, web_preferences);
 
@@ -165,7 +165,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  BrowserView::SetConstructor(isolate, base::Bind(&BrowserView::New));
+  BrowserView::SetConstructor(isolate, base::BindRepeating(&BrowserView::New));
 
   mate::Dictionary browser_view(isolate, BrowserView::GetConstructor(isolate)
                                              ->GetFunction(context)

atom/browser/api/atom_api_browser_window.cc

@@ -392,8 +392,8 @@ void BrowserWindow::ScheduleUnresponsiveEvent(int ms) {
   if (!window_unresponsive_closure_.IsCancelled())
     return;
 
-  window_unresponsive_closure_.Reset(
-      base::Bind(&BrowserWindow::NotifyWindowUnresponsive, GetWeakPtr()));
+  window_unresponsive_closure_.Reset(base::BindRepeating(
+      &BrowserWindow::NotifyWindowUnresponsive, GetWeakPtr()));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, window_unresponsive_closure_.callback(),
       base::TimeDelta::FromMilliseconds(ms));
@@ -474,8 +474,9 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("BrowserWindow", mate::CreateConstructor<BrowserWindow>(
-                                isolate, base::Bind(&BrowserWindow::New)));
+  dict.Set("BrowserWindow",
+           mate::CreateConstructor<BrowserWindow>(
+               isolate, base::BindRepeating(&BrowserWindow::New)));
 }
 
 }  // namespace

atom/browser/api/atom_api_browser_window_mac.mm

@@ -4,6 +4,9 @@
 
 #include "atom/browser/api/atom_api_browser_window.h"
 
+#include <memory>
+#include <vector>
+
 #import <Cocoa/Cocoa.h>
 
 #include "atom/browser/native_browser_view.h"

atom/browser/api/atom_api_content_tracing.cc

@@ -4,6 +4,7 @@
 
 #include <set>
 #include <string>
+#include <utility>
 
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
@@ -12,6 +13,7 @@
 #include "atom/common/promise_util.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
+#include "base/optional.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/public/browser/tracing_controller.h"
 #include "native_mate/dictionary.h"
@@ -53,35 +55,44 @@ struct Converter<base::trace_event::TraceConfig> {
 
 namespace {
 
-using CompletionCallback = base::Callback<void(const base::FilePath&)>;
+using CompletionCallback = base::OnceCallback<void(const base::FilePath&)>;
 
-scoped_refptr<TracingController::TraceDataEndpoint> GetTraceDataEndpoint(
-    const base::FilePath& path,
-    const CompletionCallback& callback) {
-  base::FilePath result_file_path = path;
-
-  // base::CreateTemporaryFile prevents blocking so we need to allow it
-  // for now since offloading this to a different sequence would require
-  // changing the api shape
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-  if (result_file_path.empty() && !base::CreateTemporaryFile(&result_file_path))
-    LOG(ERROR) << "Creating temporary file failed";
-
-  return TracingController::CreateFileEndpoint(
-      result_file_path, base::Bind(callback, result_file_path));
+base::Optional<base::FilePath> CreateTemporaryFileOnIO() {
+  base::FilePath temp_file_path;
+  if (!base::CreateTemporaryFile(&temp_file_path))
+    return base::nullopt;
+  return base::make_optional(std::move(temp_file_path));
 }
 
-v8::Local<v8::Promise> StopRecording(v8::Isolate* isolate,
-                                     const base::FilePath& path) {
-  atom::util::Promise promise(isolate);
+void StopTracing(atom::util::Promise promise,
+                 base::Optional<base::FilePath> file_path) {
+  if (file_path) {
+    auto endpoint = TracingController::CreateFileEndpoint(
+        *file_path, base::AdaptCallbackForRepeating(base::BindOnce(
+                        &atom::util::Promise::ResolvePromise<base::FilePath>,
+                        std::move(promise), *file_path)));
+    TracingController::GetInstance()->StopTracing(endpoint);
+  } else {
+    promise.RejectWithErrorMessage(
+        "Failed to create temporary file for trace data");
+  }
+}
+
+v8::Local<v8::Promise> StopRecording(mate::Arguments* args) {
+  atom::util::Promise promise(args->isolate());
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  // TODO(zcbenz): Remove the use of CopyablePromise when the
-  // CreateFileEndpoint API accepts OnceCallback.
-  TracingController::GetInstance()->StopTracing(GetTraceDataEndpoint(
-      path, base::Bind(atom::util::CopyablePromise::ResolveCopyablePromise<
-                           const base::FilePath&>,
-                       atom::util::CopyablePromise(promise))));
+  base::FilePath path;
+  if (args->GetNext(&path) && !path.empty()) {
+    StopTracing(std::move(promise), base::make_optional(path));
+  } else {
+    // use a temporary file.
+    base::PostTaskWithTraitsAndReplyWithResult(
+        FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
+        base::BindOnce(CreateTemporaryFileOnIO),
+        base::BindOnce(StopTracing, std::move(promise)));
+  }
+
   return handle;
 }
 
@@ -103,10 +114,15 @@ v8::Local<v8::Promise> StartTracing(
   atom::util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  // Note: This method always succeeds.
-  TracingController::GetInstance()->StartTracing(
-      trace_config, base::BindOnce(atom::util::Promise::ResolveEmptyPromise,
-                                   std::move(promise)));
+  if (!TracingController::GetInstance()->StartTracing(
+          trace_config, base::BindOnce(atom::util::Promise::ResolveEmptyPromise,
+                                       std::move(promise)))) {
+    // If StartTracing returns false, that means it didn't invoke its callback.
+    // Return an already-resolved promise and abandon the previous promise (it
+    // was std::move()d into the StartTracing callback and has been deleted by
+    // this point).
+    return atom::util::Promise::ResolvedPromise(isolate);
+  }
   return handle;
 }
 

atom/browser/api/atom_api_cookies.cc

@@ -12,14 +12,14 @@
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
-#include "base/task/post_task.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
-#include "native_mate/dictionary.h"
-#include "native_mate/object_template_builder.h"
+#include "content/public/browser/storage_partition.h"
+#include "gin/dictionary.h"
+#include "gin/object_template_builder.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_store.h"
 #include "net/cookies/cookie_util.h"
@@ -28,24 +28,13 @@
 
 using content::BrowserThread;
 
-namespace mate {
-
-template <>
-struct Converter<atom::api::Cookies::Error> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   atom::api::Cookies::Error val) {
-    if (val == atom::api::Cookies::SUCCESS)
-      return v8::Null(isolate);
-    else
-      return v8::Exception::Error(StringToV8(isolate, "Setting cookie failed"));
-  }
-};
+namespace gin {
 
 template <>
 struct Converter<net::CanonicalCookie> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    const net::CanonicalCookie& val) {
-    mate::Dictionary dict(isolate, v8::Object::New(isolate));
+    gin::Dictionary dict(isolate, v8::Object::New(isolate));
     dict.Set("name", val.Name());
     dict.Set("value", val.Value());
     dict.Set("domain", val.Domain());
@@ -56,7 +45,7 @@ struct Converter<net::CanonicalCookie> {
     dict.Set("session", !val.IsPersistent());
     if (val.IsPersistent())
       dict.Set("expirationDate", val.ExpiryDate().ToDoubleT());
-    return dict.GetHandle();
+    return ConvertToV8(isolate, dict).As<v8::Object>();
   }
 };
 
@@ -68,22 +57,22 @@ struct Converter<network::mojom::CookieChangeCause> {
     switch (val) {
       case network::mojom::CookieChangeCause::INSERTED:
       case network::mojom::CookieChangeCause::EXPLICIT:
-        return mate::StringToV8(isolate, "explicit");
+        return gin::StringToV8(isolate, "explicit");
       case network::mojom::CookieChangeCause::OVERWRITE:
-        return mate::StringToV8(isolate, "overwrite");
+        return gin::StringToV8(isolate, "overwrite");
       case network::mojom::CookieChangeCause::EXPIRED:
-        return mate::StringToV8(isolate, "expired");
+        return gin::StringToV8(isolate, "expired");
       case network::mojom::CookieChangeCause::EVICTED:
-        return mate::StringToV8(isolate, "evicted");
+        return gin::StringToV8(isolate, "evicted");
       case network::mojom::CookieChangeCause::EXPIRED_OVERWRITE:
-        return mate::StringToV8(isolate, "expired-overwrite");
+        return gin::StringToV8(isolate, "expired-overwrite");
       default:
-        return mate::StringToV8(isolate, "unknown");
+        return gin::StringToV8(isolate, "unknown");
     }
   }
 };
 
-}  // namespace mate
+}  // namespace gin
 
 namespace atom {
 
@@ -113,203 +102,60 @@ bool MatchesDomain(std::string filter, const std::string& domain) {
 }
 
 // Returns whether |cookie| matches |filter|.
-bool MatchesCookie(const base::DictionaryValue* filter,
+bool MatchesCookie(const base::Value& filter,
                    const net::CanonicalCookie& cookie) {
-  std::string str;
-  bool b;
-  if (filter->GetString("name", &str) && str != cookie.Name())
+  const std::string* str;
+  if ((str = filter.FindStringKey("name")) && *str != cookie.Name())
     return false;
-  if (filter->GetString("path", &str) && str != cookie.Path())
+  if ((str = filter.FindStringKey("path")) && *str != cookie.Path())
     return false;
-  if (filter->GetString("domain", &str) && !MatchesDomain(str, cookie.Domain()))
+  if ((str = filter.FindStringKey("domain")) &&
+      !MatchesDomain(*str, cookie.Domain()))
     return false;
-  if (filter->GetBoolean("secure", &b) && b != cookie.IsSecure())
+  base::Optional<bool> secure_filter = filter.FindBoolKey("secure");
+  if (secure_filter && *secure_filter == cookie.IsSecure())
     return false;
-  if (filter->GetBoolean("session", &b) && b != !cookie.IsPersistent())
+  base::Optional<bool> session_filter = filter.FindBoolKey("session");
+  if (session_filter && *session_filter != !cookie.IsPersistent())
     return false;
   return true;
 }
 
-// Helper to returns the CookieStore.
-inline net::CookieStore* GetCookieStore(
-    scoped_refptr<net::URLRequestContextGetter> getter) {
-  return getter->GetURLRequestContext()->cookie_store();
-}
-
 // Remove cookies from |list| not matching |filter|, and pass it to |callback|.
-void FilterCookies(std::unique_ptr<base::DictionaryValue> filter,
+void FilterCookies(const base::Value& filter,
                    util::Promise promise,
                    const net::CookieList& list,
                    const net::CookieStatusList& excluded_list) {
   net::CookieList result;
   for (const auto& cookie : list) {
-    if (MatchesCookie(filter.get(), cookie))
+    if (MatchesCookie(filter, cookie))
       result.push_back(cookie);
   }
 
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::UI},
-      base::BindOnce(util::Promise::ResolvePromise<const net::CookieList&>,
-                     std::move(promise), std::move(result)));
+  promise.Resolve(gin::ConvertToV8(promise.isolate(), result));
 }
 
-// Receives cookies matching |filter| in IO thread.
-void GetCookiesOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
-                    std::unique_ptr<base::DictionaryValue> filter,
-                    util::Promise promise) {
-  std::string url;
-  filter->GetString("url", &url);
-
-  auto filtered_callback =
-      base::BindOnce(FilterCookies, std::move(filter), std::move(promise));
-
-  // Empty url will match all url cookies.
-  if (url.empty())
-    GetCookieStore(getter)->GetAllCookiesAsync(std::move(filtered_callback));
-  else
-    GetCookieStore(getter)->GetAllCookiesForURLAsync(
-        GURL(url), std::move(filtered_callback));
-}
-
-// Removes cookie with |url| and |name| in IO thread.
-void RemoveCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
-                      const GURL& url,
-                      const std::string& name,
-                      util::Promise promise) {
-  net::CookieDeletionInfo cookie_info;
-  cookie_info.url = url;
-  cookie_info.name = name;
-  GetCookieStore(getter)->DeleteAllMatchingInfoAsync(
-      std::move(cookie_info),
-      base::BindOnce(
-          [](util::Promise promise, uint32_t num_deleted) {
-            util::Promise::ResolveEmptyPromise(std::move(promise));
-          },
-          std::move(promise)));
-}
-
-// Callback of SetCookie.
-void OnSetCookie(util::Promise promise,
-                 net::CanonicalCookie::CookieInclusionStatus status) {
-  std::string errmsg;
+std::string InclusionStatusToString(
+    net::CanonicalCookie::CookieInclusionStatus status) {
   switch (status) {
     case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_HTTP_ONLY:
-      errmsg = "Failed to create httponly cookie";
-      break;
+      return "Failed to create httponly cookie";
     case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY:
-      errmsg = "Cannot create a secure cookie from an insecure URL";
-      break;
+      return "Cannot create a secure cookie from an insecure URL";
     case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_FAILURE_TO_STORE:
-      errmsg = "Failed to parse cookie";
-      break;
+      return "Failed to parse cookie";
     case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_INVALID_DOMAIN:
-      errmsg = "Failed to get cookie domain";
-      break;
+      return "Failed to get cookie domain";
     case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_INVALID_PREFIX:
-      errmsg = "Failed because the cookie violated prefix rules.";
-      break;
+      return "Failed because the cookie violated prefix rules.";
     case net::CanonicalCookie::CookieInclusionStatus::
         EXCLUDE_NONCOOKIEABLE_SCHEME:
-      errmsg = "Cannot set cookie for current scheme";
-      break;
+      return "Cannot set cookie for current scheme";
     case net::CanonicalCookie::CookieInclusionStatus::INCLUDE:
-      errmsg = "";
-      break;
+      return "";
     default:
-      errmsg = "Setting cookie failed";
-      break;
+      return "Setting cookie failed";
   }
-  if (errmsg.empty()) {
-    base::PostTaskWithTraits(
-        FROM_HERE, {BrowserThread::UI},
-        base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
-  } else {
-    base::PostTaskWithTraits(
-        FROM_HERE, {BrowserThread::UI},
-        base::BindOnce(util::Promise::RejectPromise, std::move(promise),
-                       std::move(errmsg)));
-  }
-}
-
-// Flushes cookie store in IO thread.
-void FlushCookieStoreOnIOThread(
-    scoped_refptr<net::URLRequestContextGetter> getter,
-    util::Promise promise) {
-  GetCookieStore(getter)->FlushStore(
-      base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
-}
-
-// Sets cookie with |details| in IO thread.
-void SetCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
-                   std::unique_ptr<base::DictionaryValue> details,
-                   util::Promise promise) {
-  std::string url_string, name, value, domain, path;
-  bool secure = false;
-  bool http_only = false;
-  double creation_date;
-  double expiration_date;
-  double last_access_date;
-  details->GetString("url", &url_string);
-  details->GetString("name", &name);
-  details->GetString("value", &value);
-  details->GetString("domain", &domain);
-  details->GetString("path", &path);
-  details->GetBoolean("secure", &secure);
-  details->GetBoolean("httpOnly", &http_only);
-
-  base::Time creation_time;
-  if (details->GetDouble("creationDate", &creation_date)) {
-    creation_time = (creation_date == 0)
-                        ? base::Time::UnixEpoch()
-                        : base::Time::FromDoubleT(creation_date);
-  }
-
-  base::Time expiration_time;
-  if (details->GetDouble("expirationDate", &expiration_date)) {
-    expiration_time = (expiration_date == 0)
-                          ? base::Time::UnixEpoch()
-                          : base::Time::FromDoubleT(expiration_date);
-  }
-
-  base::Time last_access_time;
-  if (details->GetDouble("lastAccessDate", &last_access_date)) {
-    last_access_time = (last_access_date == 0)
-                           ? base::Time::UnixEpoch()
-                           : base::Time::FromDoubleT(last_access_date);
-  }
-
-  GURL url(url_string);
-  std::unique_ptr<net::CanonicalCookie> canonical_cookie(
-      net::CanonicalCookie::CreateSanitizedCookie(
-          url, name, value, domain, path, creation_time, expiration_time,
-          last_access_time, secure, http_only,
-          net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT));
-  auto completion_callback = base::BindOnce(OnSetCookie, std::move(promise));
-  if (!canonical_cookie || !canonical_cookie->IsCanonical()) {
-    std::move(completion_callback)
-        .Run(net::CanonicalCookie::CookieInclusionStatus::
-                 EXCLUDE_FAILURE_TO_STORE);
-    return;
-  }
-  if (url.is_empty()) {
-    std::move(completion_callback)
-        .Run(net::CanonicalCookie::CookieInclusionStatus::
-                 EXCLUDE_INVALID_DOMAIN);
-    return;
-  }
-  if (name.empty()) {
-    std::move(completion_callback)
-        .Run(net::CanonicalCookie::CookieInclusionStatus::
-                 EXCLUDE_FAILURE_TO_STORE);
-    return;
-  }
-  net::CookieOptions options;
-  if (http_only) {
-    options.set_include_httponly();
-  }
-  GetCookieStore(getter)->SetCanonicalCookieAsync(
-      std::move(canonical_cookie), url.scheme(), options,
-      std::move(completion_callback));
 }
 
 }  // namespace
@@ -319,7 +165,8 @@ Cookies::Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context)
   Init(isolate);
   cookie_change_subscription_ =
       browser_context_->cookie_change_notifier()->RegisterCookieChangeCallback(
-          base::Bind(&Cookies::OnCookieChanged, base::Unretained(this)));
+          base::BindRepeating(&Cookies::OnCookieChanged,
+                              base::Unretained(this)));
 }
 
 Cookies::~Cookies() {}
@@ -328,13 +175,33 @@ v8::Local<v8::Promise> Cookies::Get(const base::DictionaryValue& filter) {
   util::Promise promise(isolate());
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  auto copy = base::DictionaryValue::From(
-      base::Value::ToUniquePtrValue(filter.Clone()));
-  auto* getter = browser_context_->GetRequestContext();
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(GetCookiesOnIO, base::RetainedRef(getter), std::move(copy),
-                     std::move(promise)));
+  std::string url_string;
+  filter.GetString("url", &url_string);
+  GURL url(url_string);
+
+  auto callback =
+      base::BindOnce(FilterCookies, filter.Clone(), std::move(promise));
+
+  auto* storage_partition = content::BrowserContext::GetDefaultStoragePartition(
+      browser_context_.get());
+  auto* manager = storage_partition->GetCookieManagerForBrowserProcess();
+
+  if (url.is_empty()) {
+    // GetAllCookies has a different callback signature than GetCookieList, but
+    // can be treated as the same, just returning no excluded cookies.
+    // |AddCookieStatusList| takes a |GetCookieListCallback| and returns a
+    // callback that calls the input callback with an empty excluded list.
+    manager->GetAllCookies(
+        net::cookie_util::AddCookieStatusList(std::move(callback)));
+  } else {
+    net::CookieOptions options;
+    options.set_include_httponly();
+    options.set_same_site_cookie_context(
+        net::CookieOptions::SameSiteCookieContext::SAME_SITE_STRICT);
+    options.set_do_not_update_access_time();
+
+    manager->GetCookieList(url, options, std::move(callback));
+  }
 
   return handle;
 }
@@ -344,11 +211,21 @@ v8::Local<v8::Promise> Cookies::Remove(const GURL& url,
   util::Promise promise(isolate());
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  auto* getter = browser_context_->GetRequestContext();
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(RemoveCookieOnIO, base::RetainedRef(getter), url, name,
-                     std::move(promise)));
+  auto cookie_deletion_filter = network::mojom::CookieDeletionFilter::New();
+  cookie_deletion_filter->url = url;
+  cookie_deletion_filter->cookie_name = name;
+
+  auto* storage_partition = content::BrowserContext::GetDefaultStoragePartition(
+      browser_context_.get());
+  auto* manager = storage_partition->GetCookieManagerForBrowserProcess();
+
+  manager->DeleteCookies(
+      std::move(cookie_deletion_filter),
+      base::BindOnce(
+          [](util::Promise promise, uint32_t num_deleted) {
+            util::Promise::ResolveEmptyPromise(std::move(promise));
+          },
+          std::move(promise)));
 
   return handle;
 }
@@ -357,13 +234,72 @@ v8::Local<v8::Promise> Cookies::Set(const base::DictionaryValue& details) {
   util::Promise promise(isolate());
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  auto copy = base::DictionaryValue::From(
-      base::Value::ToUniquePtrValue(details.Clone()));
-  auto* getter = browser_context_->GetRequestContext();
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(SetCookieOnIO, base::RetainedRef(getter), std::move(copy),
-                     std::move(promise)));
+  const std::string* url_string = details.FindStringKey("url");
+  const std::string* name = details.FindStringKey("name");
+  const std::string* value = details.FindStringKey("value");
+  const std::string* domain = details.FindStringKey("domain");
+  const std::string* path = details.FindStringKey("path");
+  bool secure = details.FindBoolKey("secure").value_or(false);
+  bool http_only = details.FindBoolKey("httpOnly").value_or(false);
+  base::Optional<double> creation_date = details.FindDoubleKey("creationDate");
+  base::Optional<double> expiration_date =
+      details.FindDoubleKey("expirationDate");
+  base::Optional<double> last_access_date =
+      details.FindDoubleKey("lastAccessDate");
+
+  base::Time creation_time = creation_date
+                                 ? base::Time::FromDoubleT(*creation_date)
+                                 : base::Time::UnixEpoch();
+  base::Time expiration_time = expiration_date
+                                   ? base::Time::FromDoubleT(*expiration_date)
+                                   : base::Time::UnixEpoch();
+  base::Time last_access_time = last_access_date
+                                    ? base::Time::FromDoubleT(*last_access_date)
+                                    : base::Time::UnixEpoch();
+
+  GURL url(url_string ? *url_string : "");
+  if (url.is_empty()) {
+    promise.RejectWithErrorMessage(InclusionStatusToString(
+        net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_INVALID_DOMAIN));
+    return handle;
+  }
+
+  if (!name || name->empty()) {
+    promise.RejectWithErrorMessage(InclusionStatusToString(
+        net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_FAILURE_TO_STORE));
+    return handle;
+  }
+
+  auto canonical_cookie = net::CanonicalCookie::CreateSanitizedCookie(
+      url, *name, value ? *value : "", domain ? *domain : "", path ? *path : "",
+      creation_time, expiration_time, last_access_time, secure, http_only,
+      net::CookieSameSite::NO_RESTRICTION, net::COOKIE_PRIORITY_DEFAULT);
+  if (!canonical_cookie || !canonical_cookie->IsCanonical()) {
+    promise.RejectWithErrorMessage(InclusionStatusToString(
+        net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_FAILURE_TO_STORE));
+    return handle;
+  }
+  net::CookieOptions options;
+  if (http_only) {
+    options.set_include_httponly();
+  }
+
+  auto* storage_partition = content::BrowserContext::GetDefaultStoragePartition(
+      browser_context_.get());
+  auto* manager = storage_partition->GetCookieManagerForBrowserProcess();
+  manager->SetCanonicalCookie(
+      *canonical_cookie, url.scheme(), options,
+      base::BindOnce(
+          [](util::Promise promise,
+             net::CanonicalCookie::CookieInclusionStatus status) {
+            auto errmsg = InclusionStatusToString(status);
+            if (errmsg.empty()) {
+              promise.Resolve();
+            } else {
+              promise.RejectWithErrorMessage(errmsg);
+            }
+          },
+          std::move(promise)));
 
   return handle;
 }
@@ -372,29 +308,32 @@ v8::Local<v8::Promise> Cookies::FlushStore() {
   util::Promise promise(isolate());
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  auto* getter = browser_context_->GetRequestContext();
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(FlushCookieStoreOnIOThread, base::RetainedRef(getter),
-                     std::move(promise)));
+  auto* storage_partition = content::BrowserContext::GetDefaultStoragePartition(
+      browser_context_.get());
+  auto* manager = storage_partition->GetCookieManagerForBrowserProcess();
+
+  manager->FlushCookieStore(
+      base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
 
   return handle;
 }
 
 void Cookies::OnCookieChanged(const CookieDetails* details) {
-  Emit("changed", *(details->cookie), details->cause, details->removed);
+  Emit("changed", gin::ConvertToV8(isolate(), *(details->cookie)),
+       gin::ConvertToV8(isolate(), details->cause),
+       gin::ConvertToV8(isolate(), details->removed));
 }
 
 // static
-mate::Handle<Cookies> Cookies::Create(v8::Isolate* isolate,
-                                      AtomBrowserContext* browser_context) {
-  return mate::CreateHandle(isolate, new Cookies(isolate, browser_context));
+gin::Handle<Cookies> Cookies::Create(v8::Isolate* isolate,
+                                     AtomBrowserContext* browser_context) {
+  return gin::CreateHandle(isolate, new Cookies(isolate, browser_context));
 }
 
 // static
 void Cookies::BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(mate::StringToV8(isolate, "Cookies"));
+  prototype->SetClassName(gin::StringToV8(isolate, "Cookies"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("get", &Cookies::Get)
       .SetMethod("remove", &Cookies::Remove)

atom/browser/api/atom_api_cookies.h

@@ -12,7 +12,7 @@
 #include "atom/browser/net/cookie_details.h"
 #include "atom/common/promise_util.h"
 #include "base/callback_list.h"
-#include "native_mate/handle.h"
+#include "gin/handle.h"
 #include "net/cookies/canonical_cookie.h"
 
 namespace base {
@@ -31,13 +31,8 @@ namespace api {
 
 class Cookies : public mate::TrackableObject<Cookies> {
  public:
-  enum Error {
-    SUCCESS,
-    FAILED,
-  };
-
-  static mate::Handle<Cookies> Create(v8::Isolate* isolate,
-                                      AtomBrowserContext* browser_context);
+  static gin::Handle<Cookies> Create(v8::Isolate* isolate,
+                                     AtomBrowserContext* browser_context);
 
   // mate::TrackableObject:
   static void BuildPrototype(v8::Isolate* isolate,

atom/browser/api/atom_api_desktop_capturer.cc

@@ -165,8 +165,12 @@ void DesktopCapturer::UpdateSourcesList(DesktopMediaList* list) {
       std::vector<std::string> device_names;
       // Crucially, this list of device names will be in the same order as
       // |media_list_sources|.
-      webrtc::DxgiDuplicatorController::Instance()->GetDeviceNames(
-          &device_names);
+      if (!webrtc::DxgiDuplicatorController::Instance()->GetDeviceNames(
+              &device_names)) {
+        Emit("error", "Failed to get sources.");
+        return;
+      }
+
       int device_name_index = 0;
       for (auto& source : screen_sources) {
         const auto& device_name = device_names[device_name_index++];
@@ -176,13 +180,13 @@ void DesktopCapturer::UpdateSourcesList(DesktopMediaList* list) {
         const int64_t device_id =
             display::win::DisplayInfo::DeviceIdFromDeviceName(
                 wide_device_name.c_str());
-        source.display_id = base::Int64ToString(device_id);
+        source.display_id = base::NumberToString(device_id);
       }
     }
 #elif defined(OS_MACOSX)
     // On Mac, the IDs across the APIs match.
     for (auto& source : screen_sources) {
-      source.display_id = base::Int64ToString(source.media_list_source.id.id);
+      source.display_id = base::NumberToString(source.media_list_source.id.id);
     }
 #endif  // defined(OS_WIN)
     // TODO(ajmacd): Add Linux support. The IDs across APIs differ but Chrome
@@ -222,7 +226,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("desktopCapturer", atom::api::DesktopCapturer::Create(isolate));
+  dict.SetMethod("createDesktopCapturer", &atom::api::DesktopCapturer::Create);
 }
 
 }  // namespace

atom/browser/api/atom_api_menu.cc

@@ -241,7 +241,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  Menu::SetConstructor(isolate, base::Bind(&Menu::New));
+  Menu::SetConstructor(isolate, base::BindRepeating(&Menu::New));
 
   mate::Dictionary dict(isolate, exports);
   dict.Set(

atom/browser/api/atom_api_menu.h

@@ -100,16 +100,17 @@ class Menu : public mate::TrackableObject<Menu>,
   bool WorksWhenHiddenAt(int index) const;
 
   // Stored delegate methods.
-  base::Callback<bool(v8::Local<v8::Value>, int)> is_checked_;
-  base::Callback<bool(v8::Local<v8::Value>, int)> is_enabled_;
-  base::Callback<bool(v8::Local<v8::Value>, int)> is_visible_;
-  base::Callback<bool(v8::Local<v8::Value>, int)> works_when_hidden_;
-  base::Callback<v8::Local<v8::Value>(v8::Local<v8::Value>, int, bool)>
+  base::RepeatingCallback<bool(v8::Local<v8::Value>, int)> is_checked_;
+  base::RepeatingCallback<bool(v8::Local<v8::Value>, int)> is_enabled_;
+  base::RepeatingCallback<bool(v8::Local<v8::Value>, int)> is_visible_;
+  base::RepeatingCallback<bool(v8::Local<v8::Value>, int)> works_when_hidden_;
+  base::RepeatingCallback<v8::Local<v8::Value>(v8::Local<v8::Value>, int, bool)>
       get_accelerator_;
-  base::Callback<bool(v8::Local<v8::Value>, int)> should_register_accelerator_;
-  base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>, int)>
+  base::RepeatingCallback<bool(v8::Local<v8::Value>, int)>
+      should_register_accelerator_;
+  base::RepeatingCallback<void(v8::Local<v8::Value>, v8::Local<v8::Value>, int)>
       execute_command_;
-  base::Callback<void(v8::Local<v8::Value>)> menu_will_show_;
+  base::RepeatingCallback<void(v8::Local<v8::Value>)> menu_will_show_;
 
   DISALLOW_COPY_AND_ASSIGN(Menu);
 };

atom/browser/api/atom_api_menu_mac.mm

@@ -4,6 +4,9 @@
 
 #import "atom/browser/api/atom_api_menu_mac.h"
 
+#include <string>
+#include <utility>
+
 #include "atom/browser/native_window.h"
 #include "atom/browser/unresponsive_suppressor.h"
 #include "atom/common/node_includes.h"
@@ -41,10 +44,11 @@ void MenuMac::PopupAt(TopLevelWindow* window,
   if (!native_window)
     return;
 
-  auto popup = base::Bind(&MenuMac::PopupOnUI, weak_factory_.GetWeakPtr(),
-                          native_window->GetWeakPtr(), window->weak_map_id(), x,
-                          y, positioning_item, callback);
-  base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI}, popup);
+  auto popup =
+      base::BindOnce(&MenuMac::PopupOnUI, weak_factory_.GetWeakPtr(),
+                     native_window->GetWeakPtr(), window->weak_map_id(), x, y,
+                     positioning_item, callback);
+  base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI}, std::move(popup));
 }
 
 void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
@@ -57,11 +61,11 @@ void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
     return;
   NSWindow* nswindow = native_window->GetNativeWindow().GetNativeNSWindow();
 
-  auto close_callback = base::Bind(
+  auto close_callback = base::BindRepeating(
       &MenuMac::OnClosed, weak_factory_.GetWeakPtr(), window_id, callback);
-  popup_controllers_[window_id] = base::scoped_nsobject<AtomMenuController>([
-      [AtomMenuController alloc] initWithModel:model()
-                         useDefaultAccelerator:NO]);
+  popup_controllers_[window_id] = base::scoped_nsobject<AtomMenuController>(
+      [[AtomMenuController alloc] initWithModel:model()
+                          useDefaultAccelerator:NO]);
   NSMenu* menu = [popup_controllers_[window_id] menu];
   NSView* view = [nswindow contentView];
 
@@ -135,9 +139,9 @@ void MenuMac::OnClosed(int32_t window_id, base::Closure callback) {
 // static
 void Menu::SetApplicationMenu(Menu* base_menu) {
   MenuMac* menu = static_cast<MenuMac*>(base_menu);
-  base::scoped_nsobject<AtomMenuController> menu_controller([
-      [AtomMenuController alloc] initWithModel:menu->model_.get()
-                         useDefaultAccelerator:YES]);
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:menu->model_.get()
+                          useDefaultAccelerator:YES]);
 
   NSRunLoop* currentRunLoop = [NSRunLoop currentRunLoop];
   [currentRunLoop cancelPerformSelector:@selector(setMainMenu:)

atom/browser/api/atom_api_menu_views.cc

@@ -46,13 +46,13 @@ void MenuViews::PopupAt(TopLevelWindow* window,
 
   // Show the menu.
   int32_t window_id = window->weak_map_id();
-  auto close_callback = base::Bind(
+  auto close_callback = base::BindRepeating(
       &MenuViews::OnClosed, weak_factory_.GetWeakPtr(), window_id, callback);
   menu_runners_[window_id] =
       std::make_unique<MenuRunner>(model(), flags, close_callback);
   menu_runners_[window_id]->RunMenuAt(
       native_window->widget(), NULL, gfx::Rect(location, gfx::Size()),
-      views::MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_MOUSE);
+      views::MenuAnchorPosition::kTopLeft, ui::MENU_SOURCE_MOUSE);
 }
 
 void MenuViews::ClosePopupAt(int32_t window_id) {

atom/browser/api/atom_api_net.cc

@@ -51,7 +51,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
 
-  URLRequest::SetConstructor(isolate, base::Bind(URLRequest::New));
+  URLRequest::SetConstructor(isolate, base::BindRepeating(URLRequest::New));
 
   mate::Dictionary dict(isolate, exports);
   dict.Set("net", Net::Create(isolate));

atom/browser/api/atom_api_net_log.cc

@@ -8,6 +8,7 @@
 
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/net/system_network_context_manager.h"
+#include "atom/common/atom_version.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/node_includes.h"
@@ -21,103 +22,153 @@
 
 namespace atom {
 
+namespace {
+
+scoped_refptr<base::SequencedTaskRunner> CreateFileTaskRunner() {
+  // The tasks posted to this sequenced task runner do synchronous File I/O for
+  // checking paths and setting permissions on files.
+  //
+  // These operations can be skipped on shutdown since FileNetLogObserver's API
+  // doesn't require things to have completed until notified of completion.
+  return base::CreateSequencedTaskRunnerWithTraits(
+      {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
+       base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN});
+}
+
+base::File OpenFileForWriting(base::FilePath path) {
+  return base::File(path,
+                    base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
+}
+
+void ResolvePromiseWithNetError(util::Promise promise, int32_t error) {
+  if (error == net::OK) {
+    promise.Resolve();
+  } else {
+    promise.RejectWithErrorMessage(net::ErrorToString(error));
+  }
+}
+
+}  // namespace
+
 namespace api {
 
 NetLog::NetLog(v8::Isolate* isolate, AtomBrowserContext* browser_context)
-    : browser_context_(browser_context) {
+    : browser_context_(browser_context), weak_ptr_factory_(this) {
   Init(isolate);
-
-  net_log_writer_ = g_browser_process->system_network_context_manager()
-                        ->GetNetExportFileWriter();
-  net_log_writer_->AddObserver(this);
+  file_task_runner_ = CreateFileTaskRunner();
 }
 
-NetLog::~NetLog() {
-  net_log_writer_->RemoveObserver(this);
-}
+NetLog::~NetLog() = default;
 
-void NetLog::StartLogging(mate::Arguments* args) {
+v8::Local<v8::Promise> NetLog::StartLogging(mate::Arguments* args) {
   base::FilePath log_path;
   if (!args->GetNext(&log_path) || log_path.empty()) {
     args->ThrowError("The first parameter must be a valid string");
-    return;
+    return v8::Local<v8::Promise>();
   }
 
+  if (net_log_exporter_) {
+    args->ThrowError("There is already a net log running");
+    return v8::Local<v8::Promise>();
+  }
+
+  pending_start_promise_ = base::make_optional<util::Promise>(isolate());
+  v8::Local<v8::Promise> handle = pending_start_promise_->GetHandle();
+
+  auto command_line_string =
+      base::CommandLine::ForCurrentProcess()->GetCommandLineString();
+  auto channel_string = std::string("Electron " ATOM_VERSION);
+  base::Value custom_constants = base::Value::FromUniquePtrValue(
+      net_log::ChromeNetLog::GetPlatformConstants(command_line_string,
+                                                  channel_string));
+
   auto* network_context =
       content::BrowserContext::GetDefaultStoragePartition(browser_context_)
           ->GetNetworkContext();
 
+  network_context->CreateNetLogExporter(mojo::MakeRequest(&net_log_exporter_));
+  net_log_exporter_.set_connection_error_handler(
+      base::BindOnce(&NetLog::OnConnectionError, base::Unretained(this)));
+
   // TODO(deepak1556): Provide more flexibility to this module
   // by allowing customizations on the capturing options.
-  net_log_writer_->StartNetLog(
-      log_path, net::NetLogCaptureMode::Default(),
-      net_log::NetExportFileWriter::kNoLimit /* file size limit */,
-      base::CommandLine::ForCurrentProcess()->GetCommandLineString(),
-      std::string(), network_context);
+  auto capture_mode = net::NetLogCaptureMode::Default();
+  auto max_file_size = network::mojom::NetLogExporter::kUnlimitedFileSize;
+
+  base::PostTaskAndReplyWithResult(
+      file_task_runner_.get(), FROM_HERE,
+      base::BindOnce(OpenFileForWriting, log_path),
+      base::BindOnce(&NetLog::StartNetLogAfterCreateFile,
+                     weak_ptr_factory_.GetWeakPtr(), capture_mode,
+                     max_file_size, std::move(custom_constants)));
+
+  return handle;
 }
 
-std::string NetLog::GetLoggingState() const {
-  if (!net_log_state_)
-    return std::string();
-  const base::Value* current_log_state =
-      net_log_state_->FindKeyOfType("state", base::Value::Type::STRING);
-  if (!current_log_state)
-    return std::string();
-  return current_log_state->GetString();
+void NetLog::StartNetLogAfterCreateFile(net::NetLogCaptureMode capture_mode,
+                                        uint64_t max_file_size,
+                                        base::Value custom_constants,
+                                        base::File output_file) {
+  if (!net_log_exporter_) {
+    // Theoretically the mojo pipe could have been closed by the time we get
+    // here via the connection error handler. If so, the promise has already
+    // been resolved.
+    return;
+  }
+  DCHECK(pending_start_promise_);
+  if (!output_file.IsValid()) {
+    std::move(*pending_start_promise_)
+        .RejectWithErrorMessage(
+            base::File::ErrorToString(output_file.error_details()));
+    net_log_exporter_.reset();
+    return;
+  }
+  net_log_exporter_->Start(
+      std::move(output_file), std::move(custom_constants), capture_mode,
+      max_file_size,
+      base::BindOnce(&NetLog::NetLogStarted, base::Unretained(this)));
+}
+
+void NetLog::NetLogStarted(int32_t error) {
+  DCHECK(pending_start_promise_);
+  ResolvePromiseWithNetError(std::move(*pending_start_promise_), error);
+}
+
+void NetLog::OnConnectionError() {
+  net_log_exporter_.reset();
+  if (pending_start_promise_) {
+    std::move(*pending_start_promise_)
+        .RejectWithErrorMessage("Failed to start net log exporter");
+  }
 }
 
 bool NetLog::IsCurrentlyLogging() const {
-  const std::string log_state = GetLoggingState();
-  return (log_state == "STARTING_LOG") || (log_state == "LOGGING");
-}
-
-std::string NetLog::GetCurrentlyLoggingPath() const {
-  // Net log exporter has a default path which will be used
-  // when no log path is provided, but since we don't allow
-  // net log capture without user provided file path, this
-  // check is completely safe.
-  if (IsCurrentlyLogging()) {
-    const base::Value* current_log_path =
-        net_log_state_->FindKeyOfType("file", base::Value::Type::STRING);
-    if (current_log_path)
-      return current_log_path->GetString();
-  }
-
-  return std::string();
+  return !!net_log_exporter_;
 }
 
 v8::Local<v8::Promise> NetLog::StopLogging(mate::Arguments* args) {
   util::Promise promise(isolate());
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  if (IsCurrentlyLogging()) {
-    stop_callback_queue_.emplace_back(std::move(promise));
-    net_log_writer_->StopNetLog(nullptr);
+  if (net_log_exporter_) {
+    // Move the net_log_exporter_ into the callback to ensure that the mojo
+    // pointer lives long enough to resolve the promise. Moving it into the
+    // callback will cause the instance variable to become empty.
+    net_log_exporter_->Stop(
+        base::Value(base::Value::Type::DICTIONARY),
+        base::BindOnce(
+            [](network::mojom::NetLogExporterPtr, util::Promise promise,
+               int32_t error) {
+              ResolvePromiseWithNetError(std::move(promise), error);
+            },
+            std::move(net_log_exporter_), std::move(promise)));
   } else {
-    promise.Resolve(base::FilePath());
+    promise.RejectWithErrorMessage("No net log in progress");
   }
 
   return handle;
 }
 
-void NetLog::OnNewState(const base::DictionaryValue& state) {
-  net_log_state_ = state.CreateDeepCopy();
-
-  if (stop_callback_queue_.empty())
-    return;
-
-  if (GetLoggingState() == "NOT_LOGGING") {
-    for (auto& promise : stop_callback_queue_) {
-      // TODO(zcbenz): Remove the use of CopyablePromise when the
-      // GetFilePathToCompletedLog API accepts OnceCallback.
-      net_log_writer_->GetFilePathToCompletedLog(base::Bind(
-          util::CopyablePromise::ResolveCopyablePromise<const base::FilePath&>,
-          util::CopyablePromise(promise)));
-    }
-    stop_callback_queue_.clear();
-  }
-}
-
 // static
 mate::Handle<NetLog> NetLog::Create(v8::Isolate* isolate,
                                     AtomBrowserContext* browser_context) {
@@ -130,7 +181,6 @@ void NetLog::BuildPrototype(v8::Isolate* isolate,
   prototype->SetClassName(mate::StringToV8(isolate, "NetLog"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetProperty("currentlyLogging", &NetLog::IsCurrentlyLogging)
-      .SetProperty("currentlyLoggingPath", &NetLog::GetCurrentlyLoggingPath)
       .SetMethod("startLogging", &NetLog::StartLogging)
       .SetMethod("stopLogging", &NetLog::StopLogging);
 }

atom/browser/api/atom_api_net_log.h

@@ -12,9 +12,10 @@
 #include "atom/browser/api/trackable_object.h"
 #include "atom/common/promise_util.h"
 #include "base/callback.h"
+#include "base/optional.h"
 #include "base/values.h"
-#include "components/net_log/net_export_file_writer.h"
 #include "native_mate/handle.h"
+#include "services/network/public/mojom/net_log.mojom.h"
 
 namespace atom {
 
@@ -22,8 +23,7 @@ class AtomBrowserContext;
 
 namespace api {
 
-class NetLog : public mate::TrackableObject<NetLog>,
-               public net_log::NetExportFileWriter::StateObserver {
+class NetLog : public mate::TrackableObject<NetLog> {
  public:
   static mate::Handle<NetLog> Create(v8::Isolate* isolate,
                                      AtomBrowserContext* browser_context);
@@ -31,24 +31,32 @@ class NetLog : public mate::TrackableObject<NetLog>,
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
 
-  void StartLogging(mate::Arguments* args);
-  std::string GetLoggingState() const;
-  bool IsCurrentlyLogging() const;
-  std::string GetCurrentlyLoggingPath() const;
+  v8::Local<v8::Promise> StartLogging(mate::Arguments* args);
   v8::Local<v8::Promise> StopLogging(mate::Arguments* args);
+  bool IsCurrentlyLogging() const;
 
  protected:
   explicit NetLog(v8::Isolate* isolate, AtomBrowserContext* browser_context);
   ~NetLog() override;
 
-  // net_log::NetExportFileWriter::StateObserver implementation
-  void OnNewState(const base::DictionaryValue& state) override;
+  void OnConnectionError();
+
+  void StartNetLogAfterCreateFile(net::NetLogCaptureMode capture_mode,
+                                  uint64_t max_file_size,
+                                  base::Value custom_constants,
+                                  base::File output_file);
+  void NetLogStarted(int32_t error);
 
  private:
   AtomBrowserContext* browser_context_;
-  net_log::NetExportFileWriter* net_log_writer_;
-  std::list<atom::util::Promise> stop_callback_queue_;
-  std::unique_ptr<base::DictionaryValue> net_log_state_;
+
+  network::mojom::NetLogExporterPtr net_log_exporter_;
+
+  base::Optional<util::Promise> pending_start_promise_;
+
+  scoped_refptr<base::TaskRunner> file_task_runner_;
+
+  base::WeakPtrFactory<NetLog> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLog);
 };

atom/browser/api/atom_api_notification.cc

@@ -258,7 +258,8 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  Notification::SetConstructor(isolate, base::Bind(&Notification::New));
+  Notification::SetConstructor(isolate,
+                               base::BindRepeating(&Notification::New));
 
   mate::Dictionary dict(isolate, exports);
   dict.Set("Notification", Notification::GetConstructor(isolate)

atom/browser/api/atom_api_power_monitor.cc

@@ -37,11 +37,11 @@ namespace api {
 
 PowerMonitor::PowerMonitor(v8::Isolate* isolate) {
 #if defined(OS_LINUX)
-  SetShutdownHandler(
-      base::Bind(&PowerMonitor::ShouldShutdown, base::Unretained(this)));
+  SetShutdownHandler(base::BindRepeating(&PowerMonitor::ShouldShutdown,
+                                         base::Unretained(this)));
 #elif defined(OS_MACOSX)
-  Browser::Get()->SetShutdownHandler(
-      base::Bind(&PowerMonitor::ShouldShutdown, base::Unretained(this)));
+  Browser::Get()->SetShutdownHandler(base::BindRepeating(
+      &PowerMonitor::ShouldShutdown, base::Unretained(this)));
 #endif
   base::PowerMonitor::Get()->AddObserver(this);
   Init(isolate);
@@ -101,9 +101,10 @@ int PowerMonitor::GetSystemIdleTime() {
 // static
 v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
-    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
-        isolate,
-        "Cannot require \"powerMonitor\" module before app is ready")));
+    isolate->ThrowException(v8::Exception::Error(
+        mate::StringToV8(isolate,
+                         "The 'powerMonitor' module can't be used before the "
+                         "app 'ready' event")));
     return v8::Null(isolate);
   }
 
@@ -139,7 +140,8 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("powerMonitor", PowerMonitor::Create(isolate));
+  dict.Set("createPowerMonitor",
+           base::BindRepeating(&PowerMonitor::Create, isolate));
   dict.Set("PowerMonitor", PowerMonitor::GetConstructor(isolate)
                                ->GetFunction(context)
                                .ToLocalChecked());

atom/browser/api/atom_api_power_monitor_mac.mm

@@ -4,7 +4,9 @@
 
 #include "atom/browser/api/atom_api_power_monitor.h"
 
-#include <ApplicationServices/ApplicationServices.h>
+#include <vector>
+
+#import <ApplicationServices/ApplicationServices.h>
 #import <Cocoa/Cocoa.h>
 
 @interface MacLockMonitor : NSObject {

atom/browser/api/atom_api_power_save_blocker.cc

@@ -7,15 +7,17 @@
 #include <string>
 
 #include "atom/common/node_includes.h"
+#include "base/bind_helpers.h"
 #include "base/task/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/common/service_manager_connection.h"
-#include "native_mate/dictionary.h"
+#include "gin/dictionary.h"
+#include "gin/function_template.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/wake_lock_provider.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"
 
-namespace mate {
+namespace gin {
 
 template <>
 struct Converter<device::mojom::WakeLockType> {
@@ -35,17 +37,17 @@ struct Converter<device::mojom::WakeLockType> {
   }
 };
 
-}  // namespace mate
+}  // namespace gin
 
 namespace atom {
 
 namespace api {
 
+gin::WrapperInfo PowerSaveBlocker::kWrapperInfo = {gin::kEmbedderNativeGin};
+
 PowerSaveBlocker::PowerSaveBlocker(v8::Isolate* isolate)
     : current_lock_type_(device::mojom::WakeLockType::kPreventAppSuspension),
-      is_wake_lock_active_(false) {
-  Init(isolate);
-}
+      is_wake_lock_active_(false) {}
 
 PowerSaveBlocker::~PowerSaveBlocker() {}
 
@@ -118,16 +120,13 @@ bool PowerSaveBlocker::IsStarted(int id) {
 }
 
 // static
-mate::Handle<PowerSaveBlocker> PowerSaveBlocker::Create(v8::Isolate* isolate) {
-  return mate::CreateHandle(isolate, new PowerSaveBlocker(isolate));
+gin::Handle<PowerSaveBlocker> PowerSaveBlocker::Create(v8::Isolate* isolate) {
+  return gin::CreateHandle(isolate, new PowerSaveBlocker(isolate));
 }
 
-// static
-void PowerSaveBlocker::BuildPrototype(
-    v8::Isolate* isolate,
-    v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(mate::StringToV8(isolate, "PowerSaveBlocker"));
-  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+gin::ObjectTemplateBuilder PowerSaveBlocker::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return gin::Wrappable<PowerSaveBlocker>::GetObjectTemplateBuilder(isolate)
       .SetMethod("start", &PowerSaveBlocker::Start)
       .SetMethod("stop", &PowerSaveBlocker::Stop)
       .SetMethod("isStarted", &PowerSaveBlocker::IsStarted);
@@ -144,7 +143,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  mate::Dictionary dict(isolate, exports);
+  gin::Dictionary dict(isolate, exports);
   dict.Set("powerSaveBlocker", atom::api::PowerSaveBlocker::Create(isolate));
 }
 

atom/browser/api/atom_api_power_save_blocker.h

@@ -8,24 +8,24 @@
 #include <map>
 #include <memory>
 
-#include "atom/browser/api/trackable_object.h"
-#include "native_mate/handle.h"
+#include "gin/handle.h"
+#include "gin/object_template_builder.h"
+#include "gin/wrappable.h"
 #include "services/device/public/mojom/wake_lock.mojom.h"
 
-namespace mate {
-class Dictionary;
-}
-
 namespace atom {
 
 namespace api {
 
-class PowerSaveBlocker : public mate::TrackableObject<PowerSaveBlocker> {
+class PowerSaveBlocker : public gin::Wrappable<PowerSaveBlocker> {
  public:
-  static mate::Handle<PowerSaveBlocker> Create(v8::Isolate* isolate);
+  static gin::Handle<PowerSaveBlocker> Create(v8::Isolate* isolate);
 
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::FunctionTemplate> prototype);
+  // gin::Wrappable
+  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+
+  static gin::WrapperInfo kWrapperInfo;
 
  protected:
   explicit PowerSaveBlocker(v8::Isolate* isolate);

atom/browser/api/atom_api_protocol.cc

@@ -164,9 +164,9 @@ Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
     const std::string& scheme) {
   auto* job_factory = request_context_getter->job_factory();
   if (!job_factory->HasProtocolHandler(scheme))
-    return PROTOCOL_NOT_REGISTERED;
+    return ProtocolError::NOT_REGISTERED;
   job_factory->SetProtocolHandler(scheme, nullptr);
-  return PROTOCOL_OK;
+  return ProtocolError::OK;
 }
 
 bool IsProtocolHandledInIO(
@@ -209,8 +209,8 @@ Protocol::ProtocolError Protocol::UninterceptProtocolInIO(
     scoped_refptr<URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
   return request_context_getter->job_factory()->UninterceptProtocol(scheme)
-             ? PROTOCOL_OK
-             : PROTOCOL_NOT_INTERCEPTED;
+             ? ProtocolError::OK
+             : ProtocolError::NOT_INTERCEPTED;
 }
 
 void Protocol::OnIOCompleted(const CompletionCallback& callback,
@@ -222,7 +222,7 @@ void Protocol::OnIOCompleted(const CompletionCallback& callback,
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
 
-  if (error == PROTOCOL_OK) {
+  if (error == ProtocolError::OK) {
     callback.Run(v8::Null(isolate()));
   } else {
     std::string str = ErrorCodeToString(error);
@@ -232,15 +232,15 @@ void Protocol::OnIOCompleted(const CompletionCallback& callback,
 
 std::string Protocol::ErrorCodeToString(ProtocolError error) {
   switch (error) {
-    case PROTOCOL_FAIL:
+    case ProtocolError::FAIL:
       return "Failed to manipulate protocol factory";
-    case PROTOCOL_REGISTERED:
+    case ProtocolError::REGISTERED:
       return "The scheme has been registered";
-    case PROTOCOL_NOT_REGISTERED:
+    case ProtocolError::NOT_REGISTERED:
       return "The scheme has not been registered";
-    case PROTOCOL_INTERCEPTED:
+    case ProtocolError::INTERCEPTED:
       return "The scheme has been intercepted";
-    case PROTOCOL_NOT_INTERCEPTED:
+    case ProtocolError::NOT_INTERCEPTED:
       return "The scheme has not been intercepted";
     default:
       return "Unexpected error";

atom/browser/api/atom_api_protocol.h

@@ -40,9 +40,10 @@ void RegisterSchemesAsPrivileged(v8::Local<v8::Value> val,
 
 class Protocol : public mate::TrackableObject<Protocol> {
  public:
-  using Handler =
-      base::Callback<void(const base::DictionaryValue&, v8::Local<v8::Value>)>;
-  using CompletionCallback = base::Callback<void(v8::Local<v8::Value>)>;
+  using Handler = base::RepeatingCallback<void(const base::DictionaryValue&,
+                                               v8::Local<v8::Value>)>;
+  using CompletionCallback =
+      base::RepeatingCallback<void(v8::Local<v8::Value>)>;
 
   static mate::Handle<Protocol> Create(v8::Isolate* isolate,
                                        AtomBrowserContext* browser_context);
@@ -56,13 +57,13 @@ class Protocol : public mate::TrackableObject<Protocol> {
 
  private:
   // Possible errors.
-  enum ProtocolError {
-    PROTOCOL_OK,    // no error
-    PROTOCOL_FAIL,  // operation failed, should never occur
-    PROTOCOL_REGISTERED,
-    PROTOCOL_NOT_REGISTERED,
-    PROTOCOL_INTERCEPTED,
-    PROTOCOL_NOT_INTERCEPTED,
+  enum class ProtocolError {
+    OK,    // no error
+    FAIL,  // operation failed, should never occur
+    REGISTERED,
+    NOT_REGISTERED,
+    INTERCEPTED,
+    NOT_INTERCEPTED,
   };
 
   // The protocol handler that will create a protocol handler for certain
@@ -118,13 +119,13 @@ class Protocol : public mate::TrackableObject<Protocol> {
       const Handler& handler) {
     auto* job_factory = request_context_getter->job_factory();
     if (job_factory->IsHandledProtocol(scheme))
-      return PROTOCOL_REGISTERED;
+      return ProtocolError::REGISTERED;
     auto protocol_handler = std::make_unique<CustomProtocolHandler<RequestJob>>(
         isolate, request_context_getter.get(), handler);
     if (job_factory->SetProtocolHandler(scheme, std::move(protocol_handler)))
-      return PROTOCOL_OK;
+      return ProtocolError::OK;
     else
-      return PROTOCOL_FAIL;
+      return ProtocolError::FAIL;
   }
 
   // Unregister the protocol handler that handles |scheme|.
@@ -159,15 +160,15 @@ class Protocol : public mate::TrackableObject<Protocol> {
       const Handler& handler) {
     auto* job_factory = request_context_getter->job_factory();
     if (!job_factory->IsHandledProtocol(scheme))
-      return PROTOCOL_NOT_REGISTERED;
+      return ProtocolError::NOT_REGISTERED;
     // It is possible a protocol is handled but can not be intercepted.
     if (!job_factory->HasProtocolHandler(scheme))
-      return PROTOCOL_FAIL;
+      return ProtocolError::FAIL;
     auto protocol_handler = std::make_unique<CustomProtocolHandler<RequestJob>>(
         isolate, request_context_getter.get(), handler);
     if (!job_factory->InterceptProtocol(scheme, std::move(protocol_handler)))
-      return PROTOCOL_INTERCEPTED;
-    return PROTOCOL_OK;
+      return ProtocolError::INTERCEPTED;
+    return ProtocolError::OK;
   }
 
   // Restore the |scheme| to its original protocol handler.

atom/browser/api/atom_api_protocol_ns.cc

@@ -0,0 +1,181 @@
+// Copyright (c) 2019 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_protocol_ns.h"
+
+#include <memory>
+#include <utility>
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/common/native_mate_converters/net_converter.h"
+#include "atom/common/native_mate_converters/once_callback.h"
+#include "atom/common/promise_util.h"
+#include "base/stl_util.h"
+
+namespace atom {
+namespace api {
+
+namespace {
+
+const char* kBuiltinSchemes[] = {
+    "about", "file", "http", "https", "data", "filesystem",
+};
+
+// Convert error code to string.
+std::string ErrorCodeToString(ProtocolError error) {
+  switch (error) {
+    case ProtocolError::REGISTERED:
+      return "The scheme has been registered";
+    case ProtocolError::NOT_REGISTERED:
+      return "The scheme has not been registered";
+    case ProtocolError::INTERCEPTED:
+      return "The scheme has been intercepted";
+    case ProtocolError::NOT_INTERCEPTED:
+      return "The scheme has not been intercepted";
+    default:
+      return "Unexpected error";
+  }
+}
+
+}  // namespace
+
+ProtocolNS::ProtocolNS(v8::Isolate* isolate,
+                       AtomBrowserContext* browser_context) {
+  Init(isolate);
+  AttachAsUserData(browser_context);
+}
+
+ProtocolNS::~ProtocolNS() = default;
+
+void ProtocolNS::RegisterURLLoaderFactories(
+    content::ContentBrowserClient::NonNetworkURLLoaderFactoryMap* factories) {
+  for (const auto& it : handlers_) {
+    factories->emplace(it.first, std::make_unique<AtomURLLoaderFactory>(
+                                     it.second.first, it.second.second));
+  }
+}
+
+ProtocolError ProtocolNS::RegisterProtocol(ProtocolType type,
+                                           const std::string& scheme,
+                                           const ProtocolHandler& handler) {
+  ProtocolError error = ProtocolError::OK;
+  if (!base::ContainsKey(handlers_, scheme))
+    handlers_[scheme] = std::make_pair(type, handler);
+  else
+    error = ProtocolError::REGISTERED;
+  return error;
+}
+
+void ProtocolNS::UnregisterProtocol(const std::string& scheme,
+                                    mate::Arguments* args) {
+  ProtocolError error = ProtocolError::OK;
+  if (base::ContainsKey(handlers_, scheme))
+    handlers_.erase(scheme);
+  else
+    error = ProtocolError::NOT_REGISTERED;
+  HandleOptionalCallback(args, error);
+}
+
+bool ProtocolNS::IsProtocolRegistered(const std::string& scheme) {
+  return base::ContainsKey(handlers_, scheme);
+}
+
+ProtocolError ProtocolNS::InterceptProtocol(ProtocolType type,
+                                            const std::string& scheme,
+                                            const ProtocolHandler& handler) {
+  ProtocolError error = ProtocolError::OK;
+  if (!base::ContainsKey(intercept_handlers_, scheme))
+    intercept_handlers_[scheme] = std::make_pair(type, handler);
+  else
+    error = ProtocolError::INTERCEPTED;
+  return error;
+}
+
+void ProtocolNS::UninterceptProtocol(const std::string& scheme,
+                                     mate::Arguments* args) {
+  ProtocolError error = ProtocolError::OK;
+  if (base::ContainsKey(intercept_handlers_, scheme))
+    intercept_handlers_.erase(scheme);
+  else
+    error = ProtocolError::NOT_INTERCEPTED;
+  HandleOptionalCallback(args, error);
+}
+
+bool ProtocolNS::IsProtocolIntercepted(const std::string& scheme) {
+  return base::ContainsKey(intercept_handlers_, scheme);
+}
+
+v8::Local<v8::Promise> ProtocolNS::IsProtocolHandled(
+    const std::string& scheme) {
+  util::Promise promise(isolate());
+  promise.Resolve(IsProtocolRegistered(scheme) ||
+                  IsProtocolIntercepted(scheme) ||
+                  // The |isProtocolHandled| should return true for builtin
+                  // schemes, however with NetworkService it is impossible to
+                  // know which schemes are registered until a real network
+                  // request is sent.
+                  // So we have to test against a hard-coded builtin schemes
+                  // list make it work with old code. We should deprecate this
+                  // API with the new |isProtocolRegistered| API.
+                  base::ContainsValue(kBuiltinSchemes, scheme));
+  return promise.GetHandle();
+}
+
+void ProtocolNS::HandleOptionalCallback(mate::Arguments* args,
+                                        ProtocolError error) {
+  CompletionCallback callback;
+  if (args->GetNext(&callback)) {
+    if (error == ProtocolError::OK)
+      callback.Run(v8::Null(args->isolate()));
+    else
+      callback.Run(v8::Exception::Error(
+          mate::StringToV8(isolate(), ErrorCodeToString(error))));
+  }
+}
+
+// static
+mate::Handle<ProtocolNS> ProtocolNS::Create(
+    v8::Isolate* isolate,
+    AtomBrowserContext* browser_context) {
+  return mate::CreateHandle(isolate, new ProtocolNS(isolate, browser_context));
+}
+
+// static
+void ProtocolNS::BuildPrototype(v8::Isolate* isolate,
+                                v8::Local<v8::FunctionTemplate> prototype) {
+  prototype->SetClassName(mate::StringToV8(isolate, "Protocol"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .SetMethod("registerStringProtocol",
+                 &ProtocolNS::RegisterProtocolFor<ProtocolType::kString>)
+      .SetMethod("registerBufferProtocol",
+                 &ProtocolNS::RegisterProtocolFor<ProtocolType::kBuffer>)
+      .SetMethod("registerFileProtocol",
+                 &ProtocolNS::RegisterProtocolFor<ProtocolType::kFile>)
+      .SetMethod("registerHttpProtocol",
+                 &ProtocolNS::RegisterProtocolFor<ProtocolType::kHttp>)
+      .SetMethod("registerStreamProtocol",
+                 &ProtocolNS::RegisterProtocolFor<ProtocolType::kStream>)
+      .SetMethod("registerProtocol",
+                 &ProtocolNS::RegisterProtocolFor<ProtocolType::kFree>)
+      .SetMethod("unregisterProtocol", &ProtocolNS::UnregisterProtocol)
+      .SetMethod("isProtocolRegistered", &ProtocolNS::IsProtocolRegistered)
+      .SetMethod("isProtocolHandled", &ProtocolNS::IsProtocolHandled)
+      .SetMethod("interceptStringProtocol",
+                 &ProtocolNS::InterceptProtocolFor<ProtocolType::kString>)
+      .SetMethod("interceptBufferProtocol",
+                 &ProtocolNS::InterceptProtocolFor<ProtocolType::kBuffer>)
+      .SetMethod("interceptFileProtocol",
+                 &ProtocolNS::InterceptProtocolFor<ProtocolType::kFile>)
+      .SetMethod("interceptHttpProtocol",
+                 &ProtocolNS::InterceptProtocolFor<ProtocolType::kHttp>)
+      .SetMethod("interceptStreamProtocol",
+                 &ProtocolNS::InterceptProtocolFor<ProtocolType::kStream>)
+      .SetMethod("interceptProtocol",
+                 &ProtocolNS::InterceptProtocolFor<ProtocolType::kFree>)
+      .SetMethod("uninterceptProtocol", &ProtocolNS::UninterceptProtocol)
+      .SetMethod("isProtocolIntercepted", &ProtocolNS::IsProtocolIntercepted);
+}
+
+}  // namespace api
+}  // namespace atom

atom/browser/api/atom_api_protocol_ns.h

@@ -0,0 +1,95 @@
+// Copyright (c) 2019 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_PROTOCOL_NS_H_
+#define ATOM_BROWSER_API_ATOM_API_PROTOCOL_NS_H_
+
+#include <string>
+
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/net/atom_url_loader_factory.h"
+#include "content/public/browser/content_browser_client.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/handle.h"
+
+namespace atom {
+
+class AtomBrowserContext;
+
+namespace api {
+
+// Possible errors.
+enum class ProtocolError {
+  OK,  // no error
+  REGISTERED,
+  NOT_REGISTERED,
+  INTERCEPTED,
+  NOT_INTERCEPTED,
+};
+
+// Protocol implementation based on network services.
+class ProtocolNS : public mate::TrackableObject<ProtocolNS> {
+ public:
+  static mate::Handle<ProtocolNS> Create(v8::Isolate* isolate,
+                                         AtomBrowserContext* browser_context);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
+
+  // Used by AtomBrowserClient for creating URLLoaderFactory.
+  void RegisterURLLoaderFactories(
+      content::ContentBrowserClient::NonNetworkURLLoaderFactoryMap* factories);
+
+  const HandlersMap& intercept_handlers() const { return intercept_handlers_; }
+
+ private:
+  ProtocolNS(v8::Isolate* isolate, AtomBrowserContext* browser_context);
+  ~ProtocolNS() override;
+
+  // Callback types.
+  using CompletionCallback =
+      base::RepeatingCallback<void(v8::Local<v8::Value>)>;
+
+  // JS APIs.
+  ProtocolError RegisterProtocol(ProtocolType type,
+                                 const std::string& scheme,
+                                 const ProtocolHandler& handler);
+  void UnregisterProtocol(const std::string& scheme, mate::Arguments* args);
+  bool IsProtocolRegistered(const std::string& scheme);
+
+  ProtocolError InterceptProtocol(ProtocolType type,
+                                  const std::string& scheme,
+                                  const ProtocolHandler& handler);
+  void UninterceptProtocol(const std::string& scheme, mate::Arguments* args);
+  bool IsProtocolIntercepted(const std::string& scheme);
+
+  // Old async version of IsProtocolRegistered.
+  v8::Local<v8::Promise> IsProtocolHandled(const std::string& scheme);
+
+  // Helper for converting old registration APIs to new RegisterProtocol API.
+  template <ProtocolType type>
+  void RegisterProtocolFor(const std::string& scheme,
+                           const ProtocolHandler& handler,
+                           mate::Arguments* args) {
+    HandleOptionalCallback(args, RegisterProtocol(type, scheme, handler));
+  }
+  template <ProtocolType type>
+  void InterceptProtocolFor(const std::string& scheme,
+                            const ProtocolHandler& handler,
+                            mate::Arguments* args) {
+    HandleOptionalCallback(args, InterceptProtocol(type, scheme, handler));
+  }
+
+  // Be compatible with old interface, which accepts optional callback.
+  void HandleOptionalCallback(mate::Arguments* args, ProtocolError error);
+
+  HandlersMap handlers_;
+  HandlersMap intercept_handlers_;
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_PROTOCOL_NS_H_

atom/browser/api/atom_api_render_process_preferences.cc

@@ -64,9 +64,9 @@ void RenderProcessPreferences::BuildPrototype(
 // static
 mate::Handle<RenderProcessPreferences>
 RenderProcessPreferences::ForAllWebContents(v8::Isolate* isolate) {
-  return mate::CreateHandle(isolate,
-                            new RenderProcessPreferences(
-                                isolate, base::Bind(&IsWebContents, isolate)));
+  return mate::CreateHandle(
+      isolate, new RenderProcessPreferences(
+                   isolate, base::BindRepeating(&IsWebContents, isolate)));
 }
 
 }  // namespace api

atom/browser/api/atom_api_screen.cc

@@ -116,7 +116,8 @@ void Screen::OnDisplayMetricsChanged(const display::Display& display,
 v8::Local<v8::Value> Screen::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
     isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
-        isolate, "Cannot require \"screen\" module before app is ready")));
+        isolate,
+        "The 'screen' module can't be used before the app 'ready' event")));
     return v8::Null(isolate);
   }
 
@@ -162,7 +163,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("screen", Screen::Create(isolate));
+  dict.Set("createScreen", base::BindRepeating(&Screen::Create, isolate));
   dict.Set(
       "Screen",
       Screen::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());

atom/browser/api/atom_api_session.cc

@@ -14,6 +14,7 @@
 #include "atom/browser/api/atom_api_download_item.h"
 #include "atom/browser/api/atom_api_net_log.h"
 #include "atom/browser/api/atom_api_protocol.h"
+#include "atom/browser/api/atom_api_protocol_ns.h"
 #include "atom/browser/api/atom_api_web_request.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
@@ -21,6 +22,7 @@
 #include "atom/browser/browser.h"
 #include "atom/browser/media/media_device_id_salt.h"
 #include "atom/browser/net/atom_cert_verifier.h"
+#include "atom/browser/net/system_network_context_manager.h"
 #include "atom/browser/session_preferences.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/content_converter.h"
@@ -29,6 +31,7 @@
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "atom/common/node_includes.h"
+#include "atom/common/options_switches.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/strings/string_number_conversions.h"
@@ -45,12 +48,12 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item_utils.h"
 #include "content/public/browser/download_manager_delegate.h"
+#include "content/public/browser/network_service_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
+#include "net/base/completion_repeating_callback.h"
 #include "net/base/load_flags.h"
-#include "net/disk_cache/disk_cache.h"
-#include "net/dns/host_cache.h"  // nogncheck
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_auth_preferences.h"
 #include "net/http/http_cache.h"
@@ -58,6 +61,7 @@
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "services/network/public/cpp/features.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
@@ -71,15 +75,6 @@ struct ClearStorageDataOptions {
   uint32_t quota_types = StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL;
 };
 
-struct ClearAuthCacheOptions {
-  std::string type;
-  GURL origin;
-  std::string realm;
-  base::string16 username;
-  base::string16 password;
-  net::HttpAuth::Scheme auth_scheme;
-};
-
 uint32_t GetStorageMask(const std::vector<std::string>& storage_types) {
   uint32_t storage_mask = 0;
   for (const auto& it : storage_types) {
@@ -120,18 +115,6 @@ uint32_t GetQuotaMask(const std::vector<std::string>& quota_types) {
   return quota_mask;
 }
 
-net::HttpAuth::Scheme GetAuthSchemeFromString(const std::string& scheme) {
-  if (scheme == "basic")
-    return net::HttpAuth::AUTH_SCHEME_BASIC;
-  if (scheme == "digest")
-    return net::HttpAuth::AUTH_SCHEME_DIGEST;
-  if (scheme == "ntlm")
-    return net::HttpAuth::AUTH_SCHEME_NTLM;
-  if (scheme == "negotiate")
-    return net::HttpAuth::AUTH_SCHEME_NEGOTIATE;
-  return net::HttpAuth::AUTH_SCHEME_MAX;
-}
-
 void SetUserAgentInIO(scoped_refptr<net::URLRequestContextGetter> getter,
                       const std::string& accept_lang,
                       const std::string& user_agent) {
@@ -163,26 +146,6 @@ struct Converter<ClearStorageDataOptions> {
   }
 };
 
-template <>
-struct Converter<ClearAuthCacheOptions> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     ClearAuthCacheOptions* out) {
-    mate::Dictionary options;
-    if (!ConvertFromV8(isolate, val, &options))
-      return false;
-    options.Get("type", &out->type);
-    options.Get("origin", &out->origin);
-    options.Get("realm", &out->realm);
-    options.Get("username", &out->username);
-    options.Get("password", &out->password);
-    std::string scheme;
-    if (options.Get("scheme", &scheme))
-      out->auth_scheme = GetAuthSchemeFromString(scheme);
-    return true;
-  }
-};
-
 template <>
 struct Converter<atom::VerifyRequestParams> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
@@ -209,73 +172,6 @@ const char kPersistPrefix[] = "persist:";
 // Referenced session objects.
 std::map<uint32_t, v8::Global<v8::Object>> g_sessions;
 
-void ResolveOrRejectPromiseInUI(util::Promise promise, int net_error) {
-  if (net_error != net::OK) {
-    std::string err_msg = net::ErrorToString(net_error);
-    util::Promise::RejectPromise(std::move(promise), std::move(err_msg));
-  } else {
-    util::Promise::ResolveEmptyPromise(std::move(promise));
-  }
-}
-
-// Callback of HttpCache::GetBackend.
-void OnGetBackend(disk_cache::Backend** backend_ptr,
-                  Session::CacheAction action,
-                  const util::CopyablePromise& promise,
-                  int result) {
-  if (result != net::OK) {
-    std::string err_msg =
-        "Failed to retrieve cache backend: " + net::ErrorToString(result);
-    util::Promise::RejectPromise(promise.GetPromise(), std::move(err_msg));
-  } else if (backend_ptr && *backend_ptr) {
-    if (action == Session::CacheAction::CLEAR) {
-      auto success =
-          (*backend_ptr)
-              ->DoomAllEntries(base::BindOnce(&ResolveOrRejectPromiseInUI,
-                                              promise.GetPromise()));
-      if (success != net::ERR_IO_PENDING)
-        ResolveOrRejectPromiseInUI(promise.GetPromise(), success);
-    } else if (action == Session::CacheAction::STATS) {
-      base::StringPairs stats;
-      (*backend_ptr)->GetStats(&stats);
-      for (const auto& stat : stats) {
-        if (stat.first == "Current size") {
-          int current_size;
-          base::StringToInt(stat.second, &current_size);
-          util::Promise::ResolvePromise<int>(promise.GetPromise(),
-                                             current_size);
-          break;
-        }
-      }
-    }
-  }
-}
-
-void DoCacheActionInIO(
-    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
-    Session::CacheAction action,
-    util::Promise promise) {
-  auto* request_context = context_getter->GetURLRequestContext();
-
-  auto* http_cache = request_context->http_transaction_factory()->GetCache();
-  if (!http_cache) {
-    std::string err_msg =
-        "Failed to retrieve cache: " + net::ErrorToString(net::ERR_FAILED);
-    util::Promise::RejectPromise(std::move(promise), std::move(err_msg));
-    return;
-  }
-
-  // Call GetBackend and make the backend's ptr accessable in OnGetBackend.
-  using BackendPtr = disk_cache::Backend*;
-  auto** backend_ptr = new BackendPtr(nullptr);
-  net::CompletionCallback on_get_backend =
-      base::Bind(&OnGetBackend, base::Owned(backend_ptr), action,
-                 util::CopyablePromise(promise));
-  int rv = http_cache->GetBackend(backend_ptr, on_get_backend);
-  if (rv != net::ERR_IO_PENDING)
-    on_get_backend.Run(net::OK);
-}
-
 void SetCertVerifyProcInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     const AtomCertVerifier::VerifyProc& proc) {
@@ -284,61 +180,6 @@ void SetCertVerifyProcInIO(
       ->SetVerifyProc(proc);
 }
 
-void ClearHostResolverCacheInIO(
-    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
-    util::Promise promise) {
-  auto* request_context = context_getter->GetURLRequestContext();
-  auto* cache = request_context->host_resolver()->GetHostCache();
-  if (cache) {
-    cache->clear();
-    DCHECK_EQ(0u, cache->size());
-    base::PostTaskWithTraits(
-        FROM_HERE, {BrowserThread::UI},
-        base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
-  }
-}
-
-void ClearAuthCacheInIO(
-    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
-    const ClearAuthCacheOptions& options,
-    util::Promise promise) {
-  auto* request_context = context_getter->GetURLRequestContext();
-  auto* network_session =
-      request_context->http_transaction_factory()->GetSession();
-  if (network_session) {
-    if (options.type == "password") {
-      auto* auth_cache = network_session->http_auth_cache();
-      if (!options.origin.is_empty()) {
-        auth_cache->Remove(
-            options.origin, options.realm, options.auth_scheme,
-            net::AuthCredentials(options.username, options.password));
-      } else {
-        auth_cache->ClearAllEntries();
-      }
-    } else if (options.type == "clientCertificate") {
-      auto* client_auth_cache = network_session->ssl_client_auth_cache();
-      client_auth_cache->Remove(net::HostPortPair::FromURL(options.origin));
-    }
-    network_session->CloseAllConnections();
-  }
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::UI},
-      base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
-}
-
-void AllowNTLMCredentialsForDomainsInIO(
-    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
-    const std::string& domains) {
-  auto* request_context = context_getter->GetURLRequestContext();
-  auto* auth_handler = request_context->http_auth_handler_factory();
-  if (auth_handler) {
-    auto* auth_preferences = const_cast<net::HttpAuthPreferences*>(
-        auth_handler->http_auth_preferences());
-    if (auth_preferences)
-      auth_preferences->SetServerWhitelist(domains);
-  }
-}
-
 void DownloadIdCallback(content::DownloadManager* download_manager,
                         const base::FilePath& path,
                         const std::vector<GURL>& url_chain,
@@ -351,8 +192,8 @@ void DownloadIdCallback(content::DownloadManager* download_manager,
                         uint32_t id) {
   download_manager->CreateDownloadItem(
       base::GenerateGUID(), id, path, path, url_chain, GURL(), GURL(), GURL(),
-      GURL(), mime_type, mime_type, start_time, base::Time(), etag,
-      last_modified, offset, length, std::string(),
+      GURL(), base::nullopt, mime_type, mime_type, start_time, base::Time(),
+      etag, last_modified, offset, length, std::string(),
       download::DownloadItem::INTERRUPTED,
       download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
       download::DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT, false, base::Time(),
@@ -365,8 +206,9 @@ void DestroyGlobalHandle(v8::Isolate* isolate,
   v8::HandleScope handle_scope(isolate);
   if (!global_handle.IsEmpty()) {
     v8::Local<v8::Value> local_handle = global_handle.Get(isolate);
-    if (local_handle->IsObject()) {
-      v8::Local<v8::Object> object = local_handle->ToObject(isolate);
+    v8::Local<v8::Object> object;
+    if (local_handle->IsObject() &&
+        local_handle->ToObject(isolate->GetCurrentContext()).ToLocal(&object)) {
       void* ptr = object->GetAlignedPointerFromInternalField(0);
       if (!ptr)
         return;
@@ -429,24 +271,45 @@ v8::Local<v8::Promise> Session::ResolveProxy(mate::Arguments* args) {
   args->GetNext(&url);
 
   browser_context_->GetResolveProxyHelper()->ResolveProxy(
-      url,
-      base::Bind(util::CopyablePromise::ResolveCopyablePromise<std::string>,
-                 util::CopyablePromise(promise)));
+      url, base::BindOnce(util::Promise::ResolvePromise<std::string>,
+                          std::move(promise)));
 
   return handle;
 }
 
-template <Session::CacheAction action>
-v8::Local<v8::Promise> Session::DoCacheAction() {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  util::Promise promise(isolate);
-  v8::Local<v8::Promise> handle = promise.GetHandle();
+v8::Local<v8::Promise> Session::GetCacheSize() {
+  auto* isolate = v8::Isolate::GetCurrent();
+  auto promise = util::Promise(isolate);
+  auto handle = promise.GetHandle();
 
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(&DoCacheActionInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     action, std::move(promise)));
+  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
+      ->GetNetworkContext()
+      ->ComputeHttpCacheSize(base::Time(), base::Time::Max(),
+                             base::BindOnce(
+                                 [](util::Promise promise, bool is_upper_bound,
+                                    int64_t size_or_error) {
+                                   if (size_or_error < 0) {
+                                     promise.RejectWithErrorMessage(
+                                         net::ErrorToString(size_or_error));
+                                   } else {
+                                     promise.Resolve(size_or_error);
+                                   }
+                                 },
+                                 std::move(promise)));
+
+  return handle;
+}
+
+v8::Local<v8::Promise> Session::ClearCache() {
+  auto* isolate = v8::Isolate::GetCurrent();
+  auto promise = util::Promise(isolate);
+  auto handle = promise.GetHandle();
+
+  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
+      ->GetNetworkContext()
+      ->ClearHttpCache(base::Time(), base::Time::Max(), nullptr,
+                       base::BindOnce(util::Promise::ResolveEmptyPromise,
+                                      std::move(promise)));
 
   return handle;
 }
@@ -470,8 +333,7 @@ v8::Local<v8::Promise> Session::ClearStorageData(mate::Arguments* args) {
   storage_partition->ClearData(
       options.storage_types, options.quota_types, options.origin, base::Time(),
       base::Time::Max(),
-      base::Bind(util::CopyablePromise::ResolveEmptyCopyablePromise,
-                 util::CopyablePromise(promise)));
+      base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
   return handle;
 }
 
@@ -553,17 +415,18 @@ void Session::DisableNetworkEmulation() {
       network_emulation_token_, network::mojom::NetworkConditions::New());
 }
 
-void WrapVerifyProc(base::Callback<void(const VerifyRequestParams& request,
-                                        base::Callback<void(int)>)> proc,
-                    const VerifyRequestParams& request,
-                    base::OnceCallback<void(int)> cb) {
+void WrapVerifyProc(
+    base::RepeatingCallback<void(const VerifyRequestParams& request,
+                                 base::RepeatingCallback<void(int)>)> proc,
+    const VerifyRequestParams& request,
+    base::OnceCallback<void(int)> cb) {
   proc.Run(request, base::AdaptCallbackForRepeating(std::move(cb)));
 }
 
 void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
                                 mate::Arguments* args) {
-  base::Callback<void(const VerifyRequestParams& request,
-                      base::Callback<void(int)>)>
+  base::RepeatingCallback<void(const VerifyRequestParams& request,
+                               base::RepeatingCallback<void(int)>)>
       proc;
   if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &proc))) {
     args->ThrowError("Must pass null or function");
@@ -574,19 +437,38 @@ void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
       FROM_HERE, {BrowserThread::IO},
       base::BindOnce(&SetCertVerifyProcInIO,
                      WrapRefCounted(browser_context_->GetRequestContext()),
-                     base::Bind(&WrapVerifyProc, proc)));
+                     base::BindRepeating(&WrapVerifyProc, proc)));
 }
 
 void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
                                           mate::Arguments* args) {
-  AtomPermissionManager::RequestHandler handler;
-  if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &handler))) {
+  using StatusCallback =
+      base::RepeatingCallback<void(blink::mojom::PermissionStatus)>;
+  using RequestHandler =
+      base::Callback<void(content::WebContents*, content::PermissionType,
+                          StatusCallback, const base::DictionaryValue&)>;
+  auto* permission_manager = static_cast<AtomPermissionManager*>(
+      browser_context()->GetPermissionControllerDelegate());
+  if (val->IsNull()) {
+    permission_manager->SetPermissionRequestHandler(
+        AtomPermissionManager::RequestHandler());
+    return;
+  }
+  auto handler = std::make_unique<RequestHandler>();
+  if (!mate::ConvertFromV8(args->isolate(), val, handler.get())) {
     args->ThrowError("Must pass null or function");
     return;
   }
-  auto* permission_manager = static_cast<AtomPermissionManager*>(
-      browser_context()->GetPermissionControllerDelegate());
-  permission_manager->SetPermissionRequestHandler(handler);
+  permission_manager->SetPermissionRequestHandler(base::BindRepeating(
+      [](RequestHandler* handler, content::WebContents* web_contents,
+         content::PermissionType permission_type,
+         AtomPermissionManager::StatusCallback callback,
+         const base::DictionaryValue& details) {
+        handler->Run(web_contents, permission_type,
+                     base::AdaptCallbackForRepeating(std::move(callback)),
+                     details);
+      },
+      base::Owned(std::move(handler))));
 }
 
 void Session::SetPermissionCheckHandler(v8::Local<v8::Value> val,
@@ -606,39 +488,33 @@ v8::Local<v8::Promise> Session::ClearHostResolverCache(mate::Arguments* args) {
   util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(&ClearHostResolverCacheInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     std::move(promise)));
+  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
+      ->GetNetworkContext()
+      ->ClearHostCache(nullptr,
+                       base::BindOnce(util::Promise::ResolveEmptyPromise,
+                                      std::move(promise)));
+
   return handle;
 }
 
-v8::Local<v8::Promise> Session::ClearAuthCache(mate::Arguments* args) {
-  v8::Isolate* isolate = args->isolate();
+v8::Local<v8::Promise> Session::ClearAuthCache() {
+  auto* isolate = v8::Isolate::GetCurrent();
   util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  ClearAuthCacheOptions options;
-  if (!args->GetNext(&options)) {
-    promise.RejectWithErrorMessage("Must specify options object");
-    return handle;
-  }
+  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
+      ->GetNetworkContext()
+      ->ClearHttpAuthCache(base::Time(),
+                           base::BindOnce(util::Promise::ResolveEmptyPromise,
+                                          std::move(promise)));
 
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(&ClearAuthCacheInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     options, std::move(promise)));
   return handle;
 }
 
 void Session::AllowNTLMCredentialsForDomains(const std::string& domains) {
-  base::PostTaskWithTraits(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(&AllowNTLMCredentialsForDomainsInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     domains));
+  auto auth_params = CreateHttpAuthDynamicParams();
+  auth_params->server_whitelist = domains;
+  content::GetNetworkService()->ConfigureHttpAuthPrefs(std::move(auth_params));
 }
 
 void Session::SetUserAgent(const std::string& user_agent,
@@ -698,7 +574,7 @@ void Session::CreateInterruptedDownload(const mate::Dictionary& options) {
   }
   auto* download_manager =
       content::BrowserContext::GetDownloadManager(browser_context());
-  download_manager->GetDelegate()->GetNextId(base::Bind(
+  download_manager->GetDelegate()->GetNextId(base::BindRepeating(
       &DownloadIdCallback, download_manager, path, url_chain, mime_type, offset,
       length, last_modified, etag, base::Time::FromDoubleT(start_time)));
 }
@@ -726,8 +602,12 @@ v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
 
 v8::Local<v8::Value> Session::Protocol(v8::Isolate* isolate) {
   if (protocol_.IsEmpty()) {
-    auto handle = atom::api::Protocol::Create(isolate, browser_context());
-    protocol_.Reset(isolate, handle.ToV8());
+    v8::Local<v8::Value> handle;
+    if (base::FeatureList::IsEnabled(network::features::kNetworkService))
+      handle = ProtocolNS::Create(isolate, browser_context()).ToV8();
+    else
+      handle = Protocol::Create(isolate, browser_context()).ToV8();
+    protocol_.Reset(isolate, handle);
   }
   return v8::Local<v8::Value>::New(isolate, protocol_);
 }
@@ -791,8 +671,8 @@ void Session::BuildPrototype(v8::Isolate* isolate,
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .MakeDestroyable()
       .SetMethod("resolveProxy", &Session::ResolveProxy)
-      .SetMethod("getCacheSize", &Session::DoCacheAction<CacheAction::STATS>)
-      .SetMethod("clearCache", &Session::DoCacheAction<CacheAction::CLEAR>)
+      .SetMethod("getCacheSize", &Session::GetCacheSize)
+      .SetMethod("clearCache", &Session::ClearCache)
       .SetMethod("clearStorageData", &Session::ClearStorageData)
       .SetMethod("flushStorageData", &Session::FlushStorageData)
       .SetMethod("setProxy", &Session::SetProxy)

atom/browser/api/atom_api_session.h

@@ -15,7 +15,6 @@
 #include "base/values.h"
 #include "content/public/browser/download_manager.h"
 #include "native_mate/handle.h"
-#include "net/base/completion_callback.h"
 
 class GURL;
 
@@ -64,8 +63,8 @@ class Session : public mate::TrackableObject<Session>,
 
   // Methods.
   v8::Local<v8::Promise> ResolveProxy(mate::Arguments* args);
-  template <CacheAction action>
-  v8::Local<v8::Promise> DoCacheAction();
+  v8::Local<v8::Promise> GetCacheSize();
+  v8::Local<v8::Promise> ClearCache();
   v8::Local<v8::Promise> ClearStorageData(mate::Arguments* args);
   void FlushStorageData();
   v8::Local<v8::Promise> SetProxy(mate::Arguments* args);
@@ -78,7 +77,7 @@ class Session : public mate::TrackableObject<Session>,
   void SetPermissionCheckHandler(v8::Local<v8::Value> val,
                                  mate::Arguments* args);
   v8::Local<v8::Promise> ClearHostResolverCache(mate::Arguments* args);
-  v8::Local<v8::Promise> ClearAuthCache(mate::Arguments* args);
+  v8::Local<v8::Promise> ClearAuthCache();
   void AllowNTLMCredentialsForDomains(const std::string& domains);
   void SetUserAgent(const std::string& user_agent, mate::Arguments* args);
   std::string GetUserAgent();

atom/browser/api/atom_api_system_preferences.cc

@@ -106,6 +106,9 @@ void SystemPreferences::BuildPrototype(
                  &SystemPreferences::GetAppLevelAppearance)
       .SetMethod("setAppLevelAppearance",
                  &SystemPreferences::SetAppLevelAppearance)
+      .SetProperty("appLevelAppearance",
+                   &SystemPreferences::GetAppLevelAppearance,
+                   &SystemPreferences::SetAppLevelAppearance)
       .SetMethod("getSystemColor", &SystemPreferences::GetSystemColor)
       .SetMethod("canPromptTouchID", &SystemPreferences::CanPromptTouchID)
       .SetMethod("promptTouchID", &SystemPreferences::PromptTouchID)

atom/browser/api/atom_api_system_preferences.h

@@ -66,7 +66,8 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
 
 #elif defined(OS_MACOSX)
   using NotificationCallback =
-      base::Callback<void(const std::string&, const base::DictionaryValue&)>;
+      base::RepeatingCallback<void(const std::string&,
+                                   const base::DictionaryValue&)>;
 
   void PostNotification(const std::string& name,
                         const base::DictionaryValue& user_info,

atom/browser/api/atom_api_system_preferences_mac.mm

@@ -5,6 +5,9 @@
 #include "atom/browser/api/atom_api_system_preferences.h"
 
 #include <map>
+#include <memory>
+#include <string>
+#include <utility>
 
 #import <AVFoundation/AVFoundation.h>
 #import <Cocoa/Cocoa.h>
@@ -13,6 +16,7 @@
 
 #include "atom/browser/mac/atom_application.h"
 #include "atom/browser/mac/dict_util.h"
+#include "atom/browser/ui/cocoa/NSColor+Hex.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "base/mac/scoped_cftyperef.h"
@@ -111,21 +115,6 @@ std::string ConvertAuthorizationStatus(AVAuthorizationStatusMac status) {
   }
 }
 
-// Convert color to RGBA value like "aabbccdd"
-std::string ToRGBA(NSColor* color) {
-  return base::StringPrintf(
-      "%02X%02X%02X%02X", (int)(color.redComponent * 0xFF),
-      (int)(color.greenComponent * 0xFF), (int)(color.blueComponent * 0xFF),
-      (int)(color.alphaComponent * 0xFF));
-}
-
-// Convert color to RGB hex value like "#ABCDEF"
-std::string ToRGBHex(NSColor* color) {
-  return base::StringPrintf("#%02X%02X%02X", (int)(color.redComponent * 0xFF),
-                            (int)(color.greenComponent * 0xFF),
-                            (int)(color.blueComponent * 0xFF));
-}
-
 }  // namespace
 
 void SystemPreferences::PostNotification(const std::string& name,
@@ -405,7 +394,7 @@ std::string SystemPreferences::GetAccentColor() {
   if (@available(macOS 10.14, *))
     sysColor = [NSColor controlAccentColor];
 
-  return ToRGBA(sysColor);
+  return base::SysNSStringToUTF8([sysColor RGBAValue]);
 }
 
 std::string SystemPreferences::GetSystemColor(const std::string& color,
@@ -434,7 +423,7 @@ std::string SystemPreferences::GetSystemColor(const std::string& color,
     return "";
   }
 
-  return ToRGBHex(sysColor);
+  return base::SysNSStringToUTF8([sysColor hexadecimalValue]);
 }
 
 bool SystemPreferences::CanPromptTouchID() {
@@ -587,7 +576,7 @@ std::string SystemPreferences::GetColor(const std::string& color,
     return "";
   }
 
-  return ToRGBHex(sysColor);
+  return base::SysNSStringToUTF8([sysColor hexadecimalValue]);
 }
 
 std::string SystemPreferences::GetMediaAccessStatus(

atom/browser/api/atom_api_top_level_window.cc

@@ -648,10 +648,11 @@ void TopLevelWindow::SetFocusable(bool focusable) {
 }
 
 void TopLevelWindow::SetMenu(v8::Isolate* isolate, v8::Local<v8::Value> value) {
+  auto context = isolate->GetCurrentContext();
   mate::Handle<Menu> menu;
-  if (value->IsObject() &&
-      gin::V8ToString(
-          isolate, value->ToObject(isolate)->GetConstructorName()) == "Menu" &&
+  v8::Local<v8::Object> object;
+  if (value->IsObject() && value->ToObject(context).ToLocal(&object) &&
+      gin::V8ToString(isolate, object->GetConstructorName()) == "Menu" &&
       mate::ConvertFromV8(isolate, value, &menu) && !menu.IsEmpty()) {
     menu_.Reset(isolate, menu.ToV8());
     window_->SetMenu(menu->model());
@@ -736,15 +737,15 @@ void TopLevelWindow::SetProgressBar(double progress, mate::Arguments* args) {
   std::string mode;
   args->GetNext(&options) && options.Get("mode", &mode);
 
-  NativeWindow::ProgressState state = NativeWindow::PROGRESS_NORMAL;
+  NativeWindow::ProgressState state = NativeWindow::ProgressState::kNormal;
   if (mode == "error")
-    state = NativeWindow::PROGRESS_ERROR;
+    state = NativeWindow::ProgressState::kError;
   else if (mode == "paused")
-    state = NativeWindow::PROGRESS_PAUSED;
+    state = NativeWindow::ProgressState::kPaused;
   else if (mode == "indeterminate")
-    state = NativeWindow::PROGRESS_INDETERMINATE;
+    state = NativeWindow::ProgressState::kIndeterminate;
   else if (mode == "none")
-    state = NativeWindow::PROGRESS_NONE;
+    state = NativeWindow::ProgressState::kNone;
 
   window_->SetProgressBar(progress, state);
 }
@@ -1189,7 +1190,8 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  TopLevelWindow::SetConstructor(isolate, base::Bind(&TopLevelWindow::New));
+  TopLevelWindow::SetConstructor(isolate,
+                                 base::BindRepeating(&TopLevelWindow::New));
 
   mate::Dictionary constructor(isolate, TopLevelWindow::GetConstructor(isolate)
                                             ->GetFunction(context)

atom/browser/api/atom_api_top_level_window.h

@@ -211,7 +211,8 @@ class TopLevelWindow : public mate::TrackableObject<TopLevelWindow>,
   void SetIcon(mate::Handle<NativeImage> icon);
 #endif
 #if defined(OS_WIN)
-  typedef base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>
+  typedef base::RepeatingCallback<void(v8::Local<v8::Value>,
+                                       v8::Local<v8::Value>)>
       MessageCallback;
   bool HookWindowMessage(UINT message, const MessageCallback& callback);
   bool IsWindowMessageHooked(UINT message);

atom/browser/api/atom_api_tray.cc

@@ -25,18 +25,19 @@ struct Converter<atom::TrayIcon::HighlightMode> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
                      atom::TrayIcon::HighlightMode* out) {
+    using HighlightMode = atom::TrayIcon::HighlightMode;
     std::string mode;
     if (ConvertFromV8(isolate, val, &mode)) {
       if (mode == "always") {
-        *out = atom::TrayIcon::HighlightMode::ALWAYS;
+        *out = HighlightMode::ALWAYS;
         return true;
       }
       if (mode == "selection") {
-        *out = atom::TrayIcon::HighlightMode::SELECTION;
+        *out = HighlightMode::SELECTION;
         return true;
       }
       if (mode == "never") {
-        *out = atom::TrayIcon::HighlightMode::NEVER;
+        *out = HighlightMode::NEVER;
         return true;
       }
     }
@@ -59,11 +60,7 @@ Tray::Tray(v8::Isolate* isolate,
   InitWith(isolate, wrapper);
 }
 
-Tray::~Tray() {
-  // Destroy the native tray in next tick.
-  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,
-                                                  tray_icon_.release());
-}
+Tray::~Tray() = default;
 
 // static
 mate::WrappableBase* Tray::New(mate::Handle<NativeImage> image,
@@ -262,7 +259,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  Tray::SetConstructor(isolate, base::Bind(&Tray::New));
+  Tray::SetConstructor(isolate, base::BindRepeating(&Tray::New));
 
   mate::Dictionary dict(isolate, exports);
   dict.Set(

atom/browser/api/atom_api_url_request.cc

@@ -9,9 +9,9 @@
 #include "atom/browser/api/atom_api_session.h"
 #include "atom/browser/net/atom_url_request.h"
 #include "atom/common/api/event_emitter_caller.h"
-#include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/net_converter.h"
+#include "atom/common/native_mate_converters/once_callback.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "atom/common/node_includes.h"
 #include "native_mate/dictionary.h"
@@ -354,7 +354,7 @@ void URLRequest::OnReceivedRedirect(
 }
 
 void URLRequest::OnAuthenticationRequired(
-    scoped_refptr<const net::AuthChallengeInfo> auth_info) {
+    const net::AuthChallengeInfo& auth_info) {
   if (request_state_.Canceled() || request_state_.Closed()) {
     return;
   }
@@ -364,8 +364,8 @@ void URLRequest::OnAuthenticationRequired(
     return;
   }
 
-  Emit("login", auth_info.get(),
-       base::Bind(&AtomURLRequest::PassLoginInformation, atom_request_));
+  Emit("login", auth_info,
+       base::BindOnce(&AtomURLRequest::PassLoginInformation, atom_request_));
 }
 
 void URLRequest::OnResponseStarted(

atom/browser/api/atom_api_url_request.h

@@ -105,8 +105,7 @@ class URLRequest : public mate::EventEmitter<URLRequest> {
       const std::string& method,
       const GURL& url,
       scoped_refptr<net::HttpResponseHeaders> response_headers);
-  void OnAuthenticationRequired(
-      scoped_refptr<const net::AuthChallengeInfo> auth_info);
+  void OnAuthenticationRequired(const net::AuthChallengeInfo& auth_info);
   void OnResponseStarted(
       scoped_refptr<net::HttpResponseHeaders> response_headers);
   void OnResponseData(scoped_refptr<const net::IOBufferWithSize> data);

atom/browser/api/atom_api_view.cc

@@ -73,7 +73,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  View::SetConstructor(isolate, base::Bind(&View::New));
+  View::SetConstructor(isolate, base::BindRepeating(&View::New));
 
   mate::Dictionary constructor(
       isolate,

atom/browser/api/atom_api_web_contents.cc

@@ -35,20 +35,22 @@
 #include "atom/common/color_util.h"
 #include "atom/common/mouse_util.h"
 #include "atom/common/native_mate_converters/blink_converter.h"
-#include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/content_converter.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/map_converter.h"
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/native_mate_converters/network_converter.h"
+#include "atom/common/native_mate_converters/once_callback.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
 #include "base/message_loop/message_loop.h"
 #include "base/no_destructor.h"
+#include "base/optional.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -86,6 +88,7 @@
 #include "net/url_request/url_request_context.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 #include "third_party/blink/public/mojom/frame/find_in_page.mojom.h"
+#include "third_party/blink/public/platform/web_cursor_info.h"
 #include "third_party/blink/public/platform/web_input_event.h"
 #include "ui/display/screen.h"
 #include "ui/events/base_event_utils.h"
@@ -266,7 +269,7 @@ struct WebContents::FrameDispatchHelper {
 
 WebContents::WebContents(v8::Isolate* isolate,
                          content::WebContents* web_contents)
-    : content::WebContentsObserver(web_contents), type_(REMOTE) {
+    : content::WebContentsObserver(web_contents), type_(Type::REMOTE) {
   web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent(),
                                      false);
   Init(isolate);
@@ -282,7 +285,8 @@ WebContents::WebContents(v8::Isolate* isolate,
                          std::unique_ptr<content::WebContents> web_contents,
                          Type type)
     : content::WebContentsObserver(web_contents.get()), type_(type) {
-  DCHECK(type != REMOTE) << "Can't take ownership of a remote WebContents";
+  DCHECK(type != Type::REMOTE)
+      << "Can't take ownership of a remote WebContents";
   auto session = Session::CreateFrom(isolate, GetBrowserContext());
   session_.Reset(isolate, session.ToV8());
   InitWithSessionAndOptions(isolate, std::move(web_contents), session,
@@ -294,21 +298,13 @@ WebContents::WebContents(v8::Isolate* isolate,
   // Read options.
   options.Get("backgroundThrottling", &background_throttling_);
 
-  // FIXME(zcbenz): We should read "type" parameter for better design, but
-  // on Windows we have encountered a compiler bug that if we read "type"
-  // from |options| and then set |type_|, a memory corruption will happen
-  // and Electron will soon crash.
-  // Remvoe this after we upgraded to use VS 2015 Update 3.
+  // Get type
+  options.Get("type", &type_);
+
   bool b = false;
-  if (options.Get("isGuest", &b) && b)
-    type_ = WEB_VIEW;
-  else if (options.Get("isBackgroundPage", &b) && b)
-    type_ = BACKGROUND_PAGE;
-  else if (options.Get("isBrowserView", &b) && b)
-    type_ = BROWSER_VIEW;
 #if BUILDFLAG(ENABLE_OSR)
-  else if (options.Get(options::kOffscreen, &b) && b)
-    type_ = OFF_SCREEN;
+  if (options.Get(options::kOffscreen, &b) && b)
+    type_ = Type::OFF_SCREEN;
 #endif
 
   // Init embedder earlier
@@ -343,7 +339,8 @@ WebContents::WebContents(v8::Isolate* isolate,
 #if BUILDFLAG(ENABLE_OSR)
     if (embedder_ && embedder_->IsOffScreen()) {
       auto* view = new OffScreenWebContentsView(
-          false, base::Bind(&WebContents::OnPaint, base::Unretained(this)));
+          false,
+          base::BindRepeating(&WebContents::OnPaint, base::Unretained(this)));
       params.view = view;
       params.delegate_view = view;
 
@@ -360,7 +357,8 @@ WebContents::WebContents(v8::Isolate* isolate,
 
     content::WebContents::CreateParams params(session->browser_context());
     auto* view = new OffScreenWebContentsView(
-        transparent, base::Bind(&WebContents::OnPaint, base::Unretained(this)));
+        transparent,
+        base::BindRepeating(&WebContents::OnPaint, base::Unretained(this)));
     params.view = view;
     params.delegate_view = view;
 
@@ -455,12 +453,12 @@ WebContents::~WebContents() {
 
     RenderViewDeleted(web_contents()->GetRenderViewHost());
 
-    if (type_ == WEB_VIEW) {
+    if (type_ == Type::WEB_VIEW) {
       DCHECK(!web_contents()->GetOuterWebContents())
           << "Should never manually destroy an attached webview";
       // For webview simply destroy the WebContents immediately.
       DestroyWebContents(false /* async */);
-    } else if (type_ == BROWSER_WINDOW && owner_window()) {
+    } else if (type_ == Type::BROWSER_WINDOW && owner_window()) {
       // For BrowserWindow we should close the window and clean up everything
       // before WebContents is destroyed.
       for (ExtendedWebContentsObserver& observer : observers_)
@@ -490,12 +488,14 @@ void WebContents::DestroyWebContents(bool async) {
   ResetManagedWebContents(async);
 }
 
-bool WebContents::DidAddMessageToConsole(content::WebContents* source,
-                                         int32_t level,
-                                         const base::string16& message,
-                                         int32_t line_no,
-                                         const base::string16& source_id) {
-  return Emit("console-message", level, message, line_no, source_id);
+bool WebContents::DidAddMessageToConsole(
+    content::WebContents* source,
+    blink::mojom::ConsoleMessageLevel level,
+    const base::string16& message,
+    int32_t line_no,
+    const base::string16& source_id) {
+  return Emit("console-message", static_cast<int32_t>(level), message, line_no,
+              source_id);
 }
 
 void WebContents::OnCreateWindow(
@@ -505,7 +505,7 @@ void WebContents::OnCreateWindow(
     WindowOpenDisposition disposition,
     const std::vector<std::string>& features,
     const scoped_refptr<network::ResourceRequestBody>& body) {
-  if (type_ == BROWSER_WINDOW || type_ == OFF_SCREEN)
+  if (type_ == Type::BROWSER_WINDOW || type_ == Type::OFF_SCREEN)
     Emit("-new-window", target_url, frame_name, disposition, features, body,
          referrer);
   else
@@ -537,7 +537,7 @@ void WebContents::AddNewContents(
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
   auto api_web_contents =
-      CreateAndTake(isolate(), std::move(new_contents), BROWSER_WINDOW);
+      CreateAndTake(isolate(), std::move(new_contents), Type::BROWSER_WINDOW);
   if (Emit("-add-new-contents", api_web_contents, disposition, user_gesture,
            initial_rect.x(), initial_rect.y(), initial_rect.width(),
            initial_rect.height(), tracker->url, tracker->frame_name)) {
@@ -550,7 +550,7 @@ content::WebContents* WebContents::OpenURLFromTab(
     content::WebContents* source,
     const content::OpenURLParams& params) {
   if (params.disposition != WindowOpenDisposition::CURRENT_TAB) {
-    if (type_ == BROWSER_WINDOW || type_ == OFF_SCREEN)
+    if (type_ == Type::BROWSER_WINDOW || type_ == Type::OFF_SCREEN)
       Emit("-new-window", params.url, "", params.disposition);
     else
       Emit("new-window", params.url, "", params.disposition);
@@ -572,7 +572,7 @@ content::WebContents* WebContents::OpenURLFromTab(
 void WebContents::BeforeUnloadFired(content::WebContents* tab,
                                     bool proceed,
                                     bool* proceed_to_fire_unload) {
-  if (type_ == BROWSER_WINDOW || type_ == OFF_SCREEN)
+  if (type_ == Type::BROWSER_WINDOW || type_ == Type::OFF_SCREEN)
     *proceed_to_fire_unload = proceed;
   else
     *proceed_to_fire_unload = true;
@@ -606,7 +606,7 @@ void WebContents::UpdateTargetURL(content::WebContents* source,
 bool WebContents::HandleKeyboardEvent(
     content::WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
-  if (type_ == WEB_VIEW && embedder_) {
+  if (type_ == Type::WEB_VIEW && embedder_) {
     // Send the unhandled keyboard events back to the embedder.
     return embedder_->HandleKeyboardEvent(source, event);
   } else {
@@ -629,14 +629,19 @@ content::KeyboardEventProcessingResult WebContents::PreHandleKeyboardEvent(
   return content::KeyboardEventProcessingResult::NOT_HANDLED;
 }
 
+void WebContents::ContentsZoomChange(bool zoom_in) {
+  Emit("zoom-changed", zoom_in ? "in" : "out");
+}
+
 void WebContents::EnterFullscreenModeForTab(
     content::WebContents* source,
     const GURL& origin,
     const blink::WebFullscreenOptions& options) {
   auto* permission_helper =
       WebContentsPermissionHelper::FromWebContents(source);
-  auto callback = base::Bind(&WebContents::OnEnterFullscreenModeForTab,
-                             base::Unretained(this), source, origin, options);
+  auto callback =
+      base::BindRepeating(&WebContents::OnEnterFullscreenModeForTab,
+                          base::Unretained(this), source, origin, options);
   permission_helper->RequestFullscreenPermission(callback);
 }
 
@@ -675,8 +680,9 @@ bool WebContents::HandleContextMenu(content::RenderFrameHost* render_frame_host,
                                     const content::ContextMenuParams& params) {
   if (params.custom_context.is_pepper_menu) {
     Emit("pepper-context-menu", std::make_pair(params, web_contents()),
-         base::Bind(&content::WebContents::NotifyContextMenuClosed,
-                    base::Unretained(web_contents()), params.custom_context));
+         base::BindOnce(&content::WebContents::NotifyContextMenuClosed,
+                        base::Unretained(web_contents()),
+                        params.custom_context));
   } else {
     Emit("context-menu", std::make_pair(params, web_contents()));
   }
@@ -807,20 +813,20 @@ void WebContents::PluginCrashed(const base::FilePath& plugin_path,
 }
 
 void WebContents::MediaStartedPlaying(const MediaPlayerInfo& video_type,
-                                      const MediaPlayerId& id) {
+                                      const content::MediaPlayerId& id) {
   Emit("media-started-playing");
 }
 
 void WebContents::MediaStoppedPlaying(
     const MediaPlayerInfo& video_type,
-    const MediaPlayerId& id,
+    const content::MediaPlayerId& id,
     content::WebContentsObserver::MediaStoppedReason reason) {
   Emit("media-paused");
 }
 
-void WebContents::DidChangeThemeColor(SkColor theme_color) {
-  if (theme_color != SK_ColorTRANSPARENT) {
-    Emit("did-change-theme-color", atom::ToRGBHex(theme_color));
+void WebContents::DidChangeThemeColor(base::Optional<SkColor> theme_color) {
+  if (theme_color) {
+    Emit("did-change-theme-color", atom::ToRGBHex(theme_color.value()));
   } else {
     Emit("did-change-theme-color", nullptr);
   }
@@ -918,6 +924,14 @@ void WebContents::Message(bool internal,
                  internal, channel, std::move(arguments));
 }
 
+void WebContents::Invoke(const std::string& channel,
+                         base::Value arguments,
+                         InvokeCallback callback) {
+  // webContents.emit('-ipc-invoke', new Event(), channel, arguments);
+  EmitWithSender("-ipc-invoke", bindings_.dispatch_context(),
+                 std::move(callback), channel, std::move(arguments));
+}
+
 void WebContents::MessageSync(bool internal,
                               const std::string& channel,
                               base::Value arguments,
@@ -1192,7 +1206,7 @@ void WebContents::SetBackgroundThrottling(bool allowed) {
     return;
   }
 
-  const auto* render_view_host = contents->GetRenderViewHost();
+  auto* render_view_host = contents->GetRenderViewHost();
   if (!render_view_host) {
     return;
   }
@@ -1211,7 +1225,7 @@ void WebContents::SetBackgroundThrottling(bool allowed) {
   render_widget_host_impl->disable_hidden_ = !background_throttling_;
 
   if (render_widget_host_impl->is_hidden()) {
-    render_widget_host_impl->WasShown(false);
+    render_widget_host_impl->WasShown(base::nullopt);
   }
 }
 
@@ -1386,14 +1400,14 @@ v8::Local<v8::Promise> WebContents::SavePage(
 }
 
 void WebContents::OpenDevTools(mate::Arguments* args) {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return;
 
   if (!enable_devtools_)
     return;
 
   std::string state;
-  if (type_ == WEB_VIEW || !owner_window()) {
+  if (type_ == Type::WEB_VIEW || !owner_window()) {
     state = "detach";
   }
   bool activate = true;
@@ -1409,21 +1423,21 @@ void WebContents::OpenDevTools(mate::Arguments* args) {
 }
 
 void WebContents::CloseDevTools() {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return;
 
   managed_web_contents()->CloseDevTools();
 }
 
 bool WebContents::IsDevToolsOpened() {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return false;
 
   return managed_web_contents()->IsDevToolsViewShowing();
 }
 
 bool WebContents::IsDevToolsFocused() {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return false;
 
   return managed_web_contents()->GetView()->IsDevToolsViewFocused();
@@ -1431,7 +1445,7 @@ bool WebContents::IsDevToolsFocused() {
 
 void WebContents::EnableDeviceEmulation(
     const blink::WebDeviceEmulationParams& params) {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return;
 
   auto* frame_host = web_contents()->GetMainFrame();
@@ -1446,7 +1460,7 @@ void WebContents::EnableDeviceEmulation(
 }
 
 void WebContents::DisableDeviceEmulation() {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return;
 
   auto* frame_host = web_contents()->GetMainFrame();
@@ -1468,7 +1482,7 @@ void WebContents::ToggleDevTools() {
 }
 
 void WebContents::InspectElement(int x, int y) {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return;
 
   if (!enable_devtools_)
@@ -1480,7 +1494,7 @@ void WebContents::InspectElement(int x, int y) {
 }
 
 void WebContents::InspectSharedWorker() {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return;
 
   if (!enable_devtools_)
@@ -1497,7 +1511,7 @@ void WebContents::InspectSharedWorker() {
 }
 
 void WebContents::InspectServiceWorker() {
-  if (type_ == REMOTE)
+  if (type_ == Type::REMOTE)
     return;
 
   if (!enable_devtools_)
@@ -1697,7 +1711,7 @@ bool WebContents::IsFocused() const {
   if (!view)
     return false;
 
-  if (GetType() != BACKGROUND_PAGE) {
+  if (GetType() != Type::BACKGROUND_PAGE) {
     auto* window = web_contents()->GetNativeView()->GetToplevelWindow();
     if (window && !window->IsVisible())
       return false;
@@ -1915,10 +1929,9 @@ v8::Local<v8::Promise> WebContents::CapturePage(mate::Arguments* args) {
 }
 
 void WebContents::OnCursorChange(const content::WebCursor& cursor) {
-  content::CursorInfo info;
-  cursor.GetCursorInfo(&info);
+  const content::CursorInfo& info = cursor.info();
 
-  if (cursor.IsCustom()) {
+  if (info.type == blink::WebCursorInfo::kTypeCustom) {
     Emit("cursor-changed", CursorTypeToString(info),
          gfx::Image::CreateFrom1xBitmap(info.custom_image),
          info.image_scale_factor,
@@ -1930,7 +1943,7 @@ void WebContents::OnCursorChange(const content::WebCursor& cursor) {
 }
 
 bool WebContents::IsGuest() const {
-  return type_ == WEB_VIEW;
+  return type_ == Type::WEB_VIEW;
 }
 
 void WebContents::AttachToIframe(content::WebContents* embedder_web_contents,
@@ -1941,7 +1954,7 @@ void WebContents::AttachToIframe(content::WebContents* embedder_web_contents,
 
 bool WebContents::IsOffScreen() const {
 #if BUILDFLAG(ENABLE_OSR)
-  return type_ == OFF_SCREEN;
+  return type_ == Type::OFF_SCREEN;
 #else
   return false;
 #endif
@@ -2068,7 +2081,7 @@ v8::Local<v8::Value> WebContents::GetLastWebPreferences(
 }
 
 bool WebContents::IsRemoteModuleEnabled() const {
-  if (web_contents()->GetVisibleURL().SchemeIs("chrome-devtools")) {
+  if (web_contents()->GetVisibleURL().SchemeIs("devtools")) {
     return false;
   }
   if (auto* web_preferences = WebContentsPreferences::From(web_contents())) {
@@ -2153,21 +2166,23 @@ void WebContents::GrantOriginAccess(const GURL& url) {
       url::Origin::Create(url));
 }
 
-void WebContents::TakeHeapSnapshot(const base::FilePath& file_path,
-                                   base::Callback<void(bool)> callback) {
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
+v8::Local<v8::Promise> WebContents::TakeHeapSnapshot(
+    const base::FilePath& file_path) {
+  util::Promise promise(isolate());
+  v8::Local<v8::Promise> handle = promise.GetHandle();
 
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
   base::File file(file_path,
                   base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
   if (!file.IsValid()) {
-    std::move(callback).Run(false);
-    return;
+    promise.RejectWithErrorMessage("takeHeapSnapshot failed");
+    return handle;
   }
 
   auto* frame_host = web_contents()->GetMainFrame();
   if (!frame_host) {
-    std::move(callback).Run(false);
-    return;
+    promise.RejectWithErrorMessage("takeHeapSnapshot failed");
+    return handle;
   }
 
   // This dance with `base::Owned` is to ensure that the interface stays alive
@@ -2179,10 +2194,17 @@ void WebContents::TakeHeapSnapshot(const base::FilePath& file_path,
   auto* raw_ptr = electron_ptr.get();
   (*raw_ptr)->TakeHeapSnapshot(
       mojo::WrapPlatformFile(file.TakePlatformFile()),
-      base::BindOnce([](mojom::ElectronRendererAssociatedPtr* ep,
-                        base::Callback<void(bool)> callback,
-                        bool success) { callback.Run(success); },
-                     base::Owned(std::move(electron_ptr)), callback));
+      base::BindOnce(
+          [](mojom::ElectronRendererAssociatedPtr* ep, util::Promise promise,
+             bool success) {
+            if (success) {
+              promise.Resolve();
+            } else {
+              promise.RejectWithErrorMessage("takeHeapSnapshot failed");
+            }
+          },
+          base::Owned(std::move(electron_ptr)), std::move(promise)));
+  return handle;
 }
 
 // static
@@ -2245,7 +2267,6 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("beginFrameSubscription", &WebContents::BeginFrameSubscription)
       .SetMethod("endFrameSubscription", &WebContents::EndFrameSubscription)
       .SetMethod("startDrag", &WebContents::StartDrag)
-      .SetMethod("isGuest", &WebContents::IsGuest)
       .SetMethod("attachToIframe", &WebContents::AttachToIframe)
       .SetMethod("detachFromOuterFrame", &WebContents::DetachFromOuterFrame)
       .SetMethod("isOffscreen", &WebContents::IsOffScreen)
@@ -2288,7 +2309,7 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getWebRTCIPHandlingPolicy",
                  &WebContents::GetWebRTCIPHandlingPolicy)
       .SetMethod("_grantOriginAccess", &WebContents::GrantOriginAccess)
-      .SetMethod("_takeHeapSnapshot", &WebContents::TakeHeapSnapshot)
+      .SetMethod("takeHeapSnapshot", &WebContents::TakeHeapSnapshot)
       .SetProperty("id", &WebContents::ID)
       .SetProperty("session", &WebContents::Session)
       .SetProperty("hostWebContents", &WebContents::HostWebContents)

atom/browser/api/atom_api_web_contents.h

@@ -80,7 +80,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
                     public content::WebContentsObserver,
                     public mojom::ElectronBrowser {
  public:
-  enum Type {
+  enum class Type {
     BACKGROUND_PAGE,  // A DevTools extension background page.
     BROWSER_WINDOW,   // Used by BrowserWindow.
     BROWSER_VIEW,     // Used by BrowserView.
@@ -294,8 +294,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
   // the specified URL.
   void GrantOriginAccess(const GURL& url);
 
-  void TakeHeapSnapshot(const base::FilePath& file_path,
-                        base::Callback<void(bool)>);
+  v8::Local<v8::Promise> TakeHeapSnapshot(const base::FilePath& file_path);
 
   // Properties.
   int32_t ID() const;
@@ -337,7 +336,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
   // content::WebContentsDelegate:
   bool DidAddMessageToConsole(content::WebContents* source,
-                              int32_t level,
+                              blink::mojom::ConsoleMessageLevel level,
                               const base::string16& message,
                               int32_t line_no,
                               const base::string16& source_id) override;
@@ -370,6 +369,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
   content::KeyboardEventProcessingResult PreHandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event) override;
+  void ContentsZoomChange(bool zoom_in) override;
   void EnterFullscreenModeForTab(
       content::WebContents* source,
       const GURL& origin,
@@ -445,12 +445,12 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void PluginCrashed(const base::FilePath& plugin_path,
                      base::ProcessId plugin_pid) override;
   void MediaStartedPlaying(const MediaPlayerInfo& video_type,
-                           const MediaPlayerId& id) override;
+                           const content::MediaPlayerId& id) override;
   void MediaStoppedPlaying(
       const MediaPlayerInfo& video_type,
-      const MediaPlayerId& id,
+      const content::MediaPlayerId& id,
       content::WebContentsObserver::MediaStoppedReason reason) override;
-  void DidChangeThemeColor(SkColor theme_color) override;
+  void DidChangeThemeColor(base::Optional<SkColor> theme_color) override;
   void OnInterfaceRequestFromFrame(
       content::RenderFrameHost* render_frame_host,
       const std::string& interface_name,
@@ -492,6 +492,9 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void Message(bool internal,
                const std::string& channel,
                base::Value arguments) override;
+  void Invoke(const std::string& channel,
+              base::Value arguments,
+              InvokeCallback callback) override;
   void MessageSync(bool internal,
                    const std::string& channel,
                    base::Value arguments,
@@ -535,7 +538,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
   WebContentsZoomController* zoom_controller_ = nullptr;
 
   // The type of current WebContents.
-  Type type_ = BROWSER_WINDOW;
+  Type type_ = Type::BROWSER_WINDOW;
 
   // Request id used for findInPage request.
   uint32_t request_id_ = 0;

atom/browser/api/atom_api_web_contents_mac.mm

@@ -16,7 +16,7 @@ bool WebContents::IsFocused() const {
   if (!view)
     return false;
 
-  if (GetType() != BACKGROUND_PAGE) {
+  if (GetType() != Type::BACKGROUND_PAGE) {
     auto window = [web_contents()->GetNativeView().GetNativeNSView() window];
     // On Mac the render widget host view does not lose focus when the window
     // loses focus so check if the top level window is the key window.

atom/browser/api/atom_api_web_contents_view.cc

@@ -124,8 +124,9 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("WebContentsView", mate::CreateConstructor<WebContentsView>(
-                                  isolate, base::Bind(&WebContentsView::New)));
+  dict.Set("WebContentsView",
+           mate::CreateConstructor<WebContentsView>(
+               isolate, base::BindRepeating(&WebContentsView::New)));
 }
 
 }  // namespace

atom/browser/api/atom_api_web_request.cc

@@ -9,8 +9,8 @@
 
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/net/atom_network_delegate.h"
-#include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/net_converter.h"
+#include "atom/common/native_mate_converters/once_callback.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "base/task/post_task.h"
 #include "content/public/browser/browser_task_traits.h"

atom/browser/api/event.cc

@@ -52,10 +52,13 @@ void Event::FrameDeleted(content::RenderFrameHost* rfh) {
 }
 
 void Event::PreventDefault(v8::Isolate* isolate) {
-  GetWrapper()->Set(StringToV8(isolate, "defaultPrevented"), v8::True(isolate));
+  GetWrapper()
+      ->Set(isolate->GetCurrentContext(),
+            StringToV8(isolate, "defaultPrevented"), v8::True(isolate))
+      .Check();
 }
 
-bool Event::SendReply(const base::ListValue& result) {
+bool Event::SendReply(const base::Value& result) {
   if (!callback_ || sender_ == nullptr)
     return false;
 

atom/browser/api/event.h

@@ -32,8 +32,9 @@ class Event : public Wrappable<Event>, public content::WebContentsObserver {
   // event.PreventDefault().
   void PreventDefault(v8::Isolate* isolate);
 
-  // event.sendReply(array), used for replying synchronous message.
-  bool SendReply(const base::ListValue& result);
+  // event.sendReply(value), used for replying to synchronous messages and
+  // `invoke` calls.
+  bool SendReply(const base::Value& result);
 
  protected:
   explicit Event(v8::Isolate* isolate);

atom/browser/api/event_emitter.h

@@ -46,30 +46,33 @@ class EventEmitter : public Wrappable<T> {
   v8::Local<v8::Object> GetWrapper() const {
     return Wrappable<T>::GetWrapper();
   }
+  v8::MaybeLocal<v8::Object> GetWrapper(v8::Isolate* isolate) const {
+    return Wrappable<T>::GetWrapper(isolate);
+  }
 
   // this.emit(name, event, args...);
   template <typename... Args>
   bool EmitCustomEvent(const base::StringPiece& name,
                        v8::Local<v8::Object> event,
-                       const Args&... args) {
+                       Args&&... args) {
     return EmitWithEvent(
         name, internal::CreateCustomEvent(isolate(), GetWrapper(), event),
-        args...);
+        std::forward<Args>(args)...);
   }
 
   // this.emit(name, new Event(flags), args...);
   template <typename... Args>
-  bool EmitWithFlags(const base::StringPiece& name,
-                     int flags,
-                     const Args&... args) {
-    return EmitCustomEvent(
-        name, internal::CreateEventFromFlags(isolate(), flags), args...);
+  bool EmitWithFlags(const base::StringPiece& name, int flags, Args&&... args) {
+    return EmitCustomEvent(name,
+                           internal::CreateEventFromFlags(isolate(), flags),
+                           std::forward<Args>(args)...);
   }
 
   // this.emit(name, new Event(), args...);
   template <typename... Args>
-  bool Emit(const base::StringPiece& name, const Args&... args) {
-    return EmitWithSender(name, nullptr, base::nullopt, args...);
+  bool Emit(const base::StringPiece& name, Args&&... args) {
+    return EmitWithSender(name, nullptr, base::nullopt,
+                          std::forward<Args>(args)...);
   }
 
   // this.emit(name, new Event(sender, message), args...);
@@ -79,7 +82,7 @@ class EventEmitter : public Wrappable<T> {
       content::RenderFrameHost* sender,
       base::Optional<atom::mojom::ElectronBrowser::MessageSyncCallback>
           callback,
-      const Args&... args) {
+      Args&&... args) {
     v8::Locker locker(isolate());
     v8::HandleScope handle_scope(isolate());
     v8::Local<v8::Object> wrapper = GetWrapper();
@@ -88,7 +91,7 @@ class EventEmitter : public Wrappable<T> {
     }
     v8::Local<v8::Object> event = internal::CreateJSEvent(
         isolate(), wrapper, sender, std::move(callback));
-    return EmitWithEvent(name, event, args...);
+    return EmitWithEvent(name, event, std::forward<Args>(args)...);
   }
 
  protected:
@@ -99,13 +102,19 @@ class EventEmitter : public Wrappable<T> {
   template <typename... Args>
   bool EmitWithEvent(const base::StringPiece& name,
                      v8::Local<v8::Object> event,
-                     const Args&... args) {
+                     Args&&... args) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     v8::Locker locker(isolate());
     v8::HandleScope handle_scope(isolate());
-    EmitEvent(isolate(), GetWrapper(), name, event, args...);
-    return event->Get(StringToV8(isolate(), "defaultPrevented"))
-        ->BooleanValue(isolate());
+    EmitEvent(isolate(), GetWrapper(), name, event,
+              std::forward<Args>(args)...);
+    auto context = isolate()->GetCurrentContext();
+    v8::Local<v8::Value> defaultPrevented;
+    if (event->Get(context, StringToV8(isolate(), "defaultPrevented"))
+            .ToLocal(&defaultPrevented)) {
+      return defaultPrevented->BooleanValue(isolate());
+    }
+    return false;
   }
 
   DISALLOW_COPY_AND_ASSIGN(EventEmitter);

atom/browser/api/frame_subscriber.h

@@ -28,7 +28,7 @@ class FrameSubscriber : public content::WebContentsObserver,
                         public viz::mojom::FrameSinkVideoConsumer {
  public:
   using FrameCaptureCallback =
-      base::Callback<void(const gfx::Image&, const gfx::Rect&)>;
+      base::RepeatingCallback<void(const gfx::Image&, const gfx::Rect&)>;
 
   FrameSubscriber(content::WebContents* web_contents,
                   const FrameCaptureCallback& callback,

atom/browser/api/gpu_info_enumerator.cc

@@ -108,18 +108,6 @@ void GPUInfoEnumerator::EndAuxAttributes() {
   value_stack.pop();
 }
 
-void GPUInfoEnumerator::BeginOverlayCapability() {
-  value_stack.push(std::move(current));
-  current = std::make_unique<base::DictionaryValue>();
-}
-
-void GPUInfoEnumerator::EndOverlayCapability() {
-  auto& top_value = value_stack.top();
-  top_value->SetDictionary(kOverlayCapabilityKey, std::move(current));
-  current = std::move(top_value);
-  value_stack.pop();
-}
-
 void GPUInfoEnumerator::BeginDx12VulkanVersionInfo() {
   value_stack.push(std::move(current));
   current = std::make_unique<base::DictionaryValue>();

atom/browser/api/gpu_info_enumerator.h

@@ -25,7 +25,6 @@ class GPUInfoEnumerator final : public gpu::GPUInfo::Enumerator {
   const char* kImageDecodeAcceleratorSupportedProfileKey =
       "imageDecodeAcceleratorSupportedProfile";
   const char* kAuxAttributesKey = "auxAttributes";
-  const char* kOverlayCapabilityKey = "overlayCapability";
   const char* kDx12VulkanVersionInfoKey = "dx12VulkanVersionInfo";
 
  public:
@@ -47,8 +46,6 @@ class GPUInfoEnumerator final : public gpu::GPUInfo::Enumerator {
   void EndImageDecodeAcceleratorSupportedProfile() override;
   void BeginAuxAttributes() override;
   void EndAuxAttributes() override;
-  void BeginOverlayCapability() override;
-  void EndOverlayCapability() override;
   void BeginDx12VulkanVersionInfo() override;
   void EndDx12VulkanVersionInfo() override;
   std::unique_ptr<base::DictionaryValue> GetDictionary();

atom/browser/api/stream_subscriber.cc

@@ -28,9 +28,9 @@ StreamSubscriber::StreamSubscriber(
   DCHECK(ui_task_runner->RunsTasksInCurrentSequence());
 
   auto weak_self = weak_factory_.GetWeakPtr();
-  On("data", base::Bind(&StreamSubscriber::OnData, weak_self));
-  On("end", base::Bind(&StreamSubscriber::OnEnd, weak_self));
-  On("error", base::Bind(&StreamSubscriber::OnError, weak_self));
+  On("data", base::BindRepeating(&StreamSubscriber::OnData, weak_self));
+  On("end", base::BindRepeating(&StreamSubscriber::OnEnd, weak_self));
+  On("error", base::BindRepeating(&StreamSubscriber::OnError, weak_self));
 }
 
 StreamSubscriber::~StreamSubscriber() {
@@ -80,20 +80,20 @@ void StreamSubscriber::OnData(mate::Arguments* args) {
   // Pass the data to the URLJob in IO thread.
   std::vector<char> buffer(data, data + length);
   base::PostTaskWithTraits(FROM_HERE, {content::BrowserThread::IO},
-                           base::Bind(&atom::URLRequestStreamJob::OnData,
-                                      url_job_, base::Passed(&buffer)));
+                           base::BindOnce(&atom::URLRequestStreamJob::OnData,
+                                          url_job_, base::Passed(&buffer)));
 }
 
 void StreamSubscriber::OnEnd(mate::Arguments* args) {
   base::PostTaskWithTraits(
       FROM_HERE, {content::BrowserThread::IO},
-      base::Bind(&atom::URLRequestStreamJob::OnEnd, url_job_));
+      base::BindOnce(&atom::URLRequestStreamJob::OnEnd, url_job_));
 }
 
 void StreamSubscriber::OnError(mate::Arguments* args) {
   base::PostTaskWithTraits(FROM_HERE, {content::BrowserThread::IO},
-                           base::Bind(&atom::URLRequestStreamJob::OnError,
-                                      url_job_, net::ERR_FAILED));
+                           base::BindOnce(&atom::URLRequestStreamJob::OnError,
+                                          url_job_, net::ERR_FAILED));
 }
 
 void StreamSubscriber::RemoveAllListeners() {

atom/browser/api/stream_subscriber.h

@@ -40,7 +40,7 @@ class StreamSubscriber
   friend class base::RefCountedDeleteOnSequence<StreamSubscriber>;
 
   using JSHandlersMap = std::map<std::string, v8::Global<v8::Value>>;
-  using EventCallback = base::Callback<void(mate::Arguments* args)>;
+  using EventCallback = base::RepeatingCallback<void(mate::Arguments* args)>;
 
   ~StreamSubscriber();
 

atom/browser/api/views/atom_api_box_layout.cc

@@ -78,7 +78,7 @@ void Initialize(v8::Local<v8::Object> exports,
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("BoxLayout", mate::CreateConstructor<BoxLayout>(
-                            isolate, base::Bind(&BoxLayout::New)));
+                            isolate, base::BindRepeating(&BoxLayout::New)));
 }
 
 }  // namespace

atom/browser/api/views/atom_api_button.cc

@@ -50,8 +50,8 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("Button",
-           mate::CreateConstructor<Button>(isolate, base::Bind(&Button::New)));
+  dict.Set("Button", mate::CreateConstructor<Button>(
+                         isolate, base::BindRepeating(&Button::New)));
 }
 
 }  // namespace

atom/browser/api/views/atom_api_label_button.cc

@@ -71,7 +71,7 @@ void Initialize(v8::Local<v8::Object> exports,
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("LabelButton", mate::CreateConstructor<LabelButton>(
-                              isolate, base::Bind(&LabelButton::New)));
+                              isolate, base::BindRepeating(&LabelButton::New)));
 }
 
 }  // namespace

atom/browser/api/views/atom_api_layout_manager.cc

@@ -53,8 +53,9 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("LayoutManager", mate::CreateConstructor<LayoutManager>(
-                                isolate, base::Bind(&LayoutManager::New)));
+  dict.Set("LayoutManager",
+           mate::CreateConstructor<LayoutManager>(
+               isolate, base::BindRepeating(&LayoutManager::New)));
 }
 
 }  // namespace

atom/browser/api/views/atom_api_md_text_button.cc

@@ -47,8 +47,9 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("MdTextButton", mate::CreateConstructor<MdTextButton>(
-                               isolate, base::Bind(&MdTextButton::New)));
+  dict.Set("MdTextButton",
+           mate::CreateConstructor<MdTextButton>(
+               isolate, base::BindRepeating(&MdTextButton::New)));
 }
 
 }  // namespace

atom/browser/api/views/atom_api_resize_area.cc

@@ -51,7 +51,7 @@ void Initialize(v8::Local<v8::Object> exports,
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("ResizeArea", mate::CreateConstructor<ResizeArea>(
-                             isolate, base::Bind(&ResizeArea::New)));
+                             isolate, base::BindRepeating(&ResizeArea::New)));
 }
 
 }  // namespace

atom/browser/api/views/atom_api_text_field.cc

@@ -58,7 +58,7 @@ void Initialize(v8::Local<v8::Object> exports,
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("TextField", mate::CreateConstructor<TextField>(
-                            isolate, base::Bind(&TextField::New)));
+                            isolate, base::BindRepeating(&TextField::New)));
 }
 
 }  // namespace

atom/browser/atom_blob_reader.cc

@@ -81,8 +81,8 @@ void AtomBlobReader::BlobReadHelper::Read() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   storage::BlobReader::Status size_status = blob_reader_->CalculateSize(
-      base::Bind(&AtomBlobReader::BlobReadHelper::DidCalculateSize,
-                 base::Unretained(this)));
+      base::BindOnce(&AtomBlobReader::BlobReadHelper::DidCalculateSize,
+                     base::Unretained(this)));
   if (size_status != storage::BlobReader::Status::IO_PENDING)
     DidCalculateSize(net::OK);
 }
@@ -100,8 +100,8 @@ void AtomBlobReader::BlobReadHelper::DidCalculateSize(int result) {
   scoped_refptr<net::IOBuffer> blob_data =
       new net::IOBuffer(static_cast<size_t>(total_size));
   auto callback =
-      base::Bind(&AtomBlobReader::BlobReadHelper::DidReadBlobData,
-                 base::Unretained(this), base::RetainedRef(blob_data));
+      base::BindRepeating(&AtomBlobReader::BlobReadHelper::DidReadBlobData,
+                          base::Unretained(this), base::RetainedRef(blob_data));
   storage::BlobReader::Status read_status =
       blob_reader_->Read(blob_data.get(), total_size, &bytes_read, callback);
   if (read_status != storage::BlobReader::Status::IO_PENDING)

atom/browser/atom_browser_client.cc

@@ -14,10 +14,12 @@
 #include "atom/app/manifests.h"
 #include "atom/browser/api/atom_api_app.h"
 #include "atom/browser/api/atom_api_protocol.h"
+#include "atom/browser/api/atom_api_protocol_ns.h"
 #include "atom/browser/api/atom_api_web_contents.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_navigation_throttle.h"
+#include "atom/browser/atom_paths.h"
 #include "atom/browser/atom_quota_permission_context.h"
 #include "atom/browser/atom_resource_dispatcher_host_delegate.h"
 #include "atom/browser/atom_speech_recognition_manager_delegate.h"
@@ -28,6 +30,7 @@
 #include "atom/browser/native_window.h"
 #include "atom/browser/net/network_context_service.h"
 #include "atom/browser/net/network_context_service_factory.h"
+#include "atom/browser/net/proxying_url_loader_factory.h"
 #include "atom/browser/notifications/notification_presenter.h"
 #include "atom/browser/notifications/platform_notification_service.h"
 #include "atom/browser/session_preferences.h"
@@ -400,6 +403,14 @@ void AtomBrowserClient::OverrideWebkitPrefs(content::RenderViewHost* host,
     web_preferences->OverrideWebkitPrefs(prefs);
 }
 
+void AtomBrowserClient::SetCanUseCustomSiteInstance(bool should_disable) {
+  disable_process_restart_tricks_ = should_disable;
+}
+
+bool AtomBrowserClient::CanUseCustomSiteInstance() {
+  return disable_process_restart_tricks_;
+}
+
 content::ContentBrowserClient::SiteInstanceForNavigationType
 AtomBrowserClient::ShouldOverrideSiteInstanceForNavigation(
     content::RenderFrameHost* current_rfh,
@@ -498,7 +509,7 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches(
 
   content::WebContents* web_contents = GetWebContentsFromProcessID(process_id);
   if (web_contents) {
-    if (web_contents->GetVisibleURL().SchemeIs("chrome-devtools")) {
+    if (web_contents->GetVisibleURL().SchemeIs("devtools")) {
       command_line->AppendSwitch(switches::kDisableRemoteModule);
     }
     auto* web_preferences = WebContentsPreferences::From(web_contents);
@@ -506,6 +517,10 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches(
       web_preferences->AppendCommandLineSwitches(command_line);
     SessionPreferences::AppendExtraCommandLineSwitches(
         web_contents->GetBrowserContext(), command_line);
+    if (CanUseCustomSiteInstance()) {
+      command_line->AppendSwitch(
+          switches::kDisableElectronSiteInstanceOverrides);
+    }
   }
 }
 
@@ -534,7 +549,7 @@ std::string AtomBrowserClient::GetGeolocationApiKey() {
   return api_key;
 }
 
-content::QuotaPermissionContext*
+scoped_refptr<content::QuotaPermissionContext>
 AtomBrowserClient::CreateQuotaPermissionContext() {
   return new AtomQuotaPermissionContext;
 }
@@ -555,14 +570,14 @@ void AtomBrowserClient::AllowCertificateError(
     int cert_error,
     const net::SSLInfo& ssl_info,
     const GURL& request_url,
-    content::ResourceType resource_type,
+    bool is_main_frame_request,
     bool strict_enforcement,
     bool expired_previous_decision,
-    const base::Callback<void(content::CertificateRequestResultType)>&
+    const base::RepeatingCallback<void(content::CertificateRequestResultType)>&
         callback) {
   if (delegate_) {
     delegate_->AllowCertificateError(
-        web_contents, cert_error, ssl_info, request_url, resource_type,
+        web_contents, cert_error, ssl_info, request_url, is_main_frame_request,
         strict_enforcement, expired_previous_decision, callback);
   }
 }
@@ -606,11 +621,6 @@ bool AtomBrowserClient::CanCreateWindow(
 
   int opener_render_process_id = opener->GetProcess()->GetID();
 
-  if (IsRendererSandboxed(opener_render_process_id)) {
-    *no_javascript_access = false;
-    return true;
-  }
-
   if (RendererUsesNativeWindowOpen(opener_render_process_id)) {
     if (RendererDisablesPopups(opener_render_process_id)) {
       // <webview> without allowpopups attribute should return
@@ -724,17 +734,16 @@ void AtomBrowserClient::RegisterOutOfProcessServices(
 
 base::Optional<service_manager::Manifest>
 AtomBrowserClient::GetServiceManifestOverlay(base::StringPiece name) {
-  if (name == content::mojom::kBrowserServiceName) {
+  if (name == content::mojom::kBrowserServiceName)
     return GetElectronContentBrowserOverlayManifest();
-  } else if (name == content::mojom::kPackagedServicesServiceName) {
-    service_manager::Manifest overlay;
-    overlay.packaged_services = GetElectronPackagedServicesOverlayManifest();
-    return overlay;
-  }
-
   return base::nullopt;
 }
 
+std::vector<service_manager::Manifest>
+AtomBrowserClient::GetExtraServiceManifests() {
+  return GetElectronBuiltinServiceManifests();
+}
+
 net::NetLog* AtomBrowserClient::GetNetLog() {
   return g_browser_process->net_log();
 }
@@ -746,21 +755,21 @@ content::BrowserMainParts* AtomBrowserClient::CreateBrowserMainParts(
 
 void AtomBrowserClient::WebNotificationAllowed(
     int render_process_id,
-    const base::Callback<void(bool, bool)>& callback) {
+    base::OnceCallback<void(bool, bool)> callback) {
   content::WebContents* web_contents =
       WebContentsPreferences::GetWebContentsFromProcessID(render_process_id);
   if (!web_contents) {
-    callback.Run(false, false);
+    std::move(callback).Run(false, false);
     return;
   }
   auto* permission_helper =
       WebContentsPermissionHelper::FromWebContents(web_contents);
   if (!permission_helper) {
-    callback.Run(false, false);
+    std::move(callback).Run(false, false);
     return;
   }
   permission_helper->RequestWebNotificationPermission(
-      base::Bind(callback, web_contents->IsAudioMuted()));
+      base::BindOnce(std::move(callback), web_contents->IsAudioMuted()));
 }
 
 void AtomBrowserClient::RenderProcessHostDestroyed(
@@ -792,14 +801,10 @@ void AtomBrowserClient::RenderProcessExited(
 }
 
 void OnOpenExternal(const GURL& escaped_url, bool allowed) {
-  if (allowed)
+  if (allowed) {
     platform_util::OpenExternal(
-#if defined(OS_WIN)
-        base::UTF8ToUTF16(escaped_url.spec()),
-#else
-        escaped_url,
-#endif
-        platform_util::OpenExternalOptions());
+        escaped_url, platform_util::OpenExternalOptions(), base::DoNothing());
+  }
 }
 
 void HandleExternalProtocolInUI(
@@ -816,9 +821,9 @@ void HandleExternalProtocolInUI(
     return;
 
   GURL escaped_url(net::EscapeExternalHandlerValue(url.spec()));
-  auto callback = base::Bind(&OnOpenExternal, escaped_url);
-  permission_helper->RequestOpenExternalPermission(callback, has_user_gesture,
-                                                   url);
+  auto callback = base::BindOnce(&OnOpenExternal, escaped_url);
+  permission_helper->RequestOpenExternalPermission(std::move(callback),
+                                                   has_user_gesture, url);
 }
 
 bool AtomBrowserClient::HandleExternalProtocol(
@@ -829,8 +834,6 @@ bool AtomBrowserClient::HandleExternalProtocol(
     bool is_main_frame,
     ui::PageTransition page_transition,
     bool has_user_gesture,
-    const std::string& method,
-    const net::HttpRequestHeaders& headers,
     network::mojom::URLLoaderFactoryRequest* factory_request,
     // clang-format off
     network::mojom::URLLoaderFactory*& out_factory) {  // NOLINT
@@ -867,7 +870,8 @@ NotificationPresenter* AtomBrowserClient::GetNotificationPresenter() {
 }
 
 content::PlatformNotificationService*
-AtomBrowserClient::GetPlatformNotificationService() {
+AtomBrowserClient::GetPlatformNotificationService(
+    content::BrowserContext* browser_context) {
   if (!notification_service_) {
     notification_service_.reset(new PlatformNotificationService(this));
   }
@@ -900,6 +904,15 @@ void AtomBrowserClient::OnNetworkServiceCreated(
       network_service);
 }
 
+std::vector<base::FilePath>
+AtomBrowserClient::GetNetworkContextsParentDirectory() {
+  base::FilePath user_data_dir;
+  base::PathService::Get(DIR_USER_DATA, &user_data_dir);
+  DCHECK(!user_data_dir.empty());
+
+  return {user_data_dir};
+}
+
 bool AtomBrowserClient::ShouldBypassCORB(int render_process_id) const {
   // This is called on the network thread.
   base::AutoLock auto_lock(process_preferences_lock_);
@@ -912,7 +925,68 @@ std::string AtomBrowserClient::GetProduct() const {
 }
 
 std::string AtomBrowserClient::GetUserAgent() const {
-  return GetApplicationUserAgent();
+  if (user_agent_override_.empty())
+    return GetApplicationUserAgent();
+  return user_agent_override_;
+}
+
+void AtomBrowserClient::SetUserAgent(const std::string& user_agent) {
+  user_agent_override_ = user_agent;
+}
+
+void AtomBrowserClient::RegisterNonNetworkNavigationURLLoaderFactories(
+    int frame_tree_node_id,
+    NonNetworkURLLoaderFactoryMap* factories) {
+  content::WebContents* web_contents =
+      content::WebContents::FromFrameTreeNodeId(frame_tree_node_id);
+  api::ProtocolNS* protocol = api::ProtocolNS::FromWrappedClass(
+      v8::Isolate::GetCurrent(), web_contents->GetBrowserContext());
+  if (protocol)
+    protocol->RegisterURLLoaderFactories(factories);
+}
+
+void AtomBrowserClient::RegisterNonNetworkSubresourceURLLoaderFactories(
+    int render_process_id,
+    int render_frame_id,
+    NonNetworkURLLoaderFactoryMap* factories) {
+  // Chromium may call this even when NetworkService is not enabled.
+  if (!base::FeatureList::IsEnabled(network::features::kNetworkService))
+    return;
+
+  content::RenderFrameHost* frame_host =
+      content::RenderFrameHost::FromID(render_process_id, render_frame_id);
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderFrameHost(frame_host);
+  api::ProtocolNS* protocol = api::ProtocolNS::FromWrappedClass(
+      v8::Isolate::GetCurrent(), web_contents->GetBrowserContext());
+  if (protocol)
+    protocol->RegisterURLLoaderFactories(factories);
+}
+
+bool AtomBrowserClient::WillCreateURLLoaderFactory(
+    content::BrowserContext* browser_context,
+    content::RenderFrameHost* frame_host,
+    int render_process_id,
+    bool is_navigation,
+    bool is_download,
+    const url::Origin& request_initiator,
+    network::mojom::URLLoaderFactoryRequest* factory_request,
+    network::mojom::TrustedURLLoaderHeaderClientPtrInfo* header_client,
+    bool* bypass_redirect_checks) {
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderFrameHost(frame_host);
+  api::ProtocolNS* protocol = api::ProtocolNS::FromWrappedClass(
+      v8::Isolate::GetCurrent(), web_contents->GetBrowserContext());
+  if (!protocol)
+    return false;
+
+  auto proxied_request = std::move(*factory_request);
+  network::mojom::URLLoaderFactoryPtrInfo target_factory_info;
+  *factory_request = mojo::MakeRequest(&target_factory_info);
+  new ProxyingURLLoaderFactory(protocol->intercept_handlers(),
+                               std::move(proxied_request),
+                               std::move(target_factory_info));
+  return true;
 }
 
 std::string AtomBrowserClient::GetApplicationLocale() {

atom/browser/atom_browser_client.h

@@ -52,7 +52,7 @@ class AtomBrowserClient : public content::ContentBrowserClient,
   NotificationPresenter* GetNotificationPresenter();
 
   void WebNotificationAllowed(int render_process_id,
-                              const base::Callback<void(bool, bool)>& callback);
+                              base::OnceCallback<void(bool, bool)> callback);
 
   // content::NavigatorDelegate
   std::vector<std::unique_ptr<content::NavigationThrottle>>
@@ -64,6 +64,12 @@ class AtomBrowserClient : public content::ContentBrowserClient,
   // content::ContentBrowserClient:
   bool ShouldEnableStrictSiteIsolation() override;
 
+  std::string GetUserAgent() const override;
+  void SetUserAgent(const std::string& user_agent);
+
+  void SetCanUseCustomSiteInstance(bool should_disable);
+  bool CanUseCustomSiteInstance() override;
+
  protected:
   void RenderProcessWillLaunch(
       content::RenderProcessHost* host,
@@ -90,7 +96,8 @@ class AtomBrowserClient : public content::ContentBrowserClient,
       base::CommandLine* command_line) override;
   void DidCreatePpapiPlugin(content::BrowserPpapiHost* browser_host) override;
   std::string GetGeolocationApiKey() override;
-  content::QuotaPermissionContext* CreateQuotaPermissionContext() override;
+  scoped_refptr<content::QuotaPermissionContext> CreateQuotaPermissionContext()
+      override;
   content::GeneratedCodeCacheSettings GetGeneratedCodeCacheSettings(
       content::BrowserContext* context) override;
   void AllowCertificateError(
@@ -98,7 +105,7 @@ class AtomBrowserClient : public content::ContentBrowserClient,
       int cert_error,
       const net::SSLInfo& ssl_info,
       const GURL& request_url,
-      content::ResourceType resource_type,
+      bool is_main_frame_request,
       bool strict_enforcement,
       bool expired_previous_decision,
       const base::Callback<void(content::CertificateRequestResultType)>&
@@ -141,11 +148,12 @@ class AtomBrowserClient : public content::ContentBrowserClient,
   void RegisterOutOfProcessServices(OutOfProcessServiceMap* services) override;
   base::Optional<service_manager::Manifest> GetServiceManifestOverlay(
       base::StringPiece name) override;
+  std::vector<service_manager::Manifest> GetExtraServiceManifests() override;
   net::NetLog* GetNetLog() override;
   content::MediaObserver* GetMediaObserver() override;
   content::DevToolsManagerDelegate* GetDevToolsManagerDelegate() override;
-  content::PlatformNotificationService* GetPlatformNotificationService()
-      override;
+  content::PlatformNotificationService* GetPlatformNotificationService(
+      content::BrowserContext* browser_context) override;
   content::BrowserMainParts* CreateBrowserMainParts(
       const content::MainFunctionParams&) override;
   base::FilePath GetDefaultDownloadDirectory() override;
@@ -153,9 +161,26 @@ class AtomBrowserClient : public content::ContentBrowserClient,
   GetSystemSharedURLLoaderFactory() override;
   void OnNetworkServiceCreated(
       network::mojom::NetworkService* network_service) override;
+  std::vector<base::FilePath> GetNetworkContextsParentDirectory() override;
   bool ShouldBypassCORB(int render_process_id) const override;
   std::string GetProduct() const override;
-  std::string GetUserAgent() const override;
+  void RegisterNonNetworkNavigationURLLoaderFactories(
+      int frame_tree_node_id,
+      NonNetworkURLLoaderFactoryMap* factories) override;
+  void RegisterNonNetworkSubresourceURLLoaderFactories(
+      int render_process_id,
+      int render_frame_id,
+      NonNetworkURLLoaderFactoryMap* factories) override;
+  bool WillCreateURLLoaderFactory(
+      content::BrowserContext* browser_context,
+      content::RenderFrameHost* frame,
+      int render_process_id,
+      bool is_navigation,
+      bool is_download,
+      const url::Origin& request_initiator,
+      network::mojom::URLLoaderFactoryRequest* factory_request,
+      network::mojom::TrustedURLLoaderHeaderClientPtrInfo* header_client,
+      bool* bypass_redirect_checks) override;
 
   // content::RenderProcessHostObserver:
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
@@ -171,8 +196,6 @@ class AtomBrowserClient : public content::ContentBrowserClient,
       bool is_main_frame,
       ui::PageTransition page_transition,
       bool has_user_gesture,
-      const std::string& method,
-      const net::HttpRequestHeaders& headers,
       network::mojom::URLLoaderFactoryRequest* factory_request,
       // clang-format off
       network::mojom::URLLoaderFactory*& out_factory)  // NOLINT
@@ -231,6 +254,10 @@ class AtomBrowserClient : public content::ContentBrowserClient,
   mutable base::Lock process_preferences_lock_;
   std::map<int, ProcessPreferences> process_preferences_;
 
+  std::string user_agent_override_ = "";
+
+  bool disable_process_restart_tricks_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
 };
 

atom/browser/atom_browser_context.cc

@@ -7,6 +7,7 @@
 #include <utility>
 
 #include "atom/browser/atom_blob_reader.h"
+#include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_download_manager_delegate.h"
 #include "atom/browser/atom_paths.h"
@@ -67,7 +68,7 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition,
       storage_policy_(new SpecialStoragePolicy),
       in_memory_(in_memory),
       weak_factory_(this) {
-  user_agent_ = GetApplicationUserAgent();
+  user_agent_ = AtomBrowserClient::Get()->GetUserAgent();
 
   // Read options.
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();

atom/browser/atom_browser_main_parts.cc

@@ -19,6 +19,7 @@
 #include "atom/browser/atom_web_ui_controller_factory.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/browser_process_impl.h"
+#include "atom/browser/feature_list.h"
 #include "atom/browser/javascript_environment.h"
 #include "atom/browser/media/media_capture_devices_dispatcher.h"
 #include "atom/browser/node_debugger.h"
@@ -76,7 +77,7 @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/display/win/dpi.h"
-#include "ui/gfx/platform_font_win.h"
+#include "ui/gfx/system_fonts_win.h"
 #include "ui/strings/grit/app_locale_settings.h"
 #endif
 
@@ -102,7 +103,7 @@ void Erase(T* container, typename T::iterator iter) {
 
 #if defined(OS_WIN)
 // gfx::Font callbacks
-void AdjustUIFont(gfx::PlatformFontWin::FontAdjustment* font_adjustment) {
+void AdjustUIFont(gfx::win::FontAdjustment* font_adjustment) {
   l10n_util::NeedOverrideDefaultUIFont(&font_adjustment->font_family_override,
                                        &font_adjustment->font_scale);
   font_adjustment->font_scale *= display::win::GetAccessibilityFontScale();
@@ -150,7 +151,7 @@ void OverrideLinuxAppDataPath() {
 int BrowserX11ErrorHandler(Display* d, XErrorEvent* error) {
   if (!g_in_x11_io_error_handler && base::ThreadTaskRunnerHandle::IsSet()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&ui::LogErrorEventDescription, d, *error));
+        FROM_HERE, base::BindOnce(&ui::LogErrorEventDescription, d, *error));
   }
   return 0;
 }
@@ -197,23 +198,6 @@ int X11EmptyIOErrorHandler(Display* d) {
 
 }  // namespace
 
-void AtomBrowserMainParts::InitializeFeatureList() {
-  auto* cmd_line = base::CommandLine::ForCurrentProcess();
-  auto enable_features =
-      cmd_line->GetSwitchValueASCII(::switches::kEnableFeatures);
-  auto disable_features =
-      cmd_line->GetSwitchValueASCII(::switches::kDisableFeatures);
-  // Disable creation of spare renderer process with site-per-process mode,
-  // it interferes with our process preference tracking for non sandboxed mode.
-  // Can be reenabled when our site instance policy is aligned with chromium
-  // when node integration is enabled.
-  disable_features +=
-      std::string(",") + features::kSpareRendererForSitePerProcess.name;
-  auto feature_list = std::make_unique<base::FeatureList>();
-  feature_list->InitializeFromCommandLine(enable_features, disable_features);
-  base::FeatureList::SetInstance(std::move(feature_list));
-}
-
 // static
 AtomBrowserMainParts* AtomBrowserMainParts::self_ = nullptr;
 
@@ -221,7 +205,8 @@ AtomBrowserMainParts::AtomBrowserMainParts(
     const content::MainFunctionParams& params)
     : fake_browser_process_(new BrowserProcessImpl),
       browser_(new Browser),
-      node_bindings_(NodeBindings::Create(NodeBindings::BROWSER)),
+      node_bindings_(
+          NodeBindings::Create(NodeBindings::BrowserEnvironment::BROWSER)),
       electron_bindings_(new ElectronBindings(uv_default_loop())),
       main_function_params_(params) {
   DCHECK(!self_) << "Cannot have two AtomBrowserMainParts";
@@ -271,7 +256,6 @@ void AtomBrowserMainParts::RegisterDestructionCallback(
 }
 
 int AtomBrowserMainParts::PreEarlyInitialization() {
-  InitializeFeatureList();
   field_trial_list_ = std::make_unique<base::FieldTrialList>(nullptr);
 #if defined(USE_X11)
   views::LinuxUI::SetInstance(BuildGtkUi());
@@ -380,11 +364,11 @@ void AtomBrowserMainParts::ToolkitInitialized() {
 #endif
 
 #if defined(OS_WIN)
-  gfx::PlatformFontWin::SetAdjustFontCallback(&AdjustUIFont);
-  gfx::PlatformFontWin::SetGetMinimumFontSizeCallback(&GetMinimumFontSize);
+  gfx::win::SetAdjustFontCallback(&AdjustUIFont);
+  gfx::win::SetGetMinimumFontSizeCallback(&GetMinimumFontSize);
 
   wchar_t module_name[MAX_PATH] = {0};
-  if (GetModuleFileName(NULL, module_name, MAX_PATH))
+  if (GetModuleFileName(NULL, module_name, base::size(module_name)))
     ui::CursorLoaderWin::SetCursorResourceModule(module_name);
 #endif
 
@@ -410,8 +394,8 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
 
   // Start idle gc.
   gc_timer_.Start(FROM_HERE, base::TimeDelta::FromMinutes(1),
-                  base::Bind(&v8::Isolate::LowMemoryNotification,
-                             base::Unretained(js_env_->isolate())));
+                  base::BindRepeating(&v8::Isolate::LowMemoryNotification,
+                                      base::Unretained(js_env_->isolate())));
 
   content::WebUIControllerFactory::RegisterFactory(
       AtomWebUIControllerFactory::GetInstance());
@@ -469,6 +453,7 @@ void AtomBrowserMainParts::PostMainMessageLoopRun() {
   ui::SetX11ErrorHandlers(X11EmptyErrorHandler, X11EmptyIOErrorHandler);
 #endif
 
+  node_debugger_->Stop();
   js_env_->OnMessageLoopDestroying();
 
 #if defined(OS_MACOSX)

atom/browser/atom_browser_main_parts.h

@@ -87,7 +87,6 @@ class AtomBrowserMainParts : public content::BrowserMainParts {
   void PostDestroyThreads() override;
 
  private:
-  void InitializeFeatureList();
   void PreMainMessageLoopStartCommon();
 
 #if defined(OS_POSIX)

atom/browser/atom_browser_main_parts_mac.mm

@@ -41,8 +41,26 @@ void AtomBrowserMainParts::InitializeMainNib() {
   auto application = [principalClass sharedApplication];
 
   NSString* mainNibName = [infoDictionary objectForKey:@"NSMainNibFile"];
-  auto mainNib = [[NSNib alloc] initWithNibNamed:mainNibName
-                                          bundle:base::mac::FrameworkBundle()];
+
+  NSNib* mainNib;
+
+  @try {
+    mainNib = [[NSNib alloc] initWithNibNamed:mainNibName
+                                       bundle:base::mac::FrameworkBundle()];
+    // Handle failure of initWithNibNamed on SMB shares
+    // TODO(codebytere): Remove when
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=932935 is fixed
+  } @catch (NSException* exception) {
+    NSString* nibPath =
+        [NSString stringWithFormat:@"Resources/%@.nib", mainNibName];
+    nibPath = [base::mac::FrameworkBundle().bundlePath
+        stringByAppendingPathComponent:nibPath];
+
+    NSData* data = [NSData dataWithContentsOfFile:nibPath];
+    mainNib = [[NSNib alloc] initWithNibData:data
+                                      bundle:base::mac::FrameworkBundle()];
+  }
+
   [mainNib instantiateWithOwner:application topLevelObjects:nil];
   [mainNib release];
 }

atom/browser/atom_browser_main_parts_posix.cc

@@ -136,10 +136,10 @@ void ShutdownDetector::ThreadMain() {
     bytes_read += ret;
   } while (bytes_read < sizeof(signal));
   VLOG(1) << "Handling shutdown for signal " << signal << ".";
-  base::Closure task =
-      base::Bind(&Browser::Quit, base::Unretained(Browser::Get()));
 
-  if (!base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI}, task)) {
+  if (!base::PostTaskWithTraits(
+          FROM_HERE, {BrowserThread::UI},
+          base::BindOnce(&Browser::Quit, base::Unretained(Browser::Get())))) {
     // Without a UI thread to post the exit task to, there aren't many
     // options.  Raise the signal again.  The default handler will pick it up
     // and cause an ungraceful exit.

atom/browser/atom_download_manager_delegate.cc

@@ -124,11 +124,11 @@ void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     atom::util::Promise dialog_promise(isolate);
     auto dialog_callback =
-        base::Bind(&AtomDownloadManagerDelegate::OnDownloadSaveDialogDone,
-                   base::Unretained(this), download_id, callback);
+        base::BindOnce(&AtomDownloadManagerDelegate::OnDownloadSaveDialogDone,
+                       base::Unretained(this), download_id, callback);
 
+    ignore_result(dialog_promise.Then(std::move(dialog_callback)));
     file_dialog::ShowSaveDialog(settings, std::move(dialog_promise));
-    ignore_result(dialog_promise.Then(dialog_callback));
   } else {
     callback.Run(path, download::DownloadItem::TARGET_DISPOSITION_PROMPT,
                  download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, path,
@@ -136,54 +136,48 @@ void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
   }
 }
 
-#if defined(MAS_BUILD)
 void AtomDownloadManagerDelegate::OnDownloadSaveDialogDone(
     uint32_t download_id,
     const content::DownloadTargetCallback& download_callback,
-    bool result,
-    const base::FilePath& path,
-    const std::string& bookmark)
-#else
-void AtomDownloadManagerDelegate::OnDownloadSaveDialogDone(
-    uint32_t download_id,
-    const content::DownloadTargetCallback& download_callback,
-    bool result,
-    const base::FilePath& path)
-#endif
-{
+    mate::Dictionary result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   auto* item = download_manager_->GetDownload(download_id);
   if (!item)
     return;
 
-  if (result) {
-    // Remember the last selected download directory.
-    AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
-        download_manager_->GetBrowserContext());
-    browser_context->prefs()->SetFilePath(prefs::kDownloadDefaultDirectory,
-                                          path.DirName());
+  bool canceled = true;
+  result.Get("canceled", &canceled);
 
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    v8::Locker locker(isolate);
-    v8::HandleScope handle_scope(isolate);
-    api::DownloadItem* download_item =
-        api::DownloadItem::FromWrappedClass(isolate, item);
-    if (download_item)
-      download_item->SetSavePath(path);
+  base::FilePath path;
+
+  if (!canceled) {
+    if (result.Get("filePath", &path)) {
+      // Remember the last selected download directory.
+      AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
+          download_manager_->GetBrowserContext());
+      browser_context->prefs()->SetFilePath(prefs::kDownloadDefaultDirectory,
+                                            path.DirName());
+
+      v8::Isolate* isolate = v8::Isolate::GetCurrent();
+      v8::Locker locker(isolate);
+      v8::HandleScope handle_scope(isolate);
+      api::DownloadItem* download_item =
+          api::DownloadItem::FromWrappedClass(isolate, item);
+      if (download_item)
+        download_item->SetSavePath(path);
+    }
   }
 
   // Running the DownloadTargetCallback with an empty FilePath signals that the
   // download should be cancelled. If user cancels the file save dialog, run
   // the callback with empty FilePath.
-  const base::FilePath download_path = result ? path : base::FilePath();
   const auto interrupt_reason =
-      download_path.empty() ? download::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED
-                            : download::DOWNLOAD_INTERRUPT_REASON_NONE;
-  download_callback.Run(download_path,
-                        download::DownloadItem::TARGET_DISPOSITION_PROMPT,
-                        download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-                        download_path, interrupt_reason);
+      path.empty() ? download::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED
+                   : download::DOWNLOAD_INTERRUPT_REASON_NONE;
+  download_callback.Run(path, download::DownloadItem::TARGET_DISPOSITION_PROMPT,
+                        download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, path,
+                        interrupt_reason);
 }
 
 void AtomDownloadManagerDelegate::Shutdown() {

atom/browser/atom_download_manager_delegate.h

@@ -45,20 +45,10 @@ class AtomDownloadManagerDelegate : public content::DownloadManagerDelegate {
                                const content::DownloadTargetCallback& callback,
                                const base::FilePath& default_path);
 
-#if defined(MAS_BUILD)
   void OnDownloadSaveDialogDone(
       uint32_t download_id,
       const content::DownloadTargetCallback& download_callback,
-      bool result,
-      const base::FilePath& path,
-      const std::string& bookmark);
-#else
-  void OnDownloadSaveDialogDone(
-      uint32_t download_id,
-      const content::DownloadTargetCallback& download_callback,
-      bool result,
-      const base::FilePath& path);
-#endif
+      mate::Dictionary result);
 
   content::DownloadManager* download_manager_;
   base::WeakPtrFactory<AtomDownloadManagerDelegate> weak_ptr_factory_;

atom/browser/atom_gpu_client.cc

@@ -0,0 +1,25 @@
+// Copyright (c) 2019 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_gpu_client.h"
+
+#include "base/environment.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
+namespace atom {
+
+AtomGpuClient::AtomGpuClient() = default;
+
+void AtomGpuClient::PreCreateMessageLoop() {
+#if defined(OS_WIN)
+  auto env = base::Environment::Create();
+  if (env->HasVar("ELECTRON_DEFAULT_ERROR_MODE"))
+    SetErrorMode(GetErrorMode() & ~SEM_NOGPFAULTERRORBOX);
+#endif
+}
+
+}  // namespace atom

atom/browser/atom_gpu_client.h

@@ -0,0 +1,25 @@
+// Copyright (c) 2019 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_GPU_CLIENT_H_
+#define ATOM_BROWSER_ATOM_GPU_CLIENT_H_
+
+#include "content/public/gpu/content_gpu_client.h"
+
+namespace atom {
+
+class AtomGpuClient : public content::ContentGpuClient {
+ public:
+  AtomGpuClient();
+
+  // content::ContentGpuClient:
+  void PreCreateMessageLoop() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomGpuClient);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_GPU_CLIENT_H_

atom/browser/atom_javascript_dialog_manager.cc

@@ -92,12 +92,12 @@ void AtomJavaScriptDialogManager::RunJavaScriptDialog(
   }
 
   atom::ShowMessageBox(
-      window, atom::MessageBoxType::MESSAGE_BOX_TYPE_NONE, buttons, default_id,
-      cancel_id, atom::MessageBoxOptions::MESSAGE_BOX_NONE, "",
+      window, atom::MessageBoxType::kNone, buttons, default_id, cancel_id,
+      atom::MessageBoxOptions::MESSAGE_BOX_NONE, "",
       base::UTF16ToUTF8(message_text), "", checkbox, false, gfx::ImageSkia(),
-      base::Bind(&AtomJavaScriptDialogManager::OnMessageBoxCallback,
-                 base::Unretained(this), base::Passed(std::move(callback)),
-                 origin));
+      base::BindOnce(&AtomJavaScriptDialogManager::OnMessageBoxCallback,
+                     base::Unretained(this), base::Passed(std::move(callback)),
+                     origin));
 }
 
 void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(

atom/browser/atom_paths.h

@@ -28,19 +28,23 @@ enum {
 
 #if defined(OS_LINUX)
   DIR_APP_DATA,  // Application Data directory under the user profile.
-#else
+#endif
+
+  PATH_END,  // End of new paths. Those that follow redirect to base::DIR_*
+
+#if !defined(OS_LINUX)
   DIR_APP_DATA = base::DIR_APP_DATA,
 #endif
 
 #if defined(OS_POSIX)
-  DIR_CACHE = base::DIR_CACHE,  // Directory where to put cache data.
+  DIR_CACHE = base::DIR_CACHE  // Directory where to put cache data.
 #else
-  DIR_CACHE = base::DIR_APP_DATA,
+  DIR_CACHE = base::DIR_APP_DATA
 #endif
-
-  PATH_END
 };
 
+static_assert(PATH_START < PATH_END, "invalid PATH boundaries");
+
 }  // namespace atom
 
 #endif  // ATOM_BROWSER_ATOM_PATHS_H_

atom/browser/atom_permission_manager.cc

@@ -5,6 +5,7 @@
 #include "atom/browser/atom_permission_manager.h"
 
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "atom/browser/atom_browser_client.h"
@@ -32,9 +33,9 @@ bool WebContentsDestroyed(int process_id) {
 }
 
 void PermissionRequestResponseCallbackWrapper(
-    const AtomPermissionManager::StatusCallback& callback,
+    AtomPermissionManager::StatusCallback callback,
     const std::vector<blink::mojom::PermissionStatus>& vector) {
-  callback.Run(vector[0]);
+  std::move(callback).Run(vector[0]);
 }
 
 }  // namespace
@@ -43,9 +44,9 @@ class AtomPermissionManager::PendingRequest {
  public:
   PendingRequest(content::RenderFrameHost* render_frame_host,
                  const std::vector<content::PermissionType>& permissions,
-                 const StatusesCallback& callback)
+                 StatusesCallback callback)
       : render_process_id_(render_frame_host->GetProcess()->GetID()),
-        callback_(callback),
+        callback_(std::move(callback)),
         permissions_(permissions),
         results_(permissions.size(), blink::mojom::PermissionStatus::DENIED),
         remaining_results_(permissions.size()) {}
@@ -74,11 +75,15 @@ class AtomPermissionManager::PendingRequest {
 
   bool IsComplete() const { return remaining_results_ == 0; }
 
-  void RunCallback() const { callback_.Run(results_); }
+  void RunCallback() {
+    if (!callback_.is_null()) {
+      std::move(callback_).Run(results_);
+    }
+  }
 
  private:
   int render_process_id_;
-  const StatusesCallback callback_;
+  StatusesCallback callback_;
   std::vector<content::PermissionType> permissions_;
   std::vector<blink::mojom::PermissionStatus> results_;
   size_t remaining_results_;
@@ -91,8 +96,8 @@ AtomPermissionManager::~AtomPermissionManager() {}
 void AtomPermissionManager::SetPermissionRequestHandler(
     const RequestHandler& handler) {
   if (handler.is_null() && !pending_requests_.IsEmpty()) {
-    for (PendingRequestsMap::const_iterator iter(&pending_requests_);
-         !iter.IsAtEnd(); iter.Advance()) {
+    for (PendingRequestsMap::iterator iter(&pending_requests_); !iter.IsAtEnd();
+         iter.Advance()) {
       auto* request = iter.GetCurrentValue();
       if (!WebContentsDestroyed(request->render_process_id()))
         request->RunCallback();
@@ -112,11 +117,10 @@ int AtomPermissionManager::RequestPermission(
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
     bool user_gesture,
-    const base::Callback<void(blink::mojom::PermissionStatus)>&
-        response_callback) {
+    StatusCallback response_callback) {
   return RequestPermissionWithDetails(permission, render_frame_host,
                                       requesting_origin, user_gesture, nullptr,
-                                      response_callback);
+                                      std::move(response_callback));
 }
 
 int AtomPermissionManager::RequestPermissionWithDetails(
@@ -125,11 +129,12 @@ int AtomPermissionManager::RequestPermissionWithDetails(
     const GURL& requesting_origin,
     bool user_gesture,
     const base::DictionaryValue* details,
-    const StatusCallback& response_callback) {
+    StatusCallback response_callback) {
   return RequestPermissionsWithDetails(
       std::vector<content::PermissionType>(1, permission), render_frame_host,
       requesting_origin, user_gesture, details,
-      base::Bind(&PermissionRequestResponseCallbackWrapper, response_callback));
+      base::BindOnce(PermissionRequestResponseCallbackWrapper,
+                     std::move(response_callback)));
 }
 
 int AtomPermissionManager::RequestPermissions(
@@ -137,10 +142,10 @@ int AtomPermissionManager::RequestPermissions(
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
     bool user_gesture,
-    const StatusesCallback& response_callback) {
+    StatusesCallback response_callback) {
   return RequestPermissionsWithDetails(permissions, render_frame_host,
                                        requesting_origin, user_gesture, nullptr,
-                                       response_callback);
+                                       std::move(response_callback));
 }
 
 int AtomPermissionManager::RequestPermissionsWithDetails(
@@ -149,9 +154,9 @@ int AtomPermissionManager::RequestPermissionsWithDetails(
     const GURL& requesting_origin,
     bool user_gesture,
     const base::DictionaryValue* details,
-    const StatusesCallback& response_callback) {
+    StatusesCallback response_callback) {
   if (permissions.empty()) {
-    response_callback.Run(std::vector<blink::mojom::PermissionStatus>());
+    std::move(response_callback).Run({});
     return content::PermissionController::kNoPendingOperation;
   }
 
@@ -169,20 +174,20 @@ int AtomPermissionManager::RequestPermissionsWithDetails(
       }
       statuses.push_back(blink::mojom::PermissionStatus::GRANTED);
     }
-    response_callback.Run(statuses);
+    std::move(response_callback).Run(statuses);
     return content::PermissionController::kNoPendingOperation;
   }
 
   auto* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
   int request_id = pending_requests_.Add(std::make_unique<PendingRequest>(
-      render_frame_host, permissions, response_callback));
+      render_frame_host, permissions, std::move(response_callback)));
 
   for (size_t i = 0; i < permissions.size(); ++i) {
     auto permission = permissions[i];
     const auto callback =
-        base::Bind(&AtomPermissionManager::OnPermissionResponse,
-                   base::Unretained(this), request_id, i);
+        base::BindRepeating(&AtomPermissionManager::OnPermissionResponse,
+                            base::Unretained(this), request_id, i);
     if (details == nullptr) {
       request_handler_.Run(web_contents, permission, callback,
                            base::DictionaryValue());
@@ -224,7 +229,7 @@ int AtomPermissionManager::SubscribePermissionStatusChange(
     content::PermissionType permission,
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
-    const base::Callback<void(blink::mojom::PermissionStatus)>& callback) {
+    base::RepeatingCallback<void(blink::mojom::PermissionStatus)> callback) {
   return -1;
 }
 

atom/browser/atom_permission_manager.h

@@ -25,12 +25,13 @@ class AtomPermissionManager : public content::PermissionControllerDelegate {
   AtomPermissionManager();
   ~AtomPermissionManager() override;
 
-  using StatusCallback = base::Callback<void(blink::mojom::PermissionStatus)>;
-  using StatusesCallback =
-      base::Callback<void(const std::vector<blink::mojom::PermissionStatus>&)>;
+  using StatusCallback =
+      base::OnceCallback<void(blink::mojom::PermissionStatus)>;
+  using StatusesCallback = base::OnceCallback<void(
+      const std::vector<blink::mojom::PermissionStatus>&)>;
   using RequestHandler = base::Callback<void(content::WebContents*,
                                              content::PermissionType,
-                                             const StatusCallback&,
+                                             StatusCallback,
                                              const base::DictionaryValue&)>;
   using CheckHandler = base::Callback<bool(content::WebContents*,
                                            content::PermissionType,
@@ -42,35 +43,30 @@ class AtomPermissionManager : public content::PermissionControllerDelegate {
   void SetPermissionCheckHandler(const CheckHandler& handler);
 
   // content::PermissionControllerDelegate:
-  int RequestPermission(
-      content::PermissionType permission,
-      content::RenderFrameHost* render_frame_host,
-      const GURL& requesting_origin,
-      bool user_gesture,
-      const base::Callback<void(blink::mojom::PermissionStatus)>& callback)
-      override;
+  int RequestPermission(content::PermissionType permission,
+                        content::RenderFrameHost* render_frame_host,
+                        const GURL& requesting_origin,
+                        bool user_gesture,
+                        StatusCallback callback) override;
   int RequestPermissionWithDetails(content::PermissionType permission,
                                    content::RenderFrameHost* render_frame_host,
                                    const GURL& requesting_origin,
                                    bool user_gesture,
                                    const base::DictionaryValue* details,
-                                   const StatusCallback& callback);
+                                   StatusCallback callback);
   int RequestPermissions(
       const std::vector<content::PermissionType>& permissions,
       content::RenderFrameHost* render_frame_host,
       const GURL& requesting_origin,
       bool user_gesture,
-      const base::Callback<
-          void(const std::vector<blink::mojom::PermissionStatus>&)>& callback)
-      override;
+      StatusesCallback callback) override;
   int RequestPermissionsWithDetails(
       const std::vector<content::PermissionType>& permissions,
       content::RenderFrameHost* render_frame_host,
       const GURL& requesting_origin,
       bool user_gesture,
       const base::DictionaryValue* details,
-      const base::Callback<
-          void(const std::vector<blink::mojom::PermissionStatus>&)>& callback);
+      StatusesCallback callback);
   blink::mojom::PermissionStatus GetPermissionStatusForFrame(
       content::PermissionType permission,
       content::RenderFrameHost* render_frame_host,
@@ -98,7 +94,7 @@ class AtomPermissionManager : public content::PermissionControllerDelegate {
       content::PermissionType permission,
       content::RenderFrameHost* render_frame_host,
       const GURL& requesting_origin,
-      const base::Callback<void(blink::mojom::PermissionStatus)>& callback)
+      base::RepeatingCallback<void(blink::mojom::PermissionStatus)> callback)
       override;
   void UnsubscribePermissionStatusChange(int subscription_id) override;
 

atom/browser/atom_resource_dispatcher_host_delegate.cc

@@ -94,9 +94,9 @@ bool AtomResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream(
     *origin = GURL(kPdfViewerUIOrigin);
     base::PostTaskWithTraits(
         FROM_HERE, {BrowserThread::UI},
-        base::Bind(&OnPdfResourceIntercepted, request->url(),
-                   render_process_host_id, render_frame_id,
-                   info->GetWebContentsGetterForRequest()));
+        base::BindOnce(&OnPdfResourceIntercepted, request->url(),
+                       render_process_host_id, render_frame_id,
+                       info->GetWebContentsGetterForRequest()));
     return true;
   }
 #endif  // BUILDFLAG(ENABLE_PDF_VIEWER)

atom/browser/auto_updater_mac.mm

@@ -4,17 +4,19 @@
 
 #include "atom/browser/auto_updater.h"
 
+#include <string>
+
 #import <ReactiveCocoa/NSObject+RACPropertySubscribing.h>
 #import <ReactiveCocoa/RACCommand.h>
 #import <ReactiveCocoa/RACSignal.h>
 #import <Squirrel/Squirrel.h>
 
 #include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/map_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "base/bind.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/time/time.h"
-#include "native_mate/converter.h"
 #include "native_mate/dictionary.h"
 
 namespace auto_updater {
@@ -29,7 +31,7 @@ SQRLUpdater* g_updater = nil;
 namespace {
 
 bool g_update_available = false;
-std::string update_url_ = "";
+std::string update_url_ = "";  // NOLINT(runtime/string)
 
 }  // namespace