Bump v6.0.0-beta.2

This reverts commit c54b67300e.

.dockerignore

@@ -1,3 +1,4 @@
 *
 !tools/xvfb-init.sh
+!tools/run-electron.sh
 !build/install-build-deps.sh

.env.example

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

.eslintrc.json

@@ -6,11 +6,9 @@
     "browser": true
   },
   "rules": {
-    "semi": ["error", "always"],
     "no-var": "error",
     "no-unused-vars": 0,
     "no-global-assign": 0,
-    "guard-for-in": 2,
     "@typescript-eslint/no-unused-vars": ["error", {
       "vars": "all",
       "args": "after-used",

.gitattributes

@@ -1,14 +1,3 @@
 # `git apply` and friends don't understand CRLF, even on windows. Force those
 # files to be checked out with LF endings even if core.autocrlf is true.
 *.patch text eol=lf
-patches/**/.patches merge=union
-
-# Source code and markdown files should always use LF as line ending.
-*.cc text eol=lf
-*.mm text eol=lf
-*.h text eol=lf
-*.js text eol=lf
-*.ts text eol=lf
-*.py text eol=lf
-*.ps1 text eol=lf
-*.md text eol=lf

.github/CODEOWNERS

@@ -4,19 +4,17 @@
 # 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
-DEPS                                    @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
-/script/release                         @electron/wg-releases
+/npm/ @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
@@ -31,15 +31,11 @@ about: Create a report to help us improve Electron
 
 ### To Reproduce
 <!--
-Your best chance of getting this bug looked at quickly is to provide an example.
+Your best chance of getting this bug looked at quickly is to provide a REPOSITORY that can be cloned and run.
 -->
 
 <!--
-For bugs that can be encapsulated in a small experiment, you can use Electron Fiddle (https://github.com/electron/fiddle) to publish your example to a GitHub Gist and link it your bug report.
--->
-
-<!--
-If Fiddle is insufficient to produce an example, please provide an example REPOSITORY that can be cloned and run. You can fork electron-quick-start (https://github.com/electron/electron-quick-start) and include a link to the branch with your changes.
+You can fork electron-quick-start (https://github.com/electron/electron-quick-start) and include a link to the branch with your changes.
 -->
 
 <!--

.github/config.yml

@@ -29,11 +29,13 @@ firstPRMergeComment: >
 # Users authorized to run manual trop backports
 authorizedUsers:
   - alexeykuzmin
+  - BinaryMuse
   - ckerr
   - codebytere
   - deepak1556
   - jkleinsc
   - MarshallOfSound
   - miniak
+  - nitsakh
   - nornagon
   - zcbenz

.github/stale.yml

@@ -0,0 +1,25 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 45
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+   - fixme/bug
+   - fixme/crash
+   - fixme/regression
+   - fixme/security
+   - blocked
+   - blocking-stable
+   - needs-review
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity and is not currently prioritized. It will be closed
+  in a week if no further activity occurs :)
+
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: >
+  If you still think this issue is relevant, please ping a maintainer or
+  leave a comment!

.gitignore

@@ -58,10 +58,7 @@ spec/.hash
 .eslintcache
 
 # Generated native addon files
-/spec-main/fixtures/native-addon/echo/build/
+/spec/fixtures/native-addon/echo/build/
 
 # If someone runs tsc this is where stuff will end up
 ts-gen
-
-# Used to accelerate CI builds
-.depshash

CONTRIBUTING.md

@@ -20,23 +20,13 @@ Issues are created [here](https://github.com/electron/electron/issues/new).
 * [Triaging a Bug Report](https://electronjs.org/docs/development/issues#triaging-a-bug-report)
 * [Resolving a Bug Report](https://electronjs.org/docs/development/issues#resolving-a-bug-report)
 
-### Issue Closure
-
-Bug reports will be closed if the issue has been inactive and the latest affected version no longer receives support. At the moment, Electron maintains its three latest major versions, with a new major version being released every 12 weeks. (For more information on Electron's release cadence, see [this blog post](https://electronjs.org/blog/12-week-cadence).)
-
-_If an issue has been closed and you still feel it's relevant, feel free to ping a maintainer or add a comment!_
-
-### Languages
-
-We accept issues in *any* language.
-When an issue is posted in a language besides English, it is acceptable and encouraged to post an English-translated copy as a reply. 
-Anyone may post the translated reply.
-In most cases, a quick pass through translation software is sufficient.
-Having the original text _as well as_ the translation can help mitigate translation errors.
-
-Responses to posted issues may or may not be in the original language.
-
-**Please note** that using non-English as an attempt to circumvent our [Code of Conduct](https://github.com/electron/electron/blob/master/CODE_OF_CONDUCT.md) will be an immediate, and possibly indefinite, ban from the project.
+### Issue Maintenance and Closure
+* If an issue is inactive for 45 days (no activity of any kind), it will be
+marked for closure with `stale`.
+* If after this label is applied, no further activity occurs in the next 7 days,
+the issue will be closed.
+  * If an issue has been closed and you still feel it's relevant, feel free to
+  ping a maintainer or add a comment!
 
 ## [Pull Requests](https://electronjs.org/docs/development/pull-requests)
 
@@ -67,4 +57,4 @@ See [Coding Style](https://electronjs.org/docs/development/coding-style) for inf
 ## Further Reading
 
 For more in-depth guides on developing Electron, see 
-[/docs/development](/docs/development/README.md)
+[/docs/development](/docs/development/README.md)

DEPS

@@ -5,17 +5,14 @@ gclient_gn_args = [
   'checkout_android_native_support',
   'checkout_libaom',
   'checkout_nacl',
-  'checkout_oculus_sdk',
-  'checkout_openxr'
+  'checkout_oculus_sdk'
 ]
 
 vars = {
   'chromium_version':
-    '80.0.3987.163',
+    '76.0.3783.1',
   'node_version':
-    'v12.13.0',
-  'nan_version':
-    '2ee313aaca52e2b478965ac50eb5082520380d1b',
+    'a86a4a160dc520c61a602c949a32a1bc4c0fc633',
 
   'boto_version': 'f7574aa6cc2c819430c1f05e9a1a1a666ef8169b',
   'pyyaml_version': '3.12',
@@ -24,11 +21,10 @@ vars = {
   'boto_git': 'https://github.com/boto',
   'chromium_git': 'https://chromium.googlesource.com',
   'electron_git': 'https://github.com/electron',
-  'nodejs_git': 'https://github.com/nodejs',
   'requests_git': 'https://github.com/kennethreitz',
   'yaml_git': 'https://github.com/yaml',
 
-  # KEEP IN SYNC WITH utils.js FILE
+  # KEEP IN SYNC WITH spec-runner FILE
   'yarn_version': '1.15.2',
 
   # To be able to build clean Chromium from sources.
@@ -40,7 +36,6 @@ 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,
@@ -48,9 +43,6 @@ 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,8 +53,6 @@ vars = {
     True,
   'checkout_oculus_sdk':
     False,
-  'checkout_openxr':
-    False,
   'build_with_chromium':
     True,
   'checkout_android':
@@ -74,39 +64,35 @@ vars = {
 deps = {
   'src': {
     'url': (Var("chromium_git")) + '/chromium/src.git@' + (Var("chromium_version")),
-    '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',
+    'condition': 'checkout_chromium',
   },
   'src/third_party/electron_node': {
-    'url': (Var("nodejs_git")) + '/node.git@' + (Var("node_version")),
-    'condition': 'checkout_node and process_deps',
+    'url': (Var("electron_git")) + '/node.git@' + (Var("node_version")),
+    'condition': 'checkout_node',
   },
   'src/electron/vendor/pyyaml': {
     'url': (Var("yaml_git")) + '/pyyaml.git@' + (Var("pyyaml_version")),
-    'condition': 'checkout_pyyaml and process_deps',
+    'condition': 'checkout_pyyaml',
   },
   'src/electron/vendor/boto': {
     'url': Var('boto_git') + '/boto.git' + '@' +  Var('boto_version'),
-    'condition': 'checkout_boto and process_deps',
+    'condition': 'checkout_boto',
   },
   'src/electron/vendor/requests': {
     'url': Var('requests_git') + '/requests.git' + '@' +  Var('requests_version'),
-    'condition': 'checkout_requests and process_deps',
+    'condition': 'checkout_requests',
   },
 }
 
 hooks = [
   {
     'name': 'patch_chromium',
-    'condition': '(checkout_chromium and apply_patches) and process_deps',
+    'condition': 'checkout_chromium and apply_patches',
     'pattern': 'src/electron',
     'action': [
       'python',
       'src/electron/script/apply_all_patches.py',
-      'src/electron/patches/config.json',
+      'src/electron/patches/common/config.json',
     ],
   },
   {
@@ -114,7 +100,7 @@ hooks = [
     'pattern': 'src/electron/script/update-external-binaries.py',
     'condition': 'download_external_binaries',
     'action': [
-      'python3',
+      'python',
       'src/electron/script/update-external-binaries.py',
     ],
   },
@@ -130,7 +116,7 @@ hooks = [
   {
     'name': 'setup_boto',
     'pattern': 'src/electron',
-    'condition': 'checkout_boto and process_deps',
+    'condition': 'checkout_boto',
     'action': [
       'python',
       '-c',
@@ -140,7 +126,7 @@ hooks = [
   {
     'name': 'setup_requests',
     'pattern': 'src/electron',
-    'condition': 'checkout_requests and process_deps',
+    'condition': 'checkout_requests',
     'action': [
       'python',
       '-c',
@@ -152,5 +138,3 @@ hooks = [
 recursedeps = [
   'src',
 ]
-
-# Touch DEPS to bust cache

Dockerfile

@@ -10,21 +10,18 @@ RUN chmod a+rwx /tmp
 # Install Linux packages
 ADD build/install-build-deps.sh /setup/install-build-deps.sh
 RUN echo ttf-mscorefonts-installer msttcorefonts/accepted-mscorefonts-eula select true | debconf-set-selections
-RUN dpkg --add-architecture i386
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
     curl \
     libnotify-bin \
     locales \
     lsb-release \
     nano \
-    python-dbus \
+    python-dbusmock \
     python-pip \
     python-setuptools \
     sudo \
     vim-nox \
     wget \
-    g++-multilib \
-    libgl1:i386 \
   && /setup/install-build-deps.sh --syms --no-prompt --no-chromeos-fonts --lib32 --arm \
   && rm -rf /var/lib/apt/lists/*
 
@@ -36,9 +33,6 @@ RUN curl -sL https://deb.nodesource.com/setup_10.x | bash - \
 # crcmod is required by gsutil, which is used for filling the gclient git cache
 RUN pip install -U crcmod
 
-# dbusmock is needed for Electron tests
-RUN pip install python-dbusmock
-
 RUN mkdir /tmp/workspace
 RUN chown builduser:builduser /tmp/workspace
 

Dockerfile.arm32v7

@@ -19,6 +19,8 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
  libcap-dev \
  libcups2-dev \
  libdbus-1-dev \
+ libgconf-2-4 \
+ libgconf2-dev \
  libgnome-keyring-dev \
  libgtk2.0-0 \
  libgtk2.0-dev \

Dockerfile.arm64v8

@@ -1,4 +1,4 @@
-FROM arm64v8/ubuntu:18.04
+FROM arm64v8/ubuntu:16.04
 
 RUN groupadd --gid 1000 builduser \
   && useradd --uid 1000 --gid builduser --shell /bin/bash --create-home builduser
@@ -22,6 +22,8 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
  libcap-dev \
  libcups2-dev \
  libdbus-1-dev \
+ libgconf-2-4 \
+ libgconf2-dev \
  libgnome-keyring-dev \
  libgtk2.0-0 \
  libgtk2.0-dev \
@@ -39,6 +41,7 @@ RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
  nano \
  python-setuptools \
  python-pip \
+ python-dbusmock \
  sudo \
  unzip \
  wget \
@@ -53,9 +56,6 @@ RUN curl -sL https://deb.nodesource.com/setup_10.x | bash - \
 # crcmod is required by gsutil, which is used for filling the gclient git cache
 RUN pip install -U crcmod
 
-# dbusmock is needed for Electron tests
-RUN pip install python-dbusmock
-
 ADD tools/xvfb-init.sh /etc/init.d/xvfb
 RUN chmod a+x /etc/init.d/xvfb
 

ELECTRON_VERSION

@@ -1 +1 @@
-8.5.3
+6.0.0-beta.2

README.md

@@ -2,8 +2,10 @@
 
 
 [![CircleCI Build Status](https://circleci.com/gh/electron/electron/tree/master.svg?style=shield)](https://circleci.com/gh/electron/electron/tree/master)
-[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/4lggi9dpjc1qob7k/branch/master?svg=true)](https://ci.appveyor.com/project/electron-bot/electron-ljo26/branch/master)
+[![AppVeyor Build Status](https://windows-ci.electronjs.org/api/projects/status/nilyf07hcef14dvj/branch/master?svg=true)](https://windows-ci.electronjs.org/project/AppVeyor/electron/branch/master)
+[![Azure Pipelines Build Status](https://github.visualstudio.com/electron/_apis/build/status/electron-builds/electron-osx-testing?branchName=master)](https://github.visualstudio.com/electron/_build/latest?definitionId=36)
 [![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron?type=dev)
+[![Join the Electron Community on Slack](https://atom-slack.herokuapp.com/badge.svg)](https://atom-slack.herokuapp.com/)
 
 :memo: Available Translations: 🇨🇳 🇹🇼 🇧🇷 🇪🇸 🇰🇷 🇯🇵 🇷🇺 🇫🇷 🇹🇭 🇳🇱 🇹🇷 🇮🇩 🇺🇦 🇨🇿 🇮🇹 🇵🇱.
 View these docs in other languages at [electron/i18n](https://github.com/electron/i18n/tree/master/content/).
@@ -58,13 +60,13 @@ npm start
 
 ## Resources for learning Electron
 
-- [electronjs.org/docs](https://electronjs.org/docs) - All of Electron's documentation
+- [electronjs.org/docs](https://electronjs.org/docs) - all of Electron's documentation
 - [electron/fiddle](https://github.com/electron/fiddle) - A tool to build, run, and package small Electron experiments
-- [electron/electron-quick-start](https://github.com/electron/electron-quick-start) - A very basic starter Electron app
-- [electronjs.org/community#boilerplates](https://electronjs.org/community#boilerplates) - Sample starter apps created by the community
-- [electron/simple-samples](https://github.com/electron/simple-samples) - Small applications with ideas for taking them further
-- [electron/electron-api-demos](https://github.com/electron/electron-api-demos) - An Electron app that teaches you how to use Electron
-- [hokein/electron-sample-apps](https://github.com/hokein/electron-sample-apps) - Small demo apps for the various Electron APIs
+- [electron/electron-quick-start](https://github.com/electron/electron-quick-start) - a very basic starter Electron app
+- [electronjs.org/community#boilerplates](https://electronjs.org/community#boilerplates) - sample starter apps created by the community
+- [electron/simple-samples](https://github.com/electron/simple-samples) - small applications with ideas for taking them further
+- [electron/electron-api-demos](https://github.com/electron/electron-api-demos) - an Electron app that teaches you how to use Electron
+- [hokein/electron-sample-apps](https://github.com/hokein/electron-sample-apps) - small demo apps for the various Electron APIs
 
 ## Programmatic usage
 
@@ -91,10 +93,6 @@ 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,54 +23,29 @@
 # 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: vs2019-16.3-10.0.18362
+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
-  MOCHA_REPORTER: mocha-multi-reporters
-  MOCHA_MULTI_REPORTERS: mocha-appveyor-reporter, tap
-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]) {
         Write-warning "Skipping PR build for branch"; Exit-AppveyorBuild
-      } else {
-        node script/yarn.js install --frozen-lockfile
-
-        $result = node script/doc-only-change.js --prNumber=$env:APPVEYOR_PULL_REQUEST_NUMBER --prBranch=$env:APPVEYOR_REPO_BRANCH
-        Write-Output $result
-        if ($result.ExitCode -eq 0) {
-          Write-warning "Skipping build for doc only change"; Exit-AppveyorBuild
-        }
       }
   - echo "Building $env:GN_CONFIG build"
   - git config --global core.longpaths true
   - cd ..
-  - mkdir 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"
   - ps: >-
       if ($env:GN_CONFIG -eq 'release') {
-        $env:GCLIENT_EXTRA_ARGS="$env:GCLIENT_EXTRA_ARGS --custom-var=checkout_boto=True --custom-var=checkout_requests=True"
-      } else {
-        $env:NINJA_STATUS="[%r processes, %f/%t @ %o/s : %es] "
+        $env:GCLIENT_EXTRA_ARGS="--custom-var=checkout_boto=True --custom-var=checkout_requests=True"
       }
   - >-
       gclient config
@@ -78,80 +53,39 @@ build_script:
       --unmanaged
       %GCLIENT_EXTRA_ARGS%
       "https://github.com/electron/electron"
-  - gclient sync --with_branch_heads --with_tags --ignore_locks --break_repo_locks
-  - ps: >-
-      if ($env:SAVE_GCLIENT_SRC -eq 'true') {
-        # archive current source for future use 
-        # only run on x64/woa to avoid contention saving
-        if ($(7z a $zipfile src -xr!android_webview -xr!electron -xr'!*\.git' -xr!third_party\WebKit\LayoutTests! -xr!third_party\blink\web_tests -xr!third_party\blink\perf_tests -slp -t7z -mmt=30;$LASTEXITCODE -ne 0)) {
-          Write-warning "Could not save source to shared drive; continuing anyway"
-        }
-      }
-  - ps: >-
-      if ($env:GN_CONFIG -ne 'release') {
-        if (Test-Path 'env:RAW_GOMA_AUTH') {
-          $env:GOMA_OAUTH2_CONFIG_FILE = "$pwd\.goma_oauth2_config"
-          $env:RAW_GOMA_AUTH | Set-Content $env:GOMA_OAUTH2_CONFIG_FILE      
-        }
-        git clone https://github.com/electron/build-tools.git
-        cd build-tools
-        npm install
-        mkdir third_party
-        node -e "require('./src/utils/goma.js').downloadAndPrepare()"
-        $env:GN_GOMA_FILE = node -e "console.log(require('./src/utils/goma.js').gnFilePath)"
-        $env:LOCAL_GOMA_DIR = node -e "console.log(require('./src/utils/goma.js').dir)"
-        cd ..
-        .\src\electron\script\start-goma.ps1 -gomaDir $env:LOCAL_GOMA_DIR
-      }
+  - gclient sync --with_branch_heads --with_tags --reset
   - cd src
-  - set BUILD_CONFIG_PATH=//electron/build/args/%GN_CONFIG%.gn 
-  - if DEFINED GN_GOMA_FILE (gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") import(\"%GN_GOMA_FILE%\") %GN_EXTRA_ARGS% ") else (gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") %GN_EXTRA_ARGS% cc_wrapper=\"%SCCACHE_PATH%\"")
+  - ps: $env:BUILD_CONFIG_PATH="//electron/build/args/%GN_CONFIG%.gn"
+  - gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") %GN_EXTRA_ARGS%"
   - gn check out/Default //electron:electron_lib
   - gn check out/Default //electron:electron_app
   - gn check out/Default //electron:manifests
-  - gn check out/Default //electron/shell/common/api:mojo
-  - if DEFINED GN_GOMA_FILE (ninja -j 300 -C out/Default electron:electron_app) else (ninja -C out/Default electron:electron_app)
-  - if "%GN_CONFIG%"=="testing" ( python C:\Users\electron\depot_tools\post_build_ninja_summary.py -C out\Default )
+  - gn check out/Default //electron/atom/common/api:mojo
+  - ninja -C out/Default electron:electron_app
   - gn gen out/ffmpeg "--args=import(\"//electron/build/args/ffmpeg.gn\") %GN_EXTRA_ARGS%"
   - ninja -C out/ffmpeg electron:electron_ffmpeg_zip
   - ninja -C out/Default electron:electron_dist_zip
-  - ninja -C out/Default shell_browser_ui_unittests
   - ninja -C out/Default electron:electron_mksnapshot_zip
-  - ninja -C out/Default electron:hunspell_dictionaries_zip
   - ninja -C out/Default electron:electron_chromedriver_zip
   - ninja -C out/Default third_party/electron_node:headers
-  - if "%GN_CONFIG%"=="testing" ( python %LOCAL_GOMA_DIR%\goma_ctl.py stat )
   - appveyor PushArtifact out/Default/dist.zip
-  - appveyor PushArtifact out/Default/shell_browser_ui_unittests.exe
   - appveyor PushArtifact out/Default/chromedriver.zip
   - appveyor PushArtifact out/ffmpeg/ffmpeg.zip
-  - 7z a node_headers.zip out\Default\gen\node_headers
-  - appveyor PushArtifact node_headers.zip
-  - appveyor PushArtifact out/Default/mksnapshot.zip
-  - appveyor PushArtifact out/Default/hunspell_dictionaries.zip
-  - appveyor PushArtifact out/Default/electron.lib
   - ps: >-
       if ($env:GN_CONFIG -eq 'release') {
-        # Needed for msdia140.dll on 64-bit windows
-        $env:Path += ";$pwd\third_party\llvm-build\Release+Asserts\bin"
-        ninja -C out/Default electron:electron_symbols
+        ninja -C out/Default third_party/breakpad:dump_syms
       }
+  - if "%GN_CONFIG%"=="release" ( python electron\script\dump-symbols.py -d %cd%\out\Default\breakpad_symbols -v)
   - ps: >-
       if ($env:GN_CONFIG -eq 'release') {
         python electron\script\zip-symbols.py
         appveyor PushArtifact out/Default/symbols.zip
-      } else {
-        # It's useful to have pdb files when debugging testing builds that are
-        # built on CI.
-        7z a pdb.zip out\Default\*.pdb
-        appveyor PushArtifact pdb.zip
       }
-  - python electron/script/zip_manifests/check-zip-manifest.py out/Default/dist.zip electron/script/zip_manifests/dist_zip.win.%TARGET_ARCH%.manifest
 test_script:
   # Workaround for https://github.com/appveyor/ci/issues/2420
   - set "PATH=%PATH%;C:\Program Files\Git\mingw64\libexec\git-core"
   - ps: >-
-      if ((-Not (Test-Path Env:\TEST_WOA)) -And (-Not (Test-Path Env:\ELECTRON_RELEASE)) -And ($env:GN_CONFIG -in "testing", "release")) {
+      if ((-Not (Test-Path Env:\ELECTRON_RELEASE)) -And ($env:GN_CONFIG -in "testing", "release")) {
         $env:RUN_TESTS="true"
       }
   - ps: >-
@@ -162,7 +96,7 @@ test_script:
         echo "Skipping tests for $env:GN_CONFIG build"
       }
   - cd electron
-  - if "%RUN_TESTS%"=="true" ( echo Running test suite & node script/yarn test -- --ci --enable-logging)
+  - if "%RUN_TESTS%"=="true" ( echo Running test suite & npm run test -- --ci --enable-logging)
   - cd ..
   - if "%RUN_TESTS%"=="true" ( echo Verifying non proprietary ffmpeg & python electron\script\verify-ffmpeg.py --build-dir out\Default --source-root %cd% --ffmpeg-path out\ffmpeg )
   - echo "About to verify mksnapshot"
@@ -174,11 +108,9 @@ deploy_script:
       if (Test-Path Env:\ELECTRON_RELEASE) {
         if (Test-Path Env:\UPLOAD_TO_S3) {
           Write-Output "Uploading Electron release distribution to s3"
-          & python script\release\uploaders\upload.py --upload_to_s3
+          & python script\upload.py --upload_to_s3
         } else {
           Write-Output "Uploading Electron release distribution to github releases"
-          & python script\release\uploaders\upload.py
+          & python script\upload.py
         }
-      } elseif (Test-Path Env:\TEST_WOA) {
-        node script/release/ci-release-build.js --job=electron-woa-testing --ci=VSTS --armTest --appveyorJobId=$env:APPVEYOR_JOB_ID $env:APPVEYOR_REPO_BRANCH
       }

atom/app/atom_content_client.cc

@@ -2,28 +2,26 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/app/electron_content_client.h"
+#include "atom/app/atom_content_client.h"
 
 #include <string>
-#include <utility>
 #include <vector>
 
+#include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
-#include "base/path_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/common/content_constants.h"
+#include "content/public/common/pepper_plugin_info.h"
 #include "electron/buildflags/buildflags.h"
-#include "ppapi/buildflags/buildflags.h"
-#include "shell/browser/electron_paths.h"
-#include "shell/common/options_switches.h"
+#include "ppapi/shared_impl/ppapi_permissions.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "url/url_constants.h"
 // In SHARED_INTERMEDIATE_DIR.
-#include "widevine_cdm_version.h"  // NOLINT(build/include_directory)
+#include "widevine_cdm_version.h"  // NOLINT(build/include)
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
 #include "base/native_library.h"
@@ -32,16 +30,11 @@
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
 #if BUILDFLAG(ENABLE_PDF_VIEWER)
+#include "atom/common/atom_constants.h"
 #include "pdf/pdf.h"
-#include "shell/common/electron_constants.h"
 #endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
 
-#if BUILDFLAG(ENABLE_PLUGINS)
-#include "content/public/common/pepper_plugin_info.h"
-#include "ppapi/shared_impl/ppapi_permissions.h"
-#endif  // BUILDFLAG(ENABLE_PLUGINS)
-
-namespace electron {
+namespace atom {
 
 namespace {
 
@@ -105,27 +98,29 @@ content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
   std::vector<std::string> flash_version_numbers = base::SplitString(
       version, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (flash_version_numbers.empty())
-    flash_version_numbers.emplace_back("11");
+    flash_version_numbers.push_back("11");
   // |SplitString()| puts in an empty string given an empty string. :(
   else if (flash_version_numbers[0].empty())
     flash_version_numbers[0] = "11";
   if (flash_version_numbers.size() < 2)
-    flash_version_numbers.emplace_back("2");
+    flash_version_numbers.push_back("2");
   if (flash_version_numbers.size() < 3)
-    flash_version_numbers.emplace_back("999");
+    flash_version_numbers.push_back("999");
   if (flash_version_numbers.size() < 4)
-    flash_version_numbers.emplace_back("999");
+    flash_version_numbers.push_back("999");
   // E.g., "Shockwave Flash 10.2 r154":
   plugin.description = plugin.name + " " + flash_version_numbers[0] + "." +
                        flash_version_numbers[1] + " r" +
                        flash_version_numbers[2];
   plugin.version = base::JoinString(flash_version_numbers, ".");
-  plugin.mime_types.emplace_back(content::kFlashPluginSwfMimeType,
-                                 content::kFlashPluginSwfExtension,
-                                 content::kFlashPluginSwfDescription);
-  plugin.mime_types.emplace_back(content::kFlashPluginSplMimeType,
-                                 content::kFlashPluginSplExtension,
-                                 content::kFlashPluginSplDescription);
+  content::WebPluginMimeType swf_mime_type(content::kFlashPluginSwfMimeType,
+                                           content::kFlashPluginSwfExtension,
+                                           content::kFlashPluginSwfDescription);
+  plugin.mime_types.push_back(swf_mime_type);
+  content::WebPluginMimeType spl_mime_type(content::kFlashPluginSplMimeType,
+                                           content::kFlashPluginSplExtension,
+                                           content::kFlashPluginSplDescription);
+  plugin.mime_types.push_back(spl_mime_type);
 
   return plugin;
 }
@@ -145,7 +140,6 @@ void AddPepperFlashFromCommandLine(
 }
 #endif  // BUILDFLAG(ENABLE_PEPPER_FLASH)
 
-#if BUILDFLAG(ENABLE_PLUGINS)
 void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
 #if BUILDFLAG(ENABLE_PDF_VIEWER)
   content::PepperPluginInfo pdf_info;
@@ -166,79 +160,82 @@ void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
   plugins->push_back(pdf_info);
 #endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
 }
-#endif  // BUILDFLAG(ENABLE_PLUGINS)
 
-void AppendDelimitedSwitchToVector(const base::StringPiece cmd_switch,
-                                   std::vector<std::string>* append_me) {
+void ConvertStringWithSeparatorToVector(std::vector<std::string>* vec,
+                                        const char* separator,
+                                        const char* cmd_switch) {
   auto* command_line = base::CommandLine::ForCurrentProcess();
-  auto switch_value = command_line->GetSwitchValueASCII(cmd_switch);
-  if (!switch_value.empty()) {
-    constexpr base::StringPiece delimiter(",", 1);
-    auto tokens =
-        base::SplitString(switch_value, delimiter, base::TRIM_WHITESPACE,
-                          base::SPLIT_WANT_NONEMPTY);
-    append_me->reserve(append_me->size() + tokens.size());
-    std::move(std::begin(tokens), std::end(tokens),
-              std::back_inserter(*append_me));
-  }
+  auto string_with_separator = command_line->GetSwitchValueASCII(cmd_switch);
+  if (!string_with_separator.empty())
+    *vec = base::SplitString(string_with_separator, separator,
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
 }
 
 }  // namespace
 
-ElectronContentClient::ElectronContentClient() = default;
+AtomContentClient::AtomContentClient() {}
 
-ElectronContentClient::~ElectronContentClient() = default;
+AtomContentClient::~AtomContentClient() {}
 
-base::string16 ElectronContentClient::GetLocalizedString(int message_id) {
+base::string16 AtomContentClient::GetLocalizedString(int message_id) const {
   return l10n_util::GetStringUTF16(message_id);
 }
 
-base::StringPiece ElectronContentClient::GetDataResource(
+base::StringPiece AtomContentClient::GetDataResource(
     int resource_id,
-    ui::ScaleFactor scale_factor) {
+    ui::ScaleFactor scale_factor) const {
   return ui::ResourceBundle::GetSharedInstance().GetRawDataResourceForScale(
       resource_id, scale_factor);
 }
 
-gfx::Image& ElectronContentClient::GetNativeImageNamed(int resource_id) {
+gfx::Image& AtomContentClient::GetNativeImageNamed(int resource_id) const {
   return ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(
       resource_id);
 }
 
-base::RefCountedMemory* ElectronContentClient::GetDataResourceBytes(
-    int resource_id) {
+base::RefCountedMemory* AtomContentClient::GetDataResourceBytes(
+    int resource_id) const {
   return ui::ResourceBundle::GetSharedInstance().LoadDataResourceBytes(
       resource_id);
 }
 
-void ElectronContentClient::AddAdditionalSchemes(Schemes* schemes) {
-  AppendDelimitedSwitchToVector(switches::kServiceWorkerSchemes,
-                                &schemes->service_worker_schemes);
-  AppendDelimitedSwitchToVector(switches::kStandardSchemes,
-                                &schemes->standard_schemes);
-  AppendDelimitedSwitchToVector(switches::kSecureSchemes,
-                                &schemes->secure_schemes);
-  AppendDelimitedSwitchToVector(switches::kBypassCSPSchemes,
-                                &schemes->csp_bypassing_schemes);
-  AppendDelimitedSwitchToVector(switches::kCORSSchemes,
-                                &schemes->cors_enabled_schemes);
+void AtomContentClient::AddAdditionalSchemes(Schemes* schemes) {
+  std::vector<std::string> splited;
+  ConvertStringWithSeparatorToVector(&splited, ",",
+                                     switches::kServiceWorkerSchemes);
+  for (const std::string& scheme : splited)
+    schemes->service_worker_schemes.push_back(scheme);
+  schemes->service_worker_schemes.push_back(url::kFileScheme);
 
-  schemes->service_worker_schemes.emplace_back(url::kFileScheme);
-  schemes->standard_schemes.emplace_back("chrome-extension");
+  ConvertStringWithSeparatorToVector(&splited, ",", switches::kStandardSchemes);
+  for (const std::string& scheme : splited)
+    schemes->standard_schemes.push_back(scheme);
+  schemes->standard_schemes.push_back("chrome-extension");
+
+  ConvertStringWithSeparatorToVector(&splited, ",", switches::kSecureSchemes);
+  for (const std::string& scheme : splited)
+    schemes->secure_schemes.push_back(scheme);
+
+  ConvertStringWithSeparatorToVector(&splited, ",",
+                                     switches::kBypassCSPSchemes);
+  for (const std::string& scheme : splited)
+    schemes->csp_bypassing_schemes.push_back(scheme);
+
+  ConvertStringWithSeparatorToVector(&splited, ",", switches::kCORSSchemes);
+  for (const std::string& scheme : splited)
+    schemes->cors_enabled_schemes.push_back(scheme);
 }
 
-void ElectronContentClient::AddPepperPlugins(
+void AtomContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
 #if BUILDFLAG(ENABLE_PEPPER_FLASH)
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   AddPepperFlashFromCommandLine(command_line, plugins);
 #endif  // BUILDFLAG(ENABLE_PEPPER_FLASH)
-#if BUILDFLAG(ENABLE_PLUGINS)
   ComputeBuiltInPlugins(plugins);
-#endif  // BUILDFLAG(ENABLE_PLUGINS)
 }
 
-void ElectronContentClient::AddContentDecryptionModules(
+void AtomContentClient::AddContentDecryptionModules(
     std::vector<content::CdmInfo>* cdms,
     std::vector<media::CdmHostFilePath>* cdm_host_file_paths) {
   if (cdms) {
@@ -271,4 +268,4 @@ void ElectronContentClient::AddContentDecryptionModules(
   }
 }
 
-}  // namespace electron
+}  // namespace atom

atom/app/atom_content_client.h

@@ -2,29 +2,29 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_APP_ELECTRON_CONTENT_CLIENT_H_
-#define SHELL_APP_ELECTRON_CONTENT_CLIENT_H_
+#ifndef ATOM_APP_ATOM_CONTENT_CLIENT_H_
+#define ATOM_APP_ATOM_CONTENT_CLIENT_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/files/file_path.h"
 #include "content/public/common/content_client.h"
 
-namespace electron {
+namespace atom {
 
-class ElectronContentClient : public content::ContentClient {
+class AtomContentClient : public content::ContentClient {
  public:
-  ElectronContentClient();
-  ~ElectronContentClient() override;
+  AtomContentClient();
+  ~AtomContentClient() override;
 
  protected:
   // content::ContentClient:
-  base::string16 GetLocalizedString(int message_id) override;
-  base::StringPiece GetDataResource(int resource_id, ui::ScaleFactor) override;
-  gfx::Image& GetNativeImageNamed(int resource_id) override;
-  base::RefCountedMemory* GetDataResourceBytes(int resource_id) override;
+  base::string16 GetLocalizedString(int message_id) const override;
+  base::StringPiece GetDataResource(int resource_id,
+                                    ui::ScaleFactor) const override;
+  gfx::Image& GetNativeImageNamed(int resource_id) const override;
+  base::RefCountedMemory* GetDataResourceBytes(int resource_id) const override;
   void AddAdditionalSchemes(Schemes* schemes) override;
   void AddPepperPlugins(
       std::vector<content::PepperPluginInfo>* plugins) override;
@@ -33,9 +33,9 @@ class ElectronContentClient : public content::ContentClient {
       std::vector<media::CdmHostFilePath>* cdm_host_file_paths) override;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(ElectronContentClient);
+  DISALLOW_COPY_AND_ASSIGN(AtomContentClient);
 };
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_APP_ELECTRON_CONTENT_CLIENT_H_
+#endif  // ATOM_APP_ATOM_CONTENT_CLIENT_H_

atom/app/atom_library_main.h

@@ -2,22 +2,22 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_APP_ELECTRON_LIBRARY_MAIN_H_
-#define SHELL_APP_ELECTRON_LIBRARY_MAIN_H_
+#ifndef ATOM_APP_ATOM_LIBRARY_MAIN_H_
+#define ATOM_APP_ATOM_LIBRARY_MAIN_H_
 
 #include "build/build_config.h"
 #include "electron/buildflags/buildflags.h"
 
 #if defined(OS_MACOSX)
 extern "C" {
-__attribute__((visibility("default"))) int ElectronMain(int argc, char* argv[]);
+__attribute__((visibility("default"))) int AtomMain(int argc, char* argv[]);
 
 #if BUILDFLAG(ENABLE_RUN_AS_NODE)
-__attribute__((visibility("default"))) int ElectronInitializeICUandStartNode(
+__attribute__((visibility("default"))) int AtomInitializeICUandStartNode(
     int argc,
     char* argv[]);
 #endif
 }
 #endif  // OS_MACOSX
 
-#endif  // SHELL_APP_ELECTRON_LIBRARY_MAIN_H_
+#endif  // ATOM_APP_ATOM_LIBRARY_MAIN_H_

atom/app/atom_library_main.mm

@@ -2,37 +2,37 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/app/electron_library_main.h"
+#include "atom/app/atom_library_main.h"
 
+#include "atom/app/atom_main_delegate.h"
+#include "atom/app/node_main.h"
+#include "atom/common/atom_command_line.h"
+#include "atom/common/mac/main_application_bundle.h"
 #include "base/at_exit.h"
 #include "base/i18n/icu_util.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "content/public/app/content_main.h"
-#include "shell/app/electron_main_delegate.h"
-#include "shell/app/node_main.h"
-#include "shell/common/electron_command_line.h"
-#include "shell/common/mac/main_application_bundle.h"
 
-int ElectronMain(int argc, char* argv[]) {
-  electron::ElectronMainDelegate delegate;
+int AtomMain(int argc, char* argv[]) {
+  atom::AtomMainDelegate delegate;
   content::ContentMainParams params(&delegate);
   params.argc = argc;
   params.argv = const_cast<const char**>(argv);
-  electron::ElectronCommandLine::Init(argc, argv);
+  atom::AtomCommandLine::Init(argc, argv);
   return content::ContentMain(params);
 }
 
 #if BUILDFLAG(ENABLE_RUN_AS_NODE)
-int ElectronInitializeICUandStartNode(int argc, char* argv[]) {
+int AtomInitializeICUandStartNode(int argc, char* argv[]) {
   base::AtExitManager atexit_manager;
   base::mac::ScopedNSAutoreleasePool pool;
   base::mac::SetOverrideFrameworkBundlePath(
-      electron::MainApplicationBundlePath()
+      atom::MainApplicationBundlePath()
           .Append("Contents")
           .Append("Frameworks")
-          .Append(ELECTRON_PRODUCT_NAME " Framework.framework"));
+          .Append(ATOM_PRODUCT_NAME " Framework.framework"));
   base::i18n::InitializeICU();
-  return electron::NodeMain(argc, argv);
+  return atom::NodeMain(argc, argv);
 }
 #endif

atom/app/atom_login_helper.mm

@@ -1,7 +1,3 @@
-// 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.cc

@@ -2,9 +2,8 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/app/electron_main.h"
+#include "atom/app/atom_main.h"
 
-#include <algorithm>
 #include <cstdlib>
 #include <memory>
 #include <vector>
@@ -17,33 +16,32 @@
 #include <shellscalingapi.h>
 #include <tchar.h>
 
+#include "atom/app/atom_main_delegate.h"
+#include "atom/app/command_line_args.h"
+#include "atom/common/crash_reporter/win/crash_service_main.h"
 #include "base/environment.h"
 #include "base/process/launch.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "content/public/app/sandbox_helper_win.h"
 #include "sandbox/win/src/sandbox_types.h"
-#include "shell/app/command_line_args.h"
-#include "shell/app/electron_main_delegate.h"
-#include "shell/common/crash_reporter/win/crash_service_main.h"
 #elif defined(OS_LINUX)  // defined(OS_WIN)
 #include <unistd.h>
 #include <cstdio>
+#include "atom/app/atom_main_delegate.h"  // NOLINT
 #include "content/public/app/content_main.h"
-#include "shell/app/electron_main_delegate.h"  // NOLINT
-#else                                          // defined(OS_LINUX)
+#else  // defined(OS_LINUX)
 #include <mach-o/dyld.h>
 #include <unistd.h>
 #include <cstdio>
-#include "shell/app/electron_library_main.h"
+#include "atom/app/atom_library_main.h"
 #endif  // defined(OS_MACOSX)
 
+#include "atom/app/node_main.h"
+#include "atom/common/atom_command_line.h"
 #include "base/at_exit.h"
 #include "base/i18n/icu_util.h"
 #include "electron/buildflags/buildflags.h"
-#include "shell/app/node_main.h"
-#include "shell/common/electron_command_line.h"
-#include "shell/common/electron_constants.h"
 
 #if defined(HELPER_EXECUTABLE) && !defined(MAS_BUILD)
 #include "sandbox/mac/seatbelt_exec.h"  // nogncheck
@@ -51,6 +49,10 @@
 
 namespace {
 
+#if BUILDFLAG(ENABLE_RUN_AS_NODE)
+const char kRunAsNode[] = "ELECTRON_RUN_AS_NODE";
+#endif
+
 ALLOW_UNUSED_TYPE bool IsEnvSet(const char* name) {
 #if defined(OS_WIN)
   size_t required_size;
@@ -84,11 +86,6 @@ void FixStdioStreams() {
 }  // namespace
 
 #if defined(OS_WIN)
-
-namespace crash_reporter {
-extern const char kCrashpadProcess[];
-}
-
 int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   struct Arguments {
     int argc = 0;
@@ -125,7 +122,7 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
 #endif
 
 #if BUILDFLAG(ENABLE_RUN_AS_NODE)
-  bool run_as_node = IsEnvSet(electron::kRunAsNode);
+  bool run_as_node = IsEnvSet(kRunAsNode);
 #else
   bool run_as_node = false;
 #endif
@@ -134,37 +131,53 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   if (run_as_node || !IsEnvSet("ELECTRON_NO_ATTACH_CONSOLE"))
     base::RouteStdioToConsole(false);
 
-  std::vector<char*> argv(arguments.argc);
-  std::transform(arguments.argv, arguments.argv + arguments.argc, argv.begin(),
-                 [](auto& a) { return _strdup(base::WideToUTF8(a).c_str()); });
+#ifndef DEBUG
+  // Chromium has its own TLS subsystem which supports automatic destruction
+  // of thread-local data, and also depends on memory allocation routines
+  // provided by the CRT. The problem is that the auto-destruction mechanism
+  // uses a hidden feature of the OS loader which calls a callback on thread
+  // exit, but only after all loaded DLLs have been detached. Since the CRT is
+  // also a DLL, it happens that by the time Chromium's `OnThreadExit` function
+  // is called, the heap functions, though still in memory, no longer perform
+  // their duties, and when Chromium calls `free` on its buffer, it triggers
+  // an access violation error.
+  // We work around this problem by invoking Chromium's `OnThreadExit` in time
+  // from within the CRT's atexit facility, ensuring the heap functions are
+  // still active. The second invocation from the OS loader will be a no-op.
+  extern void NTAPI OnThreadExit(PVOID module, DWORD reason, PVOID reserved);
+  atexit([]() { OnThreadExit(nullptr, DLL_THREAD_DETACH, nullptr); });
+#endif
+
 #if BUILDFLAG(ENABLE_RUN_AS_NODE)
   if (run_as_node) {
+    std::vector<char*> argv(arguments.argc);
+    std::transform(
+        arguments.argv, arguments.argv + arguments.argc, argv.begin(),
+        [](auto& a) { return _strdup(base::WideToUTF8(a).c_str()); });
+
     base::AtExitManager atexit_manager;
     base::i18n::InitializeICU();
-    auto ret = electron::NodeMain(argv.size(), argv.data());
+    auto ret = atom::NodeMain(argv.size(), argv.data());
     std::for_each(argv.begin(), argv.end(), free);
     return ret;
   }
 #endif
 
-  base::CommandLine::Init(argv.size(), argv.data());
-  const base::CommandLine& cmd_line = *base::CommandLine::ForCurrentProcess();
-  if (cmd_line.GetSwitchValueASCII("type") ==
-      crash_reporter::kCrashpadProcess) {
-    return crash_service::Main(&argv);
+  if (IsEnvSet("ELECTRON_INTERNAL_CRASH_SERVICE")) {
+    return crash_service::Main(cmd);
   }
 
-  if (!electron::CheckCommandLineArguments(arguments.argc, arguments.argv))
+  if (!atom::CheckCommandLineArguments(arguments.argc, arguments.argv))
     return -1;
 
   sandbox::SandboxInterfaceInfo sandbox_info = {0};
   content::InitializeSandboxInfo(&sandbox_info);
-  electron::ElectronMainDelegate delegate;
+  atom::AtomMainDelegate delegate;
 
   content::ContentMainParams params(&delegate);
   params.instance = instance;
   params.sandbox_info = &sandbox_info;
-  electron::ElectronCommandLine::Init(arguments.argc, arguments.argv);
+  atom::AtomCommandLine::Init(arguments.argc, arguments.argv);
   return content::ContentMain(params);
 }
 
@@ -174,18 +187,18 @@ int main(int argc, char* argv[]) {
   FixStdioStreams();
 
 #if BUILDFLAG(ENABLE_RUN_AS_NODE)
-  if (IsEnvSet(electron::kRunAsNode)) {
+  if (IsEnvSet(kRunAsNode)) {
     base::i18n::InitializeICU();
     base::AtExitManager atexit_manager;
-    return electron::NodeMain(argc, argv);
+    return atom::NodeMain(argc, argv);
   }
 #endif
 
-  electron::ElectronMainDelegate delegate;
+  atom::AtomMainDelegate delegate;
   content::ContentMainParams params(&delegate);
   params.argc = argc;
   params.argv = const_cast<const char**>(argv);
-  electron::ElectronCommandLine::Init(argc, argv);
+  atom::AtomCommandLine::Init(argc, argv);
   return content::ContentMain(params);
 }
 
@@ -195,8 +208,8 @@ int main(int argc, char* argv[]) {
   FixStdioStreams();
 
 #if BUILDFLAG(ENABLE_RUN_AS_NODE)
-  if (IsEnvSet(electron::kRunAsNode)) {
-    return ElectronInitializeICUandStartNode(argc, argv);
+  if (IsEnvSet(kRunAsNode)) {
+    return AtomInitializeICUandStartNode(argc, argv);
   }
 #endif
 
@@ -229,7 +242,7 @@ int main(int argc, char* argv[]) {
   }
 #endif  // defined(HELPER_EXECUTABLE) && !defined(MAS_BUILD)
 
-  return ElectronMain(argc, argv);
+  return AtomMain(argc, argv);
 }
 
 #endif  // defined(OS_MACOSX)

atom/app/atom_main.h

@@ -2,9 +2,9 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_APP_ELECTRON_MAIN_H_
-#define SHELL_APP_ELECTRON_MAIN_H_
+#ifndef ATOM_APP_ATOM_MAIN_H_
+#define ATOM_APP_ATOM_MAIN_H_
 
 #include "content/public/app/content_main.h"
 
-#endif  // SHELL_APP_ELECTRON_MAIN_H_
+#endif  // ATOM_APP_ATOM_MAIN_H_

atom/app/atom_main_delegate.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/app/electron_main_delegate.h"
+#include "atom/app/atom_main_delegate.h"
 
 #include <iostream>
 #include <memory>
@@ -12,6 +12,13 @@
 #include <glib.h>  // for g_setenv()
 #endif
 
+#include "atom/app/atom_content_client.h"
+#include "atom/browser/atom_browser_client.h"
+#include "atom/browser/relauncher.h"
+#include "atom/common/options_switches.h"
+#include "atom/renderer/atom_renderer_client.h"
+#include "atom/renderer/atom_sandboxed_renderer_client.h"
+#include "atom/utility/atom_content_utility_client.h"
 #include "base/command_line.h"
 #include "base/debug/stack_trace.h"
 #include "base/environment.h"
@@ -24,32 +31,23 @@
 #include "ipc/ipc_buildflags.h"
 #include "services/service_manager/embedder/switches.h"
 #include "services/service_manager/sandbox/switches.h"
-#include "services/tracing/public/cpp/stack_sampling/tracing_sampler_profiler.h"
-#include "shell/app/electron_content_client.h"
-#include "shell/browser/electron_browser_client.h"
-#include "shell/browser/electron_gpu_client.h"
-#include "shell/browser/feature_list.h"
-#include "shell/browser/relauncher.h"
-#include "shell/common/options_switches.h"
-#include "shell/renderer/electron_renderer_client.h"
-#include "shell/renderer/electron_sandboxed_renderer_client.h"
-#include "shell/utility/electron_content_utility_client.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_switches.h"
 
+#if BUILDFLAG(IPC_MESSAGE_LOG_ENABLED)
+#define IPC_MESSAGE_MACROS_LOG_ENABLED
+#include "content/public/common/content_ipc_logging.h"
+#define IPC_LOG_TABLE_ADD_ENTRY(msg_id, logger) \
+  content::RegisterIPCLogger(msg_id, logger)
+#include "atom/common/common_message_generator.h"
+#endif
+
 #if defined(OS_MACOSX)
-#include "shell/app/electron_main_delegate_mac.h"
+#include "atom/app/atom_main_delegate_mac.h"
 #endif
 
-#if defined(OS_WIN)
-#include "base/win/win_util.h"
-#if defined(_WIN64)
-#include "shell/common/crash_reporter/crash_reporter_win.h"
-#endif
-#endif
-
-namespace electron {
+namespace atom {
 
 namespace {
 
@@ -60,11 +58,6 @@ bool IsBrowserProcess(base::CommandLine* cmd) {
   return process_type.empty();
 }
 
-bool IsSandboxEnabled(base::CommandLine* command_line) {
-  return command_line->HasSwitch(switches::kEnableSandbox) ||
-         !command_line->HasSwitch(service_manager::switches::kNoSandbox);
-}
-
 // Returns true if this subprocess type needs the ResourceBundle initialized
 // and resources loaded.
 bool SubprocessNeedsResourceBundle(const std::string& process_type) {
@@ -127,19 +120,15 @@ void LoadResourceBundle(const std::string& locale) {
 #endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
 }
 
-ElectronMainDelegate::ElectronMainDelegate() = default;
+AtomMainDelegate::AtomMainDelegate() {}
 
-ElectronMainDelegate::~ElectronMainDelegate() = default;
+AtomMainDelegate::~AtomMainDelegate() {}
 
-bool ElectronMainDelegate::BasicStartupComplete(int* exit_code) {
+bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
   auto* command_line = base::CommandLine::ForCurrentProcess();
 
   logging::LoggingSettings settings;
 #if defined(OS_WIN)
-#if defined(_WIN64)
-  crash_reporter::CrashReporterWin::SetUnhandledExceptionFilter();
-#endif
-
   // On Windows the terminal returns immediately, so we add a new line to
   // prevent output in the same line as the prompt.
   if (IsBrowserProcess(command_line))
@@ -147,19 +136,14 @@ bool ElectronMainDelegate::BasicStartupComplete(int* exit_code) {
 #if defined(DEBUG)
   // Print logging to debug.log on Windows
   settings.logging_dest = logging::LOG_TO_ALL;
-  base::FilePath log_filename;
-  base::PathService::Get(base::DIR_EXE, &log_filename);
-  log_filename = log_filename.AppendASCII("debug.log");
-  settings.log_file_path = log_filename.value().c_str();
+  settings.log_file = L"debug.log";
   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 | logging::LOG_TO_STDERR;
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 #endif  // defined(DEBUG)
 #else   // defined(OS_WIN)
-  settings.logging_dest =
-      logging::LOG_TO_SYSTEM_DEBUG_LOG | logging::LOG_TO_STDERR;
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 #endif  // !defined(OS_WIN)
 
   // Only enable logging when --enable-logging is specified.
@@ -183,9 +167,6 @@ bool ElectronMainDelegate::BasicStartupComplete(int* exit_code) {
   if (env->HasVar("ELECTRON_DISABLE_SANDBOX"))
     command_line->AppendSwitch(service_manager::switches::kNoSandbox);
 
-  tracing_sampler_profiler_ =
-      tracing::TracingSamplerProfiler::CreateOnMainThread();
-
   chrome::RegisterPathProvider();
 
 #if defined(OS_MACOSX)
@@ -200,41 +181,15 @@ bool ElectronMainDelegate::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
 
-#if defined(OS_LINUX)
-  // Check for --no-sandbox parameter when running as root.
-  if (getuid() == 0 && IsSandboxEnabled(command_line))
-    LOG(FATAL) << "Running as root without --"
-               << service_manager::switches::kNoSandbox
-               << " is not supported. See https://crbug.com/638180.";
-#endif
-
-#if defined(MAS_BUILD)
-  // In MAS build we are using --disable-remote-core-animation.
-  //
-  // According to ccameron:
-  // If you're running with --disable-remote-core-animation, you may want to
-  // also run with --disable-gpu-memory-buffer-compositor-resources as well.
-  // That flag makes it so we use regular GL textures instead of IOSurfaces
-  // for compositor resources. IOSurfaces are very heavyweight to
-  // create/destroy, but they can be displayed directly by CoreAnimation (and
-  // --disable-remote-core-animation makes it so we don't use this property,
-  // so they're just heavyweight with no upside).
-  command_line->AppendSwitch(
-      ::switches::kDisableGpuMemoryBufferCompositorResources);
-#endif
-
-  content_client_ = std::make_unique<ElectronContentClient>();
+  content_client_ = std::make_unique<AtomContentClient>();
   SetContentClient(content_client_.get());
 
   return false;
 }
 
-void ElectronMainDelegate::PostEarlyInitialization(bool is_running_tests) {
+void AtomMainDelegate::PostEarlyInitialization(bool is_running_tests) {
   std::string custom_locale;
   ui::ResourceBundle::InitSharedInstanceWithLocale(
       custom_locale, nullptr, ui::ResourceBundle::LOAD_COMMON_RESOURCES);
@@ -242,7 +197,7 @@ void ElectronMainDelegate::PostEarlyInitialization(bool is_running_tests) {
   if (cmd_line->HasSwitch(::switches::kLang)) {
     const std::string locale = cmd_line->GetSwitchValueASCII(::switches::kLang);
     const base::FilePath locale_file_path =
-        ui::ResourceBundle::GetSharedInstance().GetLocaleFilePath(locale);
+        ui::ResourceBundle::GetSharedInstance().GetLocaleFilePath(locale, true);
     if (!locale_file_path.empty()) {
       custom_locale = locale;
 #if defined(OS_LINUX)
@@ -260,11 +215,11 @@ void ElectronMainDelegate::PostEarlyInitialization(bool is_running_tests) {
 
   LoadResourceBundle(custom_locale);
 
-  ElectronBrowserClient::SetApplicationLocale(
+  AtomBrowserClient::SetApplicationLocale(
       l10n_util::GetApplicationLocale(custom_locale));
 }
 
-void ElectronMainDelegate::PreSandboxStartup() {
+void AtomMainDelegate::PreSandboxStartup() {
   auto* command_line = base::CommandLine::ForCurrentProcess();
 
   std::string process_type =
@@ -291,47 +246,37 @@ void ElectronMainDelegate::PreSandboxStartup() {
 #endif
 }
 
-void ElectronMainDelegate::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();
+void AtomMainDelegate::PreCreateMainMessageLoop() {
 #if defined(OS_MACOSX)
   RegisterAtomCrApp();
 #endif
 }
 
-content::ContentBrowserClient*
-ElectronMainDelegate::CreateContentBrowserClient() {
-  browser_client_ = std::make_unique<ElectronBrowserClient>();
+content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
+  browser_client_.reset(new AtomBrowserClient);
   return browser_client_.get();
 }
 
-content::ContentGpuClient* ElectronMainDelegate::CreateContentGpuClient() {
-  gpu_client_ = std::make_unique<ElectronGpuClient>();
-  return gpu_client_.get();
-}
-
 content::ContentRendererClient*
-ElectronMainDelegate::CreateContentRendererClient() {
-  auto* command_line = base::CommandLine::ForCurrentProcess();
-
-  if (IsSandboxEnabled(command_line)) {
-    renderer_client_ = std::make_unique<ElectronSandboxedRendererClient>();
+AtomMainDelegate::CreateContentRendererClient() {
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableSandbox) ||
+      !base::CommandLine::ForCurrentProcess()->HasSwitch(
+          service_manager::switches::kNoSandbox)) {
+    renderer_client_.reset(new AtomSandboxedRendererClient);
   } else {
-    renderer_client_ = std::make_unique<ElectronRendererClient>();
+    renderer_client_.reset(new AtomRendererClient);
   }
 
   return renderer_client_.get();
 }
 
-content::ContentUtilityClient*
-ElectronMainDelegate::CreateContentUtilityClient() {
-  utility_client_ = std::make_unique<ElectronContentUtilityClient>();
+content::ContentUtilityClient* AtomMainDelegate::CreateContentUtilityClient() {
+  utility_client_.reset(new AtomContentUtilityClient);
   return utility_client_.get();
 }
 
-int ElectronMainDelegate::RunProcess(
+int AtomMainDelegate::RunProcess(
     const std::string& process_type,
     const content::MainFunctionParams& main_function_params) {
   if (process_type == kRelauncherProcess)
@@ -341,18 +286,22 @@ int ElectronMainDelegate::RunProcess(
 }
 
 #if defined(OS_MACOSX)
-bool ElectronMainDelegate::DelaySandboxInitialization(
+bool AtomMainDelegate::ShouldSendMachPort(const std::string& process_type) {
+  return process_type != kRelauncherProcess;
+}
+
+bool AtomMainDelegate::DelaySandboxInitialization(
     const std::string& process_type) {
   return process_type == kRelauncherProcess;
 }
 #endif
 
-bool ElectronMainDelegate::ShouldLockSchemeRegistry() {
+bool AtomMainDelegate::ShouldLockSchemeRegistry() {
   return false;
 }
 
-bool ElectronMainDelegate::ShouldCreateFeatureList() {
+bool AtomMainDelegate::ShouldCreateFeatureList() {
   return false;
 }
 
-}  // namespace electron
+}  // namespace atom

atom/app/atom_main_delegate.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_APP_ELECTRON_MAIN_DELEGATE_H_
-#define SHELL_APP_ELECTRON_MAIN_DELEGATE_H_
+#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_H_
+#define ATOM_APP_ATOM_MAIN_DELEGATE_H_
 
 #include <memory>
 #include <string>
@@ -11,18 +11,14 @@
 #include "content/public/app/content_main_delegate.h"
 #include "content/public/common/content_client.h"
 
-namespace tracing {
-class TracingSamplerProfiler;
-}
-
-namespace electron {
+namespace atom {
 
 void LoadResourceBundle(const std::string& locale);
 
-class ElectronMainDelegate : public content::ContentMainDelegate {
+class AtomMainDelegate : public content::ContentMainDelegate {
  public:
-  ElectronMainDelegate();
-  ~ElectronMainDelegate() override;
+  AtomMainDelegate();
+  ~AtomMainDelegate() override;
 
  protected:
   // content::ContentMainDelegate:
@@ -31,13 +27,13 @@ class ElectronMainDelegate : 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(
       const std::string& process_type,
       const content::MainFunctionParams& main_function_params) override;
 #if defined(OS_MACOSX)
+  bool ShouldSendMachPort(const std::string& process_type) override;
   bool DelaySandboxInitialization(const std::string& process_type) override;
 #endif
   bool ShouldLockSchemeRegistry() override;
@@ -52,14 +48,12 @@ class ElectronMainDelegate : 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_;
-  std::unique_ptr<tracing::TracingSamplerProfiler> tracing_sampler_profiler_;
 
-  DISALLOW_COPY_AND_ASSIGN(ElectronMainDelegate);
+  DISALLOW_COPY_AND_ASSIGN(AtomMainDelegate);
 };
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_APP_ELECTRON_MAIN_DELEGATE_H_
+#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_H_

atom/app/atom_main_delegate_mac.h

@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_APP_ELECTRON_MAIN_DELEGATE_MAC_H_
-#define SHELL_APP_ELECTRON_MAIN_DELEGATE_MAC_H_
+#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_MAC_H_
+#define ATOM_APP_ATOM_MAIN_DELEGATE_MAC_H_
 
-namespace electron {
+namespace atom {
 
 // Initializes NSApplication.
 void RegisterAtomCrApp();
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_APP_ELECTRON_MAIN_DELEGATE_MAC_H_
+#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_MAC_H_

atom/app/atom_main_delegate_mac.mm

@@ -2,10 +2,11 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/app/electron_main_delegate.h"
-
-#include <string>
+#include "atom/app/atom_main_delegate.h"
 
+#include "atom/browser/mac/atom_application.h"
+#include "atom/common/application_info.h"
+#include "atom/common/mac/main_application_bundle.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/mac/bundle_locations.h"
@@ -13,13 +14,9 @@
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/path_service.h"
 #include "base/strings/sys_string_conversions.h"
-#include "content/common/mac_helpers.h"
 #include "content/public/common/content_paths.h"
-#include "shell/browser/mac/electron_application.h"
-#include "shell/common/application_info.h"
-#include "shell/common/mac/main_application_bundle.h"
 
-namespace electron {
+namespace atom {
 
 namespace {
 
@@ -29,39 +26,23 @@ base::FilePath GetFrameworksPath() {
 
 base::FilePath GetHelperAppPath(const base::FilePath& frameworks_path,
                                 const std::string& name) {
-  // Figure out what helper we are running
-  base::FilePath path;
-  base::PathService::Get(base::FILE_EXE, &path);
-
-  std::string helper_name = "Helper";
-  if (base::EndsWith(path.value(), content::kMacHelperSuffix_renderer,
-                     base::CompareCase::SENSITIVE)) {
-    helper_name += content::kMacHelperSuffix_renderer;
-  } else if (base::EndsWith(path.value(), content::kMacHelperSuffix_gpu,
-                            base::CompareCase::SENSITIVE)) {
-    helper_name += content::kMacHelperSuffix_gpu;
-  } else if (base::EndsWith(path.value(), content::kMacHelperSuffix_plugin,
-                            base::CompareCase::SENSITIVE)) {
-    helper_name += content::kMacHelperSuffix_plugin;
-  }
-
-  return frameworks_path.Append(name + " " + helper_name + ".app")
+  return frameworks_path.Append(name + " Helper.app")
       .Append("Contents")
       .Append("MacOS")
-      .Append(name + " " + helper_name);
+      .Append(name + " Helper");
 }
 
 }  // namespace
 
-void ElectronMainDelegate::OverrideFrameworkBundlePath() {
+void AtomMainDelegate::OverrideFrameworkBundlePath() {
   base::mac::SetOverrideFrameworkBundlePath(
-      GetFrameworksPath().Append(ELECTRON_PRODUCT_NAME " Framework.framework"));
+      GetFrameworksPath().Append(ATOM_PRODUCT_NAME " Framework.framework"));
 }
 
-void ElectronMainDelegate::OverrideChildProcessPath() {
+void AtomMainDelegate::OverrideChildProcessPath() {
   base::FilePath frameworks_path = GetFrameworksPath();
   base::FilePath helper_path =
-      GetHelperAppPath(frameworks_path, ELECTRON_PRODUCT_NAME);
+      GetHelperAppPath(frameworks_path, ATOM_PRODUCT_NAME);
   if (!base::PathExists(helper_path))
     helper_path = GetHelperAppPath(frameworks_path, GetApplicationName());
   if (!base::PathExists(helper_path))
@@ -69,7 +50,7 @@ void ElectronMainDelegate::OverrideChildProcessPath() {
   base::PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
 }
 
-void ElectronMainDelegate::SetUpBundleOverrides() {
+void AtomMainDelegate::SetUpBundleOverrides() {
   base::mac::ScopedNSAutoreleasePool pool;
   NSBundle* bundle = MainApplicationBundle();
   std::string base_bundle_id =
@@ -85,4 +66,4 @@ void RegisterAtomCrApp() {
   [AtomApplication sharedApplication];
 }
 
-}  // namespace electron
+}  // namespace atom

atom/app/command_line_args.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/app/command_line_args.h"
+#include "atom/app/command_line_args.h"
 
 namespace {
 
@@ -33,7 +33,7 @@ bool IsUrlArg(const base::CommandLine::CharType* arg) {
 
 }  // namespace
 
-namespace electron {
+namespace atom {
 
 bool CheckCommandLineArguments(int argc, base::CommandLine::CharType** argv) {
   const base::CommandLine::StringType dashdash(2, '-');
@@ -50,4 +50,4 @@ bool CheckCommandLineArguments(int argc, base::CommandLine::CharType** argv) {
   return true;
 }
 
-}  // namespace electron
+}  // namespace atom

atom/app/command_line_args.h

@@ -2,15 +2,15 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_APP_COMMAND_LINE_ARGS_H_
-#define SHELL_APP_COMMAND_LINE_ARGS_H_
+#ifndef ATOM_APP_COMMAND_LINE_ARGS_H_
+#define ATOM_APP_COMMAND_LINE_ARGS_H_
 
 #include "base/command_line.h"
 
-namespace electron {
+namespace atom {
 
 bool CheckCommandLineArguments(int argc, base::CommandLine::CharType** argv);
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_APP_COMMAND_LINE_ARGS_H_
+#endif  // ATOM_APP_COMMAND_LINE_ARGS_H_

atom/app/manifests.cc

@@ -0,0 +1,49 @@
+// 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/app/manifests.h"
+
+#include "base/no_destructor.h"
+#include "electron/atom/common/api/api.mojom.h"
+#include "printing/buildflags/buildflags.h"
+#include "services/proxy_resolver/public/cpp/manifest.h"
+#include "services/service_manager/public/cpp/manifest_builder.h"
+
+#if BUILDFLAG(ENABLE_PRINTING)
+#include "components/services/pdf_compositor/public/cpp/manifest.h"
+#endif
+
+#if BUILDFLAG(ENABLE_PRINT_PREVIEW)
+#include "chrome/services/printing/public/cpp/manifest.h"
+#endif
+
+const service_manager::Manifest& GetElectronContentBrowserOverlayManifest() {
+  static base::NoDestructor<service_manager::Manifest> manifest{
+      service_manager::ManifestBuilder()
+          .WithDisplayName("Electron (browser process)")
+          .RequireCapability("device", "device:geolocation_control")
+          .RequireCapability("proxy_resolver", "factory")
+          .RequireCapability("chrome_printing", "converter")
+          .RequireCapability("pdf_compositor", "compositor")
+          .ExposeInterfaceFilterCapability_Deprecated(
+              "navigation:frame", "renderer",
+              service_manager::Manifest::InterfaceList<
+                  atom::mojom::ElectronBrowser>())
+          .Build()};
+  return *manifest;
+}
+
+const std::vector<service_manager::Manifest>&
+GetElectronPackagedServicesOverlayManifest() {
+  static base::NoDestructor<std::vector<service_manager::Manifest>> manifests{{
+      proxy_resolver::GetManifest(),
+#if BUILDFLAG(ENABLE_PRINTING)
+      printing::GetPdfCompositorManifest(),
+#endif
+#if BUILDFLAG(ENABLE_PRINT_PREVIEW)
+      GetChromePrintingManifest(),
+#endif
+  }};
+  return *manifests;
+}

atom/app/manifests.h

@@ -1,14 +1,16 @@
-// 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 SHELL_APP_MANIFESTS_H_
-#define SHELL_APP_MANIFESTS_H_
-
-#include <vector>
-
-#include "services/service_manager/public/cpp/manifest.h"
-
-const service_manager::Manifest& GetElectronContentBrowserOverlayManifest();
-
-#endif  // SHELL_APP_MANIFESTS_H_
+// 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_APP_MANIFESTS_H_
+#define ATOM_APP_MANIFESTS_H_
+
+#include <vector>
+
+#include "services/service_manager/public/cpp/manifest.h"
+
+const service_manager::Manifest& GetElectronContentBrowserOverlayManifest();
+const std::vector<service_manager::Manifest>&
+GetElectronPackagedServicesOverlayManifest();
+
+#endif  // ATOM_APP_MANIFESTS_H_

atom/app/node_main.cc

@@ -2,55 +2,30 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/app/node_main.h"
+#include "atom/app/node_main.h"
 
 #include <memory>
-#include <string>
 #include <utility>
 
+#include "atom/app/uv_task_runner.h"
+#include "atom/browser/javascript_environment.h"
+#include "atom/browser/node_debugger.h"
+#include "atom/common/api/electron_bindings.h"
+#include "atom/common/atom_version.h"
+#include "atom/common/crash_reporter/crash_reporter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_bindings.h"
+#include "atom/common/node_includes.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
-#include "base/task/thread_pool/thread_pool_instance.h"
+#include "base/task/thread_pool/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "electron/electron_version.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/v8_initializer.h"
-#include "shell/app/uv_task_runner.h"
-#include "shell/browser/javascript_environment.h"
-#include "shell/browser/node_debugger.h"
-#include "shell/common/api/electron_bindings.h"
-#include "shell/common/crash_reporter/crash_reporter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/node_bindings.h"
-#include "shell/common/node_includes.h"
+#include "native_mate/dictionary.h"
 
-#if defined(_WIN64)
-#include "shell/common/crash_reporter/crash_reporter_win.h"
-#endif
-
-namespace {
-
-bool AllowWasmCodeGenerationCallback(v8::Local<v8::Context> context,
-                                     v8::Local<v8::String>) {
-  v8::Local<v8::Value> wasm_code_gen = context->GetEmbedderData(
-      node::ContextEmbedderIndex::kAllowWasmCodeGeneration);
-  return wasm_code_gen->IsUndefined() || wasm_code_gen->IsTrue();
-}
-
-}  // namespace
-
-namespace electron {
-
-#if !defined(OS_LINUX)
-void AddExtraParameter(const std::string& key, const std::string& value) {
-  crash_reporter::CrashReporter::GetInstance()->AddExtraParameter(key, value);
-}
-
-void RemoveExtraParameter(const std::string& key) {
-  crash_reporter::CrashReporter::GetInstance()->RemoveExtraParameter(key);
-}
-#endif
+namespace atom {
 
 int NodeMain(int argc, char* argv[]) {
   base::CommandLine::Init(argc, argv);
@@ -68,9 +43,15 @@ int NodeMain(int argc, char* argv[]) {
     feature_list->InitializeFromCommandLine("", "");
     base::FeatureList::SetInstance(std::move(feature_list));
 
-#if defined(_WIN64)
-    crash_reporter::CrashReporterWin::SetUnhandledExceptionFilter();
-#endif
+    gin::V8Initializer::LoadV8Snapshot(
+        gin::V8Initializer::V8SnapshotFileType::kWithAdditionalContext);
+    gin::V8Initializer::LoadV8Natives();
+
+    // V8 requires a task scheduler apparently
+    base::ThreadPool::CreateAndStartWithDefaultParams("Electron");
+
+    // Initialize gin::IsolateHolder.
+    JavascriptEnvironment gin_env(loop);
 
     // Explicitly register electron's builtin modules.
     NodeBindings::RegisterBuiltinModules();
@@ -79,59 +60,32 @@ int NodeMain(int argc, char* argv[]) {
     const char** exec_argv;
     node::Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv);
 
-    gin::V8Initializer::LoadV8Snapshot(
-        gin::V8Initializer::V8SnapshotFileType::kWithAdditionalContext);
-
-    // V8 requires a task scheduler apparently
-    base::ThreadPoolInstance::CreateAndStartWithDefaultParams("Electron");
-
-    // Initialize gin::IsolateHolder.
-    JavascriptEnvironment gin_env(loop);
-    gin_env.isolate()->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
-
-    node::IsolateData* isolate_data =
-        node::CreateIsolateData(gin_env.isolate(), loop, gin_env.platform());
-    CHECK_NE(nullptr, isolate_data);
-
     node::Environment* env = node::CreateEnvironment(
-        isolate_data, gin_env.context(), argc, argv, exec_argc, exec_argv);
-    CHECK_NE(nullptr, env);
+        node::CreateIsolateData(gin_env.isolate(), loop, gin_env.platform()),
+        gin_env.context(), argc, argv, exec_argc, exec_argv);
 
     // Enable support for v8 inspector.
     NodeDebugger node_debugger(env);
     node_debugger.Start();
 
-    gin_helper::Dictionary process(gin_env.isolate(), env->process_object());
-
-    gin_env.isolate()->SetAllowWasmCodeGenerationCallback(
-        AllowWasmCodeGenerationCallback);
-
+    mate::Dictionary process(gin_env.isolate(), env->process_object());
 #if defined(OS_WIN)
     process.SetMethod("log", &ElectronBindings::Log);
 #endif
     process.SetMethod("crash", &ElectronBindings::Crash);
 
     // Setup process.crashReporter.start in child node processes
-    gin_helper::Dictionary reporter =
-        gin::Dictionary::CreateEmpty(gin_env.isolate());
+    auto reporter = mate::Dictionary::CreateEmpty(gin_env.isolate());
     reporter.SetMethod("start", &crash_reporter::CrashReporter::StartInstance);
-
-#if !defined(OS_LINUX)
-    reporter.SetMethod("addExtraParameter", &AddExtraParameter);
-    reporter.SetMethod("removeExtraParameter", &RemoveExtraParameter);
-#endif
-
     process.Set("crashReporter", reporter);
 
-    gin_helper::Dictionary versions;
+    mate::Dictionary versions;
     if (process.Get("versions", &versions)) {
-      versions.SetReadOnly(ELECTRON_PROJECT_NAME, ELECTRON_VERSION_STRING);
+      versions.SetReadOnly(ATOM_PROJECT_NAME, ATOM_VERSION_STRING);
     }
 
     node::LoadEnvironment(env);
 
-    env->set_trace_sync_io(env->options()->trace_sync_io);
-
     bool more;
     do {
       more = uv_run(env->event_loop(), UV_RUN_ONCE);
@@ -148,20 +102,13 @@ int NodeMain(int argc, char* argv[]) {
     } while (more == true);
 
     node_debugger.Stop();
-
-    env->set_trace_sync_io(false);
-
     exit_code = node::EmitExit(env);
-    node::Stop(env);
     node::RunAtExit(env);
+    gin_env.platform()->DrainTasks(env->isolate());
+    gin_env.platform()->CancelPendingDelayedTasks(env->isolate());
+    gin_env.platform()->UnregisterIsolate(env->isolate());
 
-    v8::Isolate* isolate = env->isolate();
     node::FreeEnvironment(env);
-    node::FreeIsolateData(isolate_data);
-
-    gin_env.platform()->DrainTasks(isolate);
-    gin_env.platform()->CancelPendingDelayedTasks(isolate);
-    gin_env.platform()->UnregisterIsolate(isolate);
   }
 
   // According to "src/gin/shell/gin_main.cc":
@@ -169,11 +116,11 @@ int NodeMain(int argc, char* argv[]) {
   // 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::ThreadPoolInstance::Get()->Shutdown();
+  base::ThreadPool::GetInstance()->Shutdown();
 
   v8::V8::Dispose();
 
   return exit_code;
 }
 
-}  // namespace electron
+}  // namespace atom

atom/app/node_main.h

@@ -2,13 +2,13 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_APP_NODE_MAIN_H_
-#define SHELL_APP_NODE_MAIN_H_
+#ifndef ATOM_APP_NODE_MAIN_H_
+#define ATOM_APP_NODE_MAIN_H_
 
-namespace electron {
+namespace atom {
 
 int NodeMain(int argc, char* argv[]);
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_APP_NODE_MAIN_H_
+#endif  // ATOM_APP_NODE_MAIN_H_

atom/app/resources/mac/loginhelper-Info.plist

@@ -3,7 +3,7 @@
 <plist version="1.0">
 <dict>
 	<key>CFBundleIdentifier</key>
-	<string>${ELECTRON_BUNDLE_ID}</string>
+	<string>${ATOM_BUNDLE_ID}</string>
 	<key>CFBundleName</key>
 	<string>${PRODUCT_NAME}</string>
 	<key>CFBundleExecutable</key>
@@ -12,7 +12,5 @@
 	<string>APPL</string>
 	<key>LSBackgroundOnly</key>
 	<true/>
-	<key>LSRequiresNativeExecution</key>
-	<true/>
 </dict>
 </plist>

atom/app/uv_task_runner.cc

@@ -4,11 +4,11 @@
 
 #include <utility>
 
-#include "shell/app/uv_task_runner.h"
+#include "atom/app/uv_task_runner.h"
 
 #include "base/stl_util.h"
 
-namespace electron {
+namespace atom {
 
 UvTaskRunner::UvTaskRunner(uv_loop_t* loop) : loop_(loop) {}
 
@@ -42,13 +42,12 @@ bool UvTaskRunner::PostNonNestableDelayedTask(const base::Location& from_here,
 
 // static
 void UvTaskRunner::OnTimeout(uv_timer_t* timer) {
-  auto& tasks = static_cast<UvTaskRunner*>(timer->data)->tasks_;
-  const auto iter = tasks.find(timer);
-  if (iter == std::end(tasks))
+  UvTaskRunner* self = static_cast<UvTaskRunner*>(timer->data);
+  if (!ContainsKey(self->tasks_, timer))
     return;
 
-  std::move(iter->second).Run();
-  tasks.erase(iter);
+  std::move(self->tasks_[timer]).Run();
+  self->tasks_.erase(timer);
   uv_timer_stop(timer);
   uv_close(reinterpret_cast<uv_handle_t*>(timer), UvTaskRunner::OnClose);
 }
@@ -58,4 +57,4 @@ void UvTaskRunner::OnClose(uv_handle_t* handle) {
   delete reinterpret_cast<uv_timer_t*>(handle);
 }
 
-}  // namespace electron
+}  // namespace atom

atom/app/uv_task_runner.h

@@ -2,17 +2,17 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_APP_UV_TASK_RUNNER_H_
-#define SHELL_APP_UV_TASK_RUNNER_H_
+#ifndef ATOM_APP_UV_TASK_RUNNER_H_
+#define ATOM_APP_UV_TASK_RUNNER_H_
 
 #include <map>
 
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
-#include "uv.h"  // NOLINT(build/include_directory)
+#include "uv.h"  // NOLINT(build/include)
 
-namespace electron {
+namespace atom {
 
 // TaskRunner implementation that posts tasks into libuv's default loop.
 class UvTaskRunner : public base::SingleThreadTaskRunner {
@@ -40,6 +40,6 @@ class UvTaskRunner : public base::SingleThreadTaskRunner {
   DISALLOW_COPY_AND_ASSIGN(UvTaskRunner);
 };
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_APP_UV_TASK_RUNNER_H_
+#endif  // ATOM_APP_UV_TASK_RUNNER_H_

atom/browser/api/atom_api_app.cc

@@ -2,19 +2,35 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_app.h"
-
-#include <memory>
+#include "atom/browser/api/atom_api_app.h"
 
 #include <string>
 #include <vector>
 
-#include "base/callback_helpers.h"
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/api/atom_api_session.h"
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/api/gpuinfo_manager.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/atom_paths.h"
+#include "atom/browser/login_handler.h"
+#include "atom/browser/relauncher.h"
+#include "atom/common/application_info.h"
+#include "atom/common/atom_command_line.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/file_path_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/net_converter.h"
+#include "atom/common/native_mate_converters/network_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/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
-#include "base/optional.h"
 #include "base/path_service.h"
 #include "base/system/sys_info.h"
 #include "chrome/browser/browser_process.h"
@@ -29,70 +45,29 @@
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/content_switches.h"
-#include "gin/arguments.h"
 #include "media/audio/audio_manager.h"
-#include "native_mate/object_template_builder_deprecated.h"
+#include "native_mate/object_template_builder.h"
 #include "net/ssl/client_cert_identity.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "services/service_manager/sandbox/switches.h"
-#include "shell/browser/api/electron_api_menu.h"
-#include "shell/browser/api/electron_api_session.h"
-#include "shell/browser/api/electron_api_web_contents.h"
-#include "shell/browser/api/gpuinfo_manager.h"
-#include "shell/browser/electron_browser_context.h"
-#include "shell/browser/electron_browser_main_parts.h"
-#include "shell/browser/electron_paths.h"
-#include "shell/browser/login_handler.h"
-#include "shell/browser/relauncher.h"
-#include "shell/common/application_info.h"
-#include "shell/common/electron_command_line.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
-#include "shell/common/native_mate_converters/file_path_converter.h"
-#include "shell/common/native_mate_converters/gurl_converter.h"
-#include "shell/common/native_mate_converters/image_converter.h"
-#include "shell/common/native_mate_converters/net_converter.h"
-#include "shell/common/native_mate_converters/network_converter.h"
-#include "shell/common/native_mate_converters/once_callback.h"
-#include "shell/common/native_mate_converters/value_converter.h"
-#include "shell/common/node_includes.h"
-#include "shell/common/options_switches.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image.h"
 
 #if defined(OS_WIN)
+#include "atom/browser/ui/win/jump_list.h"
 #include "base/strings/utf_string_conversions.h"
-#include "shell/browser/ui/win/jump_list.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
-#include "shell/browser/ui/cocoa/electron_bundle_mover.h"
+#include "atom/browser/ui/cocoa/atom_bundle_mover.h"
 #endif
 
-using electron::Browser;
+using atom::Browser;
 
 namespace mate {
 
 #if defined(OS_WIN)
-template <>
-struct Converter<electron::ProcessIntegrityLevel> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   electron::ProcessIntegrityLevel value) {
-    switch (value) {
-      case electron::ProcessIntegrityLevel::Untrusted:
-        return mate::StringToV8(isolate, "untrusted");
-      case electron::ProcessIntegrityLevel::Low:
-        return mate::StringToV8(isolate, "low");
-      case electron::ProcessIntegrityLevel::Medium:
-        return mate::StringToV8(isolate, "medium");
-      case electron::ProcessIntegrityLevel::High:
-        return mate::StringToV8(isolate, "high");
-      default:
-        return mate::StringToV8(isolate, "unknown");
-    }
-  }
-};
-
 template <>
 struct Converter<Browser::UserTask> {
   static bool FromV8(v8::Isolate* isolate,
@@ -109,14 +84,13 @@ struct Converter<Browser::UserTask> {
       return false;
     dict.Get("arguments", &(out->arguments));
     dict.Get("description", &(out->description));
-    dict.Get("workingDirectory", &(out->working_dir));
     return true;
   }
 };
 
-using electron::JumpListCategory;
-using electron::JumpListItem;
-using electron::JumpListResult;
+using atom::JumpListCategory;
+using atom::JumpListItem;
+using atom::JumpListResult;
 
 template <>
 struct Converter<JumpListItem::Type> {
@@ -183,7 +157,6 @@ 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:
@@ -210,7 +183,6 @@ 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:
@@ -379,12 +351,33 @@ struct Converter<content::CertificateRequestResultType> {
 
 }  // namespace mate
 
-namespace electron {
+namespace atom {
+
+ProcessMetric::ProcessMetric(int type,
+                             base::ProcessId pid,
+                             std::unique_ptr<base::ProcessMetrics> metrics) {
+  this->type = type;
+  this->pid = pid;
+  this->metrics = std::move(metrics);
+}
+
+ProcessMetric::~ProcessMetric() = default;
 
 namespace api {
 
 namespace {
 
+class AppIdProcessIterator : public base::ProcessIterator {
+ public:
+  AppIdProcessIterator() : base::ProcessIterator(nullptr) {}
+
+ protected:
+  bool IncludeEntry() override {
+    return (entry().parent_pid() == base::GetCurrentProcId() ||
+            entry().pid() == base::GetCurrentProcId());
+  }
+};
+
 IconLoader::IconSize GetIconSizeByString(const std::string& size) {
   if (size == "small") {
     return IconLoader::IconSize::SMALL;
@@ -433,7 +426,7 @@ int GetPathConstant(const std::string& name) {
 }
 
 bool NotificationCallbackWrapper(
-    const base::RepeatingCallback<
+    const base::Callback<
         void(const base::CommandLine::StringVector& command_line,
              const base::FilePath& current_directory)>& callback,
     const base::CommandLine::StringVector& cmd,
@@ -492,13 +485,22 @@ void OnClientCertificateSelected(
       if (cert->EqualsExcludingChain((*identities)[i]->certificate())) {
         net::ClientCertIdentity::SelfOwningAcquirePrivateKey(
             std::move((*identities)[i]),
-            base::BindRepeating(&GotPrivateKey, delegate, std::move(cert)));
+            base::Bind(&GotPrivateKey, delegate, std::move(cert)));
         break;
       }
     }
   }
 }
 
+void PassLoginInformation(scoped_refptr<LoginHandler> login_handler,
+                          mate::Arguments* args) {
+  base::string16 username, password;
+  if (args->GetNext(&username) && args->GetNext(&password))
+    login_handler->Login(username, password);
+  else
+    login_handler->CancelAuth();
+}
+
 #if defined(USE_NSS_CERTS)
 int ImportIntoCertStore(CertificateManagerModel* model,
                         const base::DictionaryValue& options) {
@@ -527,7 +529,7 @@ int ImportIntoCertStore(CertificateManagerModel* model,
 }
 #endif
 
-void OnIconDataAvailable(util::Promise<gfx::Image> promise, gfx::Image icon) {
+void OnIconDataAvailable(util::Promise promise, gfx::Image icon) {
   if (!icon.IsEmpty()) {
     promise.Resolve(icon);
   } else {
@@ -538,21 +540,20 @@ void OnIconDataAvailable(util::Promise<gfx::Image> promise, gfx::Image icon) {
 }  // namespace
 
 App::App(v8::Isolate* isolate) {
-  static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
-      ->set_delegate(this);
+  static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())->set_delegate(this);
   Browser::Get()->AddObserver(this);
   content::GpuDataManager::GetInstance()->AddObserver(this);
 
   base::ProcessId pid = base::GetCurrentProcId();
-  auto process_metric = std::make_unique<electron::ProcessMetric>(
-      content::PROCESS_TYPE_BROWSER, base::GetCurrentProcessHandle(),
+  auto process_metric = std::make_unique<atom::ProcessMetric>(
+      content::PROCESS_TYPE_BROWSER, pid,
       base::ProcessMetrics::CreateCurrentProcessMetrics());
   app_metrics_[pid] = std::move(process_metric);
   Init(isolate);
 }
 
 App::~App() {
-  static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
+  static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())
       ->set_delegate(nullptr);
   Browser::Get()->RemoveObserver(this);
   content::GpuDataManager::GetInstance()->RemoveObserver(this);
@@ -576,7 +577,7 @@ void App::OnWindowAllClosed() {
 }
 
 void App::OnQuit() {
-  int exitCode = ElectronBrowserMainParts::Get()->GetExitCode();
+  int exitCode = AtomBrowserMainParts::Get()->GetExitCode();
   Emit("quit", exitCode);
 
   if (process_singleton_) {
@@ -662,6 +663,24 @@ void App::OnNewWindowForTab() {
 }
 #endif
 
+void App::OnLogin(scoped_refptr<LoginHandler> login_handler,
+                  const base::DictionaryValue& request_details) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  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)));
+  }
+
+  // Default behavior is to always cancel the auth.
+  if (!prevent_default)
+    login_handler->CancelAuth();
+}
+
 bool App::CanCreateWindow(
     content::RenderFrameHost* opener,
     const GURL& opener_url,
@@ -699,23 +718,23 @@ void App::AllowCertificateError(
     int cert_error,
     const net::SSLInfo& ssl_info,
     const GURL& request_url,
-    bool is_main_frame_request,
+    content::ResourceType resource_type,
     bool strict_enforcement,
-    base::OnceCallback<void(content::CertificateRequestResultType)> callback) {
-  auto adapted_callback = base::AdaptCallbackForRepeating(std::move(callback));
+    bool expired_previous_decision,
+    const base::Callback<void(content::CertificateRequestResultType)>&
+        callback) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  bool prevent_default =
-      Emit("certificate-error",
-           WebContents::FromOrCreate(isolate(), web_contents), request_url,
-           net::ErrorToString(cert_error), ssl_info.cert, adapted_callback);
+  bool prevent_default = Emit(
+      "certificate-error", WebContents::FromOrCreate(isolate(), web_contents),
+      request_url, net::ErrorToString(cert_error), ssl_info.cert, callback);
 
   // Deny the certificate by default.
   if (!prevent_default)
-    adapted_callback.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
+    callback.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
 }
 
-base::OnceClosure App::SelectClientCertificate(
+void App::SelectClientCertificate(
     content::WebContents* web_contents,
     net::SSLCertRequestInfo* cert_request_info,
     net::ClientCertIdentityList identities,
@@ -727,7 +746,7 @@ base::OnceClosure App::SelectClientCertificate(
   // to avoid changes in the API.
   auto client_certs = net::CertificateList();
   for (const std::unique_ptr<net::ClientCertIdentity>& identity : identities)
-    client_certs.emplace_back(identity->certificate());
+    client_certs.push_back(identity->certificate());
 
   auto shared_identities =
       std::make_shared<net::ClientCertIdentityList>(std::move(identities));
@@ -736,8 +755,8 @@ base::OnceClosure App::SelectClientCertificate(
       Emit("select-client-certificate",
            WebContents::FromOrCreate(isolate(), web_contents),
            cert_request_info->host_and_port.ToString(), std::move(client_certs),
-           base::BindOnce(&OnClientCertificateSelected, isolate(),
-                          shared_delegate, shared_identities));
+           base::Bind(&OnClientCertificateSelected, isolate(), shared_delegate,
+                      shared_identities));
 
   // Default to first certificate from the platform store.
   if (!prevent_default) {
@@ -745,13 +764,8 @@ base::OnceClosure App::SelectClientCertificate(
         (*shared_identities)[0]->certificate();
     net::ClientCertIdentity::SelfOwningAcquirePrivateKey(
         std::move((*shared_identities)[0]),
-        base::BindRepeating(&GotPrivateKey, shared_delegate, std::move(cert)));
+        base::Bind(&GotPrivateKey, shared_delegate, std::move(cert)));
   }
-  return base::OnceClosure();
-}
-
-void App::OnGpuInfoUpdate() {
-  Emit("gpu-info-update");
 }
 
 void App::OnGpuProcessCrashed(base::TerminationStatus status) {
@@ -784,14 +798,6 @@ void App::BrowserChildProcessKilled(
 void App::RenderProcessReady(content::RenderProcessHost* host) {
   ChildProcessLaunched(content::PROCESS_TYPE_RENDERER,
                        host->GetProcess().Handle());
-
-  // TODO(jeremy): this isn't really the right place to be creating
-  // `WebContents` instances, but this was implicitly happening before in
-  // `RenderProcessPreferences`, so this is at least more explicit...
-  content::WebContents* web_contents =
-      ElectronBrowserClient::Get()->GetWebContentsFromProcessID(host->GetID());
-  if (web_contents)
-    WebContents::FromOrCreate(v8::Isolate::GetCurrent(), web_contents);
 }
 
 void App::RenderProcessDisconnected(base::ProcessId host_pid) {
@@ -802,13 +808,15 @@ void App::ChildProcessLaunched(int process_type, base::ProcessHandle handle) {
   auto pid = base::GetProcId(handle);
 
 #if defined(OS_MACOSX)
-  auto metrics = base::ProcessMetrics::CreateProcessMetrics(
-      handle, content::BrowserChildProcessHost::GetPortProvider());
+  std::unique_ptr<base::ProcessMetrics> metrics(
+      base::ProcessMetrics::CreateProcessMetrics(
+          handle, content::BrowserChildProcessHost::GetPortProvider()));
 #else
-  auto metrics = base::ProcessMetrics::CreateProcessMetrics(handle);
+  std::unique_ptr<base::ProcessMetrics> metrics(
+      base::ProcessMetrics::CreateProcessMetrics(handle));
 #endif
-  app_metrics_[pid] = std::make_unique<electron::ProcessMetric>(
-      process_type, handle, std::move(metrics));
+  app_metrics_[pid] = std::make_unique<atom::ProcessMetric>(process_type, pid,
+                                                            std::move(metrics));
 }
 
 void App::ChildProcessDisconnected(base::ProcessId pid) {
@@ -824,14 +832,14 @@ void App::SetAppPath(const base::FilePath& app_path) {
 }
 
 #if !defined(OS_MACOSX)
-void App::SetAppLogsPath(gin_helper::ErrorThrower thrower,
-                         base::Optional<base::FilePath> custom_path) {
-  if (custom_path.has_value()) {
-    if (!custom_path->IsAbsolute()) {
-      thrower.ThrowError("Path must be absolute");
+void App::SetAppLogsPath(mate::Arguments* args) {
+  base::FilePath custom_path;
+  if (args->GetNext(&custom_path)) {
+    if (!custom_path.IsAbsolute()) {
+      args->ThrowError("Path must be absolute");
       return;
     }
-    base::PathService::Override(DIR_APP_LOGS, custom_path.value());
+    base::PathService::Override(DIR_APP_LOGS, custom_path);
   } else {
     base::FilePath path;
     if (base::PathService::Get(DIR_USER_DATA, &path)) {
@@ -843,52 +851,32 @@ void App::SetAppLogsPath(gin_helper::ErrorThrower thrower,
 }
 #endif
 
-base::FilePath App::GetPath(gin_helper::ErrorThrower thrower,
-                            const std::string& name) {
+base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
   bool succeed = false;
   base::FilePath path;
-
   int key = GetPathConstant(name);
-  if (key >= 0) {
+  if (key >= 0)
     succeed = base::PathService::Get(key, &path);
-    // If users try to get the logs path before setting a logs path,
-    // set the path to a sensible default and then try to get it again
-    if (!succeed && name == "logs") {
-      base::ThreadRestrictions::ScopedAllowIO allow_io;
-      SetAppLogsPath(thrower, base::Optional<base::FilePath>());
-      succeed = base::PathService::Get(key, &path);
-    }
-  }
-
   if (!succeed)
-    thrower.ThrowError("Failed to get '" + name + "' path");
-
+    args->ThrowError("Failed to get '" + name + "' path");
   return path;
 }
 
-void App::SetPath(gin_helper::ErrorThrower thrower,
+void App::SetPath(mate::Arguments* args,
                   const std::string& name,
                   const base::FilePath& path) {
   if (!path.IsAbsolute()) {
-    thrower.ThrowError("Path must be absolute");
+    args->ThrowError("Path must be absolute");
     return;
   }
 
   bool succeed = false;
   int key = GetPathConstant(name);
-  if (key >= 0) {
+  if (key >= 0)
     succeed =
         base::PathService::OverrideAndCreateIfNeeded(key, path, true, false);
-    if (key == DIR_USER_DATA) {
-      succeed |= base::PathService::OverrideAndCreateIfNeeded(
-          chrome::DIR_USER_DATA, path, true, false);
-      succeed |= base::PathService::Override(
-          chrome::DIR_APP_DICTIONARIES,
-          path.Append(base::FilePath::FromUTF8Unsafe("Dictionaries")));
-    }
-  }
   if (!succeed)
-    thrower.ThrowError("Failed to set path");
+    args->ThrowError("Failed to set path");
 }
 
 void App::SetDesktopName(const std::string& desktop_name) {
@@ -925,9 +913,9 @@ std::string App::GetLocaleCountryCode() {
                      kCFStringEncodingUTF8);
   region = temporaryCString;
 #else
-  const char* locale_ptr = setlocale(LC_TIME, nullptr);
+  const char* locale_ptr = setlocale(LC_TIME, NULL);
   if (!locale_ptr)
-    locale_ptr = setlocale(LC_NUMERIC, nullptr);
+    locale_ptr = setlocale(LC_NUMERIC, NULL);
   if (locale_ptr) {
     std::string locale = locale_ptr;
     std::string::size_type rpos = locale.find('.');
@@ -959,10 +947,10 @@ bool App::RequestSingleInstanceLock() {
   base::FilePath user_dir;
   base::PathService::Get(DIR_USER_DATA, &user_dir);
 
-  auto cb = base::BindRepeating(&App::OnSecondInstance, base::Unretained(this));
+  auto cb = base::Bind(&App::OnSecondInstance, base::Unretained(this));
 
-  process_singleton_ = std::make_unique<ProcessSingleton>(
-      user_dir, base::BindRepeating(NotificationCallbackWrapper, cb));
+  process_singleton_.reset(new ProcessSingleton(
+      user_dir, base::Bind(NotificationCallbackWrapper, cb)));
 
   switch (process_singleton_->NotifyOtherProcessOrCreate()) {
     case ProcessSingleton::NotifyResult::LOCK_ERROR:
@@ -997,8 +985,7 @@ bool App::Relaunch(mate::Arguments* js_args) {
   }
 
   if (!override_argv) {
-    const relauncher::StringVector& argv =
-        electron::ElectronCommandLine::argv();
+    const relauncher::StringVector& argv = atom::AtomCommandLine::argv();
     return relauncher::RelaunchApp(argv);
   }
 
@@ -1018,9 +1005,9 @@ bool App::Relaunch(mate::Arguments* js_args) {
   return relauncher::RelaunchApp(argv);
 }
 
-void App::DisableHardwareAcceleration(gin_helper::ErrorThrower thrower) {
+void App::DisableHardwareAcceleration(mate::Arguments* args) {
   if (Browser::Get()->is_ready()) {
-    thrower.ThrowError(
+    args->ThrowError(
         "app.disableHardwareAcceleration() can only be called "
         "before app is ready");
     return;
@@ -1028,9 +1015,9 @@ void App::DisableHardwareAcceleration(gin_helper::ErrorThrower thrower) {
   content::GpuDataManager::GetInstance()->DisableHardwareAcceleration();
 }
 
-void App::DisableDomainBlockingFor3DAPIs(gin_helper::ErrorThrower thrower) {
+void App::DisableDomainBlockingFor3DAPIs(mate::Arguments* args) {
   if (Browser::Get()->is_ready()) {
-    thrower.ThrowError(
+    args->ThrowError(
         "app.disableDomainBlockingFor3DAPIs() can only be called "
         "before app is ready");
     return;
@@ -1044,10 +1031,9 @@ bool App::IsAccessibilitySupportEnabled() {
   return ax_state->IsAccessibleBrowser();
 }
 
-void App::SetAccessibilitySupportEnabled(gin_helper::ErrorThrower thrower,
-                                         bool enabled) {
+void App::SetAccessibilitySupportEnabled(bool enabled, mate::Arguments* args) {
   if (!Browser::Get()->is_ready()) {
-    thrower.ThrowError(
+    args->ThrowError(
         "app.setAccessibilitySupportEnabled() can only be called "
         "after app is ready");
     return;
@@ -1071,15 +1057,14 @@ Browser::LoginItemSettings App::GetLoginItemSettings(mate::Arguments* args) {
 #if defined(USE_NSS_CERTS)
 void App::ImportCertificate(const base::DictionaryValue& options,
                             net::CompletionRepeatingCallback callback) {
-  auto browser_context = ElectronBrowserContext::From("", false);
+  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::BindRepeating(&App::OnCertificateManagerModelCreated,
-                            base::Unretained(this), base::Passed(&copy),
-                            callback));
+        base::Bind(&App::OnCertificateManagerModelCreated,
+                   base::Unretained(this), base::Passed(&copy), callback));
     return;
   }
 
@@ -1156,7 +1141,7 @@ JumpListResult App::SetJumpList(v8::Local<v8::Value> val,
 
 v8::Local<v8::Promise> App::GetFileIcon(const base::FilePath& path,
                                         mate::Arguments* args) {
-  util::Promise<gfx::Image> promise(isolate());
+  util::Promise promise(isolate());
   v8::Local<v8::Promise> handle = promise.GetHandle();
   base::FilePath normalized_path = path.NormalizePathSeparators();
 
@@ -1170,7 +1155,7 @@ v8::Local<v8::Promise> App::GetFileIcon(const base::FilePath& path,
     icon_size = GetIconSizeByString(icon_size_string);
   }
 
-  auto* icon_manager = ElectronBrowserMainParts::Get()->GetIconManager();
+  auto* icon_manager = AtomBrowserMainParts::Get()->GetIconManager();
   gfx::Image* icon =
       icon_manager->LookupIconFromFilepath(normalized_path, icon_size);
   if (icon) {
@@ -1193,11 +1178,8 @@ std::vector<mate::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
     mate::Dictionary pid_dict = mate::Dictionary::CreateEmpty(isolate);
     mate::Dictionary cpu_dict = mate::Dictionary::CreateEmpty(isolate);
 
-    // TODO(zcbenz): Just call SetHidden when this file is converted to gin.
-    gin_helper::Dictionary(isolate, pid_dict.GetHandle())
-        .SetHidden("simple", true);
-    gin_helper::Dictionary(isolate, cpu_dict.GetHandle())
-        .SetHidden("simple", true);
+    pid_dict.SetHidden("simple", true);
+    cpu_dict.SetHidden("simple", true);
 
     cpu_dict.Set(
         "percentCPUUsage",
@@ -1215,42 +1197,9 @@ std::vector<mate::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
 #endif
 
     pid_dict.Set("cpu", cpu_dict);
-    pid_dict.Set("pid", process_metric.second->process.Pid());
+    pid_dict.Set("pid", process_metric.second->pid);
     pid_dict.Set("type", content::GetProcessTypeNameInEnglish(
                              process_metric.second->type));
-    pid_dict.Set("creationTime",
-                 process_metric.second->process.CreationTime().ToJsTime());
-
-#if !defined(OS_LINUX)
-    auto memory_info = process_metric.second->GetMemoryInfo();
-
-    mate::Dictionary memory_dict = mate::Dictionary::CreateEmpty(isolate);
-    // TODO(zcbenz): Just call SetHidden when this file is converted to gin.
-    gin_helper::Dictionary(isolate, memory_dict.GetHandle())
-        .SetHidden("simple", true);
-    memory_dict.Set("workingSetSize",
-                    static_cast<double>(memory_info.working_set_size >> 10));
-    memory_dict.Set(
-        "peakWorkingSetSize",
-        static_cast<double>(memory_info.peak_working_set_size >> 10));
-
-#if defined(OS_WIN)
-    memory_dict.Set("privateBytes",
-                    static_cast<double>(memory_info.private_bytes >> 10));
-#endif
-
-    pid_dict.Set("memory", memory_dict);
-#endif
-
-#if defined(OS_MACOSX)
-    pid_dict.Set("sandboxed", process_metric.second->IsSandboxed());
-#elif defined(OS_WIN)
-    auto integrity_level = process_metric.second->GetIntegrityLevel();
-    auto sandboxed = ProcessMetric::IsSandboxed(integrity_level);
-    pid_dict.Set("integrityLevel", integrity_level);
-    pid_dict.Set("sandboxed", sandboxed);
-#endif
-
     result.push_back(pid_dict);
   }
 
@@ -1266,7 +1215,7 @@ v8::Local<v8::Value> App::GetGPUFeatureStatus(v8::Isolate* isolate) {
 v8::Local<v8::Promise> App::GetGPUInfo(v8::Isolate* isolate,
                                        const std::string& info_type) {
   auto* const gpu_data_manager = content::GpuDataManagerImpl::GetInstance();
-  util::Promise<base::DictionaryValue> promise(isolate);
+  util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
   if (info_type != "basic" && info_type != "complete") {
     promise.RejectWithErrorMessage(
@@ -1306,9 +1255,9 @@ static void RemoveNoSandboxSwitch(base::CommandLine* command_line) {
   }
 }
 
-void App::EnableSandbox(gin_helper::ErrorThrower thrower) {
+void App::EnableSandbox(mate::Arguments* args) {
   if (Browser::Get()->is_ready()) {
-    thrower.ThrowError(
+    args->ThrowError(
         "app.enableSandbox() can only be called "
         "before app is ready");
     return;
@@ -1319,48 +1268,25 @@ void App::EnableSandbox(gin_helper::ErrorThrower thrower) {
   command_line->AppendSwitch(switches::kEnableSandbox);
 }
 
-void App::SetUserAgentFallback(const std::string& user_agent) {
-  ElectronBrowserClient::Get()->SetUserAgent(user_agent);
-}
-
-std::string App::GetUserAgentFallback() {
-  return ElectronBrowserClient::Get()->GetUserAgent();
-}
-
-void App::SetBrowserClientCanUseCustomSiteInstance(bool should_disable) {
-  ElectronBrowserClient::Get()->SetCanUseCustomSiteInstance(should_disable);
-}
-bool App::CanBrowserClientUseCustomSiteInstance() {
-  return ElectronBrowserClient::Get()->CanUseCustomSiteInstance();
-}
-bool App::CanBrowserClientUseCustomSiteInstanceIsDefaultValue() {
-  return ElectronBrowserClient::Get()->CanUseCustomSiteInstanceIsDefaultValue();
-}
-
 #if defined(OS_MACOSX)
-bool App::MoveToApplicationsFolder(gin_helper::ErrorThrower thrower,
-                                   mate::Arguments* args) {
-  gin::Arguments gin_args(args->info());
-  return ElectronBundleMover::Move(thrower, &gin_args);
+bool App::MoveToApplicationsFolder(mate::Arguments* args) {
+  return ui::cocoa::AtomBundleMover::Move(args);
 }
 
 bool App::IsInApplicationsFolder() {
-  return ElectronBundleMover::IsCurrentAppInApplicationsFolder();
+  return ui::cocoa::AtomBundleMover::IsCurrentAppInApplicationsFolder();
 }
 
-int DockBounce(mate::Arguments* args) {
+int DockBounce(const std::string& type) {
   int request_id = -1;
-  std::string type = "informational";
-  args->GetNext(&type);
-
   if (type == "critical")
-    request_id = Browser::Get()->DockBounce(Browser::BounceType::CRITICAL);
+    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_CRITICAL);
   else if (type == "informational")
-    request_id = Browser::Get()->DockBounce(Browser::BounceType::INFORMATIONAL);
+    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_INFORMATIONAL);
   return request_id;
 }
 
-void DockSetMenu(electron::api::Menu* menu) {
+void DockSetMenu(atom::api::Menu* menu) {
   Browser::Get()->DockSetMenu(menu->model());
 }
 
@@ -1371,25 +1297,20 @@ 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::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("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("isVisible",
-                       base::BindRepeating(&Browser::DockIsVisible, browser));
+                       base::Bind(&Browser::DockIsVisible, browser));
     dock_obj.SetMethod("setMenu", &DockSetMenu);
-    dock_obj.SetMethod("setIcon",
-                       base::BindRepeating(&Browser::DockSetIcon, browser));
+    dock_obj.SetMethod("setIcon", base::Bind(&Browser::DockSetIcon, browser));
 
     dock_.Reset(isolate, dock_obj.GetHandle());
   }
@@ -1408,78 +1329,70 @@ 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::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("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("addRecentDocument",
-                 base::BindRepeating(&Browser::AddRecentDocument, browser))
+                 base::Bind(&Browser::AddRecentDocument, browser))
       .SetMethod("clearRecentDocuments",
-                 base::BindRepeating(&Browser::ClearRecentDocuments, browser))
+                 base::Bind(&Browser::ClearRecentDocuments, browser))
       .SetMethod("setAppUserModelId",
-                 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(
-          "getApplicationNameForProtocol",
-          base::BindRepeating(&Browser::GetApplicationNameForProtocol, browser))
-      .SetMethod("setBadgeCount",
-                 base::BindRepeating(&Browser::SetBadgeCount, browser))
-      .SetMethod("getBadgeCount",
-                 base::BindRepeating(&Browser::GetBadgeCount, browser))
+                 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))
       .SetMethod("getLoginItemSettings", &App::GetLoginItemSettings)
       .SetMethod("setLoginItemSettings",
-                 base::BindRepeating(&Browser::SetLoginItemSettings, browser))
+                 base::Bind(&Browser::SetLoginItemSettings, browser))
       .SetMethod("isEmojiPanelSupported",
-                 base::BindRepeating(&Browser::IsEmojiPanelSupported, browser))
+                 base::Bind(&Browser::IsEmojiPanelSupported, browser))
 #if defined(OS_MACOSX)
-      .SetMethod("hide", base::BindRepeating(&Browser::Hide, browser))
-      .SetMethod("show", base::BindRepeating(&Browser::Show, browser))
+      .SetMethod("hide", base::Bind(&Browser::Hide, browser))
+      .SetMethod("show", base::Bind(&Browser::Show, browser))
       .SetMethod("setUserActivity",
-                 base::BindRepeating(&Browser::SetUserActivity, browser))
+                 base::Bind(&Browser::SetUserActivity, browser))
       .SetMethod("getCurrentActivityType",
-                 base::BindRepeating(&Browser::GetCurrentActivityType, browser))
-      .SetMethod(
-          "invalidateCurrentActivity",
-          base::BindRepeating(&Browser::InvalidateCurrentActivity, browser))
-      .SetMethod("resignCurrentActivity",
-                 base::BindRepeating(&Browser::ResignCurrentActivity, browser))
+                 base::Bind(&Browser::GetCurrentActivityType, browser))
+      .SetMethod("invalidateCurrentActivity",
+                 base::Bind(&Browser::InvalidateCurrentActivity, browser))
       .SetMethod("updateCurrentActivity",
-                 base::BindRepeating(&Browser::UpdateCurrentActivity, browser))
+                 base::Bind(&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::BindRepeating(&Browser::SetAboutPanelOptions, browser))
+                 base::Bind(&Browser::SetAboutPanelOptions, browser))
       .SetMethod("showAboutPanel",
-                 base::BindRepeating(&Browser::ShowAboutPanel, browser))
+                 base::Bind(&Browser::ShowAboutPanel, browser))
+#endif
 #if defined(OS_MACOSX) || defined(OS_WIN)
       .SetMethod("showEmojiPanel",
-                 base::BindRepeating(&Browser::ShowEmojiPanel, browser))
+                 base::Bind(&Browser::ShowEmojiPanel, browser))
+      .SetProperty("accessibilitySupportEnabled",
+                   &App::IsAccessibilitySupportEnabled,
+                   &App::SetAccessibilitySupportEnabled)
 #endif
 #if defined(OS_WIN)
-      .SetMethod("setUserTasks",
-                 base::BindRepeating(&Browser::SetUserTasks, browser))
+      .SetMethod("setUserTasks", base::Bind(&Browser::SetUserTasks, browser))
       .SetMethod("getJumpListSettings", &App::GetJumpListSettings)
       .SetMethod("setJumpList", &App::SetJumpList)
 #endif
 #if defined(OS_LINUX)
       .SetMethod("isUnityRunning",
-                 base::BindRepeating(&Browser::IsUnityRunning, browser))
+                 base::Bind(&Browser::IsUnityRunning, browser))
 #endif
       .SetMethod("setAppPath", &App::SetAppPath)
       .SetMethod("getAppPath", &App::GetAppPath)
@@ -1496,9 +1409,9 @@ void App::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("requestSingleInstanceLock", &App::RequestSingleInstanceLock)
       .SetMethod("releaseSingleInstanceLock", &App::ReleaseSingleInstanceLock)
       .SetMethod("relaunch", &App::Relaunch)
-      .SetMethod("isAccessibilitySupportEnabled",
+      .SetMethod("_isAccessibilitySupportEnabled",
                  &App::IsAccessibilitySupportEnabled)
-      .SetMethod("setAccessibilitySupportEnabled",
+      .SetMethod("_setAccessibilitySupportEnabled",
                  &App::SetAccessibilitySupportEnabled)
       .SetMethod("disableHardwareAcceleration",
                  &App::DisableHardwareAcceleration)
@@ -1515,19 +1428,12 @@ void App::BuildPrototype(v8::Isolate* isolate,
 #if defined(OS_MACOSX)
       .SetProperty("dock", &App::GetDockAPI)
 #endif
-      .SetProperty("userAgentFallback", &App::GetUserAgentFallback,
-                   &App::SetUserAgentFallback)
-      .SetMethod("enableSandbox", &App::EnableSandbox)
-      .SetProperty("allowRendererProcessReuse",
-                   &App::CanBrowserClientUseCustomSiteInstance,
-                   &App::SetBrowserClientCanUseCustomSiteInstance)
-      .SetProperty("_allowRendererProcessReuseIsDefaultValue",
-                   &App::CanBrowserClientUseCustomSiteInstanceIsDefaultValue);
+      .SetMethod("enableSandbox", &App::EnableSandbox);
 }
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
@@ -1537,10 +1443,10 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("App", electron::api::App::GetConstructor(isolate)
+  dict.Set("App", atom::api::App::GetConstructor(isolate)
                       ->GetFunction(context)
                       .ToLocalChecked());
-  dict.Set("app", electron::api::App::Create(isolate));
+  dict.Set("app", atom::api::App::Create(isolate));
 }
 
 }  // namespace

atom/browser/api/atom_api_app.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_APP_H_
-#define SHELL_BROWSER_API_ELECTRON_API_APP_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_APP_H_
+#define ATOM_BROWSER_API_ATOM_API_APP_H_
 
 #include <memory>
 #include <string>
@@ -11,6 +11,14 @@
 #include <utility>
 #include <vector>
 
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/atom_browser_client.h"
+#include "atom/browser/browser.h"
+#include "atom/browser/browser_observer.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/promise_util.h"
+#include "base/process/process_iterator.h"
+#include "base/process/process_metrics.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "chrome/browser/icon_manager.h"
 #include "chrome/browser/process_singleton.h"
@@ -22,13 +30,6 @@
 #include "net/base/completion_once_callback.h"
 #include "net/base/completion_repeating_callback.h"
 #include "net/ssl/client_cert_identity.h"
-#include "shell/browser/api/event_emitter_deprecated.h"
-#include "shell/browser/api/process_metric.h"
-#include "shell/browser/browser.h"
-#include "shell/browser/browser_observer.h"
-#include "shell/browser/electron_browser_client.h"
-#include "shell/common/gin_helper/error_thrower.h"
-#include "shell/common/promise_util.h"
 
 #if defined(USE_NSS_CERTS)
 #include "chrome/browser/certificate_manager_model.h"
@@ -42,22 +43,33 @@ namespace mate {
 class Arguments;
 }  // namespace mate
 
-namespace electron {
+namespace atom {
 
 #if defined(OS_WIN)
 enum class JumpListResult : int;
 #endif
 
+struct ProcessMetric {
+  int type;
+  base::ProcessId pid;
+  std::unique_ptr<base::ProcessMetrics> metrics;
+
+  ProcessMetric(int type,
+                base::ProcessId pid,
+                std::unique_ptr<base::ProcessMetrics> metrics);
+  ~ProcessMetric();
+};
+
 namespace api {
 
-class App : public ElectronBrowserClient::Delegate,
+class App : public AtomBrowserClient::Delegate,
             public mate::EventEmitter<App>,
             public BrowserObserver,
             public content::GpuDataManagerObserver,
             public content::BrowserChildProcessObserver {
  public:
   using FileIconCallback =
-      base::RepeatingCallback<void(v8::Local<v8::Value>, const gfx::Image&)>;
+      base::Callback<void(v8::Local<v8::Value>, const gfx::Image&)>;
 
   static mate::Handle<App> Create(v8::Isolate* isolate);
 
@@ -90,6 +102,8 @@ class App : public ElectronBrowserClient::Delegate,
   void OnActivate(bool has_visible_windows) override;
   void OnWillFinishLaunching() override;
   void OnFinishLaunching(const base::DictionaryValue& launch_info) override;
+  void OnLogin(scoped_refptr<LoginHandler> login_handler,
+               const base::DictionaryValue& request_details) override;
   void OnAccessibilitySupportChanged() override;
   void OnPreMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
@@ -116,11 +130,12 @@ class App : public ElectronBrowserClient::Delegate,
       int cert_error,
       const net::SSLInfo& ssl_info,
       const GURL& request_url,
-      bool is_main_frame_request,
+      content::ResourceType resource_type,
       bool strict_enforcement,
-      base::OnceCallback<void(content::CertificateRequestResultType)> callback)
-      override;
-  base::OnceClosure SelectClientCertificate(
+      bool expired_previous_decision,
+      const base::Callback<void(content::CertificateRequestResultType)>&
+          callback) override;
+  void SelectClientCertificate(
       content::WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
       net::ClientCertIdentityList client_certs,
@@ -142,7 +157,6 @@ class App : public ElectronBrowserClient::Delegate,
                        bool* no_javascript_access) override;
 
   // content::GpuDataManagerObserver:
-  void OnGpuInfoUpdate() override;
   void OnGpuProcessCrashed(base::TerminationStatus status) override;
 
   // content::BrowserChildProcessObserver:
@@ -162,13 +176,11 @@ class App : public ElectronBrowserClient::Delegate,
   void ChildProcessLaunched(int process_type, base::ProcessHandle handle);
   void ChildProcessDisconnected(base::ProcessId pid);
 
-  void SetAppLogsPath(gin_helper::ErrorThrower thrower,
-                      base::Optional<base::FilePath> custom_path);
+  void SetAppLogsPath(mate::Arguments* args);
 
   // Get/Set the pre-defined path in PathService.
-  base::FilePath GetPath(gin_helper::ErrorThrower thrower,
-                         const std::string& name);
-  void SetPath(gin_helper::ErrorThrower thrower,
+  base::FilePath GetPath(mate::Arguments* args, const std::string& name);
+  void SetPath(mate::Arguments* args,
                const std::string& name,
                const base::FilePath& path);
 
@@ -181,11 +193,10 @@ class App : public ElectronBrowserClient::Delegate,
   bool RequestSingleInstanceLock();
   void ReleaseSingleInstanceLock();
   bool Relaunch(mate::Arguments* args);
-  void DisableHardwareAcceleration(gin_helper::ErrorThrower thrower);
-  void DisableDomainBlockingFor3DAPIs(gin_helper::ErrorThrower thrower);
+  void DisableHardwareAcceleration(mate::Arguments* args);
+  void DisableDomainBlockingFor3DAPIs(mate::Arguments* args);
   bool IsAccessibilitySupportEnabled();
-  void SetAccessibilitySupportEnabled(gin_helper::ErrorThrower thrower,
-                                      bool enabled);
+  void SetAccessibilitySupportEnabled(bool enabled, mate::Arguments* args);
   Browser::LoginItemSettings GetLoginItemSettings(mate::Arguments* args);
 #if defined(USE_NSS_CERTS)
   void ImportCertificate(const base::DictionaryValue& options,
@@ -198,23 +209,17 @@ class App : public ElectronBrowserClient::Delegate,
   v8::Local<v8::Value> GetGPUFeatureStatus(v8::Isolate* isolate);
   v8::Local<v8::Promise> GetGPUInfo(v8::Isolate* isolate,
                                     const std::string& info_type);
-  void EnableSandbox(gin_helper::ErrorThrower thrower);
-  void SetUserAgentFallback(const std::string& user_agent);
-  std::string GetUserAgentFallback();
-  void SetBrowserClientCanUseCustomSiteInstance(bool should_disable);
-  bool CanBrowserClientUseCustomSiteInstance();
-  bool CanBrowserClientUseCustomSiteInstanceIsDefaultValue();
+  void EnableSandbox(mate::Arguments* args);
 
 #if defined(OS_MACOSX)
-  bool MoveToApplicationsFolder(gin_helper::ErrorThrower,
-                                mate::Arguments* args);
+  bool MoveToApplicationsFolder(mate::Arguments* args);
   bool IsInApplicationsFolder();
   v8::Local<v8::Value> GetDockAPI(v8::Isolate* isolate);
   v8::Global<v8::Value> dock_;
 #endif
 
 #if defined(MAS_BUILD)
-  base::RepeatingCallback<void()> StartAccessingSecurityScopedResource(
+  base::Callback<void()> StartAccessingSecurityScopedResource(
       mate::Arguments* args);
 #endif
 
@@ -238,8 +243,7 @@ class App : public ElectronBrowserClient::Delegate,
   base::FilePath app_path_;
 
   using ProcessMetricMap =
-      std::unordered_map<base::ProcessId,
-                         std::unique_ptr<electron::ProcessMetric>>;
+      std::unordered_map<base::ProcessId, std::unique_ptr<atom::ProcessMetric>>;
   ProcessMetricMap app_metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(App);
@@ -247,6 +251,6 @@ class App : public ElectronBrowserClient::Delegate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_APP_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_APP_H_

atom/browser/api/atom_api_app_mac.mm

@@ -2,25 +2,25 @@
 // 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_app.h"
+#include "atom/browser/atom_paths.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
 #include "base/path_service.h"
-#include "shell/browser/api/electron_api_app.h"
-#include "shell/browser/electron_paths.h"
-#include "shell/common/native_mate_converters/file_path_converter.h"
 
 #import <Cocoa/Cocoa.h>
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
-void App::SetAppLogsPath(gin_helper::ErrorThrower thrower,
-                         base::Optional<base::FilePath> custom_path) {
-  if (custom_path.has_value()) {
-    if (!custom_path->IsAbsolute()) {
-      thrower.ThrowError("Path must be absolute");
+void App::SetAppLogsPath(mate::Arguments* args) {
+  base::FilePath custom_path;
+  if (args->GetNext(&custom_path)) {
+    if (!custom_path.IsAbsolute()) {
+      args->ThrowError("Path must be absolute");
       return;
     }
-    base::PathService::Override(DIR_APP_LOGS, custom_path.value());
+    base::PathService::Override(DIR_APP_LOGS, custom_path);
   } else {
     NSString* bundle_name =
         [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleName"];
@@ -33,6 +33,6 @@ void App::SetAppLogsPath(gin_helper::ErrorThrower thrower,
   }
 }
 
-}  // namespace api
+}  // namespace atom
 
-}  // namespace electron
+}  // namespace api

atom/browser/api/atom_api_app_mas.mm

@@ -2,15 +2,13 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_app.h"
-
-#include <string>
+#include "atom/browser/api/atom_api_app.h"
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/strings/sys_string_conversions.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -21,13 +19,13 @@ void OnStopAccessingSecurityScopedResource(NSURL* bookmarkUrl) {
 }
 
 // Get base64 encoded NSData, create a bookmark for it and start accessing it.
-base::RepeatingCallback<void()> App::StartAccessingSecurityScopedResource(
+base::Callback<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;
@@ -57,10 +55,9 @@ base::RepeatingCallback<void()> App::StartAccessingSecurityScopedResource(
   [bookmarkUrl retain];
 
   // Return a js callback which will close the bookmark.
-  return base::BindRepeating(&OnStopAccessingSecurityScopedResource,
-                             bookmarkUrl);
+  return base::Bind(&OnStopAccessingSecurityScopedResource, bookmarkUrl);
 }
 
-}  // namespace api
+}  // namespace atom
 
-}  // namespace electron
+}  // namespace api

atom/browser/api/atom_api_auto_updater.cc

@@ -2,19 +2,19 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_auto_updater.h"
+#include "atom/browser/api/atom_api_auto_updater.h"
 
+#include "atom/browser/browser.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/window_list.h"
+#include "atom/common/api/event_emitter_caller.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/node_includes.h"
 #include "base/time/time.h"
-#include "shell/browser/browser.h"
-#include "shell/browser/native_window.h"
-#include "shell/browser/window_list.h"
-#include "shell/common/gin_converters/callback_converter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/event_emitter_caller.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
 
-namespace gin {
+namespace mate {
 
 template <>
 struct Converter<base::Time> {
@@ -29,9 +29,9 @@ struct Converter<base::Time> {
   }
 };
 
-}  // namespace gin
+}  // namespace mate
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -47,8 +47,8 @@ AutoUpdater::~AutoUpdater() {
 void AutoUpdater::OnError(const std::string& message) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  auto error = v8::Exception::Error(gin::StringToV8(isolate(), message));
-  gin_helper::EmitEvent(
+  auto error = v8::Exception::Error(mate::StringToV8(isolate(), message));
+  mate::EmitEvent(
       isolate(), GetWrapper(), "error",
       error->ToObject(isolate()->GetCurrentContext()).ToLocalChecked(),
       // Message is also emitted to keep compatibility with old code.
@@ -60,7 +60,7 @@ void AutoUpdater::OnError(const std::string& message,
                           const std::string& domain) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  auto error = v8::Exception::Error(gin::StringToV8(isolate(), message));
+  auto error = v8::Exception::Error(mate::StringToV8(isolate(), message));
   auto errorObject =
       error->ToObject(isolate()->GetCurrentContext()).ToLocalChecked();
 
@@ -68,15 +68,15 @@ void AutoUpdater::OnError(const std::string& message,
 
   // add two new params for better error handling
   errorObject
-      ->Set(context, gin::StringToV8(isolate(), "code"),
+      ->Set(context, mate::StringToV8(isolate(), "code"),
             v8::Integer::New(isolate(), code))
       .Check();
   errorObject
-      ->Set(context, gin::StringToV8(isolate(), "domain"),
-            gin::StringToV8(isolate(), domain))
+      ->Set(context, mate::StringToV8(isolate(), "domain"),
+            mate::StringToV8(isolate(), domain))
       .Check();
 
-  gin_helper::EmitEvent(isolate(), GetWrapper(), "error", errorObject, message);
+  mate::EmitEvent(isolate(), GetWrapper(), "error", errorObject, message);
 }
 
 void AutoUpdater::OnCheckingForUpdate() {
@@ -97,15 +97,14 @@ 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::BindRepeating(&AutoUpdater::QuitAndInstall,
-                           base::Unretained(this)));
+       base::Bind(&AutoUpdater::QuitAndInstall, base::Unretained(this)));
 }
 
 void AutoUpdater::OnWindowAllClosed() {
   QuitAndInstall();
 }
 
-void AutoUpdater::SetFeedURL(gin_helper::Arguments* args) {
+void AutoUpdater::SetFeedURL(mate::Arguments* args) {
   auto_updater::AutoUpdater::SetFeedURL(args);
 }
 
@@ -124,15 +123,15 @@ void AutoUpdater::QuitAndInstall() {
 }
 
 // static
-gin::Handle<AutoUpdater> AutoUpdater::Create(v8::Isolate* isolate) {
-  return gin::CreateHandle(isolate, new AutoUpdater(isolate));
+mate::Handle<AutoUpdater> AutoUpdater::Create(v8::Isolate* isolate) {
+  return mate::CreateHandle(isolate, new AutoUpdater(isolate));
 }
 
 // static
 void AutoUpdater::BuildPrototype(v8::Isolate* isolate,
                                  v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "AutoUpdater"));
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "AutoUpdater"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("checkForUpdates", &auto_updater::AutoUpdater::CheckForUpdates)
       .SetMethod("getFeedURL", &auto_updater::AutoUpdater::GetFeedURL)
       .SetMethod("setFeedURL", &AutoUpdater::SetFeedURL)
@@ -141,18 +140,18 @@ void AutoUpdater::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::AutoUpdater;
+using atom::api::AutoUpdater;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  gin_helper::Dictionary dict(isolate, exports);
+  mate::Dictionary dict(isolate, exports);
   dict.Set("autoUpdater", AutoUpdater::Create(isolate));
   dict.Set("AutoUpdater", AutoUpdater::GetConstructor(isolate)
                               ->GetFunction(context)

atom/browser/api/atom_api_auto_updater.h

@@ -2,27 +2,26 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_AUTO_UPDATER_H_
-#define SHELL_BROWSER_API_ELECTRON_API_AUTO_UPDATER_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_
+#define ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_
 
 #include <string>
 
-#include "gin/handle.h"
-#include "native_mate/wrappable.h"
-#include "shell/browser/auto_updater.h"
-#include "shell/browser/window_list_observer.h"
-#include "shell/common/gin_helper/event_emitter.h"
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/auto_updater.h"
+#include "atom/browser/window_list_observer.h"
+#include "native_mate/arguments.h"
+#include "native_mate/handle.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
-class AutoUpdater
-    : public gin_helper::EventEmitter<mate::Wrappable<AutoUpdater>>,
-      public auto_updater::Delegate,
-      public WindowListObserver {
+class AutoUpdater : public mate::EventEmitter<AutoUpdater>,
+                    public auto_updater::Delegate,
+                    public WindowListObserver {
  public:
-  static gin::Handle<AutoUpdater> Create(v8::Isolate* isolate);
+  static mate::Handle<AutoUpdater> Create(v8::Isolate* isolate);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
@@ -49,7 +48,7 @@ class AutoUpdater
 
  private:
   std::string GetFeedURL();
-  void SetFeedURL(gin_helper::Arguments* args);
+  void SetFeedURL(mate::Arguments* args);
   void QuitAndInstall();
 
   DISALLOW_COPY_AND_ASSIGN(AutoUpdater);
@@ -57,6 +56,6 @@ class AutoUpdater
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_AUTO_UPDATER_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_

atom/browser/api/atom_api_browser_view.cc

@@ -2,28 +2,28 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_browser_view.h"
+#include "atom/browser/api/atom_api_browser_view.h"
 
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/browser.h"
+#include "atom/browser/native_browser_view.h"
+#include "atom/common/color_util.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
+#include "atom/common/options_switches.h"
+#include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
-#include "shell/browser/api/electron_api_web_contents.h"
-#include "shell/browser/browser.h"
-#include "shell/browser/native_browser_view.h"
-#include "shell/common/color_util.h"
-#include "shell/common/gin_converters/gfx_converter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
-#include "shell/common/options_switches.h"
 #include "ui/gfx/geometry/rect.h"
 
-namespace gin {
+namespace mate {
 
 template <>
-struct Converter<electron::AutoResizeFlags> {
+struct Converter<atom::AutoResizeFlags> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     electron::AutoResizeFlags* auto_resize_flags) {
-    gin_helper::Dictionary params;
+                     atom::AutoResizeFlags* auto_resize_flags) {
+    mate::Dictionary params;
     if (!ConvertFromV8(isolate, val, &params)) {
       return false;
     }
@@ -31,44 +31,46 @@ struct Converter<electron::AutoResizeFlags> {
     uint8_t flags = 0;
     bool width = false;
     if (params.Get("width", &width) && width) {
-      flags |= electron::kAutoResizeWidth;
+      flags |= atom::kAutoResizeWidth;
     }
     bool height = false;
     if (params.Get("height", &height) && height) {
-      flags |= electron::kAutoResizeHeight;
+      flags |= atom::kAutoResizeHeight;
     }
     bool horizontal = false;
     if (params.Get("horizontal", &horizontal) && horizontal) {
-      flags |= electron::kAutoResizeHorizontal;
+      flags |= atom::kAutoResizeHorizontal;
     }
     bool vertical = false;
     if (params.Get("vertical", &vertical) && vertical) {
-      flags |= electron::kAutoResizeVertical;
+      flags |= atom::kAutoResizeVertical;
     }
 
-    *auto_resize_flags = static_cast<electron::AutoResizeFlags>(flags);
+    *auto_resize_flags = static_cast<atom::AutoResizeFlags>(flags);
     return true;
   }
 };
 
-}  // namespace gin
+}  // namespace mate
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
-BrowserView::BrowserView(gin::Arguments* args,
-                         const gin_helper::Dictionary& options) {
-  v8::Isolate* isolate = args->isolate();
-  gin_helper::Dictionary web_preferences =
-      gin::Dictionary::CreateEmpty(isolate);
+BrowserView::BrowserView(v8::Isolate* isolate,
+                         v8::Local<v8::Object> wrapper,
+                         const mate::Dictionary& options) {
+  Init(isolate, wrapper, options);
+}
+
+void BrowserView::Init(v8::Isolate* isolate,
+                       v8::Local<v8::Object> wrapper,
+                       const mate::Dictionary& options) {
+  mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
   options.Get(options::kWebPreferences, &web_preferences);
-  web_preferences.Set("type", "browserView");
-  mate::Handle<class WebContents> web_contents = WebContents::Create(
-      isolate,
-      // TODO(zcbenz): No need to do convertion after converting constructor
-      // of WebContents to gin.
-      mate::Dictionary(isolate, web_preferences.GetHandle()));
+  web_preferences.Set("isBrowserView", true);
+  mate::Handle<class WebContents> web_contents =
+      WebContents::Create(isolate, web_preferences);
 
   web_contents_.Reset(isolate, web_contents.ToV8());
   api_web_contents_ = web_contents.get();
@@ -77,7 +79,7 @@ BrowserView::BrowserView(gin::Arguments* args,
   view_.reset(
       NativeBrowserView::Create(api_web_contents_->managed_web_contents()));
 
-  InitWithArgs(args);
+  InitWith(isolate, wrapper);
 }
 
 BrowserView::~BrowserView() {
@@ -94,17 +96,23 @@ void BrowserView::WebContentsDestroyed() {
 }
 
 // static
-mate::WrappableBase* BrowserView::New(gin_helper::ErrorThrower thrower,
-                                      gin::Arguments* args) {
+mate::WrappableBase* BrowserView::New(mate::Arguments* args) {
   if (!Browser::Get()->is_ready()) {
-    thrower.ThrowError("Cannot create BrowserView before app is ready");
+    args->ThrowError("Cannot create BrowserView before app is ready");
     return nullptr;
   }
 
-  gin::Dictionary options = gin::Dictionary::CreateEmpty(args->isolate());
-  args->GetNext(&options);
+  if (args->Length() > 1) {
+    args->ThrowError("Too many arguments");
+    return nullptr;
+  }
 
-  return new BrowserView(args, options);
+  mate::Dictionary options;
+  if (!(args->Length() == 1 && args->GetNext(&options))) {
+    options = mate::Dictionary::CreateEmpty(args->isolate());
+  }
+
+  return new BrowserView(args->isolate(), args->GetThis(), options);
 }
 
 int32_t BrowserView::ID() const {
@@ -119,10 +127,6 @@ void BrowserView::SetBounds(const gfx::Rect& bounds) {
   view_->SetBounds(bounds);
 }
 
-gfx::Rect BrowserView::GetBounds() {
-  return view_->GetBounds();
-}
-
 void BrowserView::SetBackgroundColor(const std::string& color_name) {
   view_->SetBackgroundColor(ParseHexColor(color_name));
 }
@@ -138,12 +142,11 @@ v8::Local<v8::Value> BrowserView::GetWebContents() {
 // static
 void BrowserView::BuildPrototype(v8::Isolate* isolate,
                                  v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "BrowserView"));
-  gin_helper::Destroyable::MakeDestroyable(isolate, prototype);
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "BrowserView"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
       .SetMethod("setAutoResize", &BrowserView::SetAutoResize)
       .SetMethod("setBounds", &BrowserView::SetBounds)
-      .SetMethod("getBounds", &BrowserView::GetBounds)
       .SetMethod("setBackgroundColor", &BrowserView::SetBackgroundColor)
       .SetProperty("webContents", &BrowserView::GetWebContents)
       .SetProperty("id", &BrowserView::ID);
@@ -151,26 +154,27 @@ void BrowserView::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::BrowserView;
+using atom::api::BrowserView;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  BrowserView::SetConstructor(isolate, base::BindRepeating(&BrowserView::New));
+  BrowserView::SetConstructor(isolate, base::Bind(&BrowserView::New));
 
-  gin_helper::Dictionary browser_view(isolate,
-                                      BrowserView::GetConstructor(isolate)
-                                          ->GetFunction(context)
-                                          .ToLocalChecked());
-  browser_view.SetMethod("fromId", &BrowserView::FromWeakMapID);
-  browser_view.SetMethod("getAllViews", &BrowserView::GetAll);
-  gin_helper::Dictionary dict(isolate, exports);
+  mate::Dictionary browser_view(isolate, BrowserView::GetConstructor(isolate)
+                                             ->GetFunction(context)
+                                             .ToLocalChecked());
+  browser_view.SetMethod("fromId",
+                         &mate::TrackableObject<BrowserView>::FromWeakMapID);
+  browser_view.SetMethod("getAllViews",
+                         &mate::TrackableObject<BrowserView>::GetAll);
+  mate::Dictionary dict(isolate, exports);
   dict.Set("BrowserView", browser_view);
 }
 

atom/browser/api/atom_api_browser_view.h

@@ -2,27 +2,27 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_BROWSER_VIEW_H_
-#define SHELL_BROWSER_API_ELECTRON_API_BROWSER_VIEW_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_BROWSER_VIEW_H_
+#define ATOM_BROWSER_API_ATOM_API_BROWSER_VIEW_H_
 
 #include <memory>
 #include <string>
 
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/native_browser_view.h"
 #include "content/public/browser/web_contents_observer.h"
-#include "gin/handle.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/browser/native_browser_view.h"
-#include "shell/common/gin_helper/error_thrower.h"
+#include "native_mate/handle.h"
 
 namespace gfx {
 class Rect;
 }
 
-namespace gin_helper {
+namespace mate {
+class Arguments;
 class Dictionary;
-}
+}  // namespace mate
 
-namespace electron {
+namespace atom {
 
 class NativeBrowserView;
 
@@ -33,8 +33,7 @@ class WebContents;
 class BrowserView : public mate::TrackableObject<BrowserView>,
                     public content::WebContentsObserver {
  public:
-  static mate::WrappableBase* New(gin_helper::ErrorThrower thrower,
-                                  gin::Arguments* args);
+  static mate::WrappableBase* New(mate::Arguments* args);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
@@ -45,16 +44,21 @@ class BrowserView : public mate::TrackableObject<BrowserView>,
   int32_t ID() const;
 
  protected:
-  BrowserView(gin::Arguments* args, const gin_helper::Dictionary& options);
+  BrowserView(v8::Isolate* isolate,
+              v8::Local<v8::Object> wrapper,
+              const mate::Dictionary& options);
   ~BrowserView() override;
 
   // content::WebContentsObserver:
   void WebContentsDestroyed() override;
 
  private:
+  void Init(v8::Isolate* isolate,
+            v8::Local<v8::Object> wrapper,
+            const mate::Dictionary& options);
+
   void SetAutoResize(AutoResizeFlags flags);
   void SetBounds(const gfx::Rect& bounds);
-  gfx::Rect GetBounds();
   void SetBackgroundColor(const std::string& color_name);
 
   v8::Local<v8::Value> GetWebContents();
@@ -69,6 +73,6 @@ class BrowserView : public mate::TrackableObject<BrowserView>,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_BROWSER_VIEW_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_BROWSER_VIEW_H_

atom/browser/api/atom_api_browser_window.cc

@@ -2,40 +2,41 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_browser_window.h"
+#include "atom/browser/api/atom_api_browser_window.h"
 
 #include <memory>
 
+#include "atom/browser/browser.h"
+#include "atom/browser/unresponsive_suppressor.h"
+#include "atom/browser/web_contents_preferences.h"
+#include "atom/browser/window_list.h"
+#include "atom/common/api/api_messages.h"
+#include "atom/common/api/constructor.h"
+#include "atom/common/color_util.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
+#include "atom/common/options_switches.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"  // nogncheck
 #include "content/browser/renderer_host/render_widget_host_owner_delegate.h"  // nogncheck
-#include "content/browser/web_contents/web_contents_impl.h"  // nogncheck
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "gin/converter.h"
 #include "native_mate/dictionary.h"
-#include "shell/browser/browser.h"
-#include "shell/browser/unresponsive_suppressor.h"
-#include "shell/browser/web_contents_preferences.h"
-#include "shell/browser/window_list.h"
-#include "shell/common/api/constructor.h"
-#include "shell/common/color_util.h"
-#include "shell/common/native_mate_converters/value_converter.h"
-#include "shell/common/node_includes.h"
-#include "shell/common/options_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
-BrowserWindow::BrowserWindow(gin::Arguments* args,
+BrowserWindow::BrowserWindow(v8::Isolate* isolate,
+                             v8::Local<v8::Object> wrapper,
                              const mate::Dictionary& options)
-    : TopLevelWindow(args->isolate(), options), weak_factory_(this) {
+    : TopLevelWindow(isolate, options), weak_factory_(this) {
   mate::Handle<class WebContents> web_contents;
 
   // Use options.webPreferences in WebContents.
-  v8::Isolate* isolate = args->isolate();
   mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
   options.Get(options::kWebPreferences, &web_preferences);
 
@@ -44,21 +45,10 @@ BrowserWindow::BrowserWindow(gin::Arguments* args,
   if (options.Get(options::kBackgroundColor, &value))
     web_preferences.Set(options::kBackgroundColor, value);
 
-  // Copy the transparent setting to webContents
   v8::Local<v8::Value> transparent;
   if (options.Get("transparent", &transparent))
     web_preferences.Set("transparent", transparent);
 
-  // Copy the show setting to webContents, but only if we don't want to paint
-  // when initially hidden
-  bool paint_when_initially_hidden = true;
-  options.Get("paintWhenInitiallyHidden", &paint_when_initially_hidden);
-  if (!paint_when_initially_hidden) {
-    bool show = true;
-    options.Get(options::kShow, &show);
-    web_preferences.Set(options::kShow, show);
-  }
-
   if (options.Get("webContents", &web_contents) && !web_contents.IsEmpty()) {
     // Set webPreferences from options if using an existing webContents.
     // These preferences will be used when the webContent launches new
@@ -77,7 +67,7 @@ BrowserWindow::BrowserWindow(gin::Arguments* args,
   }
 
   web_contents_.Reset(isolate, web_contents.ToV8());
-  api_web_contents_ = web_contents->GetWeakPtr();
+  api_web_contents_ = web_contents.get();
   api_web_contents_->AddObserver(this);
   Observe(api_web_contents_->web_contents());
 
@@ -92,10 +82,11 @@ BrowserWindow::BrowserWindow(gin::Arguments* args,
   if (host)
     host->GetWidget()->AddInputEventObserver(this);
 
-  InitWithArgs(args);
+  InitWith(isolate, wrapper);
 
 #if defined(OS_MACOSX)
-  OverrideNSWindowContentView(web_contents->managed_web_contents());
+  if (!window()->has_frame())
+    OverrideNSWindowContentView(web_contents->managed_web_contents());
 #endif
 
   // Init window after everything has been setup.
@@ -103,9 +94,7 @@ BrowserWindow::BrowserWindow(gin::Arguments* args,
 }
 
 BrowserWindow::~BrowserWindow() {
-  // FIXME This is a hack rather than a proper fix preventing shutdown crashes.
-  if (api_web_contents_)
-    api_web_contents_->RemoveObserver(this);
+  api_web_contents_->RemoveObserver(this);
   // Note that the OnWindowClosed will not be called after the destructor runs,
   // since the window object is managed by the TopLevelWindow class.
   if (web_contents())
@@ -158,32 +147,12 @@ void BrowserWindow::DidFirstVisuallyNonEmptyPaint() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(
                      [](base::WeakPtr<BrowserWindow> self) {
-                       if (self && !self->did_ready_to_show_fired_) {
-                         self->did_ready_to_show_fired_ = true;
+                       if (self)
                          self->Emit("ready-to-show");
-                       }
                      },
                      GetWeakPtr()));
 }
 
-void BrowserWindow::DidFinishLoad(content::RenderFrameHost* render_frame_host,
-                                  const GURL& validated_url) {
-  // The DidFirstVisuallyNonEmptyPaint event is not very stable that, sometimes
-  // on some machines it might not be fired, and the actual behavior depends on
-  // the version of Chromium.
-  // To work around this bug, we ensure the ready-to-show event is emitted if it
-  // has not been emitted in did-finish-load event.
-  // Note that we use did-finish-load event instead of dom-ready event because
-  // the latter may actually be emitted before the ready-to-show event.
-  // See also https://github.com/electron/electron/issues/7779.
-  if (window()->IsVisible() || did_ready_to_show_fired_)
-    return;
-  if (render_frame_host->GetParent())  // child frame
-    return;
-  did_ready_to_show_fired_ = true;
-  Emit("ready-to-show");
-}
-
 void BrowserWindow::BeforeUnloadDialogCancelled() {
   WindowList::WindowCloseCancelled(window());
   // Cancel unresponsive event when window close is cancelled.
@@ -201,6 +170,17 @@ void BrowserWindow::OnRendererUnresponsive(content::RenderProcessHost*) {
   ScheduleUnresponsiveEvent(50);
 }
 
+bool BrowserWindow::OnMessageReceived(const IPC::Message& message,
+                                      content::RenderFrameHost* rfh) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(BrowserWindow, message, rfh)
+    IPC_MESSAGE_HANDLER(AtomFrameHostMsg_UpdateDraggableRegions,
+                        UpdateDraggableRegions)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
 void BrowserWindow::OnCloseContents() {
   // On some machines it may happen that the window gets destroyed for twice,
   // checking web_contents() can effectively guard against that.
@@ -236,11 +216,6 @@ void BrowserWindow::OnRendererResponsive() {
   Emit("responsive");
 }
 
-void BrowserWindow::OnDraggableRegionsUpdated(
-    const std::vector<mojom::DraggableRegionPtr>& regions) {
-  UpdateDraggableRegions(regions);
-}
-
 void BrowserWindow::RequestPreferredWidth(int* width) {
   *width = web_contents()->GetPreferredSize().width();
 }
@@ -262,7 +237,7 @@ void BrowserWindow::OnCloseButtonClicked(bool* prevent_default) {
     // Already closed by renderer
     return;
 
-  if (web_contents()->NeedToFireBeforeUnloadOrUnload())
+  if (web_contents()->NeedToFireBeforeUnload())
     web_contents()->DispatchBeforeUnload(false /* auto_cancel */);
   else
     web_contents()->Close();
@@ -275,14 +250,22 @@ void BrowserWindow::OnWindowClosed() {
 
 void BrowserWindow::OnWindowBlur() {
   web_contents()->StoreFocus();
+#if defined(OS_MACOSX)
+  auto* rwhv = web_contents()->GetRenderWidgetHostView();
+  if (rwhv)
+    rwhv->SetActive(false);
+#endif
 
   TopLevelWindow::OnWindowBlur();
 }
 
 void BrowserWindow::OnWindowFocus() {
   web_contents()->RestoreFocus();
-
-#if !defined(OS_MACOSX)
+#if defined(OS_MACOSX)
+  auto* rwhv = web_contents()->GetRenderWidgetHostView();
+  if (rwhv)
+    rwhv->SetActive(true);
+#else
   if (!api_web_contents_->IsDevToolsOpened())
     web_contents()->Focus();
 #endif
@@ -290,18 +273,10 @@ void BrowserWindow::OnWindowFocus() {
   TopLevelWindow::OnWindowFocus();
 }
 
-void BrowserWindow::OnWindowIsKeyChanged(bool is_key) {
-#if defined(OS_MACOSX)
-  auto* rwhv = web_contents()->GetRenderWidgetHostView();
-  if (rwhv)
-    rwhv->SetActive(is_key);
-#endif
-}
-
 void BrowserWindow::OnWindowResize() {
 #if defined(OS_MACOSX)
   if (!draggable_regions_.empty())
-    UpdateDraggableRegions(draggable_regions_);
+    UpdateDraggableRegions(nullptr, draggable_regions_);
 #endif
   TopLevelWindow::OnWindowResize();
 }
@@ -333,44 +308,34 @@ void BrowserWindow::SetBackgroundColor(const std::string& color_name) {
   auto* view = web_contents()->GetRenderWidgetHostView();
   if (view)
     view->SetBackgroundColor(ParseHexColor(color_name));
-  // Also update the web preferences object otherwise the view will be reset on
-  // the next load URL call
-  if (api_web_contents_) {
-    auto* web_preferences =
-        WebContentsPreferences::From(api_web_contents_->web_contents());
-    if (web_preferences) {
-      web_preferences->preference()->SetStringKey(options::kBackgroundColor,
-                                                  color_name);
-    }
-  }
 }
 
 void BrowserWindow::SetBrowserView(v8::Local<v8::Value> value) {
   TopLevelWindow::ResetBrowserViews();
   TopLevelWindow::AddBrowserView(value);
 #if defined(OS_MACOSX)
-  UpdateDraggableRegions(draggable_regions_);
+  UpdateDraggableRegions(nullptr, draggable_regions_);
 #endif
 }
 
 void BrowserWindow::AddBrowserView(v8::Local<v8::Value> value) {
   TopLevelWindow::AddBrowserView(value);
 #if defined(OS_MACOSX)
-  UpdateDraggableRegions(draggable_regions_);
+  UpdateDraggableRegions(nullptr, draggable_regions_);
 #endif
 }
 
 void BrowserWindow::RemoveBrowserView(v8::Local<v8::Value> value) {
   TopLevelWindow::RemoveBrowserView(value);
 #if defined(OS_MACOSX)
-  UpdateDraggableRegions(draggable_regions_);
+  UpdateDraggableRegions(nullptr, draggable_regions_);
 #endif
 }
 
 void BrowserWindow::ResetBrowserViews() {
   TopLevelWindow::ResetBrowserViews();
 #if defined(OS_MACOSX)
-  UpdateDraggableRegions(draggable_regions_);
+  UpdateDraggableRegions(nullptr, draggable_regions_);
 #endif
 }
 
@@ -412,13 +377,13 @@ v8::Local<v8::Value> BrowserWindow::GetWebContents(v8::Isolate* isolate) {
 
 // Convert draggable regions in raw format to SkRegion format.
 std::unique_ptr<SkRegion> BrowserWindow::DraggableRegionsToSkRegion(
-    const std::vector<mojom::DraggableRegionPtr>& regions) {
+    const std::vector<DraggableRegion>& regions) {
   auto sk_region = std::make_unique<SkRegion>();
-  for (const auto& region : regions) {
+  for (const DraggableRegion& region : regions) {
     sk_region->op(
-        {region->bounds.x(), region->bounds.y(), region->bounds.right(),
-         region->bounds.bottom()},
-        region->draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
+        region.bounds.x(), region.bounds.y(), region.bounds.right(),
+        region.bounds.bottom(),
+        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
   return sk_region;
 }
@@ -427,8 +392,8 @@ void BrowserWindow::ScheduleUnresponsiveEvent(int ms) {
   if (!window_unresponsive_closure_.IsCancelled())
     return;
 
-  window_unresponsive_closure_.Reset(base::BindRepeating(
-      &BrowserWindow::NotifyWindowUnresponsive, GetWeakPtr()));
+  window_unresponsive_closure_.Reset(
+      base::Bind(&BrowserWindow::NotifyWindowUnresponsive, GetWeakPtr()));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, window_unresponsive_closure_.callback(),
       base::TimeDelta::FromMilliseconds(ms));
@@ -453,21 +418,10 @@ void BrowserWindow::Cleanup() {
   Observe(nullptr);
 }
 
-void BrowserWindow::OnWindowShow() {
-  web_contents()->WasShown();
-  TopLevelWindow::OnWindowShow();
-}
-
-void BrowserWindow::OnWindowHide() {
-  web_contents()->WasOccluded();
-  TopLevelWindow::OnWindowHide();
-}
-
 // static
-mate::WrappableBase* BrowserWindow::New(gin_helper::ErrorThrower thrower,
-                                        gin::Arguments* args) {
+mate::WrappableBase* BrowserWindow::New(mate::Arguments* args) {
   if (!Browser::Get()->is_ready()) {
-    thrower.ThrowError("Cannot create BrowserWindow before app is ready");
+    args->ThrowError("Cannot create BrowserWindow before app is ready");
     return nullptr;
   }
 
@@ -481,7 +435,7 @@ mate::WrappableBase* BrowserWindow::New(gin_helper::ErrorThrower thrower,
     options = mate::Dictionary::CreateEmpty(args->isolate());
   }
 
-  return new BrowserWindow(args, options);
+  return new BrowserWindow(args->isolate(), args->GetThis(), options);
 }
 
 // static
@@ -507,12 +461,12 @@ v8::Local<v8::Value> BrowserWindow::From(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::BrowserWindow;
-using electron::api::TopLevelWindow;
+using atom::api::BrowserWindow;
+using atom::api::TopLevelWindow;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
@@ -520,9 +474,8 @@ 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::BindRepeating(&BrowserWindow::New)));
+  dict.Set("BrowserWindow", mate::CreateConstructor<BrowserWindow>(
+                                isolate, base::Bind(&BrowserWindow::New)));
 }
 
 }  // namespace

atom/browser/api/atom_api_browser_window.h

@@ -2,19 +2,18 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_BROWSER_WINDOW_H_
-#define SHELL_BROWSER_API_ELECTRON_API_BROWSER_WINDOW_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_BROWSER_WINDOW_H_
+#define ATOM_BROWSER_API_ATOM_API_BROWSER_WINDOW_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/atom_api_top_level_window.h"
+#include "atom/browser/api/atom_api_web_contents.h"
 #include "base/cancelable_callback.h"
-#include "shell/browser/api/electron_api_top_level_window.h"
-#include "shell/browser/api/electron_api_web_contents.h"
-#include "shell/common/gin_helper/error_thrower.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -23,8 +22,7 @@ class BrowserWindow : public TopLevelWindow,
                       public content::WebContentsObserver,
                       public ExtendedWebContentsObserver {
  public:
-  static mate::WrappableBase* New(gin_helper::ErrorThrower thrower,
-                                  gin::Arguments* args);
+  static mate::WrappableBase* New(mate::Arguments* args);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
@@ -38,7 +36,9 @@ class BrowserWindow : public TopLevelWindow,
   }
 
  protected:
-  BrowserWindow(gin::Arguments* args, const mate::Dictionary& options);
+  BrowserWindow(v8::Isolate* isolate,
+                v8::Local<v8::Object> wrapper,
+                const mate::Dictionary& options);
   ~BrowserWindow() override;
 
   // content::RenderWidgetHost::InputEventObserver:
@@ -49,21 +49,18 @@ class BrowserWindow : public TopLevelWindow,
                              content::RenderViewHost* new_host) override;
   void RenderViewCreated(content::RenderViewHost* render_view_host) override;
   void DidFirstVisuallyNonEmptyPaint() override;
-  void DidFinishLoad(content::RenderFrameHost* render_frame_host,
-                     const GURL& validated_url) override;
   void BeforeUnloadDialogCancelled() override;
   void OnRendererUnresponsive(content::RenderProcessHost*) override;
+  bool OnMessageReceived(const IPC::Message& message,
+                         content::RenderFrameHost* rfh) override;
 
   // ExtendedWebContentsObserver:
   void OnCloseContents() override;
   void OnRendererResponsive() override;
-  void OnDraggableRegionsUpdated(
-      const std::vector<mojom::DraggableRegionPtr>& regions) override;
 
   // NativeWindowObserver:
   void RequestPreferredWidth(int* width) override;
   void OnCloseButtonClicked(bool* prevent_default) override;
-  void OnWindowIsKeyChanged(bool is_key) override;
 
   // TopLevelWindow:
   void OnWindowClosed() override;
@@ -79,8 +76,6 @@ class BrowserWindow : public TopLevelWindow,
   void RemoveBrowserView(v8::Local<v8::Value> value) override;
   void ResetBrowserViews() override;
   void SetVibrancy(v8::Isolate* isolate, v8::Local<v8::Value> value) override;
-  void OnWindowShow() override;
-  void OnWindowHide() override;
 
   // BrowserWindow APIs.
   void FocusOnWebView();
@@ -96,12 +91,12 @@ class BrowserWindow : public TopLevelWindow,
   // Helpers.
 
   // Called when the window needs to update its draggable region.
-  void UpdateDraggableRegions(
-      const std::vector<mojom::DraggableRegionPtr>& regions);
+  void UpdateDraggableRegions(content::RenderFrameHost* rfh,
+                              const std::vector<DraggableRegion>& regions);
 
   // Convert draggable regions in raw format to SkRegion format.
   std::unique_ptr<SkRegion> DraggableRegionsToSkRegion(
-      const std::vector<mojom::DraggableRegionPtr>& regions);
+      const std::vector<DraggableRegion>& regions);
 
   // Schedule a notification unresponsive event.
   void ScheduleUnresponsiveEvent(int ms);
@@ -116,14 +111,12 @@ class BrowserWindow : public TopLevelWindow,
   // it should be cancelled when we can prove that the window is responsive.
   base::CancelableClosure window_unresponsive_closure_;
 
-  bool did_ready_to_show_fired_ = false;
-
 #if defined(OS_MACOSX)
-  std::vector<mojom::DraggableRegionPtr> draggable_regions_;
+  std::vector<DraggableRegion> draggable_regions_;
 #endif
 
   v8::Global<v8::Value> web_contents_;
-  base::WeakPtr<api::WebContents> api_web_contents_;
+  api::WebContents* api_web_contents_;
 
   base::WeakPtrFactory<BrowserWindow> weak_factory_;
 
@@ -132,6 +125,6 @@ class BrowserWindow : public TopLevelWindow,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_BROWSER_WINDOW_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_BROWSER_WINDOW_H_

atom/browser/api/atom_api_browser_window_mac.mm

@@ -2,17 +2,15 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_browser_window.h"
-
-#include <memory>
-#include <vector>
+#include "atom/browser/api/atom_api_browser_window.h"
 
 #import <Cocoa/Cocoa.h>
 
+#include "atom/browser/native_browser_view.h"
+#include "atom/browser/native_window_mac.h"
+#include "atom/browser/ui/inspectable_web_contents_view.h"
+#include "atom/common/draggable_region.h"
 #include "base/mac/scoped_nsobject.h"
-#include "shell/browser/native_browser_view.h"
-#include "shell/browser/native_window_mac.h"
-#include "shell/browser/ui/inspectable_web_contents_view.h"
 
 @interface NSView (WebContentsView)
 - (void)setMouseDownCanMoveWindow:(BOOL)can_move;
@@ -33,7 +31,7 @@
 
 @end
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -47,7 +45,7 @@ std::vector<gfx::Rect> CalculateNonDraggableRegions(
     int height) {
   std::vector<gfx::Rect> result;
   SkRegion non_draggable;
-  non_draggable.op({0, 0, width, height}, SkRegion::kUnion_Op);
+  non_draggable.op(0, 0, width, height, SkRegion::kUnion_Op);
   non_draggable.op(*draggable, SkRegion::kDifference_Op);
   for (SkRegion::Iterator it(non_draggable); !it.done(); it.next()) {
     result.push_back(gfx::SkIRectToRect(it.rect()));
@@ -75,13 +73,11 @@ void BrowserWindow::OverrideNSWindowContentView(InspectableWebContents* iwc) {
 }
 
 void BrowserWindow::UpdateDraggableRegions(
-    const std::vector<mojom::DraggableRegionPtr>& regions) {
+    content::RenderFrameHost* rfh,
+    const std::vector<DraggableRegion>& regions) {
   if (window_->has_frame())
     return;
 
-  if (!web_contents())
-    return;
-
   // All ControlRegionViews should be added as children of the WebContentsView,
   // because WebContentsView will be removed and re-added when entering and
   // leaving fullscreen mode.
@@ -104,11 +100,7 @@ void BrowserWindow::UpdateDraggableRegions(
 
   // Draggable regions is implemented by having the whole web view draggable
   // (mouseDownCanMoveWindow) and overlaying regions that are not draggable.
-  if (&draggable_regions_ != &regions) {
-    draggable_regions_.clear();
-    for (const auto& r : regions)
-      draggable_regions_.push_back(r.Clone());
-  }
+  draggable_regions_ = regions;
   std::vector<gfx::Rect> drag_exclude_rects;
   if (regions.empty()) {
     drag_exclude_rects.push_back(gfx::Rect(0, 0, webViewWidth, webViewHeight));
@@ -119,7 +111,7 @@ void BrowserWindow::UpdateDraggableRegions(
 
   auto browser_views = window_->browser_views();
   for (NativeBrowserView* view : browser_views) {
-    view->UpdateDraggableRegions(drag_exclude_rects);
+    (view)->UpdateDraggableRegions(drag_exclude_rects);
   }
 
   // Create and add a ControlRegionView for each region that needs to be
@@ -142,4 +134,4 @@ void BrowserWindow::UpdateDraggableRegions(
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom

atom/browser/api/atom_api_browser_window_views.cc

@@ -2,16 +2,17 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_browser_window.h"
+#include "atom/browser/api/atom_api_browser_window.h"
 
-#include "shell/browser/native_window_views.h"
+#include "atom/browser/native_window_views.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
 void BrowserWindow::UpdateDraggableRegions(
-    const std::vector<mojom::DraggableRegionPtr>& regions) {
+    content::RenderFrameHost* rfh,
+    const std::vector<DraggableRegion>& regions) {
   if (window_->has_frame())
     return;
   static_cast<NativeWindowViews*>(window_.get())
@@ -20,4 +21,4 @@ void BrowserWindow::UpdateDraggableRegions(
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom

atom/browser/api/atom_api_content_tracing.cc

@@ -4,19 +4,17 @@
 
 #include <set>
 #include <string>
-#include <utility>
 
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
+#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"
-#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
-#include "shell/common/native_mate_converters/file_path_converter.h"
-#include "shell/common/native_mate_converters/value_converter.h"
-#include "shell/common/node_includes.h"
-#include "shell/common/promise_util.h"
 
 using content::TracingController;
 
@@ -55,57 +53,45 @@ struct Converter<base::trace_event::TraceConfig> {
 
 namespace {
 
-using CompletionCallback = base::OnceCallback<void(const base::FilePath&)>;
+using CompletionCallback = base::Callback<void(const base::FilePath&)>;
 
-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));
+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));
 }
 
-void StopTracing(electron::util::Promise<base::FilePath> promise,
-                 base::Optional<base::FilePath> file_path) {
-  if (file_path) {
-    auto endpoint = TracingController::CreateFileEndpoint(
-        *file_path,
-        base::AdaptCallbackForRepeating(base::BindOnce(
-            &electron::util::Promise<base::FilePath>::ResolvePromise,
-            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) {
-  electron::util::Promise<base::FilePath> promise(args->isolate());
+v8::Local<v8::Promise> StopRecording(v8::Isolate* isolate,
+                                     const base::FilePath& path) {
+  atom::util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  base::FilePath path;
-  if (args->GetNext(&path) && !path.empty()) {
-    StopTracing(std::move(promise), base::make_optional(path));
-  } else {
-    // use a temporary file.
-    base::PostTaskAndReplyWithResult(
-        FROM_HERE,
-        {base::ThreadPool(), base::MayBlock(),
-         base::TaskPriority::USER_VISIBLE},
-        base::BindOnce(CreateTemporaryFileOnIO),
-        base::BindOnce(StopTracing, std::move(promise)));
-  }
-
+  // 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))));
   return handle;
 }
 
 v8::Local<v8::Promise> GetCategories(v8::Isolate* isolate) {
-  electron::util::Promise<const std::set<std::string>&> promise(isolate);
+  atom::util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   // Note: This method always succeeds.
   TracingController::GetInstance()->GetCategories(base::BindOnce(
-      electron::util::Promise<const std::set<std::string>&>::ResolvePromise,
+      atom::util::Promise::ResolvePromise<const std::set<std::string>&>,
       std::move(promise)));
 
   return handle;
@@ -114,35 +100,28 @@ v8::Local<v8::Promise> GetCategories(v8::Isolate* isolate) {
 v8::Local<v8::Promise> StartTracing(
     v8::Isolate* isolate,
     const base::trace_event::TraceConfig& trace_config) {
-  electron::util::Promise<void*> promise(isolate);
+  atom::util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  if (!TracingController::GetInstance()->StartTracing(
-          trace_config,
-          base::BindOnce(electron::util::Promise<void*>::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 electron::util::Promise<void*>::ResolvedPromise(isolate);
-  }
+  // Note: This method always succeeds.
+  TracingController::GetInstance()->StartTracing(
+      trace_config, base::BindOnce(atom::util::Promise::ResolveEmptyPromise,
+                                   std::move(promise)));
   return handle;
 }
 
-void OnTraceBufferUsageAvailable(
-    electron::util::Promise<mate::Dictionary> promise,
-    float percent_full,
-    size_t approximate_count) {
+void OnTraceBufferUsageAvailable(atom::util::Promise promise,
+                                 float percent_full,
+                                 size_t approximate_count) {
   mate::Dictionary dict = mate::Dictionary::CreateEmpty(promise.isolate());
   dict.Set("percentage", percent_full);
   dict.Set("value", approximate_count);
 
-  promise.Resolve(dict);
+  promise.Resolve(dict.GetHandle());
 }
 
 v8::Local<v8::Promise> GetTraceBufferUsage(v8::Isolate* isolate) {
-  electron::util::Promise<mate::Dictionary> promise(isolate);
+  atom::util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   // Note: This method always succeeds.

atom/browser/api/atom_api_cookies.cc

@@ -0,0 +1,407 @@
+// Copyright (c) 2015 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_cookies.h"
+
+#include <memory>
+#include <utility>
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/cookie_change_notifier.h"
+#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 "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_store.h"
+#include "net/cookies/cookie_util.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+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"));
+  }
+};
+
+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));
+    dict.Set("name", val.Name());
+    dict.Set("value", val.Value());
+    dict.Set("domain", val.Domain());
+    dict.Set("hostOnly", net::cookie_util::DomainIsHostOnly(val.Domain()));
+    dict.Set("path", val.Path());
+    dict.Set("secure", val.IsSecure());
+    dict.Set("httpOnly", val.IsHttpOnly());
+    dict.Set("session", !val.IsPersistent());
+    if (val.IsPersistent())
+      dict.Set("expirationDate", val.ExpiryDate().ToDoubleT());
+    return dict.GetHandle();
+  }
+};
+
+template <>
+struct Converter<network::mojom::CookieChangeCause> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const network::mojom::CookieChangeCause& val) {
+    switch (val) {
+      case network::mojom::CookieChangeCause::INSERTED:
+      case network::mojom::CookieChangeCause::EXPLICIT:
+        return mate::StringToV8(isolate, "explicit");
+      case network::mojom::CookieChangeCause::OVERWRITE:
+        return mate::StringToV8(isolate, "overwrite");
+      case network::mojom::CookieChangeCause::EXPIRED:
+        return mate::StringToV8(isolate, "expired");
+      case network::mojom::CookieChangeCause::EVICTED:
+        return mate::StringToV8(isolate, "evicted");
+      case network::mojom::CookieChangeCause::EXPIRED_OVERWRITE:
+        return mate::StringToV8(isolate, "expired-overwrite");
+      default:
+        return mate::StringToV8(isolate, "unknown");
+    }
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+// Returns whether |domain| matches |filter|.
+bool MatchesDomain(std::string filter, const std::string& domain) {
+  // Add a leading '.' character to the filter domain if it doesn't exist.
+  if (net::cookie_util::DomainIsHostOnly(filter))
+    filter.insert(0, ".");
+
+  std::string sub_domain(domain);
+  // Strip any leading '.' character from the input cookie domain.
+  if (!net::cookie_util::DomainIsHostOnly(sub_domain))
+    sub_domain = sub_domain.substr(1);
+
+  // Now check whether the domain argument is a subdomain of the filter domain.
+  for (sub_domain.insert(0, "."); sub_domain.length() >= filter.length();) {
+    if (sub_domain == filter)
+      return true;
+    const size_t next_dot = sub_domain.find('.', 1);  // Skip over leading dot.
+    sub_domain.erase(0, next_dot);
+  }
+  return false;
+}
+
+// Returns whether |cookie| matches |filter|.
+bool MatchesCookie(const base::DictionaryValue* filter,
+                   const net::CanonicalCookie& cookie) {
+  std::string str;
+  bool b;
+  if (filter->GetString("name", &str) && str != cookie.Name())
+    return false;
+  if (filter->GetString("path", &str) && str != cookie.Path())
+    return false;
+  if (filter->GetString("domain", &str) && !MatchesDomain(str, cookie.Domain()))
+    return false;
+  if (filter->GetBoolean("secure", &b) && b != cookie.IsSecure())
+    return false;
+  if (filter->GetBoolean("session", &b) && b != !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,
+                   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))
+      result.push_back(cookie);
+  }
+
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::UI},
+      base::BindOnce(util::Promise::ResolvePromise<const net::CookieList&>,
+                     std::move(promise), std::move(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;
+  switch (status) {
+    case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_HTTP_ONLY:
+      errmsg = "Failed to create httponly cookie";
+      break;
+    case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY:
+      errmsg = "Cannot create a secure cookie from an insecure URL";
+      break;
+    case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_FAILURE_TO_STORE:
+      errmsg = "Failed to parse cookie";
+      break;
+    case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_INVALID_DOMAIN:
+      errmsg = "Failed to get cookie domain";
+      break;
+    case net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_INVALID_PREFIX:
+      errmsg = "Failed because the cookie violated prefix rules.";
+      break;
+    case net::CanonicalCookie::CookieInclusionStatus::
+        EXCLUDE_NONCOOKIEABLE_SCHEME:
+      errmsg = "Cannot set cookie for current scheme";
+      break;
+    case net::CanonicalCookie::CookieInclusionStatus::INCLUDE:
+      errmsg = "";
+      break;
+    default:
+      errmsg = "Setting cookie failed";
+      break;
+  }
+  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::NO_RESTRICTION, 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
+
+Cookies::Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context)
+    : browser_context_(browser_context) {
+  Init(isolate);
+  cookie_change_subscription_ =
+      browser_context_->cookie_change_notifier()->RegisterCookieChangeCallback(
+          base::Bind(&Cookies::OnCookieChanged, base::Unretained(this)));
+}
+
+Cookies::~Cookies() {}
+
+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)));
+
+  return handle;
+}
+
+v8::Local<v8::Promise> Cookies::Remove(const GURL& url,
+                                       const std::string& name) {
+  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)));
+
+  return handle;
+}
+
+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)));
+
+  return handle;
+}
+
+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)));
+
+  return handle;
+}
+
+void Cookies::OnCookieChanged(const CookieDetails* details) {
+  Emit("changed", *(details->cookie), details->cause, details->removed);
+}
+
+// static
+mate::Handle<Cookies> Cookies::Create(v8::Isolate* isolate,
+                                      AtomBrowserContext* browser_context) {
+  return mate::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"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .SetMethod("get", &Cookies::Get)
+      .SetMethod("remove", &Cookies::Remove)
+      .SetMethod("set", &Cookies::Set)
+      .SetMethod("flushStore", &Cookies::FlushStore);
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_cookies.h

@@ -2,69 +2,69 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_COOKIES_H_
-#define SHELL_BROWSER_API_ELECTRON_API_COOKIES_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_COOKIES_H_
+#define ATOM_BROWSER_API_ATOM_API_COOKIES_H_
 
 #include <memory>
 #include <string>
 
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/net/cookie_details.h"
+#include "atom/common/promise_util.h"
 #include "base/callback_list.h"
-#include "gin/handle.h"
+#include "native_mate/handle.h"
 #include "net/cookies/canonical_cookie.h"
-#include "net/cookies/cookie_change_dispatcher.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/common/promise_util.h"
 
 namespace base {
 class DictionaryValue;
 }
 
-namespace mate {
-class Dictionary;
-}
-
 namespace net {
 class URLRequestContextGetter;
 }
 
-namespace electron {
+namespace atom {
 
-class ElectronBrowserContext;
+class AtomBrowserContext;
 
 namespace api {
 
 class Cookies : public mate::TrackableObject<Cookies> {
  public:
-  static gin::Handle<Cookies> Create(v8::Isolate* isolate,
-                                     ElectronBrowserContext* browser_context);
+  enum Error {
+    SUCCESS,
+    FAILED,
+  };
+
+  static mate::Handle<Cookies> Create(v8::Isolate* isolate,
+                                      AtomBrowserContext* browser_context);
 
   // mate::TrackableObject:
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
 
  protected:
-  Cookies(v8::Isolate* isolate, ElectronBrowserContext* browser_context);
+  Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context);
   ~Cookies() override;
 
-  v8::Local<v8::Promise> Get(const mate::Dictionary& filter);
+  v8::Local<v8::Promise> Get(const base::DictionaryValue& filter);
   v8::Local<v8::Promise> Set(const base::DictionaryValue& details);
   v8::Local<v8::Promise> Remove(const GURL& url, const std::string& name);
   v8::Local<v8::Promise> FlushStore();
 
   // CookieChangeNotifier subscription:
-  void OnCookieChanged(const net::CookieChangeInfo& change);
+  void OnCookieChanged(const CookieDetails*);
 
  private:
-  std::unique_ptr<base::CallbackList<void(
-      const net::CookieChangeInfo& change)>::Subscription>
+  std::unique_ptr<base::CallbackList<void(const CookieDetails*)>::Subscription>
       cookie_change_subscription_;
-  scoped_refptr<ElectronBrowserContext> browser_context_;
+  scoped_refptr<AtomBrowserContext> browser_context_;
 
   DISALLOW_COPY_AND_ASSIGN(Cookies);
 };
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_COOKIES_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_COOKIES_H_

atom/browser/api/atom_api_debugger.cc

@@ -2,23 +2,24 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_debugger.h"
+#include "atom/browser/api/atom_api_debugger.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/web_contents.h"
 #include "native_mate/dictionary.h"
-#include "shell/common/native_mate_converters/value_converter.h"
-#include "shell/common/node_includes.h"
 
 using content::DevToolsAgentHost;
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -27,7 +28,7 @@ Debugger::Debugger(v8::Isolate* isolate, content::WebContents* web_contents)
   Init(isolate);
 }
 
-Debugger::~Debugger() = default;
+Debugger::~Debugger() {}
 
 void Debugger::AgentHostClosed(DevToolsAgentHost* agent_host) {
   DCHECK(agent_host == agent_host_);
@@ -54,20 +55,17 @@ void Debugger::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
     std::string method;
     if (!dict->GetString("method", &method))
       return;
-    std::string session_id;
-    dict->GetString("sessionId", &session_id);
     base::DictionaryValue* params_value = nullptr;
     base::DictionaryValue params;
     if (dict->GetDictionary("params", &params_value))
       params.Swap(params_value);
-    Emit("message", method, params, session_id);
+    Emit("message", method, params);
   } else {
     auto it = pending_requests_.find(id);
     if (it == pending_requests_.end())
       return;
 
-    electron::util::Promise<base::DictionaryValue> promise =
-        std::move(it->second);
+    atom::util::Promise promise = std::move(it->second);
     pending_requests_.erase(it);
 
     base::DictionaryValue* error = nullptr;
@@ -131,7 +129,7 @@ void Debugger::Detach() {
 }
 
 v8::Local<v8::Promise> Debugger::SendCommand(mate::Arguments* args) {
-  electron::util::Promise<base::DictionaryValue> promise(isolate());
+  atom::util::Promise promise(isolate());
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   if (!agent_host_) {
@@ -148,25 +146,14 @@ v8::Local<v8::Promise> Debugger::SendCommand(mate::Arguments* args) {
   base::DictionaryValue command_params;
   args->GetNext(&command_params);
 
-  std::string session_id;
-  if (args->GetNext(&session_id) && session_id.empty()) {
-    promise.RejectWithErrorMessage("Empty session id is not allowed");
-    return handle;
-  }
-
   base::DictionaryValue request;
   int request_id = ++previous_request_id_;
   pending_requests_.emplace(request_id, std::move(promise));
   request.SetInteger("id", request_id);
   request.SetString("method", method);
-  if (!command_params.empty()) {
+  if (!command_params.empty())
     request.Set("params",
                 base::Value::ToUniquePtrValue(command_params.Clone()));
-  }
-
-  if (!session_id.empty()) {
-    request.SetString("sessionId", session_id);
-  }
 
   std::string json_args;
   base::JSONWriter::Write(request, &json_args);
@@ -199,11 +186,11 @@ void Debugger::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::Debugger;
+using atom::api::Debugger;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,

atom/browser/api/atom_api_debugger.h

@@ -2,19 +2,19 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_DEBUGGER_H_
-#define SHELL_BROWSER_API_ELECTRON_API_DEBUGGER_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_DEBUGGER_H_
+#define ATOM_BROWSER_API_ATOM_API_DEBUGGER_H_
 
 #include <map>
 #include <string>
 
+#include "atom/browser/api/trackable_object.h"
+#include "atom/common/promise_util.h"
 #include "base/callback.h"
 #include "base/values.h"
 #include "content/public/browser/devtools_agent_host_client.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "native_mate/handle.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/common/promise_util.h"
 
 namespace content {
 class DevToolsAgentHost;
@@ -25,7 +25,7 @@ namespace mate {
 class Arguments;
 }
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -54,8 +54,7 @@ class Debugger : public mate::TrackableObject<Debugger>,
                               content::RenderFrameHost* new_rfh) override;
 
  private:
-  using PendingRequestMap =
-      std::map<int, electron::util::Promise<base::DictionaryValue>>;
+  using PendingRequestMap = std::map<int, atom::util::Promise>;
 
   void Attach(mate::Arguments* args);
   bool IsAttached();
@@ -74,6 +73,6 @@ class Debugger : public mate::TrackableObject<Debugger>,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_DEBUGGER_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_DEBUGGER_H_

atom/browser/api/atom_api_desktop_capturer.cc

@@ -2,23 +2,22 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_desktop_capturer.h"
+#include "atom/browser/api/atom_api_desktop_capturer.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
+#include "atom/common/api/atom_api_native_image.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/node_includes.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/media/webrtc/desktop_media_list.h"
 #include "chrome/browser/media/webrtc/window_icon_util.h"
 #include "content/public/browser/desktop_capture.h"
-#include "shell/common/api/electron_api_native_image.h"
-#include "shell/common/gin_converters/gfx_converter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
+#include "native_mate/dictionary.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 
@@ -28,34 +27,34 @@
 #include "ui/display/win/display_info.h"
 #endif  // defined(OS_WIN)
 
-namespace gin {
+namespace mate {
 
 template <>
-struct Converter<electron::api::DesktopCapturer::Source> {
+struct Converter<atom::api::DesktopCapturer::Source> {
   static v8::Local<v8::Value> ToV8(
       v8::Isolate* isolate,
-      const electron::api::DesktopCapturer::Source& source) {
-    gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+      const atom::api::DesktopCapturer::Source& source) {
+    mate::Dictionary dict(isolate, v8::Object::New(isolate));
     content::DesktopMediaID id = source.media_list_source.id;
     dict.Set("name", base::UTF16ToUTF8(source.media_list_source.name));
     dict.Set("id", id.ToString());
     dict.Set("thumbnail",
-             electron::api::NativeImage::Create(
+             atom::api::NativeImage::Create(
                  isolate, gfx::Image(source.media_list_source.thumbnail)));
     dict.Set("display_id", source.display_id);
     if (source.fetch_icon) {
       dict.Set(
           "appIcon",
-          electron::api::NativeImage::Create(
+          atom::api::NativeImage::Create(
               isolate, gfx::Image(GetWindowIcon(source.media_list_source.id))));
     }
     return ConvertToV8(isolate, dict);
   }
 };
 
-}  // namespace gin
+}  // namespace mate
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -63,7 +62,7 @@ DesktopCapturer::DesktopCapturer(v8::Isolate* isolate) {
   Init(isolate);
 }
 
-DesktopCapturer::~DesktopCapturer() = default;
+DesktopCapturer::~DesktopCapturer() {}
 
 void DesktopCapturer::StartHandling(bool capture_window,
                                     bool capture_screen,
@@ -91,33 +90,47 @@ void DesktopCapturer::StartHandling(bool capture_window,
     // Initialize the source list.
     // Apply the new thumbnail size and restart capture.
     if (capture_window) {
-      window_capturer_ = std::make_unique<NativeDesktopMediaList>(
+      window_capturer_.reset(new NativeDesktopMediaList(
           content::DesktopMediaID::TYPE_WINDOW,
-          content::desktop_capture::CreateWindowCapturer());
+          content::desktop_capture::CreateWindowCapturer()));
       window_capturer_->SetThumbnailSize(thumbnail_size);
       window_capturer_->AddObserver(this);
-      window_capturer_->Update(base::BindOnce(
-          &DesktopCapturer::UpdateSourcesList, weak_ptr_factory_.GetWeakPtr(),
-          window_capturer_.get()));
+      window_capturer_->StartUpdating();
     }
 
     if (capture_screen) {
-      screen_capturer_ = std::make_unique<NativeDesktopMediaList>(
+      screen_capturer_.reset(new NativeDesktopMediaList(
           content::DesktopMediaID::TYPE_SCREEN,
-          content::desktop_capture::CreateScreenCapturer());
+          content::desktop_capture::CreateScreenCapturer()));
       screen_capturer_->SetThumbnailSize(thumbnail_size);
       screen_capturer_->AddObserver(this);
-      screen_capturer_->Update(base::BindOnce(
-          &DesktopCapturer::UpdateSourcesList, weak_ptr_factory_.GetWeakPtr(),
-          screen_capturer_.get()));
+      screen_capturer_->StartUpdating();
     }
   }
 }
 
+void DesktopCapturer::OnSourceAdded(DesktopMediaList* list, int index) {}
+
+void DesktopCapturer::OnSourceRemoved(DesktopMediaList* list, int index) {}
+
+void DesktopCapturer::OnSourceMoved(DesktopMediaList* list,
+                                    int old_index,
+                                    int new_index) {}
+
+void DesktopCapturer::OnSourceNameChanged(DesktopMediaList* list, int index) {}
+
+void DesktopCapturer::OnSourceThumbnailChanged(DesktopMediaList* list,
+                                               int index) {}
+
 void DesktopCapturer::OnSourceUnchanged(DesktopMediaList* list) {
   UpdateSourcesList(list);
 }
 
+bool DesktopCapturer::ShouldScheduleNextRefresh(DesktopMediaList* list) {
+  UpdateSourcesList(list);
+  return false;
+}
+
 void DesktopCapturer::UpdateSourcesList(DesktopMediaList* list) {
   if (capture_window_ &&
       list->GetMediaListType() == content::DesktopMediaID::TYPE_WINDOW) {
@@ -188,22 +201,22 @@ void DesktopCapturer::UpdateSourcesList(DesktopMediaList* list) {
 }
 
 // static
-gin::Handle<DesktopCapturer> DesktopCapturer::Create(v8::Isolate* isolate) {
-  return gin::CreateHandle(isolate, new DesktopCapturer(isolate));
+mate::Handle<DesktopCapturer> DesktopCapturer::Create(v8::Isolate* isolate) {
+  return mate::CreateHandle(isolate, new DesktopCapturer(isolate));
 }
 
 // static
 void DesktopCapturer::BuildPrototype(
     v8::Isolate* isolate,
     v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "DesktopCapturer"));
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "DesktopCapturer"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("startHandling", &DesktopCapturer::StartHandling);
 }
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
@@ -211,9 +224,9 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
-  gin_helper::Dictionary dict(context->GetIsolate(), exports);
-  dict.SetMethod("createDesktopCapturer",
-                 &electron::api::DesktopCapturer::Create);
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.SetMethod("createDesktopCapturer", &atom::api::DesktopCapturer::Create);
 }
 
 }  // namespace

atom/browser/api/atom_api_desktop_capturer.h

@@ -2,28 +2,24 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_DESKTOP_CAPTURER_H_
-#define SHELL_BROWSER_API_ELECTRON_API_DESKTOP_CAPTURER_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_DESKTOP_CAPTURER_H_
+#define ATOM_BROWSER_API_ATOM_API_DESKTOP_CAPTURER_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/trackable_object.h"
 #include "chrome/browser/media/webrtc/desktop_media_list_observer.h"
 #include "chrome/browser/media/webrtc/native_desktop_media_list.h"
-#include "gin/handle.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/common/gin_helper/event_emitter.h"
+#include "native_mate/handle.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
-class DesktopCapturer
-    : public mate::TrackableObject<
-          DesktopCapturer,
-          gin_helper::EventEmitter<mate::Wrappable<DesktopCapturer>>>,
-      public DesktopMediaListObserver {
+class DesktopCapturer : public mate::TrackableObject<DesktopCapturer>,
+                        public DesktopMediaListObserver {
  public:
   struct Source {
     DesktopMediaList::Source media_list_source;
@@ -34,7 +30,7 @@ class DesktopCapturer
     bool fetch_icon = false;
   };
 
-  static gin::Handle<DesktopCapturer> Create(v8::Isolate* isolate);
+  static mate::Handle<DesktopCapturer> Create(v8::Isolate* isolate);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
@@ -48,15 +44,16 @@ class DesktopCapturer
   explicit DesktopCapturer(v8::Isolate* isolate);
   ~DesktopCapturer() override;
 
-  // DesktopMediaListObserver:
-  void OnSourceAdded(DesktopMediaList* list, int index) override {}
-  void OnSourceRemoved(DesktopMediaList* list, int index) override {}
+  // DesktopMediaListObserver overrides.
+  void OnSourceAdded(DesktopMediaList* list, int index) override;
+  void OnSourceRemoved(DesktopMediaList* list, int index) override;
   void OnSourceMoved(DesktopMediaList* list,
                      int old_index,
-                     int new_index) override {}
-  void OnSourceNameChanged(DesktopMediaList* list, int index) override {}
-  void OnSourceThumbnailChanged(DesktopMediaList* list, int index) override {}
+                     int new_index) override;
+  void OnSourceNameChanged(DesktopMediaList* list, int index) override;
+  void OnSourceThumbnailChanged(DesktopMediaList* list, int index) override;
   void OnSourceUnchanged(DesktopMediaList* list) override;
+  bool ShouldScheduleNextRefresh(DesktopMediaList* list) override;
 
  private:
   void UpdateSourcesList(DesktopMediaList* list);
@@ -71,13 +68,11 @@ class DesktopCapturer
   bool using_directx_capturer_ = false;
 #endif  // defined(OS_WIN)
 
-  base::WeakPtrFactory<DesktopCapturer> weak_ptr_factory_{this};
-
   DISALLOW_COPY_AND_ASSIGN(DesktopCapturer);
 };
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_DESKTOP_CAPTURER_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_DESKTOP_CAPTURER_H_

atom/browser/api/atom_api_dialog.cc

@@ -0,0 +1,132 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "atom/browser/api/atom_api_browser_window.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/ui/certificate_trust.h"
+#include "atom/browser/ui/file_dialog.h"
+#include "atom/browser/ui/message_box.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/file_dialog_converter.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/net_converter.h"
+#include "atom/common/node_includes.h"
+#include "atom/common/promise_util.h"
+#include "native_mate/dictionary.h"
+
+namespace {
+
+int ShowMessageBoxSync(int type,
+                       const std::vector<std::string>& buttons,
+                       int default_id,
+                       int cancel_id,
+                       int options,
+                       const std::string& title,
+                       const std::string& message,
+                       const std::string& detail,
+                       const std::string& checkbox_label,
+                       bool checkbox_checked,
+                       const gfx::ImageSkia& icon,
+                       atom::NativeWindow* window) {
+  return atom::ShowMessageBoxSync(
+      window, static_cast<atom::MessageBoxType>(type), buttons, default_id,
+      cancel_id, options, title, message, detail, icon);
+}
+
+void ResolvePromiseObject(atom::util::Promise promise,
+                          int result,
+                          bool checkbox_checked) {
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(promise.isolate());
+
+  dict.Set("response", result);
+  dict.Set("checkboxChecked", checkbox_checked);
+
+  promise.Resolve(dict.GetHandle());
+}
+
+v8::Local<v8::Promise> ShowMessageBox(int type,
+                                      const std::vector<std::string>& buttons,
+                                      int default_id,
+                                      int cancel_id,
+                                      int options,
+                                      const std::string& title,
+                                      const std::string& message,
+                                      const std::string& detail,
+                                      const std::string& checkbox_label,
+                                      bool checkbox_checked,
+                                      const gfx::ImageSkia& icon,
+                                      atom::NativeWindow* window,
+                                      mate::Arguments* args) {
+  v8::Isolate* isolate = args->isolate();
+  atom::util::Promise promise(isolate);
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  atom::ShowMessageBox(
+      window, static_cast<atom::MessageBoxType>(type), buttons, default_id,
+      cancel_id, options, title, message, detail, checkbox_label,
+      checkbox_checked, icon,
+      base::BindOnce(&ResolvePromiseObject, std::move(promise)));
+
+  return handle;
+}
+
+void ShowOpenDialogSync(const file_dialog::DialogSettings& settings,
+                        mate::Arguments* args) {
+  std::vector<base::FilePath> paths;
+  if (file_dialog::ShowOpenDialogSync(settings, &paths))
+    args->Return(paths);
+}
+
+v8::Local<v8::Promise> ShowOpenDialog(
+    const file_dialog::DialogSettings& settings,
+    mate::Arguments* args) {
+  atom::util::Promise promise(args->isolate());
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+  file_dialog::ShowOpenDialog(settings, std::move(promise));
+  return handle;
+}
+
+void ShowSaveDialogSync(const file_dialog::DialogSettings& settings,
+                        mate::Arguments* args) {
+  base::FilePath path;
+  if (file_dialog::ShowSaveDialogSync(settings, &path))
+    args->Return(path);
+}
+
+v8::Local<v8::Promise> ShowSaveDialog(
+    const file_dialog::DialogSettings& settings,
+    mate::Arguments* args) {
+  atom::util::Promise promise(args->isolate());
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  file_dialog::ShowSaveDialog(settings, std::move(promise));
+  return handle;
+}
+
+void Initialize(v8::Local<v8::Object> exports,
+                v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context,
+                void* priv) {
+  mate::Dictionary dict(context->GetIsolate(), exports);
+  dict.SetMethod("showMessageBoxSync", &ShowMessageBoxSync);
+  dict.SetMethod("showMessageBox", &ShowMessageBox);
+  dict.SetMethod("showErrorBox", &atom::ShowErrorBox);
+  dict.SetMethod("showOpenDialogSync", &ShowOpenDialogSync);
+  dict.SetMethod("showOpenDialog", &ShowOpenDialog);
+  dict.SetMethod("showSaveDialogSync", &ShowSaveDialogSync);
+  dict.SetMethod("showSaveDialog", &ShowSaveDialog);
+#if defined(OS_MACOSX) || defined(OS_WIN)
+  dict.SetMethod("showCertificateTrustDialog",
+                 &certificate_trust::ShowCertificateTrust);
+#endif
+}
+
+}  // namespace
+
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_dialog, Initialize)

atom/browser/api/atom_api_download_item.cc

@@ -2,19 +2,20 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_download_item.h"
+#include "atom/browser/api/atom_api_download_item.h"
 
 #include <map>
 
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/file_dialog_converter.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/node_includes.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "native_mate/dictionary.h"
 #include "net/base/filename_util.h"
-#include "shell/browser/electron_browser_main_parts.h"
-#include "shell/common/native_mate_converters/file_dialog_converter.h"
-#include "shell/common/native_mate_converters/file_path_converter.h"
-#include "shell/common/native_mate_converters/gurl_converter.h"
-#include "shell/common/node_includes.h"
 
 namespace mate {
 
@@ -46,7 +47,7 @@ struct Converter<download::DownloadItem::DownloadState> {
 
 }  // namespace mate
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -189,8 +190,8 @@ double DownloadItem::GetStartTime() const {
 void DownloadItem::BuildPrototype(v8::Isolate* isolate,
                                   v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "DownloadItem"));
-  gin_helper::Destroyable::MakeDestroyable(isolate, prototype);
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
       .SetMethod("pause", &DownloadItem::Pause)
       .SetMethod("isPaused", &DownloadItem::IsPaused)
       .SetMethod("resume", &DownloadItem::Resume)
@@ -208,8 +209,6 @@ void DownloadItem::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("isDone", &DownloadItem::IsDone)
       .SetMethod("setSavePath", &DownloadItem::SetSavePath)
       .SetMethod("getSavePath", &DownloadItem::GetSavePath)
-      .SetProperty("savePath", &DownloadItem::GetSavePath,
-                   &DownloadItem::SetSavePath)
       .SetMethod("setSaveDialogOptions", &DownloadItem::SetSaveDialogOptions)
       .SetMethod("getSaveDialogOptions", &DownloadItem::GetSaveDialogOptions)
       .SetMethod("getLastModifiedTime", &DownloadItem::GetLastModifiedTime)
@@ -234,7 +233,7 @@ mate::Handle<DownloadItem> DownloadItem::Create(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
@@ -244,7 +243,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary(isolate, exports)
-      .Set("DownloadItem", electron::api::DownloadItem::GetConstructor(isolate)
+      .Set("DownloadItem", atom::api::DownloadItem::GetConstructor(isolate)
                                ->GetFunction(context)
                                .ToLocalChecked());
 }

atom/browser/api/atom_api_download_item.h

@@ -2,20 +2,20 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_DOWNLOAD_ITEM_H_
-#define SHELL_BROWSER_API_ELECTRON_API_DOWNLOAD_ITEM_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_DOWNLOAD_ITEM_H_
+#define ATOM_BROWSER_API_ATOM_API_DOWNLOAD_ITEM_H_
 
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/ui/file_dialog.h"
 #include "base/files/file_path.h"
 #include "components/download/public/common/download_item.h"
 #include "native_mate/handle.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/browser/ui/file_dialog.h"
 #include "url/gurl.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -69,6 +69,6 @@ class DownloadItem : public mate::TrackableObject<DownloadItem>,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_DOWNLOAD_ITEM_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_DOWNLOAD_ITEM_H_

atom/browser/api/atom_api_event.cc

@@ -2,9 +2,9 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
+#include "atom/browser/api/event_emitter.h"
+#include "atom/common/node_includes.h"
 #include "native_mate/dictionary.h"
-#include "shell/browser/api/event_emitter_deprecated.h"
-#include "shell/common/node_includes.h"
 
 namespace {
 
@@ -13,17 +13,12 @@ v8::Local<v8::Object> CreateWithSender(v8::Isolate* isolate,
   return mate::internal::CreateJSEvent(isolate, sender, nullptr, base::nullopt);
 }
 
-v8::Local<v8::Object> CreateEmpty(v8::Isolate* isolate) {
-  return mate::internal::CreateEmptyJSEvent(isolate);
-}
-
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   mate::Dictionary dict(context->GetIsolate(), exports);
   dict.SetMethod("createWithSender", &CreateWithSender);
-  dict.SetMethod("createEmpty", &CreateEmpty);
 }
 
 }  // namespace

atom/browser/api/atom_api_global_shortcut.cc

@@ -2,18 +2,18 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_global_shortcut.h"
+#include "atom/browser/api/atom_api_global_shortcut.h"
 
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/atom_api_system_preferences.h"
+#include "atom/common/native_mate_converters/accelerator_converter.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/node_includes.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "native_mate/dictionary.h"
-#include "shell/browser/api/electron_api_system_preferences.h"
-#include "shell/common/native_mate_converters/accelerator_converter.h"
-#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
-#include "shell/common/node_includes.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
@@ -28,14 +28,12 @@ bool RegisteringMediaKeyForUntrustedClient(const ui::Accelerator& accelerator) {
   if (base::mac::IsAtLeastOS10_14()) {
     constexpr ui::KeyboardCode mediaKeys[] = {
         ui::VKEY_MEDIA_PLAY_PAUSE, ui::VKEY_MEDIA_NEXT_TRACK,
-        ui::VKEY_MEDIA_PREV_TRACK, ui::VKEY_MEDIA_STOP,
-        ui::VKEY_VOLUME_UP,        ui::VKEY_VOLUME_DOWN,
-        ui::VKEY_VOLUME_MUTE};
+        ui::VKEY_MEDIA_PREV_TRACK, ui::VKEY_MEDIA_STOP};
 
     if (std::find(std::begin(mediaKeys), std::end(mediaKeys),
                   accelerator.key_code()) != std::end(mediaKeys)) {
       bool trusted =
-          electron::api::SystemPreferences::IsTrustedAccessibilityClient(false);
+          atom::api::SystemPreferences::IsTrustedAccessibilityClient(false);
       if (!trusted)
         return true;
     }
@@ -46,7 +44,7 @@ bool RegisteringMediaKeyForUntrustedClient(const ui::Accelerator& accelerator) {
 
 }  // namespace
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -61,7 +59,7 @@ GlobalShortcut::~GlobalShortcut() {
 void GlobalShortcut::OnKeyPressed(const ui::Accelerator& accelerator) {
   if (accelerator_callback_map_.find(accelerator) ==
       accelerator_callback_map_.end()) {
-    // This should never occur, because if it does, GlobalShortcutListener
+    // This should never occur, because if it does, GlobalGlobalShortcutListener
     // notifies us with wrong accelerator.
     NOTREACHED();
     return;
@@ -75,13 +73,19 @@ bool GlobalShortcut::RegisterAll(
   std::vector<ui::Accelerator> registered;
 
   for (auto& accelerator : accelerators) {
-    if (!Register(accelerator, callback)) {
+#if defined(OS_MACOSX)
+    if (RegisteringMediaKeyForUntrustedClient(accelerator))
+      return false;
+
+    GlobalShortcutListener* listener = GlobalShortcutListener::GetInstance();
+    if (!listener->RegisterAccelerator(accelerator, this)) {
       // unregister all shortcuts if any failed
       UnregisterSome(registered);
       return false;
     }
-
+#endif
     registered.push_back(accelerator);
+    accelerator_callback_map_[accelerator] = callback;
   }
   return true;
 }
@@ -103,9 +107,10 @@ bool GlobalShortcut::Register(const ui::Accelerator& accelerator,
 }
 
 void GlobalShortcut::Unregister(const ui::Accelerator& accelerator) {
-  if (accelerator_callback_map_.erase(accelerator) == 0)
+  if (!ContainsKey(accelerator_callback_map_, accelerator))
     return;
 
+  accelerator_callback_map_.erase(accelerator);
   GlobalShortcutListener::GetInstance()->UnregisterAccelerator(accelerator,
                                                                this);
 }
@@ -118,7 +123,7 @@ void GlobalShortcut::UnregisterSome(
 }
 
 bool GlobalShortcut::IsRegistered(const ui::Accelerator& accelerator) {
-  return base::Contains(accelerator_callback_map_, accelerator);
+  return ContainsKey(accelerator_callback_map_, accelerator);
 }
 
 void GlobalShortcut::UnregisterAll() {
@@ -145,7 +150,7 @@ void GlobalShortcut::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
@@ -155,7 +160,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("globalShortcut", electron::api::GlobalShortcut::Create(isolate));
+  dict.Set("globalShortcut", atom::api::GlobalShortcut::Create(isolate));
 }
 
 }  // namespace

atom/browser/api/atom_api_global_shortcut.h

@@ -2,20 +2,20 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_GLOBAL_SHORTCUT_H_
-#define SHELL_BROWSER_API_ELECTRON_API_GLOBAL_SHORTCUT_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_GLOBAL_SHORTCUT_H_
+#define ATOM_BROWSER_API_ATOM_API_GLOBAL_SHORTCUT_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/trackable_object.h"
 #include "base/callback.h"
 #include "chrome/browser/extensions/global_shortcut_listener.h"
 #include "native_mate/handle.h"
-#include "shell/browser/api/trackable_object.h"
 #include "ui/base/accelerators/accelerator.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -53,6 +53,6 @@ class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_GLOBAL_SHORTCUT_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_GLOBAL_SHORTCUT_H_

atom/browser/api/atom_api_in_app_purchase.cc

@@ -2,23 +2,23 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_in_app_purchase.h"
+#include "atom/browser/api/atom_api_in_app_purchase.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/node_includes.h"
+#include "native_mate/dictionary.h"
 
-namespace gin {
+namespace mate {
 
 template <>
 struct Converter<in_app_purchase::Payment> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    const in_app_purchase::Payment& payment) {
-    gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+    mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
     dict.SetHidden("simple", true);
     dict.Set("productIdentifier", payment.productIdentifier);
     dict.Set("quantity", payment.quantity);
@@ -30,7 +30,7 @@ template <>
 struct Converter<in_app_purchase::Transaction> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    const in_app_purchase::Transaction& val) {
-    gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+    mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
     dict.SetHidden("simple", true);
     dict.Set("transactionIdentifier", val.transactionIdentifier);
     dict.Set("transactionDate", val.transactionDate);
@@ -48,7 +48,7 @@ template <>
 struct Converter<in_app_purchase::Product> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    const in_app_purchase::Product& val) {
-    gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+    mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
     dict.SetHidden("simple", true);
     dict.Set("productIdentifier", val.productIdentifier);
     dict.Set("localizedDescription", val.localizedDescription);
@@ -61,29 +61,29 @@ struct Converter<in_app_purchase::Product> {
     dict.Set("formattedPrice", val.formattedPrice);
 
     // Downloadable Content Information
-    dict.Set("isDownloadable", val.isDownloadable);
+    dict.Set("isDownloadable", val.downloadable);
 
     return dict.GetHandle();
   }
 };
 
-}  // namespace gin
+}  // namespace mate
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
 #if defined(OS_MACOSX)
 // static
-gin::Handle<InAppPurchase> InAppPurchase::Create(v8::Isolate* isolate) {
-  return gin::CreateHandle(isolate, new InAppPurchase(isolate));
+mate::Handle<InAppPurchase> InAppPurchase::Create(v8::Isolate* isolate) {
+  return mate::CreateHandle(isolate, new InAppPurchase(isolate));
 }
 
 // static
 void InAppPurchase::BuildPrototype(v8::Isolate* isolate,
                                    v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "InAppPurchase"));
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "InAppPurchase"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("canMakePayments", &in_app_purchase::CanMakePayments)
       .SetMethod("getReceiptURL", &in_app_purchase::GetReceiptURL)
       .SetMethod("purchaseProduct", &InAppPurchase::PurchaseProduct)
@@ -102,9 +102,9 @@ InAppPurchase::~InAppPurchase() {}
 
 v8::Local<v8::Promise> InAppPurchase::PurchaseProduct(
     const std::string& product_id,
-    gin::Arguments* args) {
+    mate::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
-  electron::util::Promise<bool> promise(isolate);
+  atom::util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   int quantity = 1;
@@ -112,24 +112,23 @@ v8::Local<v8::Promise> InAppPurchase::PurchaseProduct(
 
   in_app_purchase::PurchaseProduct(
       product_id, quantity,
-      base::BindOnce(util::Promise<bool>::ResolvePromise, std::move(promise)));
+      base::BindOnce(atom::util::Promise::ResolvePromise<bool>,
+                     std::move(promise)));
 
   return handle;
 }
 
 v8::Local<v8::Promise> InAppPurchase::GetProducts(
     const std::vector<std::string>& productIDs,
-    gin::Arguments* args) {
+    mate::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
-  electron::util::Promise<std::vector<in_app_purchase::Product>> promise(
-      isolate);
+  atom::util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   in_app_purchase::GetProducts(
-      productIDs,
-      base::BindOnce(
-          util::Promise<std::vector<in_app_purchase::Product>>::ResolvePromise,
-          std::move(promise)));
+      productIDs, base::BindOnce(atom::util::Promise::ResolvePromise<
+                                     std::vector<in_app_purchase::Product>>,
+                                 std::move(promise)));
 
   return handle;
 }
@@ -142,11 +141,11 @@ void InAppPurchase::OnTransactionsUpdated(
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::InAppPurchase;
+using atom::api::InAppPurchase;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
@@ -154,7 +153,7 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
 #if defined(OS_MACOSX)
   v8::Isolate* isolate = context->GetIsolate();
-  gin_helper::Dictionary dict(isolate, exports);
+  mate::Dictionary dict(isolate, exports);
   dict.Set("inAppPurchase", InAppPurchase::Create(isolate));
   dict.Set("InAppPurchase", InAppPurchase::GetConstructor(isolate)
                                 ->GetFunction(context)

atom/browser/api/atom_api_in_app_purchase.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2017 Amaplex Software, 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_IN_APP_PURCHASE_H_
+#define ATOM_BROWSER_API_ATOM_API_IN_APP_PURCHASE_H_
+
+#include <string>
+#include <vector>
+
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/mac/in_app_purchase.h"
+#include "atom/browser/mac/in_app_purchase_observer.h"
+#include "atom/browser/mac/in_app_purchase_product.h"
+#include "atom/common/promise_util.h"
+#include "native_mate/handle.h"
+
+namespace atom {
+
+namespace api {
+
+class InAppPurchase : public mate::EventEmitter<InAppPurchase>,
+                      public in_app_purchase::TransactionObserver {
+ public:
+  static mate::Handle<InAppPurchase> Create(v8::Isolate* isolate);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
+
+ protected:
+  explicit InAppPurchase(v8::Isolate* isolate);
+  ~InAppPurchase() override;
+
+  v8::Local<v8::Promise> PurchaseProduct(const std::string& product_id,
+                                         mate::Arguments* args);
+
+  v8::Local<v8::Promise> GetProducts(const std::vector<std::string>& productIDs,
+                                     mate::Arguments* args);
+
+  // TransactionObserver:
+  void OnTransactionsUpdated(
+      const std::vector<in_app_purchase::Transaction>& transactions) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(InAppPurchase);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_IN_APP_PURCHASE_H_

atom/browser/api/atom_api_menu.cc

@@ -2,35 +2,25 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_menu.h"
-
-#include <map>
-#include <utility>
+#include "atom/browser/api/atom_api_menu.h"
 
+#include "atom/browser/native_window.h"
+#include "atom/common/native_mate_converters/accelerator_converter.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_includes.h"
 #include "native_mate/constructor.h"
-#include "shell/browser/native_window.h"
-#include "shell/common/gin_converters/callback_converter.h"
-#include "shell/common/gin_converters/image_converter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/native_mate_converters/accelerator_converter.h"
-#include "shell/common/node_includes.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
 
-namespace {
-
-// We need this map to keep references to currently opened menus.
-// Without this menus would be destroyed by js garbage collector
-// even when they are still displayed.
-std::map<uint32_t, v8::Global<v8::Object>> g_menus;
-
-}  // unnamed namespace
-
-namespace electron {
+namespace atom {
 
 namespace api {
 
-Menu::Menu(gin::Arguments* args) : model_(new ElectronMenuModel(this)) {
-  InitWithArgs(args);
+Menu::Menu(v8::Isolate* isolate, v8::Local<v8::Object> wrapper)
+    : model_(new AtomMenuModel(this)) {
+  InitWith(isolate, wrapper);
   model_->AddObserver(this);
 }
 
@@ -41,8 +31,8 @@ Menu::~Menu() {
 }
 
 void Menu::AfterInit(v8::Isolate* isolate) {
-  gin::Dictionary wrappable(isolate, GetWrapper());
-  gin::Dictionary delegate(nullptr);
+  mate::Dictionary wrappable(isolate, GetWrapper());
+  mate::Dictionary delegate;
   if (!wrappable.Get("delegate", &delegate))
     return;
 
@@ -151,10 +141,6 @@ void Menu::SetSublabel(int index, const base::string16& sublabel) {
   model_->SetSublabel(index, sublabel);
 }
 
-void Menu::SetToolTip(int index, const base::string16& toolTip) {
-  model_->SetToolTip(index, toolTip);
-}
-
 void Menu::SetRole(int index, const base::string16& role) {
   model_->SetRole(index, role);
 }
@@ -183,10 +169,6 @@ base::string16 Menu::GetSublabelAt(int index) const {
   return model_->GetSublabelAt(index);
 }
 
-base::string16 Menu::GetToolTipAt(int index) const {
-  return model_->GetToolTipAt(index);
-}
-
 base::string16 Menu::GetAcceleratorTextAt(int index) const {
   ui::Accelerator accelerator;
   model_->GetAcceleratorAtWithParams(index, true, &accelerator);
@@ -210,31 +192,19 @@ bool Menu::WorksWhenHiddenAt(int index) const {
 }
 
 void Menu::OnMenuWillClose() {
-  g_menus.erase(weak_map_id());
   Emit("menu-will-close");
 }
 
 void Menu::OnMenuWillShow() {
-  g_menus[weak_map_id()] = v8::Global<v8::Object>(isolate(), GetWrapper());
   Emit("menu-will-show");
 }
 
-base::OnceClosure Menu::BindSelfToClosure(base::OnceClosure callback) {
-  // return ((callback, ref) => { callback() }).bind(null, callback, this)
-  v8::Global<v8::Value> ref(isolate(), GetWrapper());
-  return base::BindOnce(
-      [](base::OnceClosure callback, v8::Global<v8::Value> ref) {
-        std::move(callback).Run();
-      },
-      std::move(callback), std::move(ref));
-}
-
 // static
 void Menu::BuildPrototype(v8::Isolate* isolate,
                           v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "Menu"));
-  gin_helper::Destroyable::MakeDestroyable(isolate, prototype);
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "Menu"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
       .SetMethod("insertItem", &Menu::InsertItemAt)
       .SetMethod("insertCheckItem", &Menu::InsertCheckItemAt)
       .SetMethod("insertRadioItem", &Menu::InsertRadioItemAt)
@@ -242,7 +212,6 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("insertSubMenu", &Menu::InsertSubMenuAt)
       .SetMethod("setIcon", &Menu::SetIcon)
       .SetMethod("setSublabel", &Menu::SetSublabel)
-      .SetMethod("setToolTip", &Menu::SetToolTip)
       .SetMethod("setRole", &Menu::SetRole)
       .SetMethod("clear", &Menu::Clear)
       .SetMethod("getIndexOfCommandId", &Menu::GetIndexOfCommandId)
@@ -250,7 +219,6 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getCommandIdAt", &Menu::GetCommandIdAt)
       .SetMethod("getLabelAt", &Menu::GetLabelAt)
       .SetMethod("getSublabelAt", &Menu::GetSublabelAt)
-      .SetMethod("getToolTipAt", &Menu::GetToolTipAt)
       .SetMethod("getAcceleratorTextAt", &Menu::GetAcceleratorTextAt)
       .SetMethod("isItemCheckedAt", &Menu::IsItemCheckedAt)
       .SetMethod("isEnabledAt", &Menu::IsEnabledAt)
@@ -262,20 +230,20 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::Menu;
+using atom::api::Menu;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  Menu::SetConstructor(isolate, base::BindRepeating(&Menu::New));
+  Menu::SetConstructor(isolate, base::Bind(&Menu::New));
 
-  gin_helper::Dictionary dict(isolate, exports);
+  mate::Dictionary dict(isolate, exports);
   dict.Set(
       "Menu",
       Menu::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());

atom/browser/api/atom_api_menu.h

@@ -2,27 +2,26 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_MENU_H_
-#define SHELL_BROWSER_API_ELECTRON_API_MENU_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_MENU_H_
+#define ATOM_BROWSER_API_ATOM_API_MENU_H_
 
 #include <memory>
 #include <string>
 
+#include "atom/browser/api/atom_api_top_level_window.h"
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/ui/atom_menu_model.h"
 #include "base/callback.h"
-#include "gin/arguments.h"
-#include "shell/browser/api/electron_api_top_level_window.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/browser/ui/electron_menu_model.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
 class Menu : public mate::TrackableObject<Menu>,
-             public ElectronMenuModel::Delegate,
-             public ElectronMenuModel::Observer {
+             public AtomMenuModel::Delegate,
+             public AtomMenuModel::Observer {
  public:
-  static mate::WrappableBase* New(gin::Arguments* args);
+  static mate::WrappableBase* New(mate::Arguments* args);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
@@ -35,10 +34,10 @@ class Menu : public mate::TrackableObject<Menu>,
   static void SendActionToFirstResponder(const std::string& action);
 #endif
 
-  ElectronMenuModel* model() const { return model_.get(); }
+  AtomMenuModel* model() const { return model_.get(); }
 
  protected:
-  explicit Menu(gin::Arguments* args);
+  Menu(v8::Isolate* isolate, v8::Local<v8::Object> wrapper);
   ~Menu() override;
 
   // mate::Wrappable:
@@ -61,21 +60,16 @@ class Menu : public mate::TrackableObject<Menu>,
                        int x,
                        int y,
                        int positioning_item,
-                       base::OnceClosure callback) = 0;
+                       const base::Closure& callback) = 0;
   virtual void ClosePopupAt(int32_t window_id) = 0;
 
-  std::unique_ptr<ElectronMenuModel> model_;
+  std::unique_ptr<AtomMenuModel> model_;
   Menu* parent_ = nullptr;
 
   // Observable:
   void OnMenuWillClose() override;
   void OnMenuWillShow() override;
 
- protected:
-  // Returns a new callback which keeps references of the JS wrapper until the
-  // passed |callback| is called.
-  base::OnceClosure BindSelfToClosure(base::OnceClosure callback);
-
  private:
   void InsertItemAt(int index, int command_id, const base::string16& label);
   void InsertSeparatorAt(int index);
@@ -92,7 +86,6 @@ class Menu : public mate::TrackableObject<Menu>,
                        Menu* menu);
   void SetIcon(int index, const gfx::Image& image);
   void SetSublabel(int index, const base::string16& sublabel);
-  void SetToolTip(int index, const base::string16& toolTip);
   void SetRole(int index, const base::string16& role);
   void Clear();
   int GetIndexOfCommandId(int command_id);
@@ -100,7 +93,6 @@ class Menu : public mate::TrackableObject<Menu>,
   int GetCommandIdAt(int index) const;
   base::string16 GetLabelAt(int index) const;
   base::string16 GetSublabelAt(int index) const;
-  base::string16 GetToolTipAt(int index) const;
   base::string16 GetAcceleratorTextAt(int index) const;
   bool IsItemCheckedAt(int index) const;
   bool IsEnabledAt(int index) const;
@@ -108,40 +100,39 @@ class Menu : public mate::TrackableObject<Menu>,
   bool WorksWhenHiddenAt(int index) const;
 
   // Stored delegate methods.
-  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)>
+  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)>
       get_accelerator_;
-  base::RepeatingCallback<bool(v8::Local<v8::Value>, int)>
-      should_register_accelerator_;
-  base::RepeatingCallback<void(v8::Local<v8::Value>, v8::Local<v8::Value>, int)>
+  base::Callback<bool(v8::Local<v8::Value>, int)> should_register_accelerator_;
+  base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>, int)>
       execute_command_;
-  base::RepeatingCallback<void(v8::Local<v8::Value>)> menu_will_show_;
+  base::Callback<void(v8::Local<v8::Value>)> menu_will_show_;
 
   DISALLOW_COPY_AND_ASSIGN(Menu);
 };
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace mate {
 
 template <>
-struct Converter<electron::ElectronMenuModel*> {
+struct Converter<atom::AtomMenuModel*> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     electron::ElectronMenuModel** out) {
+                     atom::AtomMenuModel** out) {
     // null would be tranfered to NULL.
     if (val->IsNull()) {
       *out = nullptr;
       return true;
     }
 
-    electron::api::Menu* menu;
-    if (!Converter<electron::api::Menu*>::FromV8(isolate, val, &menu))
+    atom::api::Menu* menu;
+    if (!Converter<atom::api::Menu*>::FromV8(isolate, val, &menu))
       return false;
     *out = menu->model();
     return true;
@@ -150,4 +141,4 @@ struct Converter<electron::ElectronMenuModel*> {
 
 }  // namespace mate
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_MENU_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_H_

atom/browser/api/atom_api_menu_mac.h

@@ -2,50 +2,49 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_MENU_MAC_H_
-#define SHELL_BROWSER_API_ELECTRON_API_MENU_MAC_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
+#define ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
 
-#include "shell/browser/api/electron_api_menu.h"
+#include "atom/browser/api/atom_api_menu.h"
 
 #include <map>
 #include <string>
 
-#import "shell/browser/ui/cocoa/electron_menu_controller.h"
+#import "atom/browser/ui/cocoa/atom_menu_controller.h"
 
 using base::scoped_nsobject;
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
 class MenuMac : public Menu {
  protected:
-  explicit MenuMac(gin::Arguments* args);
+  MenuMac(v8::Isolate* isolate, v8::Local<v8::Object> wrapper);
   ~MenuMac() override;
 
   void PopupAt(TopLevelWindow* window,
                int x,
                int y,
                int positioning_item,
-               base::OnceClosure callback) override;
+               const base::Closure& callback) override;
   void PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
                  int32_t window_id,
                  int x,
                  int y,
                  int positioning_item,
-                 base::OnceClosure callback);
+                 base::Closure callback);
   void ClosePopupAt(int32_t window_id) override;
-  void ClosePopupOnUI(int32_t window_id);
 
  private:
   friend class Menu;
 
-  void OnClosed(int32_t window_id, base::OnceClosure callback);
+  void OnClosed(int32_t window_id, base::Closure callback);
 
-  scoped_nsobject<ElectronMenuController> menu_controller_;
+  scoped_nsobject<AtomMenuController> menu_controller_;
 
   // window ID -> open context menu
-  std::map<int32_t, scoped_nsobject<ElectronMenuController>> popup_controllers_;
+  std::map<int32_t, scoped_nsobject<AtomMenuController>> popup_controllers_;
 
   base::WeakPtrFactory<MenuMac> weak_factory_;
 
@@ -54,6 +53,6 @@ class MenuMac : public Menu {
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_MENU_MAC_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_

atom/browser/api/atom_api_menu_mac.mm

@@ -2,21 +2,18 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#import "shell/browser/api/electron_api_menu_mac.h"
-
-#include <string>
-#include <utility>
+#import "atom/browser/api/atom_api_menu_mac.h"
 
+#include "atom/browser/native_window.h"
+#include "atom/browser/unresponsive_suppressor.h"
+#include "atom/common/node_includes.h"
 #include "base/mac/scoped_sending_event.h"
-#include "base/message_loop/message_loop_current.h"
+#include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/task/post_task.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
-#include "shell/browser/native_window.h"
-#include "shell/browser/unresponsive_suppressor.h"
-#include "shell/common/node_includes.h"
 
 using content::BrowserThread;
 
@@ -26,11 +23,12 @@ static scoped_nsobject<NSMenu> applicationMenu_;
 
 }  // namespace
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
-MenuMac::MenuMac(gin::Arguments* args) : Menu(args), weak_factory_(this) {}
+MenuMac::MenuMac(v8::Isolate* isolate, v8::Local<v8::Object> wrapper)
+    : Menu(isolate, wrapper), weak_factory_(this) {}
 
 MenuMac::~MenuMac() = default;
 
@@ -38,20 +36,15 @@ void MenuMac::PopupAt(TopLevelWindow* window,
                       int x,
                       int y,
                       int positioning_item,
-                      base::OnceClosure callback) {
+                      const base::Closure& callback) {
   NativeWindow* native_window = window->window();
   if (!native_window)
     return;
 
-  // Make sure the Menu object would not be garbage-collected until the callback
-  // has run.
-  base::OnceClosure callback_with_ref = BindSelfToClosure(std::move(callback));
-
-  auto popup =
-      base::BindOnce(&MenuMac::PopupOnUI, weak_factory_.GetWeakPtr(),
-                     native_window->GetWeakPtr(), window->weak_map_id(), x, y,
-                     positioning_item, std::move(callback_with_ref));
-  base::SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE, std::move(popup));
+  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);
 }
 
 void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
@@ -59,17 +52,16 @@ void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
                         int x,
                         int y,
                         int positioning_item,
-                        base::OnceClosure callback) {
+                        base::Closure callback) {
   if (!native_window)
     return;
   NSWindow* nswindow = native_window->GetNativeWindow().GetNativeNSWindow();
 
-  base::OnceClosure close_callback =
-      base::BindOnce(&MenuMac::OnClosed, weak_factory_.GetWeakPtr(), window_id,
-                     std::move(callback));
-  popup_controllers_[window_id] = base::scoped_nsobject<ElectronMenuController>(
-      [[ElectronMenuController alloc] initWithModel:model()
-                              useDefaultAccelerator:NO]);
+  auto close_callback = base::Bind(
+      &MenuMac::OnClosed, weak_factory_.GetWeakPtr(), window_id, callback);
+  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];
 
@@ -104,7 +96,7 @@ void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
   if (rightmostMenuPoint > screenRight)
     position.x = position.x - [menu size].width;
 
-  [popup_controllers_[window_id] setCloseCallback:std::move(close_callback)];
+  [popup_controllers_[window_id] setCloseCallback:close_callback];
   // Make sure events can be pumped while the menu is up.
   base::MessageLoopCurrent::ScopedNestableTaskAllower allow;
 
@@ -116,18 +108,11 @@ void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
   base::mac::ScopedSendingEvent sendingEventScoper;
 
   // Don't emit unresponsive event when showing menu.
-  electron::UnresponsiveSuppressor suppressor;
+  atom::UnresponsiveSuppressor suppressor;
   [menu popUpMenuPositioningItem:item atLocation:position inView:view];
 }
 
 void MenuMac::ClosePopupAt(int32_t window_id) {
-  auto close_popup = base::BindOnce(&MenuMac::ClosePopupOnUI,
-                                    weak_factory_.GetWeakPtr(), window_id);
-  base::SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                   std::move(close_popup));
-}
-
-void MenuMac::ClosePopupOnUI(int32_t window_id) {
   auto controller = popup_controllers_.find(window_id);
   if (controller != popup_controllers_.end()) {
     // Close the controller for the window.
@@ -142,17 +127,17 @@ void MenuMac::ClosePopupOnUI(int32_t window_id) {
   }
 }
 
-void MenuMac::OnClosed(int32_t window_id, base::OnceClosure callback) {
+void MenuMac::OnClosed(int32_t window_id, base::Closure callback) {
   popup_controllers_.erase(window_id);
-  std::move(callback).Run();
+  callback.Run();
 }
 
 // static
 void Menu::SetApplicationMenu(Menu* base_menu) {
   MenuMac* menu = static_cast<MenuMac*>(base_menu);
-  base::scoped_nsobject<ElectronMenuController> menu_controller(
-      [[ElectronMenuController 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:)
@@ -177,10 +162,10 @@ void Menu::SendActionToFirstResponder(const std::string& action) {
 }
 
 // static
-mate::WrappableBase* Menu::New(gin::Arguments* args) {
-  return new MenuMac(args);
+mate::WrappableBase* Menu::New(mate::Arguments* args) {
+  return new MenuMac(args->isolate(), args->GetThis());
 }
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom

atom/browser/api/atom_api_menu_views.cc

@@ -2,22 +2,22 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_menu_views.h"
+#include "atom/browser/api/atom_api_menu_views.h"
 
 #include <memory>
-#include <utility>
 
-#include "shell/browser/native_window_views.h"
-#include "shell/browser/unresponsive_suppressor.h"
+#include "atom/browser/native_window_views.h"
+#include "atom/browser/unresponsive_suppressor.h"
 #include "ui/display/screen.h"
 
 using views::MenuRunner;
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
-MenuViews::MenuViews(gin::Arguments* args) : Menu(args), weak_factory_(this) {}
+MenuViews::MenuViews(v8::Isolate* isolate, v8::Local<v8::Object> wrapper)
+    : Menu(isolate, wrapper), weak_factory_(this) {}
 
 MenuViews::~MenuViews() = default;
 
@@ -25,7 +25,7 @@ void MenuViews::PopupAt(TopLevelWindow* window,
                         int x,
                         int y,
                         int positioning_item,
-                        base::OnceClosure callback) {
+                        const base::Closure& callback) {
   auto* native_window = static_cast<NativeWindowViews*>(window->window());
   if (!native_window)
     return;
@@ -42,25 +42,16 @@ void MenuViews::PopupAt(TopLevelWindow* window,
   int flags = MenuRunner::CONTEXT_MENU | MenuRunner::HAS_MNEMONICS;
 
   // Don't emit unresponsive event when showing menu.
-  electron::UnresponsiveSuppressor suppressor;
-
-  // Make sure the Menu object would not be garbage-collected until the callback
-  // has run.
-  base::OnceClosure callback_with_ref = BindSelfToClosure(std::move(callback));
+  atom::UnresponsiveSuppressor suppressor;
 
   // Show the menu.
-  //
-  // Note that while views::MenuRunner accepts RepeatingCallback as close
-  // callback, it is fine passing OnceCallback to it because we reset the
-  // menu runner immediately when the menu is closed.
   int32_t window_id = window->weak_map_id();
-  auto close_callback = base::AdaptCallbackForRepeating(
-      base::BindOnce(&MenuViews::OnClosed, weak_factory_.GetWeakPtr(),
-                     window_id, std::move(callback_with_ref)));
+  auto close_callback = base::Bind(
+      &MenuViews::OnClosed, weak_factory_.GetWeakPtr(), window_id, callback);
   menu_runners_[window_id] =
-      std::make_unique<MenuRunner>(model(), flags, std::move(close_callback));
+      std::make_unique<MenuRunner>(model(), flags, close_callback);
   menu_runners_[window_id]->RunMenuAt(
-      native_window->widget(), nullptr, gfx::Rect(location, gfx::Size()),
+      native_window->widget(), NULL, gfx::Rect(location, gfx::Size()),
       views::MenuAnchorPosition::kTopLeft, ui::MENU_SOURCE_MOUSE);
 }
 
@@ -78,16 +69,16 @@ void MenuViews::ClosePopupAt(int32_t window_id) {
   }
 }
 
-void MenuViews::OnClosed(int32_t window_id, base::OnceClosure callback) {
+void MenuViews::OnClosed(int32_t window_id, base::Closure callback) {
   menu_runners_.erase(window_id);
-  std::move(callback).Run();
+  callback.Run();
 }
 
 // static
-mate::WrappableBase* Menu::New(gin::Arguments* args) {
-  return new MenuViews(args);
+mate::WrappableBase* Menu::New(mate::Arguments* args) {
+  return new MenuViews(args->isolate(), args->GetThis());
 }
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom

atom/browser/api/atom_api_menu_views.h

@@ -2,24 +2,24 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_MENU_VIEWS_H_
-#define SHELL_BROWSER_API_ELECTRON_API_MENU_VIEWS_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_
+#define ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_
 
 #include <map>
 #include <memory>
 
+#include "atom/browser/api/atom_api_menu.h"
 #include "base/memory/weak_ptr.h"
-#include "shell/browser/api/electron_api_menu.h"
 #include "ui/display/screen.h"
 #include "ui/views/controls/menu/menu_runner.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
 class MenuViews : public Menu {
  public:
-  explicit MenuViews(gin::Arguments* args);
+  MenuViews(v8::Isolate* isolate, v8::Local<v8::Object> wrapper);
   ~MenuViews() override;
 
  protected:
@@ -27,11 +27,11 @@ class MenuViews : public Menu {
                int x,
                int y,
                int positioning_item,
-               base::OnceClosure callback) override;
+               const base::Closure& callback) override;
   void ClosePopupAt(int32_t window_id) override;
 
  private:
-  void OnClosed(int32_t window_id, base::OnceClosure callback);
+  void OnClosed(int32_t window_id, base::Closure callback);
 
   // window ID -> open context menu
   std::map<int32_t, std::unique_ptr<views::MenuRunner>> menu_runners_;
@@ -43,6 +43,6 @@ class MenuViews : public Menu {
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_MENU_VIEWS_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_

atom/browser/api/atom_api_net.cc

@@ -2,18 +2,12 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_net.h"
-
-#include <string>
-
+#include "atom/browser/api/atom_api_net.h"
+#include "atom/browser/api/atom_api_url_request.h"
+#include "atom/common/node_includes.h"
 #include "native_mate/dictionary.h"
-#include "native_mate/handle.h"
-#include "services/network/public/cpp/features.h"
-#include "shell/browser/api/electron_api_url_loader.h"
 
-#include "shell/common/node_includes.h"
-
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -21,7 +15,7 @@ Net::Net(v8::Isolate* isolate) {
   Init(isolate);
 }
 
-Net::~Net() = default;
+Net::~Net() {}
 
 // static
 v8::Local<v8::Value> Net::Create(v8::Isolate* isolate) {
@@ -33,32 +27,23 @@ void Net::BuildPrototype(v8::Isolate* isolate,
                          v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "Net"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
-      .SetProperty("URLLoader", &Net::URLLoader);
+      .SetProperty("URLRequest", &Net::URLRequest);
 }
 
-v8::Local<v8::Value> Net::URLLoader(v8::Isolate* isolate) {
-  v8::Local<v8::FunctionTemplate> constructor;
-  constructor = SimpleURLLoaderWrapper::GetConstructor(isolate);
-  return constructor->GetFunction(isolate->GetCurrentContext())
+v8::Local<v8::Value> Net::URLRequest(v8::Isolate* isolate) {
+  return URLRequest::GetConstructor(isolate)
+      ->GetFunction(isolate->GetCurrentContext())
       .ToLocalChecked();
 }
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-bool IsValidHeaderName(std::string header_name) {
-  return net::HttpUtil::IsValidHeaderName(header_name);
-}
-
-bool IsValidHeaderValue(std::string header_value) {
-  return net::HttpUtil::IsValidHeaderValue(header_value);
-}
-
-using electron::api::Net;
-using electron::api::SimpleURLLoaderWrapper;
+using atom::api::Net;
+using atom::api::URLRequest;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
@@ -66,15 +51,12 @@ void Initialize(v8::Local<v8::Object> exports,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
 
-  SimpleURLLoaderWrapper::SetConstructor(
-      isolate, base::BindRepeating(SimpleURLLoaderWrapper::New));
+  URLRequest::SetConstructor(isolate, base::Bind(URLRequest::New));
 
   mate::Dictionary dict(isolate, exports);
   dict.Set("net", Net::Create(isolate));
   dict.Set("Net",
            Net::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());
-  dict.SetMethod("_isValidHeaderName", &IsValidHeaderName);
-  dict.SetMethod("_isValidHeaderValue", &IsValidHeaderValue);
 }
 
 }  // namespace

atom/browser/api/atom_api_net.h

@@ -2,12 +2,12 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_NET_H_
-#define SHELL_BROWSER_API_ELECTRON_API_NET_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_NET_H_
+#define ATOM_BROWSER_API_ATOM_API_NET_H_
 
-#include "shell/browser/api/event_emitter_deprecated.h"
+#include "atom/browser/api/event_emitter.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -18,7 +18,7 @@ class Net : public mate::EventEmitter<Net> {
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
 
-  v8::Local<v8::Value> URLLoader(v8::Isolate* isolate);
+  v8::Local<v8::Value> URLRequest(v8::Isolate* isolate);
 
  protected:
   explicit Net(v8::Isolate* isolate);
@@ -30,6 +30,6 @@ class Net : public mate::EventEmitter<Net> {
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_NET_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_NET_H_

atom/browser/api/atom_api_net_log.cc

@@ -0,0 +1,140 @@
+// Copyright (c) 2018 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_net_log.h"
+
+#include <utility>
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/net/system_network_context_manager.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"
+#include "base/command_line.h"
+#include "chrome/browser/browser_process.h"
+#include "components/net_log/chrome_net_log.h"
+#include "content/public/browser/storage_partition.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/handle.h"
+#include "net/url_request/url_request_context_getter.h"
+
+namespace atom {
+
+namespace api {
+
+NetLog::NetLog(v8::Isolate* isolate, AtomBrowserContext* browser_context)
+    : browser_context_(browser_context) {
+  Init(isolate);
+
+  net_log_writer_ = g_browser_process->system_network_context_manager()
+                        ->GetNetExportFileWriter();
+  net_log_writer_->AddObserver(this);
+}
+
+NetLog::~NetLog() {
+  net_log_writer_->RemoveObserver(this);
+}
+
+void 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;
+  }
+
+  auto* network_context =
+      content::BrowserContext::GetDefaultStoragePartition(browser_context_)
+          ->GetNetworkContext();
+
+  // 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);
+}
+
+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();
+}
+
+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();
+}
+
+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);
+  } else {
+    promise.Resolve(base::FilePath());
+  }
+
+  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) {
+  return mate::CreateHandle(isolate, new NetLog(isolate, browser_context));
+}
+
+// static
+void NetLog::BuildPrototype(v8::Isolate* isolate,
+                            v8::Local<v8::FunctionTemplate> prototype) {
+  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);
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_net_log.h

@@ -0,0 +1,60 @@
+// Copyright (c) 2018 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_NET_LOG_H_
+#define ATOM_BROWSER_API_ATOM_API_NET_LOG_H_
+
+#include <list>
+#include <memory>
+#include <string>
+
+#include "atom/browser/api/trackable_object.h"
+#include "atom/common/promise_util.h"
+#include "base/callback.h"
+#include "base/values.h"
+#include "components/net_log/net_export_file_writer.h"
+#include "native_mate/handle.h"
+
+namespace atom {
+
+class AtomBrowserContext;
+
+namespace api {
+
+class NetLog : public mate::TrackableObject<NetLog>,
+               public net_log::NetExportFileWriter::StateObserver {
+ public:
+  static mate::Handle<NetLog> Create(v8::Isolate* isolate,
+                                     AtomBrowserContext* browser_context);
+
+  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> StopLogging(mate::Arguments* args);
+
+ protected:
+  explicit NetLog(v8::Isolate* isolate, AtomBrowserContext* browser_context);
+  ~NetLog() override;
+
+  // net_log::NetExportFileWriter::StateObserver implementation
+  void OnNewState(const base::DictionaryValue& state) override;
+
+ 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_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetLog);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_NET_LOG_H_

atom/browser/api/atom_api_notification.cc

@@ -2,28 +2,29 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_notification.h"
+#include "atom/browser/api/atom_api_notification.h"
 
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/atom_browser_client.h"
+#include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_includes.h"
 #include "base/guid.h"
 #include "base/strings/utf_string_conversions.h"
 #include "native_mate/constructor.h"
-#include "shell/browser/api/electron_api_menu.h"
-#include "shell/browser/browser.h"
-#include "shell/browser/electron_browser_client.h"
-#include "shell/common/gin_converters/image_converter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
 #include "url/gurl.h"
 
-namespace gin {
-
+namespace mate {
 template <>
-struct Converter<electron::NotificationAction> {
+struct Converter<atom::NotificationAction> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     electron::NotificationAction* out) {
-    gin::Dictionary dict(isolate);
+                     atom::NotificationAction* out) {
+    mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
       return false;
 
@@ -35,27 +36,28 @@ struct Converter<electron::NotificationAction> {
   }
 
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   electron::NotificationAction val) {
-    gin::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+                                   atom::NotificationAction val) {
+    mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
     dict.Set("text", val.text);
     dict.Set("type", val.type);
-    return ConvertToV8(isolate, dict);
+    return dict.GetHandle();
   }
 };
+}  // namespace mate
 
-}  // namespace gin
-
-namespace electron {
+namespace atom {
 
 namespace api {
 
-Notification::Notification(gin::Arguments* args) {
-  InitWithArgs(args);
+Notification::Notification(v8::Isolate* isolate,
+                           v8::Local<v8::Object> wrapper,
+                           mate::Arguments* args) {
+  InitWith(isolate, wrapper);
 
-  presenter_ = static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
+  presenter_ = static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())
                    ->GetNotificationPresenter();
 
-  gin::Dictionary opts(nullptr);
+  mate::Dictionary opts;
   if (args->GetNext(&opts)) {
     opts.Get("title", &title_);
     opts.Get("subtitle", &subtitle_);
@@ -66,9 +68,7 @@ Notification::Notification(gin::Arguments* args) {
     }
     opts.Get("silent", &silent_);
     opts.Get("replyPlaceholder", &reply_placeholder_);
-    opts.Get("urgency", &urgency_);
     opts.Get("hasReply", &has_reply_);
-    opts.Get("timeoutType", &timeout_type_);
     opts.Get("actions", &actions_);
     opts.Get("sound", &sound_);
     opts.Get("closeButtonText", &close_button_text_);
@@ -81,13 +81,12 @@ Notification::~Notification() {
 }
 
 // static
-mate::WrappableBase* Notification::New(gin_helper::ErrorThrower thrower,
-                                       gin::Arguments* args) {
+mate::WrappableBase* Notification::New(mate::Arguments* args) {
   if (!Browser::Get()->is_ready()) {
-    thrower.ThrowError("Cannot create Notification before app is ready");
+    args->ThrowError("Cannot create Notification before app is ready");
     return nullptr;
   }
-  return new Notification(args);
+  return new Notification(args->isolate(), args->GetThis(), args);
 }
 
 // Getters
@@ -111,10 +110,6 @@ bool Notification::GetHasReply() const {
   return has_reply_;
 }
 
-base::string16 Notification::GetTimeoutType() const {
-  return timeout_type_;
-}
-
 base::string16 Notification::GetReplyPlaceholder() const {
   return reply_placeholder_;
 }
@@ -123,11 +118,7 @@ base::string16 Notification::GetSound() const {
   return sound_;
 }
 
-base::string16 Notification::GetUrgency() const {
-  return urgency_;
-}
-
-std::vector<electron::NotificationAction> Notification::GetActions() const {
+std::vector<atom::NotificationAction> Notification::GetActions() const {
   return actions_;
 }
 
@@ -156,10 +147,6 @@ void Notification::SetHasReply(bool new_has_reply) {
   has_reply_ = new_has_reply;
 }
 
-void Notification::SetTimeoutType(const base::string16& new_timeout_type) {
-  timeout_type_ = new_timeout_type;
-}
-
 void Notification::SetReplyPlaceholder(const base::string16& new_placeholder) {
   reply_placeholder_ = new_placeholder;
 }
@@ -168,12 +155,8 @@ void Notification::SetSound(const base::string16& new_sound) {
   sound_ = new_sound;
 }
 
-void Notification::SetUrgency(const base::string16& new_urgency) {
-  urgency_ = new_urgency;
-}
-
 void Notification::SetActions(
-    const std::vector<electron::NotificationAction>& actions) {
+    const std::vector<atom::NotificationAction>& actions) {
   actions_ = actions;
 }
 
@@ -206,7 +189,6 @@ void Notification::NotificationClosed() {
 void Notification::Close() {
   if (notification_) {
     notification_->Dismiss();
-    notification_->set_delegate(nullptr);
     notification_.reset();
   }
 }
@@ -217,7 +199,7 @@ void Notification::Show() {
   if (presenter_) {
     notification_ = presenter_->CreateNotification(this, base::GenerateGUID());
     if (notification_) {
-      electron::NotificationOptions options;
+      atom::NotificationOptions options;
       options.title = title_;
       options.subtitle = subtitle_;
       options.msg = body_;
@@ -225,28 +207,26 @@ void Notification::Show() {
       options.icon = icon_.AsBitmap();
       options.silent = silent_;
       options.has_reply = has_reply_;
-      options.timeout_type = timeout_type_;
       options.reply_placeholder = reply_placeholder_;
       options.actions = actions_;
       options.sound = sound_;
       options.close_button_text = close_button_text_;
-      options.urgency = urgency_;
       notification_->Show(options);
     }
   }
 }
 
 bool Notification::IsSupported() {
-  return !!static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
+  return !!static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())
                ->GetNotificationPresenter();
 }
 
 // static
 void Notification::BuildPrototype(v8::Isolate* isolate,
                                   v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "Notification"));
-  gin_helper::Destroyable::MakeDestroyable(isolate, prototype);
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "Notification"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
       .SetMethod("show", &Notification::Show)
       .SetMethod("close", &Notification::Close)
       .SetProperty("title", &Notification::GetTitle, &Notification::SetTitle)
@@ -256,12 +236,8 @@ void Notification::BuildPrototype(v8::Isolate* isolate,
       .SetProperty("silent", &Notification::GetSilent, &Notification::SetSilent)
       .SetProperty("hasReply", &Notification::GetHasReply,
                    &Notification::SetHasReply)
-      .SetProperty("timeoutType", &Notification::GetTimeoutType,
-                   &Notification::SetTimeoutType)
       .SetProperty("replyPlaceholder", &Notification::GetReplyPlaceholder,
                    &Notification::SetReplyPlaceholder)
-      .SetProperty("urgency", &Notification::GetUrgency,
-                   &Notification::SetUrgency)
       .SetProperty("sound", &Notification::GetSound, &Notification::SetSound)
       .SetProperty("actions", &Notification::GetActions,
                    &Notification::SetActions)
@@ -271,21 +247,20 @@ void Notification::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::Notification;
+using atom::api::Notification;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  Notification::SetConstructor(isolate,
-                               base::BindRepeating(&Notification::New));
+  Notification::SetConstructor(isolate, base::Bind(&Notification::New));
 
-  gin_helper::Dictionary dict(isolate, exports);
+  mate::Dictionary dict(isolate, exports);
   dict.Set("Notification", Notification::GetConstructor(isolate)
                                ->GetFunction(context)
                                .ToLocalChecked());

atom/browser/api/atom_api_notification.h

@@ -2,34 +2,29 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_NOTIFICATION_H_
-#define SHELL_BROWSER_API_ELECTRON_API_NOTIFICATION_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_NOTIFICATION_H_
+#define ATOM_BROWSER_API_ATOM_API_NOTIFICATION_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/notifications/notification.h"
+#include "atom/browser/notifications/notification_delegate.h"
+#include "atom/browser/notifications/notification_presenter.h"
 #include "base/strings/utf_string_conversions.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/browser/notifications/notification.h"
-#include "shell/browser/notifications/notification_delegate.h"
-#include "shell/browser/notifications/notification_presenter.h"
-#include "shell/common/gin_helper/error_thrower.h"
+#include "native_mate/handle.h"
 #include "ui/gfx/image/image.h"
 
-namespace gin {
-class Arguments;
-}
-
-namespace electron {
+namespace atom {
 
 namespace api {
 
 class Notification : public mate::TrackableObject<Notification>,
                      public NotificationDelegate {
  public:
-  static mate::WrappableBase* New(gin_helper::ErrorThrower thrower,
-                                  gin::Arguments* args);
+  static mate::WrappableBase* New(mate::Arguments* args);
   static bool IsSupported();
 
   static void BuildPrototype(v8::Isolate* isolate,
@@ -44,7 +39,9 @@ class Notification : public mate::TrackableObject<Notification>,
   void NotificationClosed() override;
 
  protected:
-  explicit Notification(gin::Arguments* args);
+  Notification(v8::Isolate* isolate,
+               v8::Local<v8::Object> wrapper,
+               mate::Arguments* args);
   ~Notification() override;
 
   void Show();
@@ -56,11 +53,9 @@ class Notification : public mate::TrackableObject<Notification>,
   base::string16 GetBody() const;
   bool GetSilent() const;
   bool GetHasReply() const;
-  base::string16 GetTimeoutType() const;
   base::string16 GetReplyPlaceholder() const;
-  base::string16 GetUrgency() const;
   base::string16 GetSound() const;
-  std::vector<electron::NotificationAction> GetActions() const;
+  std::vector<atom::NotificationAction> GetActions() const;
   base::string16 GetCloseButtonText() const;
 
   // Prop Setters
@@ -69,11 +64,9 @@ class Notification : public mate::TrackableObject<Notification>,
   void SetBody(const base::string16& new_body);
   void SetSilent(bool new_silent);
   void SetHasReply(bool new_has_reply);
-  void SetUrgency(const base::string16& new_urgency);
-  void SetTimeoutType(const base::string16& new_timeout_type);
   void SetReplyPlaceholder(const base::string16& new_reply_placeholder);
   void SetSound(const base::string16& sound);
-  void SetActions(const std::vector<electron::NotificationAction>& actions);
+  void SetActions(const std::vector<atom::NotificationAction>& actions);
   void SetCloseButtonText(const base::string16& text);
 
  private:
@@ -85,22 +78,20 @@ class Notification : public mate::TrackableObject<Notification>,
   bool has_icon_ = false;
   bool silent_ = false;
   bool has_reply_ = false;
-  base::string16 timeout_type_;
   base::string16 reply_placeholder_;
   base::string16 sound_;
-  base::string16 urgency_;
-  std::vector<electron::NotificationAction> actions_;
+  std::vector<atom::NotificationAction> actions_;
   base::string16 close_button_text_;
 
-  electron::NotificationPresenter* presenter_;
+  atom::NotificationPresenter* presenter_;
 
-  base::WeakPtr<electron::Notification> notification_;
+  base::WeakPtr<atom::Notification> notification_;
 
   DISALLOW_COPY_AND_ASSIGN(Notification);
 };
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_NOTIFICATION_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_NOTIFICATION_H_

atom/browser/api/atom_api_power_monitor.cc

@@ -2,14 +2,14 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_power_monitor.h"
+#include "atom/browser/api/atom_api_power_monitor.h"
 
+#include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/node_includes.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
-#include "gin/dictionary.h"
-#include "shell/browser/browser.h"
-#include "shell/common/gin_converters/callback_converter.h"
-#include "shell/common/node_includes.h"
+#include "native_mate/dictionary.h"
 
 namespace mate {
 template <>
@@ -31,19 +31,19 @@ struct Converter<ui::IdleState> {
 };
 }  // namespace mate
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
 PowerMonitor::PowerMonitor(v8::Isolate* isolate) {
 #if defined(OS_LINUX)
-  SetShutdownHandler(base::BindRepeating(&PowerMonitor::ShouldShutdown,
-                                         base::Unretained(this)));
+  SetShutdownHandler(
+      base::Bind(&PowerMonitor::ShouldShutdown, base::Unretained(this)));
 #elif defined(OS_MACOSX)
-  Browser::Get()->SetShutdownHandler(base::BindRepeating(
-      &PowerMonitor::ShouldShutdown, base::Unretained(this)));
+  Browser::Get()->SetShutdownHandler(
+      base::Bind(&PowerMonitor::ShouldShutdown, base::Unretained(this)));
 #endif
-  base::PowerMonitor::AddObserver(this);
+  base::PowerMonitor::Get()->AddObserver(this);
   Init(isolate);
 #if defined(OS_MACOSX) || defined(OS_WIN)
   InitPlatformSpecificMonitors();
@@ -51,7 +51,7 @@ PowerMonitor::PowerMonitor(v8::Isolate* isolate) {
 }
 
 PowerMonitor::~PowerMonitor() {
-  base::PowerMonitor::RemoveObserver(this);
+  base::PowerMonitor::Get()->RemoveObserver(this);
 }
 
 bool PowerMonitor::ShouldShutdown() {
@@ -101,10 +101,9 @@ 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,
-                         "The 'powerMonitor' module can't be used before the "
-                         "app 'ready' event")));
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate,
+        "Cannot require \"powerMonitor\" module before app is ready")));
     return v8::Null(isolate);
   }
 
@@ -115,8 +114,9 @@ v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
 void PowerMonitor::BuildPrototype(v8::Isolate* isolate,
                                   v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "PowerMonitor"));
-  gin_helper::Destroyable::MakeDestroyable(isolate, prototype);
+
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
 #if defined(OS_LINUX)
       .SetMethod("blockShutdown", &PowerMonitor::BlockShutdown)
       .SetMethod("unblockShutdown", &PowerMonitor::UnblockShutdown)
@@ -127,19 +127,19 @@ void PowerMonitor::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::PowerMonitor;
+using atom::api::PowerMonitor;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  gin::Dictionary dict(isolate, exports);
-  dict.Set("createPowerMonitor", base::BindRepeating(&PowerMonitor::Create));
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("powerMonitor", PowerMonitor::Create(isolate));
   dict.Set("PowerMonitor", PowerMonitor::GetConstructor(isolate)
                                ->GetFunction(context)
                                .ToLocalChecked());

atom/browser/api/atom_api_power_monitor.h

@@ -2,16 +2,16 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_POWER_MONITOR_H_
-#define SHELL_BROWSER_API_ELECTRON_API_POWER_MONITOR_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
+#define ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
 
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/lib/power_observer.h"
 #include "base/compiler_specific.h"
 #include "native_mate/handle.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/browser/lib/power_observer.h"
 #include "ui/base/idle/idle.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -76,6 +76,6 @@ class PowerMonitor : public mate::TrackableObject<PowerMonitor>,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_POWER_MONITOR_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_

atom/browser/api/atom_api_power_monitor_mac.mm

@@ -2,19 +2,17 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_power_monitor.h"
+#include "atom/browser/api/atom_api_power_monitor.h"
 
-#include <vector>
-
-#import <ApplicationServices/ApplicationServices.h>
+#include <ApplicationServices/ApplicationServices.h>
 #import <Cocoa/Cocoa.h>
 
 @interface MacLockMonitor : NSObject {
  @private
-  std::vector<electron::api::PowerMonitor*> emitters;
+  std::vector<atom::api::PowerMonitor*> emitters;
 }
 
-- (void)addEmitter:(electron::api::PowerMonitor*)monitor_;
+- (void)addEmitter:(atom::api::PowerMonitor*)monitor_;
 
 @end
 
@@ -24,27 +22,14 @@
   if ((self = [super init])) {
     NSDistributedNotificationCenter* distCenter =
         [NSDistributedNotificationCenter defaultCenter];
-    // A notification that the screen was locked.
     [distCenter addObserver:self
                    selector:@selector(onScreenLocked:)
                        name:@"com.apple.screenIsLocked"
                      object:nil];
-    // A notification that the screen was unlocked by the user.
     [distCenter addObserver:self
                    selector:@selector(onScreenUnlocked:)
                        name:@"com.apple.screenIsUnlocked"
                      object:nil];
-    // A notification that the workspace posts before the machine goes to sleep.
-    [distCenter addObserver:self
-                   selector:@selector(isSuspending:)
-                       name:NSWorkspaceWillSleepNotification
-                     object:nil];
-    // A notification that the workspace posts when the machine wakes from
-    // sleep.
-    [distCenter addObserver:self
-                   selector:@selector(isResuming:)
-                       name:NSWorkspaceDidWakeNotification
-                     object:nil];
   }
   return self;
 }
@@ -54,37 +39,25 @@
   [super dealloc];
 }
 
-- (void)addEmitter:(electron::api::PowerMonitor*)monitor_ {
+- (void)addEmitter:(atom::api::PowerMonitor*)monitor_ {
   self->emitters.push_back(monitor_);
 }
 
-- (void)isSuspending:(NSNotification*)notify {
-  for (auto* emitter : self->emitters) {
-    emitter->Emit("suspend");
-  }
-}
-
-- (void)isResuming:(NSNotification*)notify {
-  for (auto* emitter : self->emitters) {
-    emitter->Emit("resume");
-  }
-}
-
 - (void)onScreenLocked:(NSNotification*)notification {
-  for (auto* emitter : self->emitters) {
+  for (auto*& emitter : self->emitters) {
     emitter->Emit("lock-screen");
   }
 }
 
 - (void)onScreenUnlocked:(NSNotification*)notification {
-  for (auto* emitter : self->emitters) {
+  for (auto*& emitter : self->emitters) {
     emitter->Emit("unlock-screen");
   }
 }
 
 @end
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -98,4 +71,4 @@ void PowerMonitor::InitPlatformSpecificMonitors() {
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom

atom/browser/api/atom_api_power_monitor_win.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_power_monitor.h"
+#include "atom/browser/api/atom_api_power_monitor.h"
 
 #include <windows.h>
 #include <wtsapi32.h>
@@ -11,7 +11,7 @@
 #include "ui/base/win/shell.h"
 #include "ui/gfx/win/hwnd_util.h"
 
-namespace electron {
+namespace atom {
 
 namespace {
 
@@ -39,18 +39,6 @@ void PowerMonitor::InitPlatformSpecificMonitors() {
 
   // Tel windows we want to be notified with session events
   WTSRegisterSessionNotification(window_, NOTIFY_FOR_THIS_SESSION);
-
-  // For Windows 8 and later, a new "connected standy" mode has been added and
-  // we must explicitly register for its notifications.
-  auto RegisterSuspendResumeNotification =
-      reinterpret_cast<decltype(&::RegisterSuspendResumeNotification)>(
-          GetProcAddress(GetModuleHandle(L"user32.dll"),
-                         "RegisterSuspendResumeNotification"));
-
-  if (RegisterSuspendResumeNotification) {
-    RegisterSuspendResumeNotification(static_cast<HANDLE>(window_),
-                                      DEVICE_NOTIFY_WINDOW_HANDLE);
-  }
 }
 
 LRESULT CALLBACK PowerMonitor::WndProcStatic(HWND hwnd,
@@ -75,16 +63,10 @@ LRESULT CALLBACK PowerMonitor::WndProc(HWND hwnd,
     } else if (wparam == WTS_SESSION_UNLOCK) {
       Emit("unlock-screen");
     }
-  } else if (message == WM_POWERBROADCAST) {
-    if (wparam == PBT_APMRESUMEAUTOMATIC) {
-      Emit("resume");
-    } else if (wparam == PBT_APMSUSPEND) {
-      Emit("suspend");
-    }
   }
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom

atom/browser/api/atom_api_power_save_blocker.cc

@@ -2,22 +2,20 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_power_save_blocker.h"
+#include "atom/browser/api/atom_api_power_save_blocker.h"
 
 #include <string>
 
-#include "base/bind_helpers.h"
+#include "atom/common/node_includes.h"
 #include "base/task/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "content/public/browser/system_connector.h"
-#include "gin/dictionary.h"
-#include "gin/function_template.h"
+#include "content/public/common/service_manager_connection.h"
+#include "native_mate/dictionary.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"
-#include "shell/common/node_includes.h"
 
-namespace gin {
+namespace mate {
 
 template <>
 struct Converter<device::mojom::WakeLockType> {
@@ -37,19 +35,19 @@ struct Converter<device::mojom::WakeLockType> {
   }
 };
 
-}  // namespace gin
+}  // namespace mate
 
-namespace electron {
+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) {}
+      is_wake_lock_active_(false) {
+  Init(isolate);
+}
 
-PowerSaveBlocker::~PowerSaveBlocker() = default;
+PowerSaveBlocker::~PowerSaveBlocker() {}
 
 void PowerSaveBlocker::UpdatePowerSaveBlocker() {
   if (wake_lock_types_.empty()) {
@@ -87,16 +85,17 @@ void PowerSaveBlocker::UpdatePowerSaveBlocker() {
 
 device::mojom::WakeLock* PowerSaveBlocker::GetWakeLock() {
   if (!wake_lock_) {
-    mojo::Remote<device::mojom::WakeLockProvider> wake_lock_provider;
-    DCHECK(content::GetSystemConnector());
-    content::GetSystemConnector()->Connect(
-        device::mojom::kServiceName,
-        wake_lock_provider.BindNewPipeAndPassReceiver());
+    device::mojom::WakeLockProviderPtr wake_lock_provider;
+    DCHECK(content::ServiceManagerConnection::GetForProcess());
+    auto* connector =
+        content::ServiceManagerConnection::GetForProcess()->GetConnector();
+    connector->BindInterface(device::mojom::kServiceName,
+                             mojo::MakeRequest(&wake_lock_provider));
 
     wake_lock_provider->GetWakeLockWithoutContext(
         device::mojom::WakeLockType::kPreventAppSuspension,
-        device::mojom::WakeLockReason::kOther, ELECTRON_PRODUCT_NAME,
-        wake_lock_.BindNewPipeAndPassReceiver());
+        device::mojom::WakeLockReason::kOther, ATOM_PRODUCT_NAME,
+        mojo::MakeRequest(&wake_lock_));
   }
   return wake_lock_.get();
 }
@@ -119,13 +118,16 @@ bool PowerSaveBlocker::IsStarted(int id) {
 }
 
 // static
-gin::Handle<PowerSaveBlocker> PowerSaveBlocker::Create(v8::Isolate* isolate) {
-  return gin::CreateHandle(isolate, new PowerSaveBlocker(isolate));
+mate::Handle<PowerSaveBlocker> PowerSaveBlocker::Create(v8::Isolate* isolate) {
+  return mate::CreateHandle(isolate, new PowerSaveBlocker(isolate));
 }
 
-gin::ObjectTemplateBuilder PowerSaveBlocker::GetObjectTemplateBuilder(
-    v8::Isolate* isolate) {
-  return gin::Wrappable<PowerSaveBlocker>::GetObjectTemplateBuilder(isolate)
+// static
+void PowerSaveBlocker::BuildPrototype(
+    v8::Isolate* isolate,
+    v8::Local<v8::FunctionTemplate> prototype) {
+  prototype->SetClassName(mate::StringToV8(isolate, "PowerSaveBlocker"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("start", &PowerSaveBlocker::Start)
       .SetMethod("stop", &PowerSaveBlocker::Stop)
       .SetMethod("isStarted", &PowerSaveBlocker::IsStarted);
@@ -133,7 +135,7 @@ gin::ObjectTemplateBuilder PowerSaveBlocker::GetObjectTemplateBuilder(
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
@@ -142,9 +144,8 @@ void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  gin::Dictionary dict(isolate, exports);
-  dict.Set("powerSaveBlocker",
-           electron::api::PowerSaveBlocker::Create(isolate));
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("powerSaveBlocker", atom::api::PowerSaveBlocker::Create(isolate));
 }
 
 }  // namespace

atom/browser/api/atom_api_power_save_blocker.h

@@ -2,31 +2,30 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_POWER_SAVE_BLOCKER_H_
-#define SHELL_BROWSER_API_ELECTRON_API_POWER_SAVE_BLOCKER_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_POWER_SAVE_BLOCKER_H_
+#define ATOM_BROWSER_API_ATOM_API_POWER_SAVE_BLOCKER_H_
 
 #include <map>
 #include <memory>
 
-#include "gin/handle.h"
-#include "gin/object_template_builder.h"
-#include "gin/wrappable.h"
-#include "mojo/public/cpp/bindings/remote.h"
+#include "atom/browser/api/trackable_object.h"
+#include "native_mate/handle.h"
 #include "services/device/public/mojom/wake_lock.mojom.h"
 
-namespace electron {
+namespace mate {
+class Dictionary;
+}
+
+namespace atom {
 
 namespace api {
 
-class PowerSaveBlocker : public gin::Wrappable<PowerSaveBlocker> {
+class PowerSaveBlocker : public mate::TrackableObject<PowerSaveBlocker> {
  public:
-  static gin::Handle<PowerSaveBlocker> Create(v8::Isolate* isolate);
+  static mate::Handle<PowerSaveBlocker> Create(v8::Isolate* isolate);
 
-  // gin::Wrappable
-  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) override;
-
-  static gin::WrapperInfo kWrapperInfo;
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
 
  protected:
   explicit PowerSaveBlocker(v8::Isolate* isolate);
@@ -50,13 +49,13 @@ class PowerSaveBlocker : public gin::Wrappable<PowerSaveBlocker> {
   using WakeLockTypeMap = std::map<int, device::mojom::WakeLockType>;
   WakeLockTypeMap wake_lock_types_;
 
-  mojo::Remote<device::mojom::WakeLock> wake_lock_;
+  device::mojom::WakeLockPtr wake_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerSaveBlocker);
 };
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_POWER_SAVE_BLOCKER_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_POWER_SAVE_BLOCKER_H_

atom/browser/api/atom_api_protocol.cc

@@ -0,0 +1,316 @@
+// Copyright (c) 2013 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.h"
+
+#include "atom/browser/atom_browser_client.h"
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/browser.h"
+#include "atom/browser/net/url_request_async_asar_job.h"
+#include "atom/browser/net/url_request_buffer_job.h"
+#include "atom/browser/net/url_request_fetch_job.h"
+#include "atom/browser/net/url_request_stream_job.h"
+#include "atom/browser/net/url_request_string_job.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
+#include "atom/common/options_switches.h"
+#include "base/command_line.h"
+#include "base/strings/string_util.h"
+#include "content/public/browser/child_process_security_policy.h"
+#include "native_mate/dictionary.h"
+#include "url/url_util.h"
+
+using content::BrowserThread;
+
+namespace {
+
+// List of registered custom standard schemes.
+std::vector<std::string> g_standard_schemes;
+
+struct SchemeOptions {
+  bool standard = false;
+  bool secure = false;
+  bool bypassCSP = false;
+  bool allowServiceWorkers = false;
+  bool supportFetchAPI = false;
+  bool corsEnabled = false;
+};
+
+struct CustomScheme {
+  std::string scheme;
+  SchemeOptions options;
+};
+
+}  // namespace
+
+namespace mate {
+
+template <>
+struct Converter<CustomScheme> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     CustomScheme* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
+      return false;
+    if (!dict.Get("scheme", &(out->scheme)))
+      return false;
+    mate::Dictionary opt;
+    // options are optional. Default values specified in SchemeOptions are used
+    if (dict.Get("privileges", &opt)) {
+      opt.Get("standard", &(out->options.standard));
+      opt.Get("supportFetchAPI", &(out->options.supportFetchAPI));
+      opt.Get("secure", &(out->options.secure));
+      opt.Get("bypassCSP", &(out->options.bypassCSP));
+      opt.Get("allowServiceWorkers", &(out->options.allowServiceWorkers));
+      opt.Get("supportFetchAPI", &(out->options.supportFetchAPI));
+      opt.Get("corsEnabled", &(out->options.corsEnabled));
+    }
+    return true;
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+
+namespace api {
+
+std::vector<std::string> GetStandardSchemes() {
+  return g_standard_schemes;
+}
+
+void RegisterSchemesAsPrivileged(v8::Local<v8::Value> val,
+                                 mate::Arguments* args) {
+  std::vector<CustomScheme> custom_schemes;
+  if (!mate::ConvertFromV8(args->isolate(), val, &custom_schemes)) {
+    args->ThrowError("Argument must be an array of custom schemes.");
+    return;
+  }
+
+  std::vector<std::string> secure_schemes, cspbypassing_schemes, fetch_schemes,
+      service_worker_schemes, cors_schemes;
+  for (const auto& custom_scheme : custom_schemes) {
+    // Register scheme to privileged list (https, wss, data, chrome-extension)
+    if (custom_scheme.options.standard) {
+      auto* policy = content::ChildProcessSecurityPolicy::GetInstance();
+      url::AddStandardScheme(custom_scheme.scheme.c_str(),
+                             url::SCHEME_WITH_HOST);
+      g_standard_schemes.push_back(custom_scheme.scheme);
+      policy->RegisterWebSafeScheme(custom_scheme.scheme);
+    }
+    if (custom_scheme.options.secure) {
+      secure_schemes.push_back(custom_scheme.scheme);
+      url::AddSecureScheme(custom_scheme.scheme.c_str());
+    }
+    if (custom_scheme.options.bypassCSP) {
+      cspbypassing_schemes.push_back(custom_scheme.scheme);
+      url::AddCSPBypassingScheme(custom_scheme.scheme.c_str());
+    }
+    if (custom_scheme.options.corsEnabled) {
+      cors_schemes.push_back(custom_scheme.scheme);
+      url::AddCorsEnabledScheme(custom_scheme.scheme.c_str());
+    }
+    if (custom_scheme.options.supportFetchAPI) {
+      fetch_schemes.push_back(custom_scheme.scheme);
+    }
+    if (custom_scheme.options.allowServiceWorkers) {
+      service_worker_schemes.push_back(custom_scheme.scheme);
+    }
+  }
+
+  const auto AppendSchemesToCmdLine = [](const char* switch_name,
+                                         std::vector<std::string> schemes) {
+    // Add the schemes to command line switches, so child processes can also
+    // register them.
+    base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+        switch_name, base::JoinString(schemes, ","));
+  };
+
+  AppendSchemesToCmdLine(atom::switches::kSecureSchemes, secure_schemes);
+  AppendSchemesToCmdLine(atom::switches::kBypassCSPSchemes,
+                         cspbypassing_schemes);
+  AppendSchemesToCmdLine(atom::switches::kCORSSchemes, cors_schemes);
+  AppendSchemesToCmdLine(atom::switches::kFetchSchemes, fetch_schemes);
+  AppendSchemesToCmdLine(atom::switches::kServiceWorkerSchemes,
+                         service_worker_schemes);
+  AppendSchemesToCmdLine(atom::switches::kStandardSchemes, g_standard_schemes);
+}
+
+Protocol::Protocol(v8::Isolate* isolate, AtomBrowserContext* browser_context)
+    : browser_context_(browser_context), weak_factory_(this) {
+  Init(isolate);
+}
+
+Protocol::~Protocol() {}
+void Protocol::UnregisterProtocol(const std::string& scheme,
+                                  mate::Arguments* args) {
+  CompletionCallback callback;
+  args->GetNext(&callback);
+  auto* getter = static_cast<URLRequestContextGetter*>(
+      browser_context_->GetRequestContext());
+  base::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE, {content::BrowserThread::IO},
+      base::BindOnce(&Protocol::UnregisterProtocolInIO,
+                     base::RetainedRef(getter), scheme),
+      base::BindOnce(&Protocol::OnIOCompleted, GetWeakPtr(), callback));
+}
+
+// static
+Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
+    scoped_refptr<URLRequestContextGetter> request_context_getter,
+    const std::string& scheme) {
+  auto* job_factory = request_context_getter->job_factory();
+  if (!job_factory->HasProtocolHandler(scheme))
+    return PROTOCOL_NOT_REGISTERED;
+  job_factory->SetProtocolHandler(scheme, nullptr);
+  return PROTOCOL_OK;
+}
+
+bool IsProtocolHandledInIO(
+    scoped_refptr<URLRequestContextGetter> request_context_getter,
+    const std::string& scheme) {
+  bool is_handled =
+      request_context_getter->job_factory()->IsHandledProtocol(scheme);
+  return is_handled;
+}
+
+v8::Local<v8::Promise> Protocol::IsProtocolHandled(const std::string& scheme) {
+  util::Promise promise(isolate());
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+  auto* getter = static_cast<URLRequestContextGetter*>(
+      browser_context_->GetRequestContext());
+
+  base::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE, {content::BrowserThread::IO},
+      base::BindOnce(&IsProtocolHandledInIO, base::RetainedRef(getter), scheme),
+      base::BindOnce(util::Promise::ResolvePromise<bool>, std::move(promise)));
+
+  return handle;
+}
+
+void Protocol::UninterceptProtocol(const std::string& scheme,
+                                   mate::Arguments* args) {
+  CompletionCallback callback;
+  args->GetNext(&callback);
+  auto* getter = static_cast<URLRequestContextGetter*>(
+      browser_context_->GetRequestContext());
+  base::PostTaskWithTraitsAndReplyWithResult(
+      FROM_HERE, {content::BrowserThread::IO},
+      base::BindOnce(&Protocol::UninterceptProtocolInIO,
+                     base::RetainedRef(getter), scheme),
+      base::BindOnce(&Protocol::OnIOCompleted, GetWeakPtr(), callback));
+}
+
+// static
+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;
+}
+
+void Protocol::OnIOCompleted(const CompletionCallback& callback,
+                             ProtocolError error) {
+  // The completion callback is optional.
+  if (callback.is_null())
+    return;
+
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+
+  if (error == PROTOCOL_OK) {
+    callback.Run(v8::Null(isolate()));
+  } else {
+    std::string str = ErrorCodeToString(error);
+    callback.Run(v8::Exception::Error(mate::StringToV8(isolate(), str)));
+  }
+}
+
+std::string Protocol::ErrorCodeToString(ProtocolError error) {
+  switch (error) {
+    case PROTOCOL_FAIL:
+      return "Failed to manipulate protocol factory";
+    case PROTOCOL_REGISTERED:
+      return "The scheme has been registered";
+    case PROTOCOL_NOT_REGISTERED:
+      return "The scheme has not been registered";
+    case PROTOCOL_INTERCEPTED:
+      return "The scheme has been intercepted";
+    case PROTOCOL_NOT_INTERCEPTED:
+      return "The scheme has not been intercepted";
+    default:
+      return "Unexpected error";
+  }
+}
+
+// static
+mate::Handle<Protocol> Protocol::Create(v8::Isolate* isolate,
+                                        AtomBrowserContext* browser_context) {
+  return mate::CreateHandle(isolate, new Protocol(isolate, browser_context));
+}
+
+// static
+void Protocol::BuildPrototype(v8::Isolate* isolate,
+                              v8::Local<v8::FunctionTemplate> prototype) {
+  prototype->SetClassName(mate::StringToV8(isolate, "Protocol"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .SetMethod("registerStringProtocol",
+                 &Protocol::RegisterProtocol<URLRequestStringJob>)
+      .SetMethod("registerBufferProtocol",
+                 &Protocol::RegisterProtocol<URLRequestBufferJob>)
+      .SetMethod("registerFileProtocol",
+                 &Protocol::RegisterProtocol<URLRequestAsyncAsarJob>)
+      .SetMethod("registerHttpProtocol",
+                 &Protocol::RegisterProtocol<URLRequestFetchJob>)
+      .SetMethod("registerStreamProtocol",
+                 &Protocol::RegisterProtocol<URLRequestStreamJob>)
+      .SetMethod("unregisterProtocol", &Protocol::UnregisterProtocol)
+      .SetMethod("isProtocolHandled", &Protocol::IsProtocolHandled)
+      .SetMethod("interceptStringProtocol",
+                 &Protocol::InterceptProtocol<URLRequestStringJob>)
+      .SetMethod("interceptBufferProtocol",
+                 &Protocol::InterceptProtocol<URLRequestBufferJob>)
+      .SetMethod("interceptFileProtocol",
+                 &Protocol::InterceptProtocol<URLRequestAsyncAsarJob>)
+      .SetMethod("interceptHttpProtocol",
+                 &Protocol::InterceptProtocol<URLRequestFetchJob>)
+      .SetMethod("interceptStreamProtocol",
+                 &Protocol::InterceptProtocol<URLRequestStreamJob>)
+      .SetMethod("uninterceptProtocol", &Protocol::UninterceptProtocol);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void RegisterSchemesAsPrivileged(v8::Local<v8::Value> val,
+                                 mate::Arguments* args) {
+  if (atom::Browser::Get()->is_ready()) {
+    args->ThrowError(
+        "protocol.registerSchemesAsPrivileged should be called before "
+        "app is ready");
+    return;
+  }
+
+  atom::api::RegisterSchemesAsPrivileged(val, args);
+}
+
+void Initialize(v8::Local<v8::Object> exports,
+                v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context,
+                void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.SetMethod("registerSchemesAsPrivileged", &RegisterSchemesAsPrivileged);
+  dict.SetMethod("getStandardSchemes", &atom::api::GetStandardSchemes);
+}
+
+}  // namespace
+
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_protocol, Initialize)

atom/browser/api/atom_api_protocol.h

@@ -0,0 +1,197 @@
+// Copyright (c) 2013 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_H_
+#define ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/net/atom_url_request_job_factory.h"
+#include "atom/common/promise_util.h"
+#include "base/callback.h"
+#include "base/memory/weak_ptr.h"
+#include "base/task/post_task.h"
+#include "content/public/browser/browser_task_traits.h"
+#include "content/public/browser/browser_thread.h"
+#include "native_mate/arguments.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/handle.h"
+#include "net/url_request/url_request_context.h"
+
+namespace base {
+class DictionaryValue;
+}
+
+namespace atom {
+
+namespace api {
+
+std::vector<std::string> GetStandardSchemes();
+
+void RegisterSchemesAsPrivileged(v8::Local<v8::Value> val,
+                                 mate::Arguments* args);
+
+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>)>;
+
+  static mate::Handle<Protocol> Create(v8::Isolate* isolate,
+                                       AtomBrowserContext* browser_context);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
+
+ protected:
+  Protocol(v8::Isolate* isolate, AtomBrowserContext* browser_context);
+  ~Protocol() override;
+
+ 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,
+  };
+
+  // The protocol handler that will create a protocol handler for certain
+  // request job.
+  template <typename RequestJob>
+  class CustomProtocolHandler
+      : public net::URLRequestJobFactory::ProtocolHandler {
+   public:
+    CustomProtocolHandler(v8::Isolate* isolate,
+                          net::URLRequestContextGetter* request_context,
+                          const Handler& handler)
+        : isolate_(isolate),
+          request_context_(request_context),
+          handler_(handler) {}
+    ~CustomProtocolHandler() override {}
+
+    net::URLRequestJob* MaybeCreateJob(
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const override {
+      RequestJob* request_job = new RequestJob(request, network_delegate);
+      request_job->SetHandlerInfo(isolate_, request_context_, handler_);
+      return request_job;
+    }
+
+   private:
+    v8::Isolate* isolate_;
+    net::URLRequestContextGetter* request_context_;
+    Protocol::Handler handler_;
+
+    DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
+  };
+
+  // Register the protocol with certain request job.
+  template <typename RequestJob>
+  void RegisterProtocol(const std::string& scheme,
+                        const Handler& handler,
+                        mate::Arguments* args) {
+    CompletionCallback callback;
+    args->GetNext(&callback);
+    auto* getter = static_cast<URLRequestContextGetter*>(
+        browser_context_->GetRequestContext());
+    base::PostTaskWithTraitsAndReplyWithResult(
+        FROM_HERE, {content::BrowserThread::IO},
+        base::BindOnce(&Protocol::RegisterProtocolInIO<RequestJob>,
+                       base::RetainedRef(getter), isolate(), scheme, handler),
+        base::BindOnce(&Protocol::OnIOCompleted, GetWeakPtr(), callback));
+  }
+  template <typename RequestJob>
+  static ProtocolError RegisterProtocolInIO(
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
+      v8::Isolate* isolate,
+      const std::string& scheme,
+      const Handler& handler) {
+    auto* job_factory = request_context_getter->job_factory();
+    if (job_factory->IsHandledProtocol(scheme))
+      return PROTOCOL_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;
+    else
+      return PROTOCOL_FAIL;
+  }
+
+  // Unregister the protocol handler that handles |scheme|.
+  void UnregisterProtocol(const std::string& scheme, mate::Arguments* args);
+  static ProtocolError UnregisterProtocolInIO(
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
+      const std::string& scheme);
+
+  // Whether the protocol has handler registered.
+  v8::Local<v8::Promise> IsProtocolHandled(const std::string& scheme);
+
+  // Replace the protocol handler with a new one.
+  template <typename RequestJob>
+  void InterceptProtocol(const std::string& scheme,
+                         const Handler& handler,
+                         mate::Arguments* args) {
+    CompletionCallback callback;
+    args->GetNext(&callback);
+    auto* getter = static_cast<URLRequestContextGetter*>(
+        browser_context_->GetRequestContext());
+    base::PostTaskWithTraitsAndReplyWithResult(
+        FROM_HERE, {content::BrowserThread::IO},
+        base::BindOnce(&Protocol::InterceptProtocolInIO<RequestJob>,
+                       base::RetainedRef(getter), isolate(), scheme, handler),
+        base::BindOnce(&Protocol::OnIOCompleted, GetWeakPtr(), callback));
+  }
+  template <typename RequestJob>
+  static ProtocolError InterceptProtocolInIO(
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
+      v8::Isolate* isolate,
+      const std::string& scheme,
+      const Handler& handler) {
+    auto* job_factory = request_context_getter->job_factory();
+    if (!job_factory->IsHandledProtocol(scheme))
+      return PROTOCOL_NOT_REGISTERED;
+    // It is possible a protocol is handled but can not be intercepted.
+    if (!job_factory->HasProtocolHandler(scheme))
+      return PROTOCOL_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;
+  }
+
+  // Restore the |scheme| to its original protocol handler.
+  void UninterceptProtocol(const std::string& scheme, mate::Arguments* args);
+  static ProtocolError UninterceptProtocolInIO(
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
+      const std::string& scheme);
+
+  // Convert error code to JS exception and call the callback.
+  void OnIOCompleted(const CompletionCallback& callback, ProtocolError error);
+
+  // Convert error code to string.
+  std::string ErrorCodeToString(ProtocolError error);
+
+  base::WeakPtr<Protocol> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
+
+  scoped_refptr<AtomBrowserContext> browser_context_;
+  base::WeakPtrFactory<Protocol> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(Protocol);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_

atom/browser/api/atom_api_render_process_preferences.cc

@@ -0,0 +1,90 @@
+// Copyright (c) 2016 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_render_process_preferences.h"
+
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/atom_browser_client.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
+#include "content/public/browser/render_process_host.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+bool IsWebContents(v8::Isolate* isolate, content::RenderProcessHost* process) {
+  content::WebContents* web_contents =
+      static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())
+          ->GetWebContentsFromProcessID(process->GetID());
+  if (!web_contents)
+    return false;
+
+  auto api_web_contents = WebContents::FromOrCreate(isolate, web_contents);
+  auto type = api_web_contents->GetType();
+  return type == WebContents::Type::BROWSER_WINDOW ||
+         type == WebContents::Type::WEB_VIEW;
+}
+
+}  // namespace
+
+RenderProcessPreferences::RenderProcessPreferences(
+    v8::Isolate* isolate,
+    const atom::RenderProcessPreferences::Predicate& predicate)
+    : preferences_(predicate) {
+  Init(isolate);
+}
+
+RenderProcessPreferences::~RenderProcessPreferences() {}
+
+int RenderProcessPreferences::AddEntry(const base::DictionaryValue& entry) {
+  return preferences_.AddEntry(entry);
+}
+
+void RenderProcessPreferences::RemoveEntry(int id) {
+  preferences_.RemoveEntry(id);
+}
+
+// static
+void RenderProcessPreferences::BuildPrototype(
+    v8::Isolate* isolate,
+    v8::Local<v8::FunctionTemplate> prototype) {
+  prototype->SetClassName(
+      mate::StringToV8(isolate, "RenderProcessPreferences"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .SetMethod("addEntry", &RenderProcessPreferences::AddEntry)
+      .SetMethod("removeEntry", &RenderProcessPreferences::RemoveEntry);
+}
+
+// static
+mate::Handle<RenderProcessPreferences>
+RenderProcessPreferences::ForAllWebContents(v8::Isolate* isolate) {
+  return mate::CreateHandle(isolate,
+                            new RenderProcessPreferences(
+                                isolate, base::Bind(&IsWebContents, isolate)));
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Local<v8::Object> exports,
+                v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context,
+                void* priv) {
+  mate::Dictionary dict(context->GetIsolate(), exports);
+  dict.SetMethod("forAllWebContents",
+                 &atom::api::RenderProcessPreferences::ForAllWebContents);
+}
+
+}  // namespace
+
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_render_process_preferences,
+                                 Initialize)

atom/browser/api/atom_api_render_process_preferences.h

@@ -0,0 +1,44 @@
+// Copyright (c) 2016 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_RENDER_PROCESS_PREFERENCES_H_
+#define ATOM_BROWSER_API_ATOM_API_RENDER_PROCESS_PREFERENCES_H_
+
+#include "atom/browser/render_process_preferences.h"
+#include "native_mate/handle.h"
+#include "native_mate/wrappable.h"
+
+namespace atom {
+
+namespace api {
+
+class RenderProcessPreferences
+    : public mate::Wrappable<RenderProcessPreferences> {
+ public:
+  static mate::Handle<RenderProcessPreferences> ForAllWebContents(
+      v8::Isolate* isolate);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
+
+  int AddEntry(const base::DictionaryValue& entry);
+  void RemoveEntry(int id);
+
+ protected:
+  RenderProcessPreferences(
+      v8::Isolate* isolate,
+      const atom::RenderProcessPreferences::Predicate& predicate);
+  ~RenderProcessPreferences() override;
+
+ private:
+  atom::RenderProcessPreferences preferences_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenderProcessPreferences);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_RENDER_PROCESS_PREFERENCES_H_

atom/browser/api/atom_api_screen.cc

@@ -2,21 +2,18 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_screen.h"
+#include "atom/browser/api/atom_api_screen.h"
 
 #include <algorithm>
 #include <string>
 
+#include "atom/browser/api/atom_api_browser_window.h"
+#include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/node_includes.h"
 #include "base/bind.h"
-#include "gin/dictionary.h"
-#include "gin/handle.h"
-#include "shell/browser/browser.h"
-#include "shell/common/gin_converters/callback_converter.h"
-#include "shell/common/gin_converters/gfx_converter.h"
-#include "shell/common/gin_converters/native_window_converter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/point.h"
@@ -25,7 +22,7 @@
 #include "ui/display/win/screen_win.h"
 #endif
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -44,29 +41,16 @@ typename T::iterator FindById(T* container, int id) {
 std::vector<std::string> MetricsToArray(uint32_t metrics) {
   std::vector<std::string> array;
   if (metrics & display::DisplayObserver::DISPLAY_METRIC_BOUNDS)
-    array.emplace_back("bounds");
+    array.push_back("bounds");
   if (metrics & display::DisplayObserver::DISPLAY_METRIC_WORK_AREA)
-    array.emplace_back("workArea");
+    array.push_back("workArea");
   if (metrics & display::DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR)
-    array.emplace_back("scaleFactor");
+    array.push_back("scaleFactor");
   if (metrics & display::DisplayObserver::DISPLAY_METRIC_ROTATION)
-    array.emplace_back("rotation");
+    array.push_back("rotation");
   return array;
 }
 
-void DelayEmit(Screen* screen,
-               base::StringPiece name,
-               const display::Display& display) {
-  screen->Emit(name, display);
-}
-
-void DelayEmitWithMetrics(Screen* screen,
-                          base::StringPiece name,
-                          const display::Display& display,
-                          const std::vector<std::string>& metrics) {
-  screen->Emit(name, display, metrics);
-}
-
 }  // namespace
 
 Screen::Screen(v8::Isolate* isolate, display::Screen* screen)
@@ -101,13 +85,13 @@ display::Display Screen::GetDisplayMatching(const gfx::Rect& match_rect) {
 
 #if defined(OS_WIN)
 
-static gfx::Rect ScreenToDIPRect(electron::NativeWindow* window,
+static gfx::Rect ScreenToDIPRect(atom::NativeWindow* window,
                                  const gfx::Rect& rect) {
   HWND hwnd = window ? window->GetAcceleratedWidget() : nullptr;
   return display::win::ScreenWin::ScreenToDIPRect(hwnd, rect);
 }
 
-static gfx::Rect DIPToScreenRect(electron::NativeWindow* window,
+static gfx::Rect DIPToScreenRect(atom::NativeWindow* window,
                                  const gfx::Rect& rect) {
   HWND hwnd = window ? window->GetAcceleratedWidget() : nullptr;
   return display::win::ScreenWin::DIPToScreenRect(hwnd, rect);
@@ -116,49 +100,41 @@ static gfx::Rect DIPToScreenRect(electron::NativeWindow* window,
 #endif
 
 void Screen::OnDisplayAdded(const display::Display& new_display) {
-  base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
-      FROM_HERE, base::Bind(&DelayEmit, base::Unretained(this), "display-added",
-                            new_display));
+  Emit("display-added", new_display);
 }
 
 void Screen::OnDisplayRemoved(const display::Display& old_display) {
-  base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
-      FROM_HERE, base::Bind(&DelayEmit, base::Unretained(this),
-                            "display-removed", old_display));
+  Emit("display-removed", old_display);
 }
 
 void Screen::OnDisplayMetricsChanged(const display::Display& display,
                                      uint32_t changed_metrics) {
-  base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
-      FROM_HERE, base::Bind(&DelayEmitWithMetrics, base::Unretained(this),
-                            "display-metrics-changed", display,
-                            MetricsToArray(changed_metrics)));
+  Emit("display-metrics-changed", display, MetricsToArray(changed_metrics));
 }
 
 // static
-v8::Local<v8::Value> Screen::Create(gin_helper::ErrorThrower error_thrower) {
+v8::Local<v8::Value> Screen::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
-    error_thrower.ThrowError(
-        "The 'screen' module can't be used before the app 'ready' event");
-    return v8::Null(error_thrower.isolate());
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Cannot require \"screen\" module before app is ready")));
+    return v8::Null(isolate);
   }
 
   display::Screen* screen = display::Screen::GetScreen();
   if (!screen) {
-    error_thrower.ThrowError("Failed to get screen information");
-    return v8::Null(error_thrower.isolate());
+    isolate->ThrowException(v8::Exception::Error(
+        mate::StringToV8(isolate, "Failed to get screen information")));
+    return v8::Null(isolate);
   }
 
-  return gin::CreateHandle(error_thrower.isolate(),
-                           new Screen(error_thrower.isolate(), screen))
-      .ToV8();
+  return mate::CreateHandle(isolate, new Screen(isolate, screen)).ToV8();
 }
 
 // static
 void Screen::BuildPrototype(v8::Isolate* isolate,
                             v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "Screen"));
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "Screen"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("getCursorScreenPoint", &Screen::GetCursorScreenPoint)
       .SetMethod("getPrimaryDisplay", &Screen::GetPrimaryDisplay)
       .SetMethod("getAllDisplays", &Screen::GetAllDisplays)
@@ -174,19 +150,19 @@ void Screen::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::Screen;
+using atom::api::Screen;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  gin_helper::Dictionary dict(isolate, exports);
-  dict.SetMethod("createScreen", base::BindRepeating(&Screen::Create));
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("screen", Screen::Create(isolate));
   dict.Set(
       "Screen",
       Screen::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());

atom/browser/api/atom_api_screen.h

@@ -2,14 +2,13 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_SCREEN_H_
-#define SHELL_BROWSER_API_ELECTRON_API_SCREEN_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_SCREEN_H_
+#define ATOM_BROWSER_API_ATOM_API_SCREEN_H_
 
 #include <vector>
 
-#include "native_mate/wrappable.h"
-#include "shell/common/gin_helper/error_thrower.h"
-#include "shell/common/gin_helper/event_emitter.h"
+#include "atom/browser/api/event_emitter.h"
+#include "native_mate/handle.h"
 #include "ui/display/display_observer.h"
 #include "ui/display/screen.h"
 
@@ -19,14 +18,14 @@ class Rect;
 class Screen;
 }  // namespace gfx
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
-class Screen : public gin_helper::EventEmitter<mate::Wrappable<Screen>>,
+class Screen : public mate::EventEmitter<Screen>,
                public display::DisplayObserver {
  public:
-  static v8::Local<v8::Value> Create(gin_helper::ErrorThrower error_thrower);
+  static v8::Local<v8::Value> Create(v8::Isolate* isolate);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
@@ -55,6 +54,6 @@ class Screen : public gin_helper::EventEmitter<mate::Wrappable<Screen>>,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_SCREEN_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_SCREEN_H_

atom/browser/api/atom_api_session.cc

@@ -2,16 +2,33 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_session.h"
+#include "atom/browser/api/atom_api_session.h"
 
-#include <algorithm>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "base/command_line.h"
+#include "atom/browser/api/atom_api_cookies.h"
+#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_web_request.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/atom_permission_manager.h"
+#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/session_preferences.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/gurl_converter.h"
+#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 "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/strings/string_number_conversions.h"
@@ -20,7 +37,6 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
 #include "components/download/public/common/download_danger_type.h"
-#include "components/download/public/common/download_url_parameters.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/value_map_pref_store.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
@@ -29,80 +45,25 @@
 #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 "mojo/public/cpp/bindings/pending_remote.h"
-#include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "native_mate/dictionary.h"
-#include "native_mate/object_template_builder_deprecated.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"
-#include "net/http/http_util.h"
-#include "services/network/network_service.h"
-#include "services/network/public/cpp/features.h"
-#include "shell/browser/api/electron_api_cookies.h"
-#include "shell/browser/api/electron_api_data_pipe_holder.h"
-#include "shell/browser/api/electron_api_download_item.h"
-#include "shell/browser/api/electron_api_net_log.h"
-#include "shell/browser/api/electron_api_protocol_ns.h"
-#include "shell/browser/api/electron_api_web_request_ns.h"
-#include "shell/browser/browser.h"
-#include "shell/browser/electron_browser_context.h"
-#include "shell/browser/electron_browser_main_parts.h"
-#include "shell/browser/electron_permission_manager.h"
-#include "shell/browser/media/media_device_id_salt.h"
-#include "shell/browser/net/cert_verifier_client.h"
-#include "shell/browser/session_preferences.h"
-#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
-#include "shell/common/native_mate_converters/content_converter.h"
-#include "shell/common/native_mate_converters/file_path_converter.h"
-#include "shell/common/native_mate_converters/gurl_converter.h"
-#include "shell/common/native_mate_converters/net_converter.h"
-#include "shell/common/native_mate_converters/once_callback.h"
-#include "shell/common/native_mate_converters/value_converter.h"
-#include "shell/common/node_includes.h"
-#include "shell/common/options_switches.h"
+#include "net/http/http_transaction_factory.h"
+#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 "ui/base/l10n/l10n_util.h"
 
-#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
-#include "shell/browser/extensions/electron_extension_system.h"
-#endif
-
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-#include "chrome/browser/spellchecker/spellcheck_factory.h"  // nogncheck
-#include "chrome/browser/spellchecker/spellcheck_service.h"  // nogncheck
-#include "components/spellcheck/browser/pref_names.h"
-#include "components/spellcheck/common/spellcheck_common.h"
-
-#if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-#include "components/spellcheck/browser/spellcheck_platform.h"
-#include "components/spellcheck/common/spellcheck_features.h"
-#endif
-#endif
-
 using content::BrowserThread;
 using content::StoragePartition;
 
-namespace predictors {
-// NOTE(nornagon): this is copied from
-// //chrome/browser/predictors/resource_prefetch_predictor.cc we don't need
-// anything in that file other than this constructor. Without it we get a link
-// error. Probably upstream the constructor should be moved to
-// preconnect_manager.cc.
-PreconnectRequest::PreconnectRequest(
-    const url::Origin& origin,
-    int num_sockets,
-    const net::NetworkIsolationKey& network_isolation_key)
-    : origin(origin),
-      num_sockets(num_sockets),
-      network_isolation_key(network_isolation_key) {
-  DCHECK_GE(num_sockets, 0);
-}
-}  // namespace predictors
-
 namespace {
 
 struct ClearStorageDataOptions {
@@ -111,6 +72,15 @@ 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) {
@@ -151,6 +121,27 @@ 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) {
+  getter->GetURLRequestContext()->set_http_user_agent_settings(
+      new net::StaticHttpUserAgentSettings(
+          net::HttpUtil::GenerateAcceptLanguageHeader(accept_lang),
+          user_agent));
+}
+
 }  // namespace
 
 namespace mate {
@@ -173,9 +164,42 @@ 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,
+                                   atom::VerifyRequestParams val) {
+    mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+    dict.Set("hostname", val.hostname);
+    dict.Set("certificate", val.certificate);
+    dict.Set("verificationResult", val.default_result);
+    dict.Set("errorCode", val.error_code);
+    return dict.GetHandle();
+  }
+};
+
 }  // namespace mate
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -186,6 +210,136 @@ 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::CompletionRepeatingCallback 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) {
+  auto* request_context = context_getter->GetURLRequestContext();
+  static_cast<AtomCertVerifier*>(request_context->cert_verifier())
+      ->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,
@@ -198,8 +352,8 @@ void DownloadIdCallback(content::DownloadManager* download_manager,
                         uint32_t id) {
   download_manager->CreateDownloadItem(
       base::GenerateGUID(), id, path, path, url_chain, GURL(), GURL(), GURL(),
-      GURL(), base::nullopt, mime_type, mime_type, start_time, base::Time(),
-      etag, last_modified, offset, length, std::string(),
+      GURL(), 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(),
@@ -226,7 +380,7 @@ void DestroyGlobalHandle(v8::Isolate* isolate,
 
 }  // namespace
 
-Session::Session(v8::Isolate* isolate, ElectronBrowserContext* browser_context)
+Session::Session(v8::Isolate* isolate, AtomBrowserContext* browser_context)
     : network_emulation_token_(base::UnguessableToken::Create()),
       browser_context_(browser_context) {
   // Observe DownloadManager to get download notifications.
@@ -237,32 +391,13 @@ Session::Session(v8::Isolate* isolate, ElectronBrowserContext* browser_context)
 
   Init(isolate);
   AttachAsUserData(browser_context);
-
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-  SpellcheckService* service =
-      SpellcheckServiceFactory::GetForContext(browser_context_.get());
-  if (service) {
-    service->SetHunspellObserver(this);
-  }
-#endif
 }
 
 Session::~Session() {
   content::BrowserContext::GetDownloadManager(browser_context())
       ->RemoveObserver(this);
-
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-  SpellcheckService* service =
-      SpellcheckServiceFactory::GetForContext(browser_context_.get());
-  if (service) {
-    service->SetHunspellObserver(nullptr);
-  }
-#endif
-
-  // TODO(zcbenz): Now since URLRequestContextGetter is gone, is this still
-  // needed?
-  // Refs https://github.com/electron/electron/pull/12305.
   DestroyGlobalHandle(isolate(), cookies_);
+  DestroyGlobalHandle(isolate(), web_request_);
   DestroyGlobalHandle(isolate(), protocol_);
   DestroyGlobalHandle(isolate(), net_log_);
   g_sessions.erase(weak_map_id());
@@ -287,77 +422,40 @@ void Session::OnDownloadCreated(content::DownloadManager* manager,
   }
 }
 
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-void Session::OnHunspellDictionaryInitialized(const std::string& language) {
-  Emit("spellcheck-dictionary-initialized", language);
-}
-void Session::OnHunspellDictionaryDownloadBegin(const std::string& language) {
-  Emit("spellcheck-dictionary-download-begin", language);
-}
-void Session::OnHunspellDictionaryDownloadSuccess(const std::string& language) {
-  Emit("spellcheck-dictionary-download-success", language);
-}
-void Session::OnHunspellDictionaryDownloadFailure(const std::string& language) {
-  Emit("spellcheck-dictionary-download-failure", language);
-}
-#endif
-
 v8::Local<v8::Promise> Session::ResolveProxy(mate::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
-  util::Promise<std::string> promise(isolate);
+  util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   GURL url;
   args->GetNext(&url);
 
   browser_context_->GetResolveProxyHelper()->ResolveProxy(
-      url, base::BindOnce(util::Promise<std::string>::ResolvePromise,
-                          std::move(promise)));
+      url,
+      base::Bind(util::CopyablePromise::ResolveCopyablePromise<std::string>,
+                 util::CopyablePromise(promise)));
 
   return handle;
 }
 
-v8::Local<v8::Promise> Session::GetCacheSize() {
-  auto* isolate = v8::Isolate::GetCurrent();
-  util::Promise<int64_t> promise(isolate);
-  auto handle = promise.GetHandle();
+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();
 
-  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
-      ->GetNetworkContext()
-      ->ComputeHttpCacheSize(
-          base::Time(), base::Time::Max(),
-          base::BindOnce(
-              [](util::Promise<int64_t> 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();
-  util::Promise<void*> promise(isolate);
-  auto handle = promise.GetHandle();
-
-  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
-      ->GetNetworkContext()
-      ->ClearHttpCache(base::Time(), base::Time::Max(), nullptr,
-                       base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
-                                      std::move(promise)));
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&DoCacheActionInIO,
+                     WrapRefCounted(browser_context_->GetRequestContext()),
+                     action, std::move(promise)));
 
   return handle;
 }
 
 v8::Local<v8::Promise> Session::ClearStorageData(mate::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
-  util::Promise<void*> promise(isolate);
+  util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   ClearStorageDataOptions options;
@@ -374,8 +472,8 @@ 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::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
-                     std::move(promise)));
+      base::Bind(util::CopyablePromise::ResolveEmptyCopyablePromise,
+                 util::CopyablePromise(promise)));
   return handle;
 }
 
@@ -387,7 +485,7 @@ void Session::FlushStorageData() {
 
 v8::Local<v8::Promise> Session::SetProxy(mate::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
-  util::Promise<void*> promise(isolate);
+  util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   mate::Dictionary options;
@@ -420,8 +518,8 @@ v8::Local<v8::Promise> Session::SetProxy(mate::Arguments* args) {
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
-                                std::move(promise)));
+      FROM_HERE,
+      base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
 
   return handle;
 }
@@ -457,123 +555,106 @@ 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) {
+  proc.Run(request, base::AdaptCallbackForRepeating(std::move(cb)));
+}
+
 void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
                                 mate::Arguments* args) {
-  CertVerifierClient::CertVerifyProc proc;
+  base::Callback<void(const VerifyRequestParams& request,
+                      base::Callback<void(int)>)>
+      proc;
   if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &proc))) {
     args->ThrowError("Must pass null or function");
     return;
   }
 
-  mojo::PendingRemote<network::mojom::CertVerifierClient>
-      cert_verifier_client_remote;
-  if (proc) {
-    mojo::MakeSelfOwnedReceiver(
-        std::make_unique<CertVerifierClient>(proc),
-        cert_verifier_client_remote.InitWithNewPipeAndPassReceiver());
-  }
-  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
-      ->GetNetworkContext()
-      ->SetCertVerifierClient(std::move(cert_verifier_client_remote));
-
-  // This causes the cert verifier cache to be cleared.
-  content::GetNetworkService()->OnCertDBChanged();
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&SetCertVerifyProcInIO,
+                     WrapRefCounted(browser_context_->GetRequestContext()),
+                     base::Bind(&WrapVerifyProc, proc)));
 }
 
 void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
                                           mate::Arguments* args) {
-  auto* permission_manager = static_cast<ElectronPermissionManager*>(
-      browser_context()->GetPermissionControllerDelegate());
-  if (val->IsNull()) {
-    permission_manager->SetPermissionRequestHandler(
-        ElectronPermissionManager::RequestHandler());
-    return;
-  }
-  auto handler = std::make_unique<ElectronPermissionManager::RequestHandler>();
-  if (!mate::ConvertFromV8(args->isolate(), val, handler.get())) {
-    args->ThrowError("Must pass null or function");
-    return;
-  }
-  permission_manager->SetPermissionRequestHandler(base::BindRepeating(
-      [](ElectronPermissionManager::RequestHandler* handler,
-         content::WebContents* web_contents,
-         content::PermissionType permission_type,
-         ElectronPermissionManager::StatusCallback callback,
-         const base::Value& 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,
-                                        mate::Arguments* args) {
-  ElectronPermissionManager::CheckHandler handler;
+  AtomPermissionManager::RequestHandler handler;
   if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &handler))) {
     args->ThrowError("Must pass null or function");
     return;
   }
-  auto* permission_manager = static_cast<ElectronPermissionManager*>(
+  auto* permission_manager = static_cast<AtomPermissionManager*>(
+      browser_context()->GetPermissionControllerDelegate());
+  permission_manager->SetPermissionRequestHandler(handler);
+}
+
+void Session::SetPermissionCheckHandler(v8::Local<v8::Value> val,
+                                        mate::Arguments* args) {
+  AtomPermissionManager::CheckHandler handler;
+  if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &handler))) {
+    args->ThrowError("Must pass null or function");
+    return;
+  }
+  auto* permission_manager = static_cast<AtomPermissionManager*>(
       browser_context()->GetPermissionControllerDelegate());
   permission_manager->SetPermissionCheckHandler(handler);
 }
 
 v8::Local<v8::Promise> Session::ClearHostResolverCache(mate::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
-  util::Promise<void*> promise(isolate);
+  util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
-      ->GetNetworkContext()
-      ->ClearHostCache(nullptr,
-                       base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
-                                      std::move(promise)));
-
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&ClearHostResolverCacheInIO,
+                     WrapRefCounted(browser_context_->GetRequestContext()),
+                     std::move(promise)));
   return handle;
 }
 
-v8::Local<v8::Promise> Session::ClearAuthCache() {
-  auto* isolate = v8::Isolate::GetCurrent();
-  util::Promise<void*> promise(isolate);
+v8::Local<v8::Promise> Session::ClearAuthCache(mate::Arguments* args) {
+  v8::Isolate* isolate = args->isolate();
+  util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
-      ->GetNetworkContext()
-      ->ClearHttpAuthCache(
-          base::Time(),
-          base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
-                         std::move(promise)));
+  ClearAuthCacheOptions options;
+  if (!args->GetNext(&options)) {
+    promise.RejectWithErrorMessage("Must specify options object");
+    return handle;
+  }
 
+  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) {
-  auto* command_line = base::CommandLine::ForCurrentProcess();
-  network::mojom::HttpAuthDynamicParamsPtr auth_dynamic_params =
-      network::mojom::HttpAuthDynamicParams::New();
-  auth_dynamic_params->server_allowlist = domains;
-  auth_dynamic_params->enable_negotiate_port =
-      command_line->HasSwitch(electron::switches::kEnableAuthNegotiatePort);
-  auth_dynamic_params->ntlm_v2_enabled =
-      !command_line->HasSwitch(electron::switches::kDisableNTLMv2);
-  content::GetNetworkService()->ConfigureHttpAuthPrefs(
-      std::move(auth_dynamic_params));
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&AllowNTLMCredentialsForDomainsInIO,
+                     WrapRefCounted(browser_context_->GetRequestContext()),
+                     domains));
 }
 
 void Session::SetUserAgent(const std::string& user_agent,
                            mate::Arguments* args) {
   browser_context_->SetUserAgent(user_agent);
-  auto* network_context = content::BrowserContext::GetDefaultStoragePartition(
-                              browser_context_.get())
-                              ->GetNetworkContext();
-  network_context->SetUserAgent(user_agent);
 
-  std::string accept_lang;
-  if (args->GetNext(&accept_lang)) {
-    network_context->SetAcceptLanguage(
-        net::HttpUtil::GenerateAcceptLanguageHeader(accept_lang));
-  }
+  std::string accept_lang = g_browser_process->GetApplicationLocale();
+  args->GetNext(&accept_lang);
+
+  scoped_refptr<net::URLRequestContextGetter> getter(
+      browser_context_->GetRequestContext());
+  getter->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&SetUserAgentInIO, getter, accept_lang, user_agent));
 }
 
 std::string Session::GetUserAgent() {
@@ -582,27 +663,20 @@ std::string Session::GetUserAgent() {
 
 v8::Local<v8::Promise> Session::GetBlobData(v8::Isolate* isolate,
                                             const std::string& uuid) {
-  gin::Handle<DataPipeHolder> holder = DataPipeHolder::From(isolate, uuid);
-  if (holder.IsEmpty()) {
-    util::Promise<v8::Local<v8::Value>> promise(isolate);
-    promise.RejectWithErrorMessage("Could not get blob data handle");
-    return promise.GetHandle();
-  }
+  util::Promise promise(isolate);
+  v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  return holder->ReadAll(isolate);
-}
-
-void Session::DownloadURL(const GURL& url) {
-  auto* download_manager =
-      content::BrowserContext::GetDownloadManager(browser_context());
-  auto download_params = std::make_unique<download::DownloadUrlParameters>(
-      url, MISSING_TRAFFIC_ANNOTATION, net::NetworkIsolationKey());
-  download_manager->DownloadUrl(std::move(download_params));
+  AtomBlobReader* blob_reader = browser_context()->GetBlobReader();
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::IO},
+      base::BindOnce(&AtomBlobReader::StartReading,
+                     base::Unretained(blob_reader), uuid, std::move(promise)));
+  return handle;
 }
 
 void Session::CreateInterruptedDownload(const mate::Dictionary& options) {
   int64_t offset = 0, length = 0;
-  double start_time = base::Time::Now().ToDoubleT();
+  double start_time = 0.0;
   std::string mime_type, last_modified, etag;
   base::FilePath path;
   std::vector<GURL> url_chain;
@@ -626,7 +700,7 @@ void Session::CreateInterruptedDownload(const mate::Dictionary& options) {
   }
   auto* download_manager =
       content::BrowserContext::GetDownloadManager(browser_context());
-  download_manager->GetDelegate()->GetNextId(base::BindRepeating(
+  download_manager->GetDelegate()->GetNextId(base::Bind(
       &DownloadIdCallback, download_manager, path, url_chain, mime_type, offset,
       length, last_modified, etag, base::Time::FromDoubleT(start_time)));
 }
@@ -644,14 +718,6 @@ std::vector<base::FilePath::StringType> Session::GetPreloads() const {
   return prefs->preloads();
 }
 
-#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
-void Session::LoadChromeExtension(const base::FilePath extension_path) {
-  auto* extension_system = static_cast<extensions::ElectronExtensionSystem*>(
-      extensions::ExtensionSystem::Get(browser_context()));
-  extension_system->LoadExtension(extension_path);
-}
-#endif
-
 v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
   if (cookies_.IsEmpty()) {
     auto handle = Cookies::Create(isolate, browser_context());
@@ -662,16 +728,15 @@ v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
 
 v8::Local<v8::Value> Session::Protocol(v8::Isolate* isolate) {
   if (protocol_.IsEmpty()) {
-    v8::Local<v8::Value> handle;
-    handle = ProtocolNS::Create(isolate, browser_context()).ToV8();
-    protocol_.Reset(isolate, handle);
+    auto handle = atom::api::Protocol::Create(isolate, browser_context());
+    protocol_.Reset(isolate, handle.ToV8());
   }
   return v8::Local<v8::Value>::New(isolate, protocol_);
 }
 
 v8::Local<v8::Value> Session::WebRequest(v8::Isolate* isolate) {
   if (web_request_.IsEmpty()) {
-    auto handle = WebRequestNS::Create(isolate, browser_context());
+    auto handle = atom::api::WebRequest::Create(isolate, browser_context());
     web_request_.Reset(isolate, handle.ToV8());
   }
   return v8::Local<v8::Value>::New(isolate, web_request_);
@@ -679,103 +744,15 @@ v8::Local<v8::Value> Session::WebRequest(v8::Isolate* isolate) {
 
 v8::Local<v8::Value> Session::NetLog(v8::Isolate* isolate) {
   if (net_log_.IsEmpty()) {
-    auto handle = electron::api::NetLog::Create(isolate, browser_context());
+    auto handle = atom::api::NetLog::Create(isolate, browser_context());
     net_log_.Reset(isolate, handle.ToV8());
   }
   return v8::Local<v8::Value>::New(isolate, net_log_);
 }
 
-static void StartPreconnectOnUI(
-    scoped_refptr<ElectronBrowserContext> browser_context,
-    const GURL& url,
-    int num_sockets_to_preconnect) {
-  std::vector<predictors::PreconnectRequest> requests = {
-      {url::Origin::Create(url), num_sockets_to_preconnect,
-       net::NetworkIsolationKey()}};
-  browser_context->GetPreconnectManager()->Start(url, requests);
-}
-
-void Session::Preconnect(const mate::Dictionary& options,
-                         mate::Arguments* args) {
-  GURL url;
-  if (!options.Get("url", &url) || !url.is_valid()) {
-    args->ThrowError("Must pass non-empty valid url to session.preconnect.");
-    return;
-  }
-  int num_sockets_to_preconnect = 1;
-  if (options.Get("numSockets", &num_sockets_to_preconnect)) {
-    const int kMinSocketsToPreconnect = 1;
-    const int kMaxSocketsToPreconnect = 6;
-    if (num_sockets_to_preconnect < kMinSocketsToPreconnect ||
-        num_sockets_to_preconnect > kMaxSocketsToPreconnect) {
-      args->ThrowError(
-          base::StringPrintf("numSocketsToPreconnect is outside range [%d,%d]",
-                             kMinSocketsToPreconnect, kMaxSocketsToPreconnect));
-      return;
-    }
-  }
-
-  DCHECK_GT(num_sockets_to_preconnect, 0);
-  base::PostTask(
-      FROM_HERE, {content::BrowserThread::UI},
-      base::BindOnce(&StartPreconnectOnUI, base::RetainedRef(browser_context_),
-                     url, num_sockets_to_preconnect));
-}
-
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-base::Value Session::GetSpellCheckerLanguages() {
-  return browser_context_->prefs()
-      ->Get(spellcheck::prefs::kSpellCheckDictionaries)
-      ->Clone();
-}
-
-void Session::SetSpellCheckerLanguages(
-    gin_helper::ErrorThrower thrower,
-    const std::vector<std::string>& languages) {
-  base::ListValue language_codes;
-  for (const std::string& lang : languages) {
-    std::string code = spellcheck::GetCorrespondingSpellCheckLanguage(lang);
-    if (code.empty()) {
-      thrower.ThrowError("Invalid language code provided: \"" + lang +
-                         "\" is not a valid language code");
-      return;
-    }
-    language_codes.AppendString(code);
-  }
-  browser_context_->prefs()->Set(spellcheck::prefs::kSpellCheckDictionaries,
-                                 language_codes);
-}
-
-void SetSpellCheckerDictionaryDownloadURL(gin_helper::ErrorThrower thrower,
-                                          const GURL& url) {
-  if (!url.is_valid()) {
-    thrower.ThrowError(
-        "The URL you provided to setSpellCheckerDictionaryDownloadURL is not a "
-        "valid URL");
-    return;
-  }
-  SpellcheckHunspellDictionary::SetBaseDownloadURL(url);
-}
-
-bool Session::AddWordToSpellCheckerDictionary(const std::string& word) {
-#if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-  if (spellcheck::UseBrowserSpellChecker()) {
-    spellcheck_platform::AddWord(base::UTF8ToUTF16(word));
-  }
-#endif
-  SpellcheckService* spellcheck =
-      SpellcheckServiceFactory::GetForContext(browser_context_.get());
-  if (!spellcheck)
-    return false;
-
-  return spellcheck->GetCustomDictionary()->AddWord(word);
-}
-#endif  // BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-
 // static
-mate::Handle<Session> Session::CreateFrom(
-    v8::Isolate* isolate,
-    ElectronBrowserContext* browser_context) {
+mate::Handle<Session> Session::CreateFrom(v8::Isolate* isolate,
+                                          AtomBrowserContext* browser_context) {
   auto* existing = TrackableObject::FromWrappedClass(isolate, browser_context);
   if (existing)
     return mate::CreateHandle(isolate, static_cast<Session*>(existing));
@@ -796,15 +773,15 @@ mate::Handle<Session> Session::FromPartition(
     v8::Isolate* isolate,
     const std::string& partition,
     const base::DictionaryValue& options) {
-  scoped_refptr<ElectronBrowserContext> browser_context;
+  scoped_refptr<AtomBrowserContext> browser_context;
   if (partition.empty()) {
-    browser_context = ElectronBrowserContext::From("", false, options);
+    browser_context = AtomBrowserContext::From("", false, options);
   } else if (base::StartsWith(partition, kPersistPrefix,
                               base::CompareCase::SENSITIVE)) {
     std::string name = partition.substr(8);
-    browser_context = ElectronBrowserContext::From(name, false, options);
+    browser_context = AtomBrowserContext::From(name, false, options);
   } else {
-    browser_context = ElectronBrowserContext::From(partition, true, options);
+    browser_context = AtomBrowserContext::From(partition, true, options);
   }
   return CreateFrom(isolate, browser_context.get());
 }
@@ -813,11 +790,11 @@ mate::Handle<Session> Session::FromPartition(
 void Session::BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "Session"));
-  gin_helper::Destroyable::MakeDestroyable(isolate, prototype);
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
       .SetMethod("resolveProxy", &Session::ResolveProxy)
-      .SetMethod("getCacheSize", &Session::GetCacheSize)
-      .SetMethod("clearCache", &Session::ClearCache)
+      .SetMethod("getCacheSize", &Session::DoCacheAction<CacheAction::STATS>)
+      .SetMethod("clearCache", &Session::DoCacheAction<CacheAction::CLEAR>)
       .SetMethod("clearStorageData", &Session::ClearStorageData)
       .SetMethod("flushStorageData", &Session::FlushStorageData)
       .SetMethod("setProxy", &Session::SetProxy)
@@ -836,25 +813,10 @@ void Session::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setUserAgent", &Session::SetUserAgent)
       .SetMethod("getUserAgent", &Session::GetUserAgent)
       .SetMethod("getBlobData", &Session::GetBlobData)
-      .SetMethod("downloadURL", &Session::DownloadURL)
       .SetMethod("createInterruptedDownload",
                  &Session::CreateInterruptedDownload)
       .SetMethod("setPreloads", &Session::SetPreloads)
       .SetMethod("getPreloads", &Session::GetPreloads)
-#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
-      .SetMethod("loadChromeExtension", &Session::LoadChromeExtension)
-#endif
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-      .SetMethod("getSpellCheckerLanguages", &Session::GetSpellCheckerLanguages)
-      .SetMethod("setSpellCheckerLanguages", &Session::SetSpellCheckerLanguages)
-      .SetProperty("availableSpellCheckerLanguages",
-                   &spellcheck::SpellCheckLanguages)
-      .SetMethod("setSpellCheckerDictionaryDownloadURL",
-                 &SetSpellCheckerDictionaryDownloadURL)
-      .SetMethod("addWordToSpellCheckerDictionary",
-                 &Session::AddWordToSpellCheckerDictionary)
-#endif
-      .SetMethod("preconnect", &Session::Preconnect)
       .SetProperty("cookies", &Session::Cookies)
       .SetProperty("netLog", &Session::NetLog)
       .SetProperty("protocol", &Session::Protocol)
@@ -863,18 +825,18 @@ void Session::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::Cookies;
-using electron::api::NetLog;
-using electron::api::ProtocolNS;
-using electron::api::Session;
+using atom::api::Cookies;
+using atom::api::NetLog;
+using atom::api::Protocol;
+using atom::api::Session;
 
 v8::Local<v8::Value> FromPartition(const std::string& partition,
                                    mate::Arguments* args) {
-  if (!electron::Browser::Get()->is_ready()) {
+  if (!atom::Browser::Get()->is_ready()) {
     args->ThrowError("Session can only be received when app is ready");
     return v8::Null(args->isolate());
   }
@@ -898,9 +860,9 @@ void Initialize(v8::Local<v8::Object> exports,
   dict.Set(
       "NetLog",
       NetLog::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());
-  dict.Set("Protocol", ProtocolNS::GetConstructor(isolate)
-                           ->GetFunction(context)
-                           .ToLocalChecked());
+  dict.Set(
+      "Protocol",
+      Protocol::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());
   dict.SetMethod("fromPartition", &FromPartition);
 }
 

atom/browser/api/atom_api_session.h

@@ -2,23 +2,19 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_SESSION_H_
-#define SHELL_BROWSER_API_ELECTRON_API_SESSION_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_SESSION_H_
+#define ATOM_BROWSER_API_ATOM_API_SESSION_H_
 
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/atom_blob_reader.h"
+#include "atom/browser/net/resolve_proxy_helper.h"
+#include "atom/common/promise_util.h"
 #include "base/values.h"
 #include "content/public/browser/download_manager.h"
-#include "electron/buildflags/buildflags.h"
 #include "native_mate/handle.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/browser/net/resolve_proxy_helper.h"
-#include "shell/common/promise_util.h"
-
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-#include "chrome/browser/spellchecker/spellcheck_hunspell_dictionary.h"  // nogncheck
-#endif
 
 class GURL;
 
@@ -35,22 +31,23 @@ namespace net {
 class ProxyConfig;
 }
 
-namespace electron {
+namespace atom {
 
-class ElectronBrowserContext;
+class AtomBrowserContext;
 
 namespace api {
 
 class Session : public mate::TrackableObject<Session>,
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-                public SpellcheckHunspellDictionary::Observer,
-#endif
                 public content::DownloadManager::Observer {
  public:
+  enum class CacheAction {
+    CLEAR,
+    STATS,
+  };
+
   // Gets or creates Session from the |browser_context|.
-  static mate::Handle<Session> CreateFrom(
-      v8::Isolate* isolate,
-      ElectronBrowserContext* browser_context);
+  static mate::Handle<Session> CreateFrom(v8::Isolate* isolate,
+                                          AtomBrowserContext* browser_context);
 
   // Gets the Session of |partition|.
   static mate::Handle<Session> FromPartition(
@@ -58,9 +55,7 @@ class Session : public mate::TrackableObject<Session>,
       const std::string& partition,
       const base::DictionaryValue& options = base::DictionaryValue());
 
-  ElectronBrowserContext* browser_context() const {
-    return browser_context_.get();
-  }
+  AtomBrowserContext* browser_context() const { return browser_context_.get(); }
 
   // mate::TrackableObject:
   static void BuildPrototype(v8::Isolate* isolate,
@@ -68,8 +63,8 @@ class Session : public mate::TrackableObject<Session>,
 
   // Methods.
   v8::Local<v8::Promise> ResolveProxy(mate::Arguments* args);
-  v8::Local<v8::Promise> GetCacheSize();
-  v8::Local<v8::Promise> ClearCache();
+  template <CacheAction action>
+  v8::Local<v8::Promise> DoCacheAction();
   v8::Local<v8::Promise> ClearStorageData(mate::Arguments* args);
   void FlushStorageData();
   v8::Local<v8::Promise> SetProxy(mate::Arguments* args);
@@ -82,13 +77,12 @@ 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();
+  v8::Local<v8::Promise> ClearAuthCache(mate::Arguments* args);
   void AllowNTLMCredentialsForDomains(const std::string& domains);
   void SetUserAgent(const std::string& user_agent, mate::Arguments* args);
   std::string GetUserAgent();
   v8::Local<v8::Promise> GetBlobData(v8::Isolate* isolate,
                                      const std::string& uuid);
-  void DownloadURL(const GURL& url);
   void CreateInterruptedDownload(const mate::Dictionary& options);
   void SetPreloads(const std::vector<base::FilePath::StringType>& preloads);
   std::vector<base::FilePath::StringType> GetPreloads() const;
@@ -96,55 +90,32 @@ class Session : public mate::TrackableObject<Session>,
   v8::Local<v8::Value> Protocol(v8::Isolate* isolate);
   v8::Local<v8::Value> WebRequest(v8::Isolate* isolate);
   v8::Local<v8::Value> NetLog(v8::Isolate* isolate);
-  void Preconnect(const mate::Dictionary& options, mate::Arguments* args);
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-  base::Value GetSpellCheckerLanguages();
-  void SetSpellCheckerLanguages(gin_helper::ErrorThrower thrower,
-                                const std::vector<std::string>& languages);
-  bool AddWordToSpellCheckerDictionary(const std::string& word);
-#endif
-
-#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
-  void LoadChromeExtension(const base::FilePath extension_path);
-#endif
 
  protected:
-  Session(v8::Isolate* isolate, ElectronBrowserContext* browser_context);
+  Session(v8::Isolate* isolate, AtomBrowserContext* browser_context);
   ~Session() override;
 
   // content::DownloadManager::Observer:
   void OnDownloadCreated(content::DownloadManager* manager,
                          download::DownloadItem* item) override;
 
-#if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
-  // SpellcheckHunspellDictionary::Observer
-  void OnHunspellDictionaryInitialized(const std::string& language) override;
-  void OnHunspellDictionaryDownloadBegin(const std::string& language) override;
-  void OnHunspellDictionaryDownloadSuccess(
-      const std::string& language) override;
-  void OnHunspellDictionaryDownloadFailure(
-      const std::string& language) override;
-#endif
-
  private:
-  // Cached mate::Wrappable objects.
+  // Cached object.
   v8::Global<v8::Value> cookies_;
   v8::Global<v8::Value> protocol_;
-  v8::Global<v8::Value> net_log_;
-
-  // Cached object.
   v8::Global<v8::Value> web_request_;
+  v8::Global<v8::Value> net_log_;
 
   // The client id to enable the network throttler.
   base::UnguessableToken network_emulation_token_;
 
-  scoped_refptr<ElectronBrowserContext> browser_context_;
+  scoped_refptr<AtomBrowserContext> browser_context_;
 
   DISALLOW_COPY_AND_ASSIGN(Session);
 };
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_SESSION_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_SESSION_H_

atom/browser/api/atom_api_system_preferences.cc

@@ -2,18 +2,16 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_system_preferences.h"
+#include "atom/browser/api/atom_api_system_preferences.h"
 
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
 #include "native_mate/dictionary.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/native_mate_converters/callback_converter_deprecated.h"
-#include "shell/common/native_mate_converters/value_converter.h"
-#include "shell/common/node_includes.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/color_utils.h"
-#include "ui/native_theme/native_theme.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -32,7 +30,7 @@ SystemPreferences::~SystemPreferences() {
 
 #if !defined(OS_MACOSX)
 bool SystemPreferences::IsDarkMode() {
-  return ui::NativeTheme::GetInstanceForNativeUi()->ShouldUseDarkColors();
+  return false;
 }
 #endif
 
@@ -40,13 +38,15 @@ bool SystemPreferences::IsInvertedColorScheme() {
   return color_utils::IsInvertedColorScheme();
 }
 
+#if !defined(OS_WIN)
 bool SystemPreferences::IsHighContrastColorScheme() {
-  return ui::NativeTheme::GetInstanceForNativeUi()->UsesHighContrastColors();
+  return false;
 }
+#endif  // !defined(OS_WIN)
 
 v8::Local<v8::Value> SystemPreferences::GetAnimationSettings(
     v8::Isolate* isolate) {
-  gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
+  mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
   dict.SetHidden("simple", true);
   dict.Set("shouldRenderRichAnimation",
            gfx::Animation::ShouldRenderRichAnimation());
@@ -72,8 +72,6 @@ void SystemPreferences::BuildPrototype(
 #if defined(OS_WIN) || defined(OS_MACOSX)
       .SetMethod("getColor", &SystemPreferences::GetColor)
       .SetMethod("getAccentColor", &SystemPreferences::GetAccentColor)
-      .SetMethod("getMediaAccessStatus",
-                 &SystemPreferences::GetMediaAccessStatus)
 #endif
 
 #if defined(OS_WIN)
@@ -113,6 +111,8 @@ void SystemPreferences::BuildPrototype(
       .SetMethod("promptTouchID", &SystemPreferences::PromptTouchID)
       .SetMethod("isTrustedAccessibilityClient",
                  &SystemPreferences::IsTrustedAccessibilityClient)
+      .SetMethod("getMediaAccessStatus",
+                 &SystemPreferences::GetMediaAccessStatus)
       .SetMethod("askForMediaAccess", &SystemPreferences::AskForMediaAccess)
 #endif
       .SetMethod("isInvertedColorScheme",
@@ -126,11 +126,11 @@ void SystemPreferences::BuildPrototype(
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::SystemPreferences;
+using atom::api::SystemPreferences;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,

atom/browser/api/atom_api_system_preferences.h

@@ -2,27 +2,29 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_SYSTEM_PREFERENCES_H_
-#define SHELL_BROWSER_API_ELECTRON_API_SYSTEM_PREFERENCES_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_SYSTEM_PREFERENCES_H_
+#define ATOM_BROWSER_API_ATOM_API_SYSTEM_PREFERENCES_H_
 
 #include <memory>
 #include <string>
 
+#include "atom/browser/api/event_emitter.h"
+#include "atom/common/promise_util.h"
 #include "base/callback.h"
 #include "base/values.h"
 #include "native_mate/handle.h"
-#include "shell/browser/api/event_emitter_deprecated.h"
-#include "shell/common/gin_helper/error_thrower.h"
-#include "shell/common/node_includes.h"
-#include "shell/common/promise_util.h"
 
 #if defined(OS_WIN)
-#include "shell/browser/browser.h"
-#include "shell/browser/browser_observer.h"
+#include "atom/browser/browser.h"
+#include "atom/browser/browser_observer.h"
 #include "ui/gfx/sys_color_change_listener.h"
 #endif
 
-namespace electron {
+namespace base {
+class DictionaryValue;
+}
+
+namespace atom {
 
 namespace api {
 
@@ -49,12 +51,7 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
   std::string GetAccentColor();
-  std::string GetColor(gin_helper::ErrorThrower thrower,
-                       const std::string& color);
-  // TODO(codebytere): Write tests for these methods once we
-  // are running tests on a Mojave machine
-  std::string GetMediaAccessStatus(const std::string& media_type,
-                                   mate::Arguments* args);
+  std::string GetColor(const std::string& color, mate::Arguments* args);
 #endif
 #if defined(OS_WIN)
   bool IsAeroGlassEnabled();
@@ -69,9 +66,7 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
 
 #elif defined(OS_MACOSX)
   using NotificationCallback =
-      base::RepeatingCallback<void(const std::string&,
-                                   const base::DictionaryValue&,
-                                   const std::string&)>;
+      base::Callback<void(const std::string&, const base::DictionaryValue&)>;
 
   void PostNotification(const std::string& name,
                         const base::DictionaryValue& user_info,
@@ -98,8 +93,7 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
   void RemoveUserDefault(const std::string& name);
   bool IsSwipeTrackingFromScrollEventsEnabled();
 
-  std::string GetSystemColor(gin_helper::ErrorThrower thrower,
-                             const std::string& color);
+  std::string GetSystemColor(const std::string& color, mate::Arguments* args);
 
   bool CanPromptTouchID();
   v8::Local<v8::Promise> PromptTouchID(v8::Isolate* isolate,
@@ -107,6 +101,10 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
 
   static bool IsTrustedAccessibilityClient(bool prompt);
 
+  // TODO(codebytere): Write tests for these methods once we
+  // are running tests on a Mojave machine
+  std::string GetMediaAccessStatus(const std::string& media_type,
+                                   mate::Arguments* args);
   v8::Local<v8::Promise> AskForMediaAccess(v8::Isolate* isolate,
                                            const std::string& media_type);
 
@@ -167,6 +165,6 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_SYSTEM_PREFERENCES_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_SYSTEM_PREFERENCES_H_

atom/browser/api/atom_api_system_preferences_mac.mm

@@ -2,18 +2,20 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_system_preferences.h"
+#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>
 #import <LocalAuthentication/LocalAuthentication.h>
 #import <Security/Security.h>
 
+#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"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/sequenced_task_runner.h"
@@ -21,16 +23,8 @@
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/values.h"
-#include "chrome/browser/media/webrtc/system_media_capture_permissions_mac.h"
-#include "native_mate/object_template_builder_deprecated.h"
+#include "native_mate/object_template_builder.h"
 #include "net/base/mac/url_conversions.h"
-#include "shell/browser/mac/dict_util.h"
-#include "shell/browser/mac/electron_application.h"
-#include "shell/browser/ui/cocoa/NSColor+Hex.h"
-#include "shell/common/deprecate_util.h"
-#include "shell/common/native_mate_converters/gurl_converter.h"
-#include "shell/common/native_mate_converters/value_converter.h"
-#include "ui/native_theme/native_theme.h"
 
 namespace mate {
 template <>
@@ -68,11 +62,11 @@ struct Converter<NSAppearance*> {
       return v8::Null(isolate);
     }
 
-    if ([val.name isEqualToString:NSAppearanceNameAqua]) {
+    if (val.name == NSAppearanceNameAqua) {
       return mate::ConvertToV8(isolate, "light");
     }
     if (@available(macOS 10.14, *)) {
-      if ([val.name isEqualToString:NSAppearanceNameDarkAqua]) {
+      if (val.name == NSAppearanceNameDarkAqua) {
         return mate::ConvertToV8(isolate, "dark");
       }
     }
@@ -82,7 +76,7 @@ struct Converter<NSAppearance*> {
 };
 }  // namespace mate
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -103,17 +97,15 @@ AVMediaType ParseMediaType(const std::string& media_type) {
   }
 }
 
-std::string ConvertSystemPermission(
-    system_media_permissions::SystemPermission value) {
-  using SystemPermission = system_media_permissions::SystemPermission;
-  switch (value) {
-    case SystemPermission::kNotDetermined:
+std::string ConvertAuthorizationStatus(AVAuthorizationStatusMac status) {
+  switch (status) {
+    case AVAuthorizationStatusNotDeterminedMac:
       return "not-determined";
-    case SystemPermission::kRestricted:
+    case AVAuthorizationStatusRestrictedMac:
       return "restricted";
-    case SystemPermission::kDenied:
+    case AVAuthorizationStatusDeniedMac:
       return "denied";
-    case SystemPermission::kAllowed:
+    case AVAuthorizationStatusAuthorizedMac:
       return "granted";
     default:
       return "unknown";
@@ -215,20 +207,13 @@ int SystemPreferences::DoSubscribeNotification(
               usingBlock:^(NSNotification* notification) {
                 std::unique_ptr<base::DictionaryValue> user_info =
                     NSDictionaryToDictionaryValue(notification.userInfo);
-
-                std::string object = "";
-                if ([notification.object isKindOfClass:[NSString class]]) {
-                  object = base::SysNSStringToUTF8(notification.object);
-                }
-
                 if (user_info) {
                   copied_callback.Run(
-                      base::SysNSStringToUTF8(notification.name), *user_info,
-                      object);
+                      base::SysNSStringToUTF8(notification.name), *user_info);
                 } else {
                   copied_callback.Run(
                       base::SysNSStringToUTF8(notification.name),
-                      base::DictionaryValue(), object);
+                      base::DictionaryValue());
                 }
               }];
   return request_id;
@@ -409,8 +394,8 @@ std::string SystemPreferences::GetAccentColor() {
   return base::SysNSStringToUTF8([sysColor RGBAValue]);
 }
 
-std::string SystemPreferences::GetSystemColor(gin_helper::ErrorThrower thrower,
-                                              const std::string& color) {
+std::string SystemPreferences::GetSystemColor(const std::string& color,
+                                              mate::Arguments* args) {
   NSColor* sysColor = nil;
   if (color == "blue") {
     sysColor = [NSColor systemBlueColor];
@@ -431,7 +416,7 @@ std::string SystemPreferences::GetSystemColor(gin_helper::ErrorThrower thrower,
   } else if (color == "yellow") {
     sysColor = [NSColor systemYellowColor];
   } else {
-    thrower.ThrowError("Unknown system color: " + color);
+    args->ThrowError("Unknown system color: " + color);
     return "";
   }
 
@@ -455,7 +440,7 @@ bool SystemPreferences::CanPromptTouchID() {
 v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
     v8::Isolate* isolate,
     const std::string& reason) {
-  util::Promise<void*> promise(isolate);
+  util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   if (@available(macOS 10.12.2, *)) {
@@ -472,7 +457,7 @@ v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
     scoped_refptr<base::SequencedTaskRunner> runner =
         base::SequencedTaskRunnerHandle::Get();
 
-    __block util::Promise<void*> p = std::move(promise);
+    __block util::Promise p = std::move(promise);
     [context
         evaluateAccessControl:access_control
                     operation:LAAccessControlOperationUseKeySign
@@ -483,14 +468,14 @@ v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
                                 [error.localizedDescription UTF8String]);
                             runner->PostTask(
                                 FROM_HERE,
-                                base::BindOnce(
-                                    util::Promise<void*>::RejectPromise,
-                                    std::move(p), std::move(err_msg)));
+                                base::BindOnce(util::Promise::RejectPromise,
+                                               std::move(p),
+                                               std::move(err_msg)));
                           } else {
                             runner->PostTask(
                                 FROM_HERE,
                                 base::BindOnce(
-                                    util::Promise<void*>::ResolveEmptyPromise,
+                                    util::Promise::ResolveEmptyPromise,
                                     std::move(p)));
                           }
                         }];
@@ -507,23 +492,18 @@ bool SystemPreferences::IsTrustedAccessibilityClient(bool prompt) {
   return AXIsProcessTrustedWithOptions((CFDictionaryRef)options);
 }
 
-std::string SystemPreferences::GetColor(gin_helper::ErrorThrower thrower,
-                                        const std::string& color) {
+std::string SystemPreferences::GetColor(const std::string& color,
+                                        mate::Arguments* args) {
   NSColor* sysColor = nil;
   if (color == "alternate-selected-control-text") {
     sysColor = [NSColor alternateSelectedControlTextColor];
-    EmitDeprecationWarning(
-        node::Environment::GetCurrent(thrower.isolate()),
-        "'alternate-selected-control-text' is deprecated as an input to "
-        "getColor.  Use 'selected-content-background' instead.",
-        "electron");
   } else if (color == "control-background") {
     sysColor = [NSColor controlBackgroundColor];
   } else if (color == "control") {
     sysColor = [NSColor controlColor];
   } else if (color == "control-text") {
     sysColor = [NSColor controlTextColor];
-  } else if (color == "disabled-control-text") {
+  } else if (color == "disabled-control") {
     sysColor = [NSColor disabledControlTextColor];
   } else if (color == "find-highlight") {
     if (@available(macOS 10.14, *))
@@ -589,26 +569,24 @@ std::string SystemPreferences::GetColor(gin_helper::ErrorThrower thrower,
   } else if (color == "window-frame-text") {
     sysColor = [NSColor windowFrameTextColor];
   } else {
-    thrower.ThrowError("Unknown color: " + color);
+    args->ThrowError("Unknown color: " + color);
+    return "";
   }
 
-  if (sysColor)
-    return base::SysNSStringToUTF8([sysColor hexadecimalValue]);
-  return "";
+  return base::SysNSStringToUTF8([sysColor hexadecimalValue]);
 }
 
 std::string SystemPreferences::GetMediaAccessStatus(
     const std::string& media_type,
     mate::Arguments* args) {
-  if (media_type == "camera") {
-    return ConvertSystemPermission(
-        system_media_permissions::CheckSystemVideoCapturePermission());
-  } else if (media_type == "microphone") {
-    return ConvertSystemPermission(
-        system_media_permissions::CheckSystemAudioCapturePermission());
-  } else if (media_type == "screen") {
-    return ConvertSystemPermission(
-        system_media_permissions::CheckSystemScreenCapturePermission());
+  if (auto type = ParseMediaType(media_type)) {
+    if (@available(macOS 10.14, *)) {
+      return ConvertAuthorizationStatus(
+          [AVCaptureDevice authorizationStatusForMediaType:type]);
+    } else {
+      // access always allowed pre-10.14 Mojave
+      return ConvertAuthorizationStatus(AVAuthorizationStatusAuthorizedMac);
+    }
   } else {
     args->ThrowError("Invalid media type");
     return std::string();
@@ -618,12 +596,12 @@ std::string SystemPreferences::GetMediaAccessStatus(
 v8::Local<v8::Promise> SystemPreferences::AskForMediaAccess(
     v8::Isolate* isolate,
     const std::string& media_type) {
-  util::Promise<bool> promise(isolate);
+  util::Promise promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   if (auto type = ParseMediaType(media_type)) {
     if (@available(macOS 10.14, *)) {
-      __block util::Promise<bool> p = std::move(promise);
+      __block util::Promise p = std::move(promise);
       [AVCaptureDevice requestAccessForMediaType:type
                                completionHandler:^(BOOL granted) {
                                  dispatch_async(dispatch_get_main_queue(), ^{
@@ -647,9 +625,6 @@ void SystemPreferences::RemoveUserDefault(const std::string& name) {
 }
 
 bool SystemPreferences::IsDarkMode() {
-  if (@available(macOS 10.14, *)) {
-    return ui::NativeTheme::GetInstanceForNativeUi()->ShouldUseDarkColors();
-  }
   NSString* mode = [[NSUserDefaults standardUserDefaults]
       stringForKey:@"AppleInterfaceStyle"];
   return [mode isEqualToString:@"Dark"];
@@ -690,4 +665,4 @@ void SystemPreferences::SetAppLevelAppearance(mate::Arguments* args) {
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom

atom/browser/api/atom_api_system_preferences_win.cc

@@ -3,80 +3,33 @@
 // found in the LICENSE file.
 
 #include <dwmapi.h>
-#include <windows.devices.enumeration.h>
-#include <wrl/client.h>
 #include <iomanip>
 
-#include "shell/browser/api/electron_api_system_preferences.h"
+#include "atom/browser/api/atom_api_system_preferences.h"
 
-#include "base/win/core_winrt_util.h"
+#include "atom/common/color_util.h"
 #include "base/win/wrapped_window_proc.h"
-#include "shell/common/color_util.h"
 #include "ui/base/win/shell.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/win/hwnd_util.h"
 
-namespace electron {
+namespace atom {
 
 namespace {
 
 const wchar_t kSystemPreferencesWindowClass[] =
     L"Electron_SystemPreferencesHostWindow";
 
-using ABI::Windows::Devices::Enumeration::DeviceAccessStatus;
-using ABI::Windows::Devices::Enumeration::DeviceClass;
-using ABI::Windows::Devices::Enumeration::IDeviceAccessInformation;
-using ABI::Windows::Devices::Enumeration::IDeviceAccessInformationStatics;
-using Microsoft::WRL::ComPtr;
+bool g_is_high_contract_color_scheme = false;
+bool g_is_high_contract_color_scheme_initialized = false;
 
-DeviceAccessStatus GetDeviceAccessStatus(DeviceClass device_class) {
-  if (!base::win::ResolveCoreWinRTDelayload()) {
-    VLOG(1) << "base::win::ResolveCoreWinRTDelayload failed";
-    return DeviceAccessStatus::DeviceAccessStatus_Allowed;
-  }
-
-  if (!base::win::ScopedHString::ResolveCoreWinRTStringDelayload()) {
-    VLOG(1)
-        << "base::win::ScopedHString::ResolveCoreWinRTStringDelayload failed";
-    return DeviceAccessStatus::DeviceAccessStatus_Allowed;
-  }
-
-  ComPtr<IDeviceAccessInformationStatics> dev_access_info_statics;
-  HRESULT hr = base::win::GetActivationFactory<
-      IDeviceAccessInformationStatics,
-      RuntimeClass_Windows_Devices_Enumeration_DeviceAccessInformation>(
-      &dev_access_info_statics);
-  if (FAILED(hr)) {
-    VLOG(1) << "IDeviceAccessInformationStatics failed: " << hr;
-    return DeviceAccessStatus::DeviceAccessStatus_Allowed;
-  }
-
-  ComPtr<IDeviceAccessInformation> dev_access_info;
-  hr = dev_access_info_statics->CreateFromDeviceClass(device_class,
-                                                      &dev_access_info);
-  if (FAILED(hr)) {
-    VLOG(1) << "IDeviceAccessInformation failed: " << hr;
-    return DeviceAccessStatus::DeviceAccessStatus_Allowed;
-  }
-
-  auto status = DeviceAccessStatus::DeviceAccessStatus_Unspecified;
-  dev_access_info->get_CurrentStatus(&status);
-  return status;
-}
-
-std::string ConvertDeviceAccessStatus(DeviceAccessStatus value) {
-  switch (value) {
-    case DeviceAccessStatus::DeviceAccessStatus_Unspecified:
-      return "not-determined";
-    case DeviceAccessStatus::DeviceAccessStatus_Allowed:
-      return "granted";
-    case DeviceAccessStatus::DeviceAccessStatus_DeniedBySystem:
-      return "restricted";
-    case DeviceAccessStatus::DeviceAccessStatus_DeniedByUser:
-      return "denied";
-    default:
-      return "unknown";
-  }
+void UpdateHighContrastColorScheme() {
+  HIGHCONTRAST high_contrast = {0};
+  high_contrast.cbSize = sizeof(HIGHCONTRAST);
+  g_is_high_contract_color_scheme =
+      SystemParametersInfo(SPI_GETHIGHCONTRAST, 0, &high_contrast, 0) &&
+      ((high_contrast.dwFlags & HCF_HIGHCONTRASTON) != 0);
+  g_is_high_contract_color_scheme_initialized = true;
 }
 
 }  // namespace
@@ -87,6 +40,12 @@ bool SystemPreferences::IsAeroGlassEnabled() {
   return ui::win::IsAeroGlassEnabled();
 }
 
+bool SystemPreferences::IsHighContrastColorScheme() {
+  if (!g_is_high_contract_color_scheme_initialized)
+    UpdateHighContrastColorScheme();
+  return g_is_high_contract_color_scheme;
+}
+
 std::string hexColorDWORDToRGBA(DWORD color) {
   DWORD rgba = color << 8 | color >> 24;
   std::ostringstream stream;
@@ -105,8 +64,8 @@ std::string SystemPreferences::GetAccentColor() {
   return hexColorDWORDToRGBA(color);
 }
 
-std::string SystemPreferences::GetColor(gin_helper::ErrorThrower thrower,
-                                        const std::string& color) {
+std::string SystemPreferences::GetColor(const std::string& color,
+                                        mate::Arguments* args) {
   int id;
   if (color == "3d-dark-shadow") {
     id = COLOR_3DDKSHADOW;
@@ -169,31 +128,13 @@ std::string SystemPreferences::GetColor(gin_helper::ErrorThrower thrower,
   } else if (color == "window-text") {
     id = COLOR_WINDOWTEXT;
   } else {
-    thrower.ThrowError("Unknown color: " + color);
+    args->ThrowError("Unknown color: " + color);
     return "";
   }
 
   return ToRGBHex(color_utils::GetSysSkColor(id));
 }
 
-std::string SystemPreferences::GetMediaAccessStatus(
-    const std::string& media_type,
-    mate::Arguments* args) {
-  if (media_type == "camera") {
-    return ConvertDeviceAccessStatus(
-        GetDeviceAccessStatus(DeviceClass::DeviceClass_VideoCapture));
-  } else if (media_type == "microphone") {
-    return ConvertDeviceAccessStatus(
-        GetDeviceAccessStatus(DeviceClass::DeviceClass_AudioCapture));
-  } else if (media_type == "screen") {
-    return ConvertDeviceAccessStatus(
-        DeviceAccessStatus::DeviceAccessStatus_Allowed);
-  } else {
-    args->ThrowError("Invalid media type");
-    return std::string();
-  }
-}
-
 void SystemPreferences::InitializeWindow() {
   invertered_color_scheme_ = IsInvertedColorScheme();
   high_contrast_color_scheme_ = IsHighContrastColorScheme();
@@ -247,6 +188,9 @@ LRESULT CALLBACK SystemPreferences::WndProc(HWND hwnd,
       Emit("accent-color-changed", hexColorDWORDToRGBA(new_color));
       current_color_ = new_color_string;
     }
+  } else if (message == WM_SYSCOLORCHANGE ||
+             (message == WM_SETTINGCHANGE && wparam == SPI_SETHIGHCONTRAST)) {
+    UpdateHighContrastColorScheme();
   }
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
@@ -274,4 +218,4 @@ void SystemPreferences::OnFinishLaunching(
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom

atom/browser/api/atom_api_top_level_window.cc

@@ -2,50 +2,48 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_top_level_window.h"
+#include "atom/browser/api/atom_api_top_level_window.h"
 
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/atom_api_browser_view.h"
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/api/atom_api_view.h"
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/common/color_util.h"
+#include "atom/common/native_mate_converters/callback.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/image_converter.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 "electron/buildflags/buildflags.h"
-#include "gin/dictionary.h"
+#include "gin/converter.h"
+#include "native_mate/handle.h"
 #include "native_mate/persistent_dictionary.h"
-#include "shell/browser/api/electron_api_browser_view.h"
-#include "shell/browser/api/electron_api_menu.h"
-#include "shell/browser/api/electron_api_view.h"
-#include "shell/browser/api/electron_api_web_contents.h"
-#include "shell/common/color_util.h"
-#include "shell/common/deprecate_util.h"
-#include "shell/common/gin_converters/callback_converter.h"
-#include "shell/common/gin_converters/file_path_converter.h"
-#include "shell/common/gin_converters/gfx_converter.h"
-#include "shell/common/gin_converters/image_converter.h"
-#include "shell/common/gin_converters/native_window_converter.h"
-#include "shell/common/gin_converters/value_converter_gin_adapter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
-#include "shell/common/options_switches.h"
 
 #if defined(TOOLKIT_VIEWS)
-#include "shell/browser/native_window_views.h"
+#include "atom/browser/native_window_views.h"
 #endif
 
 #if defined(OS_WIN)
-#include "shell/browser/ui/win/taskbar_host.h"
+#include "atom/browser/ui/win/taskbar_host.h"
 #include "ui/base/win/shell.h"
 #endif
 
 #if defined(OS_WIN)
-namespace gin {
+namespace mate {
 
 template <>
-struct Converter<electron::TaskbarHost::ThumbarButton> {
+struct Converter<atom::TaskbarHost::ThumbarButton> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Handle<v8::Value> val,
-                     electron::TaskbarHost::ThumbarButton* out) {
-    gin::Dictionary dict(isolate);
-    if (!gin::ConvertFromV8(isolate, val, &dict))
+                     atom::TaskbarHost::ThumbarButton* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
       return false;
     dict.Get("click", &(out->clicked_callback));
     dict.Get("tooltip", &(out->tooltip));
@@ -54,10 +52,10 @@ struct Converter<electron::TaskbarHost::ThumbarButton> {
   }
 };
 
-}  // namespace gin
+}  // namespace mate
 #endif
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
@@ -105,10 +103,11 @@ TopLevelWindow::TopLevelWindow(v8::Isolate* isolate,
 #endif
 }
 
-TopLevelWindow::TopLevelWindow(gin_helper::Arguments* args,
+TopLevelWindow::TopLevelWindow(v8::Isolate* isolate,
+                               v8::Local<v8::Object> wrapper,
                                const mate::Dictionary& options)
-    : TopLevelWindow(args->isolate(), options) {
-  InitWithArgs(args);
+    : TopLevelWindow(isolate, options) {
+  InitWith(isolate, wrapper);
   // Init window after everything has been setup.
   window()->InitFromOptions(options);
 }
@@ -125,16 +124,13 @@ TopLevelWindow::~TopLevelWindow() {
 void TopLevelWindow::InitWith(v8::Isolate* isolate,
                               v8::Local<v8::Object> wrapper) {
   AttachAsUserData(window_.get());
-  mate::TrackableObject<
-      TopLevelWindow, gin_helper::EventEmitter<
-                          mate::Wrappable<TopLevelWindow>>>::InitWith(isolate,
-                                                                      wrapper);
+  mate::TrackableObject<TopLevelWindow>::InitWith(isolate, wrapper);
 
   // We can only append this window to parent window's child windows after this
   // window's JS wrapper gets initialized.
   if (!parent_window_.IsEmpty()) {
     mate::Handle<TopLevelWindow> parent;
-    gin::ConvertFromV8(isolate, GetParentWindow(), &parent);
+    mate::ConvertFromV8(isolate, GetParentWindow(), &parent);
     DCHECK(!parent.IsEmpty());
     parent->child_windows_.Set(isolate, weak_map_id(), wrapper);
   }
@@ -250,10 +246,6 @@ void TopLevelWindow::OnWindowSwipe(const std::string& direction) {
   Emit("swipe", direction);
 }
 
-void TopLevelWindow::OnWindowRotateGesture(float rotation) {
-  Emit("rotate-gesture", rotation);
-}
-
 void TopLevelWindow::OnWindowSheetBegin() {
   Emit("sheet-begin");
 }
@@ -381,8 +373,7 @@ bool TopLevelWindow::IsFullscreen() {
   return window_->IsFullscreen();
 }
 
-void TopLevelWindow::SetBounds(const gfx::Rect& bounds,
-                               gin_helper::Arguments* args) {
+void TopLevelWindow::SetBounds(const gfx::Rect& bounds, mate::Arguments* args) {
   bool animate = false;
   args->GetNext(&animate);
   window_->SetBounds(bounds, animate);
@@ -401,7 +392,7 @@ gfx::Rect TopLevelWindow::GetNormalBounds() {
 }
 
 void TopLevelWindow::SetContentBounds(const gfx::Rect& bounds,
-                                      gin_helper::Arguments* args) {
+                                      mate::Arguments* args) {
   bool animate = false;
   args->GetNext(&animate);
   window_->SetContentBounds(bounds, animate);
@@ -411,9 +402,7 @@ gfx::Rect TopLevelWindow::GetContentBounds() {
   return window_->GetContentBounds();
 }
 
-void TopLevelWindow::SetSize(int width,
-                             int height,
-                             gin_helper::Arguments* args) {
+void TopLevelWindow::SetSize(int width, int height, mate::Arguments* args) {
   bool animate = false;
   gfx::Size size = window_->GetMinimumSize();
   size.SetToMax(gfx::Size(width, height));
@@ -431,7 +420,7 @@ std::vector<int> TopLevelWindow::GetSize() {
 
 void TopLevelWindow::SetContentSize(int width,
                                     int height,
-                                    gin_helper::Arguments* args) {
+                                    mate::Arguments* args) {
   bool animate = false;
   args->GetNext(&animate);
   window_->SetContentSize(gfx::Size(width, height), animate);
@@ -469,8 +458,7 @@ std::vector<int> TopLevelWindow::GetMaximumSize() {
   return result;
 }
 
-void TopLevelWindow::SetSheetOffset(double offsetY,
-                                    gin_helper::Arguments* args) {
+void TopLevelWindow::SetSheetOffset(double offsetY, mate::Arguments* args) {
   double offsetX = 0.0;
   args->GetNext(&offsetX);
   window_->SetSheetOffset(offsetX, offsetY);
@@ -524,26 +512,28 @@ bool TopLevelWindow::IsClosable() {
   return window_->IsClosable();
 }
 
-void TopLevelWindow::SetAlwaysOnTop(bool top, gin_helper::Arguments* args) {
+void TopLevelWindow::SetAlwaysOnTop(bool top, mate::Arguments* args) {
   std::string level = "floating";
   int relative_level = 0;
   args->GetNext(&level);
   args->GetNext(&relative_level);
 
-  ui::ZOrderLevel z_order =
-      top ? ui::ZOrderLevel::kFloatingWindow : ui::ZOrderLevel::kNormal;
-  window_->SetAlwaysOnTop(z_order, level, relative_level);
+  std::string error;
+  window_->SetAlwaysOnTop(top, level, relative_level, &error);
+
+  if (!error.empty())
+    args->ThrowError(error);
 }
 
 bool TopLevelWindow::IsAlwaysOnTop() {
-  return window_->GetZOrderLevel() != ui::ZOrderLevel::kNormal;
+  return window_->IsAlwaysOnTop();
 }
 
 void TopLevelWindow::Center() {
   window_->Center();
 }
 
-void TopLevelWindow::SetPosition(int x, int y, gin_helper::Arguments* args) {
+void TopLevelWindow::SetPosition(int x, int y, mate::Arguments* args) {
   bool animate = false;
   args->GetNext(&animate);
   window_->SetPosition(gfx::Point(x, y), animate);
@@ -556,15 +546,6 @@ std::vector<int> TopLevelWindow::GetPosition() {
   result[1] = pos.y();
   return result;
 }
-void TopLevelWindow::MoveAbove(const std::string& sourceId,
-                               gin_helper::Arguments* args) {
-#if BUILDFLAG(ENABLE_DESKTOP_CAPTURER)
-  if (!window_->MoveAbove(sourceId))
-    args->ThrowError("Invalid media source id");
-#else
-  args->ThrowError("enable_desktop_capturer=true to use this feature");
-#endif
-}
 
 void TopLevelWindow::MoveTop() {
   window_->MoveTop();
@@ -578,14 +559,6 @@ std::string TopLevelWindow::GetTitle() {
   return window_->GetTitle();
 }
 
-void TopLevelWindow::SetAccessibleTitle(const std::string& title) {
-  window_->SetAccessibleTitle(title);
-}
-
-std::string TopLevelWindow::GetAccessibleTitle() {
-  return window_->GetAccessibleTitle();
-}
-
 void TopLevelWindow::FlashFrame(bool flash) {
   window_->FlashFrame(flash);
 }
@@ -659,9 +632,8 @@ bool TopLevelWindow::IsDocumentEdited() {
   return window_->IsDocumentEdited();
 }
 
-void TopLevelWindow::SetIgnoreMouseEvents(bool ignore,
-                                          gin_helper::Arguments* args) {
-  gin_helper::Dictionary options;
+void TopLevelWindow::SetIgnoreMouseEvents(bool ignore, mate::Arguments* args) {
+  mate::Dictionary options;
   bool forward = false;
   args->GetNext(&options) && options.Get("forward", &forward);
   return window_->SetIgnoreMouseEvents(ignore, forward);
@@ -681,21 +653,15 @@ void TopLevelWindow::SetMenu(v8::Isolate* isolate, v8::Local<v8::Value> value) {
   v8::Local<v8::Object> object;
   if (value->IsObject() && value->ToObject(context).ToLocal(&object) &&
       gin::V8ToString(isolate, object->GetConstructorName()) == "Menu" &&
-      gin::ConvertFromV8(isolate, value, &menu) && !menu.IsEmpty()) {
+      mate::ConvertFromV8(isolate, value, &menu) && !menu.IsEmpty()) {
     menu_.Reset(isolate, menu.ToV8());
-
-    // We only want to update the menu if the menu has a non-zero item count,
-    // or we risk crashes.
-    if (menu->model()->GetItemCount() == 0) {
-      RemoveMenu();
-    } else {
-      window_->SetMenu(menu->model());
-    }
+    window_->SetMenu(menu->model());
   } else if (value->IsNull()) {
-    RemoveMenu();
+    menu_.Reset();
+    window_->SetMenu(nullptr);
   } else {
     isolate->ThrowException(
-        v8::Exception::TypeError(gin::StringToV8(isolate, "Invalid Menu")));
+        v8::Exception::TypeError(mate::StringToV8(isolate, "Invalid Menu")));
   }
 }
 
@@ -705,7 +671,7 @@ void TopLevelWindow::RemoveMenu() {
 }
 
 void TopLevelWindow::SetParentWindow(v8::Local<v8::Value> value,
-                                     gin_helper::Arguments* args) {
+                                     mate::Arguments* args) {
   if (IsModal()) {
     args->ThrowError("Can not be called for modal window");
     return;
@@ -734,7 +700,7 @@ void TopLevelWindow::SetBrowserView(v8::Local<v8::Value> value) {
 void TopLevelWindow::AddBrowserView(v8::Local<v8::Value> value) {
   mate::Handle<BrowserView> browser_view;
   if (value->IsObject() &&
-      gin::ConvertFromV8(isolate(), value, &browser_view)) {
+      mate::ConvertFromV8(isolate(), value, &browser_view)) {
     auto get_that_view = browser_views_.find(browser_view->weak_map_id());
     if (get_that_view == browser_views_.end()) {
       window_->AddBrowserView(browser_view->view());
@@ -747,7 +713,7 @@ void TopLevelWindow::AddBrowserView(v8::Local<v8::Value> value) {
 void TopLevelWindow::RemoveBrowserView(v8::Local<v8::Value> value) {
   mate::Handle<BrowserView> browser_view;
   if (value->IsObject() &&
-      gin::ConvertFromV8(isolate(), value, &browser_view)) {
+      mate::ConvertFromV8(isolate(), value, &browser_view)) {
     auto get_that_view = browser_views_.find(browser_view->weak_map_id());
     if (get_that_view != browser_views_.end()) {
       window_->RemoveBrowserView(browser_view->view());
@@ -758,11 +724,6 @@ void TopLevelWindow::RemoveBrowserView(v8::Local<v8::Value> value) {
     }
   }
 }
-
-std::string TopLevelWindow::GetMediaSourceId() const {
-  return window_->GetDesktopMediaID().ToString();
-}
-
 v8::Local<v8::Value> TopLevelWindow::GetNativeWindowHandle() {
   // TODO(MarshallOfSound): Replace once
   // https://chromium-review.googlesource.com/c/chromium/src/+/1253094/ has
@@ -771,21 +732,20 @@ v8::Local<v8::Value> TopLevelWindow::GetNativeWindowHandle() {
   return ToBuffer(isolate(), &handle, sizeof(handle));
 }
 
-void TopLevelWindow::SetProgressBar(double progress,
-                                    gin_helper::Arguments* args) {
-  gin_helper::Dictionary options;
+void TopLevelWindow::SetProgressBar(double progress, mate::Arguments* args) {
+  mate::Dictionary options;
   std::string mode;
   args->GetNext(&options) && options.Get("mode", &mode);
 
-  NativeWindow::ProgressState state = NativeWindow::ProgressState::kNormal;
+  NativeWindow::ProgressState state = NativeWindow::PROGRESS_NORMAL;
   if (mode == "error")
-    state = NativeWindow::ProgressState::kError;
+    state = NativeWindow::PROGRESS_ERROR;
   else if (mode == "paused")
-    state = NativeWindow::ProgressState::kPaused;
+    state = NativeWindow::PROGRESS_PAUSED;
   else if (mode == "indeterminate")
-    state = NativeWindow::ProgressState::kIndeterminate;
+    state = NativeWindow::PROGRESS_INDETERMINATE;
   else if (mode == "none")
-    state = NativeWindow::ProgressState::kNone;
+    state = NativeWindow::PROGRESS_NONE;
 
   window_->SetProgressBar(progress, state);
 }
@@ -796,18 +756,11 @@ void TopLevelWindow::SetOverlayIcon(const gfx::Image& overlay,
 }
 
 void TopLevelWindow::SetVisibleOnAllWorkspaces(bool visible,
-                                               gin_helper::Arguments* args) {
-  gin_helper::Dictionary options;
+                                               mate::Arguments* args) {
+  mate::Dictionary options;
   bool visibleOnFullScreen = false;
   args->GetNext(&options) &&
       options.Get("visibleOnFullScreen", &visibleOnFullScreen);
-  if (visibleOnFullScreen) {
-    node::Environment* env = node::Environment::GetCurrent(args->isolate());
-    EmitDeprecationWarning(
-        env, "visibleOnFullScreen is deprecated and will be removed",
-        "electron");
-  }
-
   return window_->SetVisibleOnAllWorkspaces(visible, visibleOnFullScreen);
 }
 
@@ -825,16 +778,6 @@ void TopLevelWindow::SetVibrancy(v8::Isolate* isolate,
   window_->SetVibrancy(type);
 }
 
-#if defined(OS_MACOSX)
-void TopLevelWindow::SetTrafficLightPosition(const gfx::Point& position) {
-  window_->SetTrafficLightPosition(position);
-}
-
-gfx::Point TopLevelWindow::GetTrafficLightPosition() const {
-  return window_->GetTrafficLightPosition();
-}
-#endif
-
 void TopLevelWindow::SetTouchBar(
     const std::vector<mate::PersistentDictionary>& items) {
   window_->SetTouchBar(items);
@@ -870,13 +813,13 @@ void TopLevelWindow::ToggleTabBar() {
 }
 
 void TopLevelWindow::AddTabbedWindow(NativeWindow* window,
-                                     gin_helper::Arguments* args) {
+                                     mate::Arguments* args) {
   if (!window_->AddTabbedWindow(window))
     args->ThrowError("AddTabbedWindow cannot be called by a window on itself.");
 }
 
 void TopLevelWindow::SetWindowButtonVisibility(bool visible,
-                                               gin_helper::Arguments* args) {
+                                               mate::Arguments* args) {
   if (!window_->SetWindowButtonVisibility(visible)) {
     args->ThrowError("Not supported for this window");
   }
@@ -899,14 +842,14 @@ bool TopLevelWindow::IsMenuBarVisible() {
 }
 
 void TopLevelWindow::SetAspectRatio(double aspect_ratio,
-                                    gin_helper::Arguments* args) {
+                                    mate::Arguments* args) {
   gfx::Size extra_size;
   args->GetNext(&extra_size);
   window_->SetAspectRatio(aspect_ratio, extra_size);
 }
 
 void TopLevelWindow::PreviewFile(const std::string& path,
-                                 gin_helper::Arguments* args) {
+                                 mate::Arguments* args) {
   std::string display_name;
   if (!args->GetNext(&display_name))
     display_name = path;
@@ -917,10 +860,6 @@ void TopLevelWindow::CloseFilePreview() {
   window_->CloseFilePreview();
 }
 
-void TopLevelWindow::SetGTKDarkThemeEnabled(bool use_dark_theme) {
-  window_->SetGTKDarkThemeEnabled(use_dark_theme);
-}
-
 v8::Local<v8::Value> TopLevelWindow::GetContentView() const {
   if (content_view_.IsEmpty())
     return v8::Null(isolate());
@@ -940,7 +879,7 @@ std::vector<v8::Local<v8::Object>> TopLevelWindow::GetChildWindows() const {
 }
 
 v8::Local<v8::Value> TopLevelWindow::GetBrowserView(
-    gin_helper::Arguments* args) const {
+    mate::Arguments* args) const {
   if (browser_views_.size() == 0) {
     return v8::Null(isolate());
   } else if (browser_views_.size() == 1) {
@@ -968,7 +907,7 @@ bool TopLevelWindow::IsModal() const {
   return window_->is_modal();
 }
 
-bool TopLevelWindow::SetThumbarButtons(gin_helper::Arguments* args) {
+bool TopLevelWindow::SetThumbarButtons(mate::Arguments* args) {
 #if defined(OS_WIN)
   std::vector<TaskbarHost::ThumbarButton> buttons;
   if (!args->GetNext(&buttons)) {
@@ -1004,11 +943,14 @@ bool TopLevelWindow::HookWindowMessage(UINT message,
 }
 
 void TopLevelWindow::UnhookWindowMessage(UINT message) {
+  if (!ContainsKey(messages_callback_map_, message))
+    return;
+
   messages_callback_map_.erase(message);
 }
 
 bool TopLevelWindow::IsWindowMessageHooked(UINT message) {
-  return base::Contains(messages_callback_map_, message);
+  return ContainsKey(messages_callback_map_, message);
 }
 
 void TopLevelWindow::UnhookAllWindowMessages() {
@@ -1027,7 +969,7 @@ bool TopLevelWindow::SetThumbnailToolTip(const std::string& tooltip) {
       window_->GetAcceleratedWidget(), tooltip);
 }
 
-void TopLevelWindow::SetAppDetails(const gin_helper::Dictionary& options) {
+void TopLevelWindow::SetAppDetails(const mate::Dictionary& options) {
   base::string16 app_id;
   base::FilePath app_icon_path;
   int app_icon_index = 0;
@@ -1053,9 +995,9 @@ int32_t TopLevelWindow::GetID() const {
 void TopLevelWindow::ResetBrowserViews() {
   for (auto& item : browser_views_) {
     mate::Handle<BrowserView> browser_view;
-    if (gin::ConvertFromV8(isolate(),
-                           v8::Local<v8::Value>::New(isolate(), item.second),
-                           &browser_view) &&
+    if (mate::ConvertFromV8(isolate(),
+                            v8::Local<v8::Value>::New(isolate(), item.second),
+                            &browser_view) &&
         !browser_view.IsEmpty()) {
       window_->RemoveBrowserView(browser_view->view());
       browser_view->web_contents()->SetOwnerWindow(nullptr);
@@ -1072,7 +1014,7 @@ void TopLevelWindow::RemoveFromParentChildWindows() {
     return;
 
   mate::Handle<TopLevelWindow> parent;
-  if (!gin::ConvertFromV8(isolate(), GetParentWindow(), &parent) ||
+  if (!mate::ConvertFromV8(isolate(), GetParentWindow(), &parent) ||
       parent.IsEmpty()) {
     return;
   }
@@ -1081,19 +1023,19 @@ void TopLevelWindow::RemoveFromParentChildWindows() {
 }
 
 // static
-mate::WrappableBase* TopLevelWindow::New(gin_helper::Arguments* args) {
-  mate::Dictionary options = mate::Dictionary::CreateEmpty(args->isolate());
-  args->GetNext(&options);
-
-  return new TopLevelWindow(args, options);
+mate::WrappableBase* TopLevelWindow::New(mate::Arguments* args) {
+  mate::Dictionary options;
+  if (!(args->Length() == 1 && args->GetNext(&options)))
+    options = mate::Dictionary::CreateEmpty(args->isolate());
+  return new TopLevelWindow(args->isolate(), args->GetThis(), options);
 }
 
 // static
 void TopLevelWindow::BuildPrototype(v8::Isolate* isolate,
                                     v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "TopLevelWindow"));
-  gin_helper::Destroyable::MakeDestroyable(isolate, prototype);
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "TopLevelWindow"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
       .SetMethod("setContentView", &TopLevelWindow::SetContentView)
       .SetMethod("close", &TopLevelWindow::Close)
       .SetMethod("focus", &TopLevelWindow::Focus)
@@ -1128,11 +1070,10 @@ void TopLevelWindow::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setMaximumSize", &TopLevelWindow::SetMaximumSize)
       .SetMethod("getMaximumSize", &TopLevelWindow::GetMaximumSize)
       .SetMethod("setSheetOffset", &TopLevelWindow::SetSheetOffset)
-      .SetMethod("moveAbove", &TopLevelWindow::MoveAbove)
-      .SetMethod("moveTop", &TopLevelWindow::MoveTop)
       .SetMethod("setResizable", &TopLevelWindow::SetResizable)
       .SetMethod("isResizable", &TopLevelWindow::IsResizable)
       .SetMethod("setMovable", &TopLevelWindow::SetMovable)
+      .SetMethod("moveTop", &TopLevelWindow::MoveTop)
       .SetMethod("isMovable", &TopLevelWindow::IsMovable)
       .SetMethod("setMinimizable", &TopLevelWindow::SetMinimizable)
       .SetMethod("isMinimizable", &TopLevelWindow::IsMinimizable)
@@ -1149,8 +1090,6 @@ void TopLevelWindow::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getPosition", &TopLevelWindow::GetPosition)
       .SetMethod("setTitle", &TopLevelWindow::SetTitle)
       .SetMethod("getTitle", &TopLevelWindow::GetTitle)
-      .SetProperty("accessibleTitle", &TopLevelWindow::GetAccessibleTitle,
-                   &TopLevelWindow::SetAccessibleTitle)
       .SetMethod("flashFrame", &TopLevelWindow::FlashFrame)
       .SetMethod("setSkipTaskbar", &TopLevelWindow::SetSkipTaskbar)
       .SetMethod("setSimpleFullScreen", &TopLevelWindow::SetSimpleFullScreen)
@@ -1178,7 +1117,6 @@ void TopLevelWindow::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setBrowserView", &TopLevelWindow::SetBrowserView)
       .SetMethod("addBrowserView", &TopLevelWindow::AddBrowserView)
       .SetMethod("removeBrowserView", &TopLevelWindow::RemoveBrowserView)
-      .SetMethod("getMediaSourceId", &TopLevelWindow::GetMediaSourceId)
       .SetMethod("getNativeWindowHandle",
                  &TopLevelWindow::GetNativeWindowHandle)
       .SetMethod("setProgressBar", &TopLevelWindow::SetProgressBar)
@@ -1191,12 +1129,6 @@ void TopLevelWindow::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setAutoHideCursor", &TopLevelWindow::SetAutoHideCursor)
 #endif
       .SetMethod("setVibrancy", &TopLevelWindow::SetVibrancy)
-#if defined(OS_MACOSX)
-      .SetMethod("setTrafficLightPosition",
-                 &TopLevelWindow::SetTrafficLightPosition)
-      .SetMethod("getTrafficLightPosition",
-                 &TopLevelWindow::GetTrafficLightPosition)
-#endif
       .SetMethod("_setTouchBarItems", &TopLevelWindow::SetTouchBar)
       .SetMethod("_refreshTouchBarItem", &TopLevelWindow::RefreshTouchBarItem)
       .SetMethod("_setEscapeTouchBarItem",
@@ -1247,28 +1179,28 @@ void TopLevelWindow::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::TopLevelWindow;
+using atom::api::TopLevelWindow;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  TopLevelWindow::SetConstructor(isolate,
-                                 base::BindRepeating(&TopLevelWindow::New));
+  TopLevelWindow::SetConstructor(isolate, base::Bind(&TopLevelWindow::New));
 
-  gin_helper::Dictionary constructor(isolate,
-                                     TopLevelWindow::GetConstructor(isolate)
-                                         ->GetFunction(context)
-                                         .ToLocalChecked());
-  constructor.SetMethod("fromId", &TopLevelWindow::FromWeakMapID);
-  constructor.SetMethod("getAllWindows", &TopLevelWindow::GetAll);
+  mate::Dictionary constructor(isolate, TopLevelWindow::GetConstructor(isolate)
+                                            ->GetFunction(context)
+                                            .ToLocalChecked());
+  constructor.SetMethod("fromId",
+                        &mate::TrackableObject<TopLevelWindow>::FromWeakMapID);
+  constructor.SetMethod("getAllWindows",
+                        &mate::TrackableObject<TopLevelWindow>::GetAll);
 
-  gin_helper::Dictionary dict(isolate, exports);
+  mate::Dictionary dict(isolate, exports);
   dict.Set("TopLevelWindow", constructor);
 }
 

atom/browser/api/atom_api_top_level_window.h

@@ -2,36 +2,33 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef SHELL_BROWSER_API_ELECTRON_API_TOP_LEVEL_WINDOW_H_
-#define SHELL_BROWSER_API_ELECTRON_API_TOP_LEVEL_WINDOW_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_TOP_LEVEL_WINDOW_H_
+#define ATOM_BROWSER_API_ATOM_API_TOP_LEVEL_WINDOW_H_
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/native_window_observer.h"
+#include "atom/common/api/atom_api_native_image.h"
 #include "base/task/post_task.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
-#include "shell/browser/api/trackable_object.h"
-#include "shell/browser/native_window.h"
-#include "shell/browser/native_window_observer.h"
-#include "shell/common/api/electron_api_native_image.h"
-#include "shell/common/gin_helper/event_emitter.h"
+#include "native_mate/handle.h"
 
-namespace electron {
+namespace atom {
 
 namespace api {
 
 class View;
 
-class TopLevelWindow
-    : public mate::TrackableObject<
-          TopLevelWindow,
-          gin_helper::EventEmitter<mate::Wrappable<TopLevelWindow>>>,
-      public NativeWindowObserver {
+class TopLevelWindow : public mate::TrackableObject<TopLevelWindow>,
+                       public NativeWindowObserver {
  public:
-  static mate::WrappableBase* New(gin_helper::Arguments* args);
+  static mate::WrappableBase* New(mate::Arguments* args);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
@@ -46,7 +43,9 @@ class TopLevelWindow
   // Common constructor.
   TopLevelWindow(v8::Isolate* isolate, const mate::Dictionary& options);
   // Creating independent TopLevelWindow instance.
-  TopLevelWindow(gin_helper::Arguments* args, const mate::Dictionary& options);
+  TopLevelWindow(v8::Isolate* isolate,
+                 v8::Local<v8::Object> wrapper,
+                 const mate::Dictionary& options);
   ~TopLevelWindow() override;
 
   // TrackableObject:
@@ -74,7 +73,6 @@ class TopLevelWindow
   void OnWindowScrollTouchBegin() override;
   void OnWindowScrollTouchEnd() override;
   void OnWindowSwipe(const std::string& direction) override;
-  void OnWindowRotateGesture(float rotation) override;
   void OnWindowSheetBegin() override;
   void OnWindowSheetEnd() override;
   void OnWindowEnterFullScreen() override;
@@ -110,13 +108,13 @@ class TopLevelWindow
   bool IsMinimized();
   void SetFullScreen(bool fullscreen);
   bool IsFullscreen();
-  void SetBounds(const gfx::Rect& bounds, gin_helper::Arguments* args);
+  void SetBounds(const gfx::Rect& bounds, mate::Arguments* args);
   gfx::Rect GetBounds();
-  void SetSize(int width, int height, gin_helper::Arguments* args);
+  void SetSize(int width, int height, mate::Arguments* args);
   std::vector<int> GetSize();
-  void SetContentSize(int width, int height, gin_helper::Arguments* args);
+  void SetContentSize(int width, int height, mate::Arguments* args);
   std::vector<int> GetContentSize();
-  void SetContentBounds(const gfx::Rect& bounds, gin_helper::Arguments* args);
+  void SetContentBounds(const gfx::Rect& bounds, mate::Arguments* args);
   gfx::Rect GetContentBounds();
   bool IsNormal();
   gfx::Rect GetNormalBounds();
@@ -124,11 +122,10 @@ class TopLevelWindow
   std::vector<int> GetMinimumSize();
   void SetMaximumSize(int width, int height);
   std::vector<int> GetMaximumSize();
-  void SetSheetOffset(double offsetY, gin_helper::Arguments* args);
+  void SetSheetOffset(double offsetY, mate::Arguments* args);
   void SetResizable(bool resizable);
   bool IsResizable();
   void SetMovable(bool movable);
-  void MoveAbove(const std::string& sourceId, gin_helper::Arguments* args);
   void MoveTop();
   bool IsMovable();
   void SetMinimizable(bool minimizable);
@@ -139,15 +136,13 @@ class TopLevelWindow
   bool IsFullScreenable();
   void SetClosable(bool closable);
   bool IsClosable();
-  void SetAlwaysOnTop(bool top, gin_helper::Arguments* args);
+  void SetAlwaysOnTop(bool top, mate::Arguments* args);
   bool IsAlwaysOnTop();
   void Center();
-  void SetPosition(int x, int y, gin_helper::Arguments* args);
+  void SetPosition(int x, int y, mate::Arguments* args);
   std::vector<int> GetPosition();
   void SetTitle(const std::string& title);
   std::string GetTitle();
-  void SetAccessibleTitle(const std::string& title);
-  std::string GetAccessibleTitle();
   void FlashFrame(bool flash);
   void SetSkipTaskbar(bool skip);
   void SetExcludedFromShownWindowsMenu(bool excluded);
@@ -166,32 +161,25 @@ class TopLevelWindow
   std::string GetRepresentedFilename();
   void SetDocumentEdited(bool edited);
   bool IsDocumentEdited();
-  void SetIgnoreMouseEvents(bool ignore, gin_helper::Arguments* args);
+  void SetIgnoreMouseEvents(bool ignore, mate::Arguments* args);
   void SetContentProtection(bool enable);
   void SetFocusable(bool focusable);
   void SetMenu(v8::Isolate* isolate, v8::Local<v8::Value> menu);
   void RemoveMenu();
-  void SetParentWindow(v8::Local<v8::Value> value, gin_helper::Arguments* args);
+  void SetParentWindow(v8::Local<v8::Value> value, mate::Arguments* args);
   virtual void SetBrowserView(v8::Local<v8::Value> value);
   virtual void AddBrowserView(v8::Local<v8::Value> value);
   virtual void RemoveBrowserView(v8::Local<v8::Value> value);
   virtual std::vector<v8::Local<v8::Value>> GetBrowserViews() const;
   virtual void ResetBrowserViews();
-  std::string GetMediaSourceId() const;
   v8::Local<v8::Value> GetNativeWindowHandle();
-  void SetProgressBar(double progress, gin_helper::Arguments* args);
+  void SetProgressBar(double progress, mate::Arguments* args);
   void SetOverlayIcon(const gfx::Image& overlay,
                       const std::string& description);
-  void SetVisibleOnAllWorkspaces(bool visible, gin_helper::Arguments* args);
+  void SetVisibleOnAllWorkspaces(bool visible, mate::Arguments* args);
   bool IsVisibleOnAllWorkspaces();
   void SetAutoHideCursor(bool auto_hide);
   virtual void SetVibrancy(v8::Isolate* isolate, v8::Local<v8::Value> value);
-
-#if defined(OS_MACOSX)
-  void SetTrafficLightPosition(const gfx::Point& position);
-  gfx::Point GetTrafficLightPosition() const;
-#endif
-
   void SetTouchBar(const std::vector<mate::PersistentDictionary>& items);
   void RefreshTouchBarItem(const std::string& item_id);
   void SetEscapeTouchBarItem(const mate::PersistentDictionary& item);
@@ -200,32 +188,30 @@ class TopLevelWindow
   void MergeAllWindows();
   void MoveTabToNewWindow();
   void ToggleTabBar();
-  void AddTabbedWindow(NativeWindow* window, gin_helper::Arguments* args);
-  void SetWindowButtonVisibility(bool visible, gin_helper::Arguments* args);
+  void AddTabbedWindow(NativeWindow* window, mate::Arguments* args);
+  void SetWindowButtonVisibility(bool visible, mate::Arguments* args);
   void SetAutoHideMenuBar(bool auto_hide);
   bool IsMenuBarAutoHide();
   void SetMenuBarVisibility(bool visible);
   bool IsMenuBarVisible();
-  void SetAspectRatio(double aspect_ratio, gin_helper::Arguments* args);
-  void PreviewFile(const std::string& path, gin_helper::Arguments* args);
+  void SetAspectRatio(double aspect_ratio, mate::Arguments* args);
+  void PreviewFile(const std::string& path, mate::Arguments* args);
   void CloseFilePreview();
-  void SetGTKDarkThemeEnabled(bool use_dark_theme);
 
   // Public getters of NativeWindow.
   v8::Local<v8::Value> GetContentView() const;
   v8::Local<v8::Value> GetParentWindow() const;
   std::vector<v8::Local<v8::Object>> GetChildWindows() const;
-  v8::Local<v8::Value> GetBrowserView(gin_helper::Arguments* args) const;
+  v8::Local<v8::Value> GetBrowserView(mate::Arguments* args) const;
   bool IsModal() const;
 
   // Extra APIs added in JS.
-  bool SetThumbarButtons(gin_helper::Arguments* args);
+  bool SetThumbarButtons(mate::Arguments* args);
 #if defined(TOOLKIT_VIEWS)
   void SetIcon(mate::Handle<NativeImage> icon);
 #endif
 #if defined(OS_WIN)
-  typedef base::RepeatingCallback<void(v8::Local<v8::Value>,
-                                       v8::Local<v8::Value>)>
+  typedef base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>
       MessageCallback;
   bool HookWindowMessage(UINT message, const MessageCallback& callback);
   bool IsWindowMessageHooked(UINT message);
@@ -233,7 +219,7 @@ class TopLevelWindow
   void UnhookAllWindowMessages();
   bool SetThumbnailClip(const gfx::Rect& region);
   bool SetThumbnailToolTip(const std::string& tooltip);
-  void SetAppDetails(const gin_helper::Dictionary& options);
+  void SetAppDetails(const mate::Dictionary& options);
 #endif
   int32_t GetID() const;
 
@@ -247,7 +233,7 @@ class TopLevelWindow
 
   template <typename... Args>
   void EmitEventSoon(base::StringPiece eventName) {
-    base::PostTask(
+    base::PostTaskWithTraits(
         FROM_HERE, {content::BrowserThread::UI},
         base::BindOnce(base::IgnoreResult(&TopLevelWindow::Emit<Args...>),
                        weak_factory_.GetWeakPtr(), eventName));
@@ -271,6 +257,29 @@ class TopLevelWindow
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
-#endif  // SHELL_BROWSER_API_ELECTRON_API_TOP_LEVEL_WINDOW_H_
+namespace mate {
+
+template <>
+struct Converter<atom::NativeWindow*> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     atom::NativeWindow** out) {
+    // null would be tranfered to NULL.
+    if (val->IsNull()) {
+      *out = NULL;
+      return true;
+    }
+
+    atom::api::TopLevelWindow* window;
+    if (!Converter<atom::api::TopLevelWindow*>::FromV8(isolate, val, &window))
+      return false;
+    *out = window->window();
+    return true;
+  }
+};
+
+}  // namespace mate
+
+#endif  // ATOM_BROWSER_API_ATOM_API_TOP_LEVEL_WINDOW_H_

atom/browser/api/atom_api_tray.cc

@@ -2,77 +2,77 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "shell/browser/api/electron_api_tray.h"
+#include "atom/browser/api/atom_api_tray.h"
 
 #include <string>
 
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/browser.h"
+#include "atom/common/api/atom_api_native_image.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_includes.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "shell/browser/api/electron_api_menu.h"
-#include "shell/browser/browser.h"
-#include "shell/common/api/electron_api_native_image.h"
-#include "shell/common/gin_converters/gfx_converter.h"
-#include "shell/common/gin_converters/image_converter.h"
-#include "shell/common/gin_helper/dictionary.h"
-#include "shell/common/gin_helper/object_template_builder.h"
-#include "shell/common/node_includes.h"
+#include "native_mate/constructor.h"
+#include "native_mate/dictionary.h"
 #include "ui/gfx/image/image.h"
 
-namespace gin {
+namespace mate {
 
 template <>
-struct Converter<electron::TrayIcon::IconType> {
+struct Converter<atom::TrayIcon::HighlightMode> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     electron::TrayIcon::IconType* out) {
-    using IconType = electron::TrayIcon::IconType;
+                     atom::TrayIcon::HighlightMode* out) {
     std::string mode;
     if (ConvertFromV8(isolate, val, &mode)) {
-      if (mode == "none") {
-        *out = IconType::None;
+      if (mode == "always") {
+        *out = atom::TrayIcon::HighlightMode::ALWAYS;
         return true;
-      } else if (mode == "info") {
-        *out = IconType::Info;
+      }
+      if (mode == "selection") {
+        *out = atom::TrayIcon::HighlightMode::SELECTION;
         return true;
-      } else if (mode == "warning") {
-        *out = IconType::Warning;
-        return true;
-      } else if (mode == "error") {
-        *out = IconType::Error;
-        return true;
-      } else if (mode == "custom") {
-        *out = IconType::Custom;
+      }
+      if (mode == "never") {
+        *out = atom::TrayIcon::HighlightMode::NEVER;
         return true;
       }
     }
     return false;
   }
 };
+}  // namespace mate
 
-}  // namespace gin
-
-namespace electron {
+namespace atom {
 
 namespace api {
 
-Tray::Tray(gin::Handle<NativeImage> image, gin_helper::Arguments* args)
+Tray::Tray(v8::Isolate* isolate,
+           v8::Local<v8::Object> wrapper,
+           mate::Handle<NativeImage> image)
     : tray_icon_(TrayIcon::Create()) {
-  SetImage(args->isolate(), image);
+  SetImage(isolate, image);
   tray_icon_->AddObserver(this);
 
-  InitWithArgs(args);
+  InitWith(isolate, wrapper);
 }
 
-Tray::~Tray() = default;
+Tray::~Tray() {
+  // Destroy the native tray in next tick.
+  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,
+                                                  tray_icon_.release());
+}
 
 // static
-mate::WrappableBase* Tray::New(gin_helper::ErrorThrower thrower,
-                               gin::Handle<NativeImage> image,
-                               gin_helper::Arguments* args) {
+mate::WrappableBase* Tray::New(mate::Handle<NativeImage> image,
+                               mate::Arguments* args) {
   if (!Browser::Get()->is_ready()) {
-    thrower.ThrowError("Cannot create Tray before app is ready");
+    args->ThrowError("Cannot create Tray before app is ready");
     return nullptr;
   }
-  return new Tray(image, args);
+  return new Tray(args->isolate(), args->GetThis(), image);
 }
 
 void Tray::OnClicked(const gfx::Rect& bounds,
@@ -137,7 +137,7 @@ void Tray::OnDragEnded() {
   Emit("drag-end");
 }
 
-void Tray::SetImage(v8::Isolate* isolate, gin::Handle<NativeImage> image) {
+void Tray::SetImage(v8::Isolate* isolate, mate::Handle<NativeImage> image) {
 #if defined(OS_WIN)
   tray_icon_->SetImage(image->GetHICON(GetSystemMetrics(SM_CXSMICON)));
 #else
@@ -146,7 +146,7 @@ void Tray::SetImage(v8::Isolate* isolate, gin::Handle<NativeImage> image) {
 }
 
 void Tray::SetPressedImage(v8::Isolate* isolate,
-                           gin::Handle<NativeImage> image) {
+                           mate::Handle<NativeImage> image) {
 #if defined(OS_WIN)
   tray_icon_->SetPressedImage(image->GetHICON(GetSystemMetrics(SM_CXSMICON)));
 #else
@@ -172,6 +172,10 @@ std::string Tray::GetTitle() {
 #endif
 }
 
+void Tray::SetHighlightMode(TrayIcon::HighlightMode mode) {
+  tray_icon_->SetHighlightMode(mode);
+}
+
 void Tray::SetIgnoreDoubleClickEvents(bool ignore) {
 #if defined(OS_MACOSX)
   tray_icon_->SetIgnoreDoubleClickEvents(ignore);
@@ -186,63 +190,37 @@ bool Tray::GetIgnoreDoubleClickEvents() {
 #endif
 }
 
-void Tray::DisplayBalloon(gin_helper::ErrorThrower thrower,
-                          const gin_helper::Dictionary& options) {
-  TrayIcon::BalloonOptions balloon_options;
-
-  if (!options.Get("title", &balloon_options.title) ||
-      !options.Get("content", &balloon_options.content)) {
-    thrower.ThrowError("'title' and 'content' must be defined");
+void Tray::DisplayBalloon(mate::Arguments* args,
+                          const mate::Dictionary& options) {
+  mate::Handle<NativeImage> icon;
+  options.Get("icon", &icon);
+  base::string16 title, content;
+  if (!options.Get("title", &title) || !options.Get("content", &content)) {
+    args->ThrowError("'title' and 'content' must be defined");
     return;
   }
 
-  gin::Handle<NativeImage> icon;
-  options.Get("icon", &icon);
-  options.Get("iconType", &balloon_options.icon_type);
-  options.Get("largeIcon", &balloon_options.large_icon);
-  options.Get("noSound", &balloon_options.no_sound);
-  options.Get("respectQuietTime", &balloon_options.respect_quiet_time);
-
-  if (!icon.IsEmpty()) {
 #if defined(OS_WIN)
-    balloon_options.icon = icon->GetHICON(
-        GetSystemMetrics(balloon_options.large_icon ? SM_CXICON : SM_CXSMICON));
+  tray_icon_->DisplayBalloon(
+      icon.IsEmpty() ? NULL : icon->GetHICON(GetSystemMetrics(SM_CXSMICON)),
+      title, content);
 #else
-    balloon_options.icon = icon->image();
+  tray_icon_->DisplayBalloon(icon.IsEmpty() ? gfx::Image() : icon->image(),
+                             title, content);
 #endif
-  }
-
-  tray_icon_->DisplayBalloon(balloon_options);
 }
 
-void Tray::RemoveBalloon() {
-  tray_icon_->RemoveBalloon();
-}
-
-void Tray::Focus() {
-  tray_icon_->Focus();
-}
-
-void Tray::PopUpContextMenu(gin_helper::Arguments* args) {
-  gin::Handle<Menu> menu;
+void Tray::PopUpContextMenu(mate::Arguments* args) {
+  mate::Handle<Menu> menu;
   args->GetNext(&menu);
   gfx::Point pos;
   args->GetNext(&pos);
   tray_icon_->PopUpContextMenu(pos, menu.IsEmpty() ? nullptr : menu->model());
 }
 
-void Tray::SetContextMenu(gin_helper::ErrorThrower thrower,
-                          v8::Local<v8::Value> arg) {
-  gin::Handle<Menu> menu;
-  if (arg->IsNull()) {
-    menu_.Reset();
-    tray_icon_->SetContextMenu(nullptr);
-  } else if (gin::ConvertFromV8(thrower.isolate(), arg, &menu)) {
-    menu_.Reset(thrower.isolate(), menu.ToV8());
-    tray_icon_->SetContextMenu(menu->model());
-  } else {
-    thrower.ThrowTypeError("Must pass Menu or null");
-  }
+void Tray::SetContextMenu(v8::Isolate* isolate, mate::Handle<Menu> menu) {
+  menu_.Reset(isolate, menu.ToV8());
+  tray_icon_->SetContextMenu(menu.IsEmpty() ? nullptr : menu->model());
 }
 
 gfx::Rect Tray::GetBounds() {
@@ -252,21 +230,20 @@ gfx::Rect Tray::GetBounds() {
 // static
 void Tray::BuildPrototype(v8::Isolate* isolate,
                           v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(gin::StringToV8(isolate, "Tray"));
-  gin_helper::Destroyable::MakeDestroyable(isolate, prototype);
-  gin_helper::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+  prototype->SetClassName(mate::StringToV8(isolate, "Tray"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
       .SetMethod("setImage", &Tray::SetImage)
       .SetMethod("setPressedImage", &Tray::SetPressedImage)
       .SetMethod("setToolTip", &Tray::SetToolTip)
       .SetMethod("setTitle", &Tray::SetTitle)
       .SetMethod("getTitle", &Tray::GetTitle)
+      .SetMethod("setHighlightMode", &Tray::SetHighlightMode)
       .SetMethod("setIgnoreDoubleClickEvents",
                  &Tray::SetIgnoreDoubleClickEvents)
       .SetMethod("getIgnoreDoubleClickEvents",
                  &Tray::GetIgnoreDoubleClickEvents)
       .SetMethod("displayBalloon", &Tray::DisplayBalloon)
-      .SetMethod("removeBalloon", &Tray::RemoveBalloon)
-      .SetMethod("focus", &Tray::Focus)
       .SetMethod("popUpContextMenu", &Tray::PopUpContextMenu)
       .SetMethod("setContextMenu", &Tray::SetContextMenu)
       .SetMethod("getBounds", &Tray::GetBounds);
@@ -274,20 +251,20 @@ void Tray::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace api
 
-}  // namespace electron
+}  // namespace atom
 
 namespace {
 
-using electron::api::Tray;
+using atom::api::Tray;
 
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  Tray::SetConstructor(isolate, base::BindRepeating(&Tray::New));
+  Tray::SetConstructor(isolate, base::Bind(&Tray::New));
 
-  gin_helper::Dictionary dict(isolate, exports);
+  mate::Dictionary dict(isolate, exports);
   dict.Set(
       "Tray",
       Tray::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());