Bump v5.0.13

* fix: add patch to disable remote layer APIs

* fix: add patch to disable remote accessibility APIs

* fix: add patch to disable private window frame APIs

* fix: add patch to disable NSURLFileTypeMappings API

.dockerignore

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

.env.example

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

.eslintrc.json

@@ -0,0 +1,12 @@
+{
+  "extends": "standard",
+  "env": {
+    "browser": true
+  },
+  "rules": {
+    "no-var": "error",
+    "prefer-const": ["error", {
+      "destructuring": "all"
+    }]
+  }
+}

.gitattributes

@@ -0,0 +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

.github/CODEOWNERS

@@ -3,19 +3,25 @@
 # https://help.github.com/articles/about-codeowners
 # https://git-scm.com/docs/gitignore
 
-# Everything that falls through the cracks:
-* @electron/reviewers
+# Most stuff in here is owned by the Community & Safety WG...
+/.github/*                              @electron/wg-community
 
-# filename patterns
-*browser_view* @electron/browserview
-*notification* @electron/notifications
-*pdf* @electron/printing
-*printing* @electron/printing
-*updater* @electron/updater
+# ...except the Admin WG maintains this file.
+/.github/CODEOWNERS                     @electron/wg-admin
 
-# directories
-/.github/ @electron/hubbers
-/default_app/ @electron/docs
-/docs/ @electron/docs
-/docs-translations/ @electron/i18n
-/npm/ @electron/hubbers
+# Upgrades WG
+/patches/                               @electron/wg-upgrades
+DEPS                                    @electron/wg-upgrades
+
+# Releases WG
+/npm/                                   @electron/wg-releases
+/script/release-notes                   @electron/wg-releases
+/script/prepare-release.js              @electron/wg-releases
+/script/bump-version.js                 @electron/wg-releases
+/script/ci-release-build.js             @electron/wg-releases
+/script/release.js                      @electron/wg-releases
+/script/upload-to-github.js             @electron/wg-releases
+/script/release-artifact-cleanup.js     @electron/wg-releases
+/script/get-last-major-for-master.js    @electron/wg-releases
+/script/find-release.js                 @electron/wg-releases
+/script/download-circleci-artifacts.js  @electron/wg-releases

.github/ISSUE_TEMPLATE.md

@@ -7,8 +7,11 @@ Thanks for opening an issue! A few things to keep in mind:
 - If you need general advice, join our Slack: http://atom-slack.herokuapp.com
 -->
 
-* Electron version:
-* Operating system:
+* Output of `node_modules/.bin/electron --version`:
+* Operating System (Platform and Version):
+
+<!-- If this used to work -->
+* Output of `node_modules/.bin/electron --version` on last known working Electron version (if applicable):
 
 ### Expected behavior
 

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a report to help us improve Electron
+
+---
+
+* Output of `node_modules/.bin/electron --version`:
+* Operating System (Platform and Version):
+* Output of `node_modules/.bin/electron --version` on last known working Electron version (if applicable):
+
+**Expected Behavior**
+A clear and concise description of what you expected to happen.
+
+**Actual behavior**
+A clear and concise description of what actually happened.
+
+**To Reproduce**
+Your best chance of getting this bug looked at quickly is to provide a 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.
+
+If you provide a URL, please list the commands required to clone/setup/run your repo e.g.
+```sh
+$ git clone $YOUR_URL -b $BRANCH
+$ npm install
+$ npm start || electron .
+```
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional Information**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/Feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for Electron
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is.
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/mac-app-store-private-api-rejection.md

@@ -0,0 +1,13 @@
+---
+name: Mac App Store Private API Rejection
+about: Your app was rejected from the Mac App Store for using private API's
+
+---
+
+* Electron Version: 
+
+**Rejection Email**
+Paste the contents of your rejection email here, censoring any private information such as app names.
+
+**Additional Information**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/security-report.md

@@ -0,0 +1,9 @@
+---
+name: Security report
+about: Do not create an issue for security reports, send an email to security@electronjs.org
+
+---
+
+Do not create an issue for security reports, send an email to:
+
+security@electronjs.org

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,8 +1,22 @@
+#### Description of Change
 <!--
 Thank you for your Pull Request. Please provide a description above and review
 the requirements below.
 
-Bug fixes and new features should include tests and possibly benchmarks.
-
 Contributors guide: https://github.com/electron/electron/blob/master/CONTRIBUTING.md
--->
+-->
+
+#### Checklist
+<!-- Remove items that do not apply. For completed items, change [ ] to [x]. -->
+
+- [ ] PR description included and stakeholders cc'd
+- [ ] `npm test` passes
+- [ ] tests are [changed or added](https://github.com/electron/electron/blob/master/docs/development/testing.md)
+- [ ] relevant documentation is changed or added
+- [ ] PR title follows semantic [commit guidelines](https://github.com/electron/electron/blob/master/docs/development/pull-requests.md#commit-message-guidelines)
+- [ ] [PR release notes](https://github.com/electron/clerk/blob/master/README.md) describe the change in a way relevant to app developers, and are [capitalized, punctuated, and past tense](https://github.com/electron/clerk/blob/master/README.md#examples).
+
+
+#### Release Notes
+
+Notes: <!-- Please add a one-line description for app developers to read in the release notes, or `no-notes` if no notes relevant to app developers. Examples and help on special cases: https://github.com/electron/clerk/blob/master/README.md#examples -->

.github/config.yml

@@ -4,7 +4,7 @@
 newIssueWelcomeComment: |
   👋 Thanks for opening your first issue here! If you're reporting a 🐞 bug, please make sure you include steps to reproduce it. We get a lot of issues on this repo, so please be patient and we will get back to you as soon as we can.
 
-  To help make it easier for us to investigate your issue, please follow the [contributing guidelines](https://github.com/electron/electron/blob/master/CONTRIBUTING.md#submitting-issues).
+  To help make it easier for us to investigate your issue, please follow the [contributing guidelines](https://github.com/electron/electron/blob/master/CONTRIBUTING.md).
 
 # Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome
 
@@ -12,14 +12,22 @@ newIssueWelcomeComment: |
 newPRWelcomeComment: |
   💖 Thanks for opening this pull request! 💖
 
-  ![typing cat](https://user-images.githubusercontent.com/2289/36400158-2c7c589e-1584-11e8-81c7-bd34fd3c392b.gif)
+  We use [semantic commit messages](https://github.com/electron/electron/blob/master/docs/development/pull-requests.md#commit-message-guidelines) to streamline the release process. Before your pull request can be merged, you should **update your pull request title** to start with a semantic prefix.
+
+  Examples of commit messages with semantic prefixes:
+
+  - `fix: don't overwrite prevent_default if default wasn't prevented`
+  - `feat: add app.isPackaged() method`
+  - `docs: app.isDefaultProtocolClient is now available on Linux`
+
+  Things that will help get your PR across the finish line:
 
-  Here is a list of things that will help get it across the finish line:
   - Follow the JavaScript, C++, and Python [coding style](https://github.com/electron/electron/blob/master/docs/development/coding-style.md).
   - Run `npm run lint` locally to catch formatting errors earlier.
   - Document any user-facing changes you've made following the [documentation styleguide](https://github.com/electron/electron/blob/master/docs/styleguide.md).
   - Include tests when adding/changing behavior.
   - Include screenshots and animated GIFs whenever possible.
+
   We get a lot of pull requests on this repo, so please be patient and we will get back to you as soon as we can.
 
 # Configuration for first-pr-merge - https://github.com/behaviorbot/first-pr-merge
@@ -28,4 +36,20 @@ newPRWelcomeComment: |
 firstPRMergeComment: >
   Congrats on merging your first pull request! 🎉🎉🎉
 
-# It is recommend to include as many gifs and emojis as possible
+# Configuration for trop - https://github.com/electron/trop
+
+watchedProject:
+  name: Backports
+
+# Users authorized to run manual trop backports
+authorizedUsers:
+  - alexeykuzmin
+  - BinaryMuse
+  - ckerr
+  - codebytere
+  - deepak1556
+  - jkleinsc
+  - MarshallOfSound
+  - nitsakh
+  - nornagon
+  - zcbenz

.gitignore

@@ -16,26 +16,15 @@
 *.vcxproj.user
 *.xcodeproj
 /.idea/
-/brightray/brightray.opensdf
-/brightray/brightray.sdf
-/brightray/brightray.sln
-/brightray/brightray.suo
-/brightray/brightray.v12.suo
-/brightray/brightray.vcxproj*
-/brightray/brightray.xcodeproj/
-/build/
 /dist/
 /external_binaries/
 /out/
 /vendor/.gclient
-/vendor/debian_jessie_amd64-sysroot/
-/vendor/debian_jessie_arm-sysroot/
-/vendor/debian_jessie_arm64-sysroot/
-/vendor/debian_jessie_i386-sysroot/
 /vendor/debian_jessie_mips64-sysroot/
-/vendor/debian_wheezy_amd64-sysroot/
-/vendor/debian_wheezy_arm-sysroot/
-/vendor/debian_wheezy_i386-sysroot/
+/vendor/debian_stretch_amd64-sysroot/
+/vendor/debian_stretch_arm-sysroot/
+/vendor/debian_stretch_arm64-sysroot/
+/vendor/debian_stretch_i386-sysroot/
 /vendor/gcc-4.8.3-d197-n64-loongson/
 /vendor/readme-gcc483-loongson.txt
 /vendor/download/
@@ -43,6 +32,30 @@
 /vendor/llvm/
 /vendor/npm/
 /vendor/python_26/
+/vendor/native_mksnapshot
+/vendor/LICENSES.chromium.html
+/vendor/pyyaml
 node_modules/
 SHASUMS256.txt
-**/package-lock.json
+**/yarn.lock
+compile_commands.json
+.envrc
+
+# npm package
+/npm/dist
+/npm/path.txt
+
+.npmrc
+
+# Generated API definitions
+electron-api.json
+electron.d.ts
+
+# Spec hash calculation
+spec/.hash
+
+# Eslint Cache
+.eslintcache
+
+# Generated native addon files
+/spec/fixtures/native-addon/echo/build/

.gitmodules

@@ -1,30 +1,6 @@
-[submodule "vendor/node"]
-	path = vendor/node
-	url = https://github.com/electron/node.git
-[submodule "vendor/depot_tools"]
-	path = vendor/depot_tools
-	url = https://chromium.googlesource.com/chromium/tools/depot_tools.git
-[submodule "vendor/breakpad"]
-	path = vendor/breakpad
-	url = https://github.com/electron/chromium-breakpad.git
-[submodule "vendor/native_mate"]
-	path = vendor/native_mate
-	url = https://github.com/electron/native-mate.git
-[submodule "vendor/crashpad"]
-	path = vendor/crashpad
-	url = https://github.com/electron/crashpad.git
 [submodule "vendor/requests"]
 	path = vendor/requests
 	url = https://github.com/kennethreitz/requests
 [submodule "vendor/boto"]
 	path = vendor/boto
 	url = https://github.com/boto/boto.git
-[submodule "vendor/pdf_viewer"]
-	path = vendor/pdf_viewer
-	url = https://github.com/electron/pdf-viewer.git
-[submodule "vendor/gyp"]
-	path = vendor/gyp
-	url = https://github.com/electron/gyp
-[submodule "vendor/libchromiumcontent"]
-	path = vendor/libchromiumcontent
-	url = https://github.com/electron/libchromiumcontent

.node-version

@@ -1 +0,0 @@
-v8.2.1

.travis.yml

@@ -1,34 +0,0 @@
-git:
-  depth: 10
-notifications:
-  email: false
-
-before_install:
-  - export BOTO_CONFIG=/dev/null
-
-language: node_js
-node_js:
-  - "4"
-os:
-  - linux
-  - osx
-env:
-  - TARGET_ARCH=x64
-osx_image: xcode7.3
-
-matrix:
-  include:
-    - os: linux
-      env: TARGET_ARCH=arm
-    - os: linux
-      env: TARGET_ARCH=ia32
-    - os: linux
-      env: TARGET_ARCH=arm64
-  allow_failures:
-    - os: osx
-
-script: './script/cibuild'
-
-branches:
-  only:
-    - master

CODE_OF_CONDUCT.md

@@ -34,7 +34,7 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at [electron@github.com](mailto:electron@github.com). All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at [coc@electronjs.org](mailto:coc@electronjs.org). All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 

CONTRIBUTING.md

@@ -4,7 +4,7 @@
 
 This project adheres to the Contributor Covenant [code of conduct](CODE_OF_CONDUCT.md).
 By participating, you are expected to uphold this code. Please report unacceptable
-behavior to electron@github.com.
+behavior to coc@electronjs.org.
 
 The following is a set of guidelines for contributing to Electron.
 These are just guidelines, not rules, use your best judgment and feel free to
@@ -54,3 +54,7 @@ dependencies, and tools contained in the `electron/electron` repository.
 
 See [Coding Style](https://electronjs.org/docs/development/coding-style) for information about which standards Electron adheres to in different parts of its codebase.
 
+## Further Reading
+
+For more in-depth guides on developing Electron, see 
+[/docs/development](/docs/development/README.md)

DEPS

@@ -0,0 +1,138 @@
+gclient_gn_args_file = 'src/build/config/gclient_args.gni'
+gclient_gn_args = [
+  'build_with_chromium',
+  'checkout_android',
+  'checkout_android_native_support',
+  'checkout_libaom',
+  'checkout_nacl',
+  'checkout_oculus_sdk'
+]
+
+vars = {
+  'chromium_version':
+    '73.0.3683.121',
+  'node_version':
+    '666c67e078bddc32f25409f4a929c1e9b5f47373',
+
+  'boto_version': 'f7574aa6cc2c819430c1f05e9a1a1a666ef8169b',
+  'pyyaml_version': '3.12',
+  'requests_version': 'e4d59bedfd3c7f4f254f4f5d036587bcd8152458',
+
+  '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',
+
+  # To be able to build clean Chromium from sources.
+  'apply_patches': True,
+
+  # Python interface to Amazon Web Services. Is used for releases only.
+  'checkout_boto': False,
+
+  # To allow in-house builds to checkout those manually.
+  'checkout_chromium': True,
+  'checkout_node': True,
+
+  # It's only needed to parse the native tests configurations.
+  'checkout_pyyaml': False,
+
+  # Python "requests" module is used for releases only.
+  'checkout_requests': False,
+
+  # It is always needed for normal Electron builds,
+  # but might be impossible for custom in-house builds.
+  'download_external_binaries': True,
+
+  'checkout_nacl':
+    False,
+  'checkout_libaom':
+    True,
+  'checkout_oculus_sdk':
+    False,
+  'build_with_chromium':
+    True,
+  'checkout_android':
+    False,
+  'checkout_android_native_support':
+    False,
+}
+
+deps = {
+  'src': {
+    'url': (Var("chromium_git")) + '/chromium/src.git@' + (Var("chromium_version")),
+    'condition': 'checkout_chromium',
+  },
+  'src/third_party/electron_node': {
+    'url': (Var("nodejs_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',
+  },
+  'src/electron/vendor/boto': {
+    'url': Var('boto_git') + '/boto.git' + '@' +  Var('boto_version'),
+    'condition': 'checkout_boto',
+  },
+  'src/electron/vendor/requests': {
+    'url': Var('requests_git') + '/requests.git' + '@' +  Var('requests_version'),
+    'condition': 'checkout_requests',
+  },
+}
+
+hooks = [
+  {
+    'name': 'patch_chromium',
+    'condition': 'checkout_chromium and apply_patches',
+    'pattern': 'src/electron',
+    'action': [
+      'python',
+      'src/electron/script/apply_all_patches.py',
+      'src/electron/patches/common/config.json',
+    ],
+  },
+  {
+    'name': 'electron_external_binaries',
+    'pattern': 'src/electron/script/update-external-binaries.py',
+    'condition': 'download_external_binaries',
+    'action': [
+      'python',
+      'src/electron/script/update-external-binaries.py',
+    ],
+  },
+  {
+    'name': 'electron_npm_deps',
+    'pattern': 'src/electron/package.json',
+    'action': [
+      'python',
+      '-c',
+      'import os; os.chdir("src"); os.chdir("electron"); os.system("npm install")',
+    ],
+  },
+  {
+    'name': 'setup_boto',
+    'pattern': 'src/electron',
+    'condition': 'checkout_boto',
+    'action': [
+      'python',
+      '-c',
+      'import os; os.chdir("src"); os.chdir("electron"); os.chdir("vendor"); os.chdir("boto"); os.system("python setup.py build");',
+    ],
+  },
+  {
+    'name': 'setup_requests',
+    'pattern': 'src/electron',
+    'condition': 'checkout_requests',
+    'action': [
+      'python',
+      '-c',
+      'import os; os.chdir("src"); os.chdir("electron"); os.chdir("vendor"); os.chdir("requests"); os.system("python setup.py build");',
+    ],
+  }
+]
+
+recursedeps = [
+  'src',
+]

Dockerfile

@@ -1,21 +1,47 @@
-FROM electronbuilds/libchromiumcontent:0.0.4
+FROM ubuntu:18.04
 
-USER root
+RUN groupadd --gid 1000 builduser \
+  && useradd --uid 1000 --gid builduser --shell /bin/bash --create-home builduser
 
-# Set up HOME directory
-ENV HOME=/home
-RUN chmod a+rwx /home
+# Set up TEMP directory
+ENV TEMP=/tmp
+RUN chmod a+rwx /tmp
 
-# Install node.js
-RUN curl -sL https://deb.nodesource.com/setup_6.x | bash -
-RUN apt-get update && apt-get install -y nodejs
+# 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 apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
+    curl \
+    libnotify-bin \
+    locales \
+    lsb-release \
+    nano \
+    python-dbus \
+    python-pip \
+    python-setuptools \
+    sudo \
+    vim-nox \
+    wget \
+  && /setup/install-build-deps.sh --syms --no-prompt --no-chromeos-fonts --lib32 --arm \
+  && rm -rf /var/lib/apt/lists/*
 
-# Install wget used by crash reporter
-RUN apt-get install -y wget
+# Install Node.js
+RUN curl -sL https://deb.nodesource.com/setup_10.x | bash - \
+  && DEBIAN_FRONTEND=noninteractive apt-get install -y nodejs \
+  && rm -rf /var/lib/apt/lists/*
 
-# Install python-dbusmock
-RUN apt-get install -y python-dbusmock
+# 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
 
 # Add xvfb init script
 ADD tools/xvfb-init.sh /etc/init.d/xvfb
 RUN chmod a+x /etc/init.d/xvfb
+
+USER builduser
+WORKDIR /home/builduser

Dockerfile.arm32v7

@@ -0,0 +1,61 @@
+FROM arm32v7/ubuntu:18.04
+
+RUN groupadd --gid 1000 builduser \
+  && useradd --uid 1000 --gid builduser --shell /bin/bash --create-home builduser
+
+# Set up TEMP directory
+ENV TEMP=/tmp
+RUN chmod a+rwx /tmp
+
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
+ bison \
+ build-essential \
+ clang \
+ curl \
+ gperf \
+ git \
+ libasound2 \
+ libasound2-dev \
+ libcap-dev \
+ libcups2-dev \
+ libdbus-1-dev \
+ libgconf-2-4 \
+ libgconf2-dev \
+ libgnome-keyring-dev \
+ libgtk2.0-0 \
+ libgtk2.0-dev \
+ libgtk-3-0 \
+ libgtk-3-dev \
+ libnotify-bin \
+ libnss3 \
+ libnss3-dev \
+ libxss1 \
+ libxtst-dev \
+ libxtst6 \
+ lsb-release \
+ locales \
+ nano \
+ python-setuptools \
+ python-pip \
+ python-dbusmock \
+ sudo \
+ unzip \
+ wget \
+ xvfb \
+&& rm -rf /var/lib/apt/lists/*
+
+# Install Node.js
+RUN curl -sL https://deb.nodesource.com/setup_10.x | bash - \
+  && DEBIAN_FRONTEND=noninteractive apt-get install -y nodejs \
+  && rm -rf /var/lib/apt/lists/*
+
+# crcmod is required by gsutil, which is used for filling the gclient git cache
+RUN pip install -U crcmod
+
+ADD tools/xvfb-init.sh /etc/init.d/xvfb
+RUN chmod a+x /etc/init.d/xvfb
+
+RUN usermod -aG sudo builduser
+RUN echo 'builduser ALL=(ALL:ALL) NOPASSWD:ALL' >> /etc/sudoers
+
+WORKDIR /home/builduser

Dockerfile.arm64

@@ -1,34 +0,0 @@
-FROM multiarch/debian-debootstrap:arm64-jessie
-
-RUN apt-get update && apt-get install -y\
- bison \
- build-essential \
- clang \
- curl \
- gperf \
- libasound2 \
- libasound2-dev \
- libcap-dev \
- libcups2-dev \
- libdbus-1-dev \
- libgconf-2-4 \
- libgconf2-dev \
- libgnome-keyring-dev \
- libgtk-3-0 \
- libgtk-3-dev \
- libnotify-dev \
- libnss3 \
- libnss3-dev \
- libx11-xcb-dev \
- libxss1 \
- libxtst-dev \
- libxtst6 \
- python-dbusmock \
- wget \
- xvfb
-
-ADD tools/xvfb-init.sh /etc/init.d/xvfb
-RUN chmod a+x /etc/init.d/xvfb
-ADD tools/run-electron.sh /run-electron.sh
-RUN chmod a+x /run-electron.sh
-CMD sh /run-electron.sh

Dockerfile.arm64v8

@@ -0,0 +1,65 @@
+FROM arm64v8/ubuntu:16.04
+
+RUN groupadd --gid 1000 builduser \
+  && useradd --uid 1000 --gid builduser --shell /bin/bash --create-home builduser
+
+# Set up TEMP directory
+ENV TEMP=/tmp
+RUN chmod a+rwx /tmp
+
+RUN dpkg --add-architecture armhf
+
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
+ bison \
+ build-essential \
+ clang \
+ curl \
+ gperf \
+ git \
+ libasound2 \
+ libasound2-dev \
+ libc6:armhf \
+ libcap-dev \
+ libcups2-dev \
+ libdbus-1-dev \
+ libgconf-2-4 \
+ libgconf2-dev \
+ libgnome-keyring-dev \
+ libgtk2.0-0 \
+ libgtk2.0-dev \
+ libgtk-3-0 \
+ libgtk-3-dev \
+ libnotify-bin \
+ libnss3 \
+ libnss3-dev \
+ libstdc++6:armhf \
+ libxss1 \
+ libxtst-dev \
+ libxtst6 \
+ lsb-release \
+ locales \
+ nano \
+ python-setuptools \
+ python-pip \
+ python-dbusmock \
+ sudo \
+ unzip \
+ wget \
+ xvfb \
+&& rm -rf /var/lib/apt/lists/*
+
+# Install Node.js
+RUN curl -sL https://deb.nodesource.com/setup_10.x | bash - \
+  && DEBIAN_FRONTEND=noninteractive apt-get install -y nodejs \
+  && rm -rf /var/lib/apt/lists/*
+
+# crcmod is required by gsutil, which is used for filling the gclient git cache
+RUN pip install -U crcmod
+
+ADD tools/xvfb-init.sh /etc/init.d/xvfb
+RUN chmod a+x /etc/init.d/xvfb
+
+RUN usermod -aG sudo builduser
+RUN echo 'builduser ALL=(ALL:ALL) NOPASSWD:ALL' >> /etc/sudoers
+
+WORKDIR /home/builduser

Dockerfile.armv7

@@ -1,40 +0,0 @@
-FROM multiarch/debian-debootstrap:armhf-jessie
-
-RUN apt-get update && apt-get install -y\
- bison \
- build-essential \
- clang \
- curl \
- gperf \
- libasound2 \
- libasound2-dev \
- libcap-dev \
- libcups2-dev \
- libdbus-1-dev \
- libgconf-2-4 \
- libgconf2-dev \
- libgnome-keyring-dev \
- libgtk-3-0 \
- libgtk-3-dev \
- libnotify-dev \
- libnss3 \
- libnss3-dev \
- libx11-xcb-dev \
- libxss1 \
- libxtst-dev \
- libxtst6 \
- python-dbusmock \
- git \
- wget \
- xvfb
-
-# Install node.js
-RUN curl -sL https://deb.nodesource.com/setup_6.x | bash -
-RUN apt-get update && apt-get install -y nodejs
-
-ADD tools/xvfb-init.sh /etc/init.d/xvfb
-RUN chmod a+x /etc/init.d/xvfb
-ADD tools/run-electron.sh /run-electron.sh
-RUN chmod a+x /run-electron.sh
-
-CMD sh /run-electron.sh

Dockerfile.circleci

@@ -1,20 +0,0 @@
-FROM electronbuilds/libchromiumcontent:0.0.4
-
-USER root
-
-# Install node.js
-RUN curl -sL https://deb.nodesource.com/setup_6.x | bash -
-RUN apt-get update && apt-get install -y nodejs
-
-# Install wget used by crash reporter
-RUN apt-get install -y wget
-
-# Install python-dbusmock
-RUN apt-get install -y python-dbusmock
-
-# Add xvfb init script
-ADD tools/xvfb-init.sh /etc/init.d/xvfb
-RUN chmod a+x /etc/init.d/xvfb
-
-USER builduser
-WORKDIR /home/builduser

ELECTRON_VERSION

@@ -0,0 +1 @@
+5.0.13

Jenkinsfile

@@ -1,48 +0,0 @@
-pipeline {
-  agent none
-  stages {
-    stage('Build') {
-      parallel {
-        stage('electron-osx-x64') {
-            agent {
-              label 'osx'
-            }
-            steps {
-              timeout(60) {
-                sh 'script/bootstrap.py --target_arch=x64 --dev'
-                sh 'npm run lint'
-                sh 'script/build.py -c D'
-                sh 'script/test.py --ci --rebuild_native_modules'
-              }
-            }
-            post {
-              always {
-                cleanWs()
-              }
-            }
-        }
-        stage('electron-mas-x64') {
-          agent {
-            label 'osx'
-          }
-          environment {
-            MAS_BUILD = '1'
-          }
-          steps {
-            timeout(60) {
-              sh 'script/bootstrap.py --target_arch=x64 --dev'
-              sh 'npm run lint'
-              sh 'script/build.py -c D'
-              sh 'script/test.py --ci --rebuild_native_modules'
-            }
-          }
-          post {
-            always {
-              cleanWs()
-            }
-          }
-        }
-      }
-    }
-  }
-}

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2018 GitHub Inc.
+Copyright (c) 2013-2019 GitHub Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -3,12 +3,12 @@
 
 [![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://windows-ci.electronjs.org/api/projects/status/nilyf07hcef14dvj/branch/master?svg=true)](https://windows-ci.electronjs.org/project/AppVeyor/electron/branch/master)
-[![Jenkins Build Status](https://mac-ci.electronjs.org/buildStatus/icon?job=Electron%20org/electron/master)](https://mac-ci.electronjs.org/blue/organizations/jenkins/Electron%20org%2Felectron/activity?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/electron-i18n](https://github.com/electron/electron-i18n/tree/master/content/).
+View these docs in other languages at [electron/i18n](https://github.com/electron/i18n/tree/master/content/).
 
 The Electron framework lets you write cross-platform desktop applications
 using JavaScript, HTML and CSS. It is based on [Node.js](https://nodejs.org/) and
@@ -21,7 +21,7 @@ announcements.
 This project adheres to the Contributor Covenant
 [code of conduct](https://github.com/electron/electron/tree/master/CODE_OF_CONDUCT.md).
 By participating, you are expected to uphold this code. Please report unacceptable
-behavior to [electron@github.com](mailto:electron@github.com).
+behavior to [coc@electronjs.org](mailto:coc@electronjs.org).
 
 ## Installation
 
@@ -30,19 +30,24 @@ The preferred method is to install Electron as a development dependency in your
 app:
 
 ```sh
-npm install electron --save-dev --save-exact
+npm install electron --save-dev [--save-exact]
 ```
 
-The `--save-exact` flag is recommended as Electron does not follow semantic
-versioning. For info on how to manage Electron versions in your apps, see
+The `--save-exact` flag is recommended for Electron prior to version 2, as it does not follow semantic
+versioning. As of version 2.0.0, Electron follows semver, so you don't need `--save-exact` flag. For info on how to manage Electron versions in your apps, see
 [Electron versioning](docs/tutorial/electron-versioning.md).
 
 For more installation options and troubleshooting tips, see
 [installation](docs/tutorial/installation.md).
 
-## Quick start
+## Quick start & Electron Fiddle
 
-Clone and run the
+Use [`Electron Fiddle`](https://github.com/electron/fiddle)
+to build, run, and package small Electron experiments, to see code examples for all of Electron's APIs, and
+to try out different versions of Electron. It's designed to make the start of your journey with
+Electron easier.
+
+Alternatively, clone and run the
 [electron/electron-quick-start](https://github.com/electron/electron-quick-start)
 repository to see a minimal Electron app in action:
 
@@ -56,6 +61,7 @@ npm start
 ## Resources for learning Electron
 
 - [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
@@ -85,26 +91,12 @@ const child = proc.spawn(electron)
 
 ## Documentation Translations
 
-Find documentation translations in [electron/electron-i18n](https://github.com/electron/electron-i18n).
+Find documentation translations in [electron/i18n](https://github.com/electron/i18n).
 
 ## Community
 
-You can ask questions and interact with the community in the following
-locations:
-- [`electron`](https://discuss.atom.io/c/electron) category on the Atom
-forums
-- `#atom-shell` channel on Freenode
-- [`Atom`](https://atom-slack.herokuapp.com) channel on Slack
-- [`electron-ru`](https://telegram.me/electron_ru) *(Russian)*
-- [`electron-br`](https://electron-br.slack.com) *(Brazilian Portuguese)*
-- [`electron-kr`](https://electron-kr.github.io/electron-kr) *(Korean)*
-- [`electron-jp`](https://electron-jp.slack.com) *(Japanese)*
-- [`electron-tr`](https://electron-tr.herokuapp.com) *(Turkish)*
-- [`electron-id`](https://electron-id.slack.com) *(Indonesia)*
-- [`electron-pl`](https://electronpl.github.io) *(Poland)*
-
-Check out [awesome-electron](https://github.com/sindresorhus/awesome-electron)
-for a community maintained list of useful example apps, tools and resources.
+Info on reporting bugs, getting help, finding third-party tools and sample apps,
+and more can be found in the [support document](docs/tutorial/support.md#finding-support).
 
 ## License
 

SECURITY.md

@@ -2,7 +2,7 @@
 
 The Electron team and community take security bugs in Electron seriously. We appreciate your efforts to responsibly disclose your findings, and will make every effort to acknowledge your contributions.
 
-To report a security issue, email [electron@github.com](mailto:electron@github.com) and include the word "SECURITY" in the subject line.
+To report a security issue, email [security@electronjs.org](mailto:security@electronjs.org) and include the word "SECURITY" in the subject line.
 
 The Electron team will send a response indicating the next steps in handling your report. After the initial reply to your report, the security team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance.
 

appveyor.yml

@@ -0,0 +1,114 @@
+# The config expects the following environment variables to be set:
+#  - "GN_CONFIG" Build type. One of {'debug', 'testing', 'release'}.
+#  - "GN_EXTRA_ARGS" Additional gn arguments for a build config,
+#      e.g. 'target_cpu="x86"' to build for a 32bit platform.
+#      https://gn.googlesource.com/gn/+/master/docs/reference.md#target_cpu
+#      Don't forget to set up "NPM_CONFIG_ARCH" and "TARGET_ARCH" accordningly
+#      if you pass a custom value for 'target_cpu'.
+#  - "ELECTRON_RELEASE" Set it to '1' upload binaries on success.
+#  - "NPM_CONFIG_ARCH" E.g. 'x86'. Is used to build native Node.js modules.
+#      Must match 'target_cpu' passed to "GN_EXTRA_ARGS" and "TARGET_ARCH" value.
+#  - "TARGET_ARCH" Choose from {'ia32', 'x64', 'arm', 'arm64', 'mips64el'}.
+#      Is used in some publishing scripts, but does NOT affect the Electron binary.
+#      Must match 'target_cpu' passed to "GN_EXTRA_ARGS" and "NPM_CONFIG_ARCH" value.
+#  - "UPLOAD_TO_S3" Set it to '1' upload a release to the S3 bucket.
+#      Otherwise the release will be uploaded to the Github Releases.
+#      (The value is only checked if "ELECTRON_RELEASE" is defined.)
+#
+# The publishing scripts expect access tokens to be defined as env vars,
+# but those are not covered here.
+#
+# AppVeyor docs on variables:
+# https://www.appveyor.com/docs/environment-variables/
+# https://www.appveyor.com/docs/build-configuration/#secure-variables
+# https://www.appveyor.com/docs/build-configuration/#custom-environment-variables
+
+version: 1.0.{build}
+build_cloud: libcc-20
+image: libcc-20-vs2017-15.7.4
+environment:
+  GIT_CACHE_PATH: C:\Users\electron\libcc_cache
+  DISABLE_CRASH_REPORTER_TESTS: true
+  ELECTRON_OUT_DIR: Default
+build_script:
+  - ps: >-
+      if($env:APPVEYOR_PROJECT_NAME -eq "electron-woa-testing") {
+        Write-warning "WOA builds not supported on older versions of Electron"; Exit-AppveyorBuild
+      }
+      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
+      }
+  - echo "Building $env:GN_CONFIG build"
+  - git config --global core.longpaths true
+  - cd ..
+  - md src
+  - 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="--custom-var=checkout_boto=True --custom-var=checkout_requests=True"
+      }
+  - >-
+      gclient config
+      --name "src\electron"
+      --unmanaged
+      %GCLIENT_EXTRA_ARGS%
+      "https://github.com/electron/electron"
+  - gclient sync --with_branch_heads --with_tags
+  - cd src
+  - ps: $env:BUILD_CONFIG_PATH="//electron/build/args/%GN_CONFIG%.gn"
+  - gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") %GN_EXTRA_ARGS%"
+  - 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 electron:electron_mksnapshot_zip
+  - ninja -C out/Default electron:electron_chromedriver_zip
+  - ninja -C out/Default third_party/electron_node:headers
+  - appveyor PushArtifact out/Default/dist.zip
+  - appveyor PushArtifact out/Default/chromedriver.zip
+  - appveyor PushArtifact out/ffmpeg/ffmpeg.zip
+  - 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
+      }
+  - ps: >-
+      if ($env:GN_CONFIG -eq 'release') {
+        python electron\script\zip-symbols.py
+        appveyor PushArtifact out/Default/symbols.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:
+  - ps: >-
+      if ((-Not (Test-Path Env:\ELECTRON_RELEASE)) -And ($env:GN_CONFIG -in "testing", "release")) {
+        $env:RUN_TESTS="true"
+      }
+  - ps: >-
+      if ($env:RUN_TESTS -eq 'true') {
+        New-Item .\out\Default\gen\node_headers\Release -Type directory
+        Copy-Item -path .\out\Default\electron.lib -destination .\out\Default\gen\node_headers\Release\node.lib
+      } else {
+        echo "Skipping tests for $env:GN_CONFIG build"
+      }
+  - cd electron
+  - 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"
+  - if "%RUN_TESTS%"=="true" ( echo Verifying mksnapshot & python electron\script\verify-mksnapshot.py --build-dir out\Default --source-root %cd% )
+  - echo "Done verifying mksnapshot"
+deploy_script:
+  - cd electron
+  - ps: >-
+      if (Test-Path Env:\ELECTRON_RELEASE) {
+        if (Test-Path Env:\UPLOAD_TO_S3) {
+          Write-Output "Uploading Electron release distribution to s3"
+          & python script\upload.py --upload_to_s3
+        } else {
+          Write-Output "Uploading Electron release distribution to github releases"
+          & python script\upload.py
+        }
+      }

atom/CPPLINT.cfg

@@ -1 +0,0 @@
-filter=+build/include_alpha

atom/app/BRANDING.json

@@ -0,0 +1,5 @@
+{
+  "project_name": "electron",
+  "product_name": "Electron",
+  "mac_bundle_id": "com.github.Electron"
+}

atom/app/atom_content_client.cc

@@ -5,11 +5,9 @@
 #include "atom/app/atom_content_client.h"
 
 #include <string>
+#include <utility>
 #include <vector>
 
-#include "atom/common/atom_constants.h"
-#include "atom/common/atom_version.h"
-#include "atom/common/chrome_version.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ -18,21 +16,77 @@
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/pepper_plugin_info.h"
-#include "content/public/common/user_agent.h"
-#include "pdf/pdf.h"
+#include "electron/buildflags/buildflags.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
-#include "third_party/widevine/cdm/stub/widevine_cdm_version.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)
 
-#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
-#include "chrome/common/widevine_cdm_constants.h"
-#endif
+#if defined(WIDEVINE_CDM_AVAILABLE)
+#include "base/native_library.h"
+#include "content/public/common/cdm_info.h"
+#include "media/base/video_codecs.h"
+#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+
+#if BUILDFLAG(ENABLE_PDF_VIEWER)
+#include "atom/common/atom_constants.h"
+#include "pdf/pdf.h"
+#endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
 
 namespace atom {
 
 namespace {
 
+#if defined(WIDEVINE_CDM_AVAILABLE)
+bool IsWidevineAvailable(
+    base::FilePath* cdm_path,
+    std::vector<media::VideoCodec>* codecs_supported,
+    base::flat_set<media::CdmSessionType>* session_types_supported,
+    base::flat_set<media::EncryptionMode>* modes_supported) {
+  static enum {
+    NOT_CHECKED,
+    FOUND,
+    NOT_FOUND,
+  } widevine_cdm_file_check = NOT_CHECKED;
+
+  if (widevine_cdm_file_check == NOT_CHECKED) {
+    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+    *cdm_path = command_line->GetSwitchValuePath(switches::kWidevineCdmPath);
+    if (!cdm_path->empty()) {
+      *cdm_path = cdm_path->AppendASCII(
+          base::GetNativeLibraryName(kWidevineCdmLibraryName));
+      widevine_cdm_file_check = base::PathExists(*cdm_path) ? FOUND : NOT_FOUND;
+    }
+  }
+
+  if (widevine_cdm_file_check == FOUND) {
+    // Add the supported codecs as if they came from the component manifest.
+    // This list must match the CDM that is being bundled with Chrome.
+    codecs_supported->push_back(media::VideoCodec::kCodecVP8);
+    codecs_supported->push_back(media::VideoCodec::kCodecVP9);
+#if BUILDFLAG(USE_PROPRIETARY_CODECS)
+    codecs_supported->push_back(media::VideoCodec::kCodecH264);
+#endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
+
+    // TODO(crbug.com/767941): Push persistent-license support info here once
+    // we check in a new CDM that supports it on Linux.
+    session_types_supported->insert(media::CdmSessionType::kTemporary);
+#if defined(OS_CHROMEOS)
+    session_types_supported->insert(media::CdmSessionType::kPersistentLicense);
+#endif  // defined(OS_CHROMEOS)
+
+    modes_supported->insert(media::EncryptionMode::kCenc);
+
+    return true;
+  }
+
+  return false;
+}
+#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+
+#if BUILDFLAG(ENABLE_PEPPER_FLASH)
 content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
                                                 const std::string& version) {
   content::PepperPluginInfo plugin;
@@ -57,60 +111,38 @@ content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
     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];
+                       flash_version_numbers[1] + " r" +
+                       flash_version_numbers[2];
   plugin.version = base::JoinString(flash_version_numbers, ".");
-  content::WebPluginMimeType swf_mime_type(
-      content::kFlashPluginSwfMimeType,
-      content::kFlashPluginSwfExtension,
-      content::kFlashPluginSwfDescription);
+  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);
+  content::WebPluginMimeType spl_mime_type(content::kFlashPluginSplMimeType,
+                                           content::kFlashPluginSplExtension,
+                                           content::kFlashPluginSplDescription);
   plugin.mime_types.push_back(spl_mime_type);
 
   return plugin;
 }
 
-#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
-content::PepperPluginInfo CreateWidevineCdmInfo(const base::FilePath& path,
-                                                const std::string& version) {
-  content::PepperPluginInfo widevine_cdm;
-  widevine_cdm.is_out_of_process = true;
-  widevine_cdm.path = path;
-  widevine_cdm.name = kWidevineCdmDisplayName;
-  widevine_cdm.description = kWidevineCdmDescription +
-                             std::string(" (version: ") +
-                             version + ")";
-  widevine_cdm.version = version;
-  content::WebPluginMimeType widevine_cdm_mime_type(
-      kWidevineCdmPluginMimeType,
-      kWidevineCdmPluginExtension,
-      kWidevineCdmPluginMimeTypeDescription);
+void AddPepperFlashFromCommandLine(
+    base::CommandLine* command_line,
+    std::vector<content::PepperPluginInfo>* plugins) {
+  base::FilePath flash_path =
+      command_line->GetSwitchValuePath(switches::kPpapiFlashPath);
+  if (flash_path.empty())
+    return;
 
-  // Add the supported codecs as if they came from the component manifest.
-  std::vector<std::string> codecs;
-  codecs.push_back(kCdmSupportedCodecVp8);
-  codecs.push_back(kCdmSupportedCodecVp9);
-#if BUILDFLAG(USE_PROPRIETARY_CODECS)
-  codecs.push_back(kCdmSupportedCodecAvc1);
-#endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
-  std::string codec_string = base::JoinString(
-      codecs, std::string(1, kCdmSupportedCodecsValueDelimiter));
-  widevine_cdm_mime_type.additional_param_names.push_back(
-      base::ASCIIToUTF16(kCdmSupportedCodecsParamName));
-  widevine_cdm_mime_type.additional_param_values.push_back(
-      base::ASCIIToUTF16(codec_string));
+  auto flash_version =
+      command_line->GetSwitchValueASCII(switches::kPpapiFlashVersion);
 
-  widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
-  widevine_cdm.permissions = kWidevineCdmPluginPermissions;
-
-  return widevine_cdm;
+  plugins->push_back(CreatePepperFlashInfo(flash_path, flash_version));
 }
-#endif
+#endif  // BUILDFLAG(ENABLE_PEPPER_FLASH)
 
 void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
+#if BUILDFLAG(ENABLE_PDF_VIEWER)
   content::PepperPluginInfo pdf_info;
   pdf_info.is_internal = true;
   pdf_info.is_out_of_process = true;
@@ -127,99 +159,108 @@ void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
       chrome_pdf::PPP_ShutdownModule;
   pdf_info.permissions = ppapi::PERMISSION_PRIVATE | ppapi::PERMISSION_DEV;
   plugins->push_back(pdf_info);
+#endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
 }
 
-void ConvertStringWithSeparatorToVector(std::vector<std::string>* vec,
-                                        const char* separator,
-                                        const char* cmd_switch) {
-  auto command_line = base::CommandLine::ForCurrentProcess();
-  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);
+void AppendDelimitedSwitchToVector(const base::StringPiece cmd_switch,
+                                   std::vector<std::string>* append_me) {
+  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));
+  }
 }
 
 }  // namespace
 
-void AddPepperFlashFromCommandLine(
-    std::vector<content::PepperPluginInfo>* plugins) {
-  auto command_line = base::CommandLine::ForCurrentProcess();
-  base::FilePath flash_path = command_line->GetSwitchValuePath(
-      switches::kPpapiFlashPath);
-  if (flash_path.empty())
-    return;
+AtomContentClient::AtomContentClient() {}
 
-  auto flash_version = command_line->GetSwitchValueASCII(
-      switches::kPpapiFlashVersion);
-
-  plugins->push_back(CreatePepperFlashInfo(flash_path, flash_version));
-}
-
-#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
-void AddWidevineCdmFromCommandLine(
-    std::vector<content::PepperPluginInfo>* plugins) {
-  auto command_line = base::CommandLine::ForCurrentProcess();
-  base::FilePath widevine_cdm_path = command_line->GetSwitchValuePath(
-      switches::kWidevineCdmPath);
-  if (widevine_cdm_path.empty())
-    return;
-
-  if (!base::PathExists(widevine_cdm_path))
-    return;
-
-  auto widevine_cdm_version = command_line->GetSwitchValueASCII(
-      switches::kWidevineCdmVersion);
-  if (widevine_cdm_version.empty())
-    return;
-
-  plugins->push_back(CreateWidevineCdmInfo(widevine_cdm_path,
-                                           widevine_cdm_version));
-}
-#endif
-
-AtomContentClient::AtomContentClient() {
-}
-
-AtomContentClient::~AtomContentClient() {
-}
-
-std::string AtomContentClient::GetProduct() const {
-  return "Chrome/" CHROME_VERSION_STRING;
-}
-
-std::string AtomContentClient::GetUserAgent() const {
-  return content::BuildUserAgentFromProduct(
-      "Chrome/" CHROME_VERSION_STRING " "
-      ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING);
-}
+AtomContentClient::~AtomContentClient() {}
 
 base::string16 AtomContentClient::GetLocalizedString(int message_id) const {
   return l10n_util::GetStringUTF16(message_id);
 }
 
+base::StringPiece AtomContentClient::GetDataResource(
+    int resource_id,
+    ui::ScaleFactor scale_factor) const {
+  return ui::ResourceBundle::GetSharedInstance().GetRawDataResourceForScale(
+      resource_id, scale_factor);
+}
+
+gfx::Image& AtomContentClient::GetNativeImageNamed(int resource_id) const {
+  return ui::ResourceBundle::GetSharedInstance().GetNativeImageNamed(
+      resource_id);
+}
+
+base::RefCountedMemory* AtomContentClient::GetDataResourceBytes(
+    int resource_id) const {
+  return ui::ResourceBundle::GetSharedInstance().LoadDataResourceBytes(
+      resource_id);
+}
+
 void AtomContentClient::AddAdditionalSchemes(Schemes* schemes) {
-  schemes->standard_schemes.push_back("chrome-extension");
+  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);
 
-  std::vector<std::string> splited;
-  ConvertStringWithSeparatorToVector(&splited, ",",
-                                     switches::kRegisterServiceWorkerSchemes);
-  for (const std::string& scheme : splited)
-    schemes->service_worker_schemes.push_back(scheme);
   schemes->service_worker_schemes.push_back(url::kFileScheme);
-
-  ConvertStringWithSeparatorToVector(&splited, ",", switches::kSecureSchemes);
-  for (const std::string& scheme : splited)
-    schemes->secure_schemes.push_back(scheme);
+  schemes->standard_schemes.push_back("chrome-extension");
 }
 
 void AtomContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
-  AddPepperFlashFromCommandLine(plugins);
-#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
-  AddWidevineCdmFromCommandLine(plugins);
-#endif
+#if BUILDFLAG(ENABLE_PEPPER_FLASH)
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  AddPepperFlashFromCommandLine(command_line, plugins);
+#endif  // BUILDFLAG(ENABLE_PEPPER_FLASH)
   ComputeBuiltInPlugins(plugins);
 }
 
+void AtomContentClient::AddContentDecryptionModules(
+    std::vector<content::CdmInfo>* cdms,
+    std::vector<media::CdmHostFilePath>* cdm_host_file_paths) {
+  if (cdms) {
+#if defined(WIDEVINE_CDM_AVAILABLE)
+    base::FilePath cdm_path;
+    std::vector<media::VideoCodec> video_codecs_supported;
+    base::flat_set<media::CdmSessionType> session_types_supported;
+    base::flat_set<media::EncryptionMode> encryption_modes_supported;
+    if (IsWidevineAvailable(&cdm_path, &video_codecs_supported,
+                            &session_types_supported,
+                            &encryption_modes_supported)) {
+      base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+      auto cdm_version_string =
+          command_line->GetSwitchValueASCII(switches::kWidevineCdmVersion);
+      // CdmInfo needs |path| to be the actual Widevine library,
+      // not the adapter, so adjust as necessary. It will be in the
+      // same directory as the installed adapter.
+      const base::Version version(cdm_version_string);
+      DCHECK(version.IsValid());
+
+      content::CdmCapability capability(
+          video_codecs_supported, encryption_modes_supported,
+          session_types_supported, base::flat_set<media::CdmProxy::Protocol>());
+
+      cdms->push_back(content::CdmInfo(
+          kWidevineCdmDisplayName, kWidevineCdmGuid, version, cdm_path,
+          kWidevineCdmFileSystemId, capability, kWidevineKeySystem, false));
+    }
+#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+  }
+}
+
 }  // namespace atom

atom/app/atom_content_client.h

@@ -9,23 +9,28 @@
 #include <string>
 #include <vector>
 
-#include "brightray/common/content_client.h"
+#include "content/public/common/content_client.h"
 
 namespace atom {
 
-class AtomContentClient : public brightray::ContentClient {
+class AtomContentClient : public content::ContentClient {
  public:
   AtomContentClient();
-  virtual ~AtomContentClient();
+  ~AtomContentClient() override;
 
  protected:
   // content::ContentClient:
-  std::string GetProduct() const override;
-  std::string GetUserAgent() const 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;
+  void AddContentDecryptionModules(
+      std::vector<content::CdmInfo>* cdms,
+      std::vector<media::CdmHostFilePath>* cdm_host_file_paths) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AtomContentClient);

atom/app/atom_library_main.h

@@ -6,14 +6,17 @@
 #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 AtomMain(int argc, char* argv[]);
+__attribute__((visibility("default"))) int AtomMain(int argc, char* argv[]);
 
-__attribute__((visibility("default")))
-int AtomInitializeICUandStartNode(int argc, char *argv[]);
+#if BUILDFLAG(ENABLE_RUN_AS_NODE)
+__attribute__((visibility("default"))) int AtomInitializeICUandStartNode(
+    int argc,
+    char* argv[]);
+#endif
 }
 #endif  // OS_MACOSX
 

atom/app/atom_library_main.mm

@@ -7,14 +7,13 @@
 #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 "brightray/common/mac/main_application_bundle.h"
 #include "content/public/app/content_main.h"
 
-#if defined(OS_MACOSX)
 int AtomMain(int argc, char* argv[]) {
   atom::AtomMainDelegate delegate;
   content::ContentMainParams params(&delegate);
@@ -24,15 +23,16 @@ int AtomMain(int argc, char* argv[]) {
   return content::ContentMain(params);
 }
 
-int AtomInitializeICUandStartNode(int argc, char *argv[]) {
+#if BUILDFLAG(ENABLE_RUN_AS_NODE)
+int AtomInitializeICUandStartNode(int argc, char* argv[]) {
   base::AtExitManager atexit_manager;
   base::mac::ScopedNSAutoreleasePool pool;
   base::mac::SetOverrideFrameworkBundlePath(
-      brightray::MainApplicationBundlePath()
+      atom::MainApplicationBundlePath()
           .Append("Contents")
           .Append("Frameworks")
           .Append(ATOM_PRODUCT_NAME " Framework.framework"));
   base::i18n::InitializeICU();
   return atom::NodeMain(argc, argv);
 }
-#endif  // OS_MACOSX
+#endif

atom/app/atom_login_helper.mm

@@ -3,7 +3,8 @@
 int main(int argc, char* argv[]) {
   NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
   NSArray* pathComponents = [[[NSBundle mainBundle] bundlePath] pathComponents];
-  pathComponents = [pathComponents subarrayWithRange:NSMakeRange(0, [pathComponents count] - 4)];
+  pathComponents = [pathComponents
+      subarrayWithRange:NSMakeRange(0, [pathComponents count] - 4)];
   NSString* path = [NSString pathWithComponents:pathComponents];
   [[NSWorkspace sharedWorkspace] launchApplication:path];
   [pool drain];

atom/app/atom_main.cc

@@ -5,6 +5,7 @@
 #include "atom/app/atom_main.h"
 
 #include <cstdlib>
+#include <memory>
 #include <vector>
 
 #if defined(OS_WIN)
@@ -25,9 +26,14 @@
 #include "content/public/app/sandbox_helper_win.h"
 #include "sandbox/win/src/sandbox_types.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"
 #else  // defined(OS_LINUX)
+#include <mach-o/dyld.h>
+#include <unistd.h>
+#include <cstdio>
 #include "atom/app/atom_library_main.h"
 #endif  // defined(OS_MACOSX)
 
@@ -35,14 +41,19 @@
 #include "atom/common/atom_command_line.h"
 #include "base/at_exit.h"
 #include "base/i18n/icu_util.h"
+#include "electron/buildflags/buildflags.h"
+
+#if defined(HELPER_EXECUTABLE) && !defined(MAS_BUILD)
+#include "sandbox/mac/seatbelt_exec.h"  // nogncheck
+#endif
 
 namespace {
 
-#ifdef ENABLE_RUN_AS_NODE
-const auto kRunAsNode = "ELECTRON_RUN_AS_NODE";
+#if BUILDFLAG(ENABLE_RUN_AS_NODE)
+const char kRunAsNode[] = "ELECTRON_RUN_AS_NODE";
 #endif
 
-bool IsEnvSet(const char* name) {
+ALLOW_UNUSED_TYPE bool IsEnvSet(const char* name) {
 #if defined(OS_WIN)
   size_t required_size;
   getenv_s(&required_size, nullptr, 0, name);
@@ -53,6 +64,25 @@ bool IsEnvSet(const char* name) {
 #endif
 }
 
+#if defined(OS_POSIX)
+void FixStdioStreams() {
+  // libuv may mark stdin/stdout/stderr as close-on-exec, which interferes
+  // with chromium's subprocess spawning. As a workaround, we detect if these
+  // streams are closed on startup, and reopen them as /dev/null if necessary.
+  // Otherwise, an unrelated file descriptor will be assigned as stdout/stderr
+  // which may cause various errors when attempting to write to them.
+  //
+  // For details see https://github.com/libuv/libuv/issues/2062
+  struct stat st;
+  if (fstat(STDIN_FILENO, &st) < 0 && errno == EBADF)
+    ignore_result(freopen("/dev/null", "r", stdin));
+  if (fstat(STDOUT_FILENO, &st) < 0 && errno == EBADF)
+    ignore_result(freopen("/dev/null", "w", stdout));
+  if (fstat(STDERR_FILENO, &st) < 0 && errno == EBADF)
+    ignore_result(freopen("/dev/null", "w", stderr));
+}
+#endif
+
 }  // namespace
 
 #if defined(OS_WIN)
@@ -69,7 +99,7 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
 
 #ifdef _DEBUG
   // Don't display assert dialog boxes in CI test runs
-  static const auto kCI = "ELECTRON_CI";
+  static const char* kCI = "ELECTRON_CI";
   bool is_ci = IsEnvSet(kCI);
   if (!is_ci) {
     for (int i = 0; i < arguments.argc; ++i) {
@@ -91,7 +121,7 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   }
 #endif
 
-#ifdef ENABLE_RUN_AS_NODE
+#if BUILDFLAG(ENABLE_RUN_AS_NODE)
   bool run_as_node = IsEnvSet(kRunAsNode);
 #else
   bool run_as_node = false;
@@ -115,12 +145,10 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   // 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);
-  });
+  atexit([]() { OnThreadExit(nullptr, DLL_THREAD_DETACH, nullptr); });
 #endif
 
-#ifdef ENABLE_RUN_AS_NODE
+#if BUILDFLAG(ENABLE_RUN_AS_NODE)
   if (run_as_node) {
     std::vector<char*> argv(arguments.argc);
     std::transform(
@@ -156,7 +184,9 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
 #elif defined(OS_LINUX)  // defined(OS_WIN)
 
 int main(int argc, char* argv[]) {
-#ifdef ENABLE_RUN_AS_NODE
+  FixStdioStreams();
+
+#if BUILDFLAG(ENABLE_RUN_AS_NODE)
   if (IsEnvSet(kRunAsNode)) {
     base::i18n::InitializeICU();
     base::AtExitManager atexit_manager;
@@ -175,12 +205,43 @@ int main(int argc, char* argv[]) {
 #else  // defined(OS_LINUX)
 
 int main(int argc, char* argv[]) {
-#ifdef ENABLE_RUN_AS_NODE
+  FixStdioStreams();
+
+#if BUILDFLAG(ENABLE_RUN_AS_NODE)
   if (IsEnvSet(kRunAsNode)) {
     return AtomInitializeICUandStartNode(argc, argv);
   }
 #endif
 
+#if defined(HELPER_EXECUTABLE) && !defined(MAS_BUILD)
+  uint32_t exec_path_size = 0;
+  int rv = _NSGetExecutablePath(NULL, &exec_path_size);
+  if (rv != -1) {
+    fprintf(stderr, "_NSGetExecutablePath: get length failed\n");
+    abort();
+  }
+
+  std::unique_ptr<char[]> exec_path(new char[exec_path_size]);
+  rv = _NSGetExecutablePath(exec_path.get(), &exec_path_size);
+  if (rv != 0) {
+    fprintf(stderr, "_NSGetExecutablePath: get path failed\n");
+    abort();
+  }
+  sandbox::SeatbeltExecServer::CreateFromArgumentsResult seatbelt =
+      sandbox::SeatbeltExecServer::CreateFromArguments(exec_path.get(), argc,
+                                                       argv);
+  if (seatbelt.sandbox_required) {
+    if (!seatbelt.server) {
+      fprintf(stderr, "Failed to create seatbelt sandbox server.\n");
+      abort();
+    }
+    if (!seatbelt.server->InitializeSandbox()) {
+      fprintf(stderr, "Failed to initialize sandbox.\n");
+      abort();
+    }
+  }
+#endif  // defined(HELPER_EXECUTABLE) && !defined(MAS_BUILD)
+
   return AtomMain(argc, argv);
 }
 

atom/app/atom_main_delegate.cc

@@ -5,12 +5,16 @@
 #include "atom/app/atom_main_delegate.h"
 
 #include <iostream>
+#include <memory>
 #include <string>
 
+#if defined(OS_LINUX)
+#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/google_api_key.h"
 #include "atom/common/options_switches.h"
 #include "atom/renderer/atom_renderer_client.h"
 #include "atom/renderer/atom_sandboxed_renderer_client.h"
@@ -19,11 +23,17 @@
 #include "base/debug/stack_trace.h"
 #include "base/environment.h"
 #include "base/logging.h"
+#include "base/mac/bundle_locations.h"
+#include "base/path_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/common/content_switches.h"
-#include "ipc/ipc_features.h"
+#include "electron/buildflags/buildflags.h"
+#include "ipc/ipc_buildflags.h"
+#include "services/service_manager/embedder/switches.h"
+#include "services/service_manager/sandbox/switches.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
@@ -33,6 +43,10 @@
 #include "atom/common/common_message_generator.h"
 #endif
 
+#if defined(OS_MACOSX)
+#include "atom/app/atom_main_delegate_mac.h"
+#endif
+
 namespace atom {
 
 namespace {
@@ -44,23 +58,79 @@ 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) {
+  return
+#if defined(OS_POSIX) && !defined(OS_MACOSX)
+      // The zygote process opens the resources for the renderers.
+      process_type == service_manager::switches::kZygoteProcess ||
+#endif
+#if defined(OS_MACOSX)
+      // Mac needs them too for scrollbar related images and for sandbox
+      // profiles.
+      process_type == ::switches::kPpapiPluginProcess ||
+      process_type == ::switches::kPpapiBrokerProcess ||
+      process_type == ::switches::kGpuProcess ||
+#endif
+      process_type == ::switches::kRendererProcess ||
+      process_type == ::switches::kUtilityProcess;
+}
+
 #if defined(OS_WIN)
-void InvalidParameterHandler(const wchar_t*, const wchar_t*, const wchar_t*,
-                             unsigned int, uintptr_t) {
+void InvalidParameterHandler(const wchar_t*,
+                             const wchar_t*,
+                             const wchar_t*,
+                             unsigned int,
+                             uintptr_t) {
   // noop.
 }
 #endif
 
 }  // namespace
 
-AtomMainDelegate::AtomMainDelegate() {
+void LoadResourceBundle(const std::string& locale) {
+  const bool initialized = ui::ResourceBundle::HasSharedInstance();
+  if (initialized)
+    ui::ResourceBundle::CleanupSharedInstance();
+
+  // Load other resource files.
+  base::FilePath pak_dir;
+#if defined(OS_MACOSX)
+  pak_dir =
+      base::mac::FrameworkBundlePath().Append(FILE_PATH_LITERAL("Resources"));
+#else
+  base::PathService::Get(base::DIR_MODULE, &pak_dir);
+#endif
+
+  ui::ResourceBundle::InitSharedInstanceWithLocale(
+      locale, nullptr, ui::ResourceBundle::LOAD_COMMON_RESOURCES);
+  ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
+  bundle.ReloadLocaleResources(locale);
+  bundle.AddDataPackFromPath(pak_dir.Append(FILE_PATH_LITERAL("resources.pak")),
+                             ui::SCALE_FACTOR_NONE);
+#if BUILDFLAG(ENABLE_PDF_VIEWER)
+  NOTIMPLEMENTED()
+      << "Hi, whoever's fixing PDF support! Thanks! The pdf "
+         "viewer resources haven't been ported over to the GN build yet, so "
+         "you'll probably need to change this bit of code.";
+  bundle.AddDataPackFromPath(
+      pak_dir.Append(FILE_PATH_LITERAL("pdf_viewer_resources.pak")),
+      ui::GetSupportedScaleFactors()[0]);
+#endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
 }
 
-AtomMainDelegate::~AtomMainDelegate() {
-}
+AtomMainDelegate::AtomMainDelegate() {}
+
+AtomMainDelegate::~AtomMainDelegate() {}
 
 bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
-  auto command_line = base::CommandLine::ForCurrentProcess();
+  auto* command_line = base::CommandLine::ForCurrentProcess();
 
   logging::LoggingSettings settings;
 #if defined(OS_WIN)
@@ -77,12 +147,12 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 #else
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 #endif  // defined(DEBUG)
-#else  // defined(OS_WIN)
+#else   // defined(OS_WIN)
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 #endif  // !defined(OS_WIN)
 
   // Only enable logging when --enable-logging is specified.
-  std::unique_ptr<base::Environment> env(base::Environment::Create());
+  auto env = base::Environment::Create();
   if (!command_line->HasSwitch(::switches::kEnableLogging) &&
       !env->HasVar("ELECTRON_ENABLE_LOGGING")) {
     settings.logging_dest = logging::LOG_NONE;
@@ -94,18 +164,19 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
   // Logging with pid and timestamp.
   logging::SetLogItems(true, false, true, false);
 
-  // Enable convient stack printing.
-#if defined(DEBUG) && defined(OS_LINUX)
-  bool enable_stack_dumping = true;
-#else
-  bool enable_stack_dumping = env->HasVar("ELECTRON_ENABLE_STACK_DUMPING");
-#endif
-  if (enable_stack_dumping)
+  // Enable convient stack printing. This is enabled by default in non-official
+  // builds.
+  if (env->HasVar("ELECTRON_ENABLE_STACK_DUMPING"))
     base::debug::EnableInProcessStackDumping();
 
+  if (env->HasVar("ELECTRON_DISABLE_SANDBOX"))
+    command_line->AppendSwitch(service_manager::switches::kNoSandbox);
+
   chrome::RegisterPathProvider();
 
 #if defined(OS_MACOSX)
+  OverrideChildProcessPath();
+  OverrideFrameworkBundlePath();
   SetUpBundleOverrides();
 #endif
 
@@ -117,36 +188,68 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
   base::win::DisableHandleVerifier();
 #endif
 
-  return brightray::MainDelegate::BasicStartupComplete(exit_code);
+#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
+
+  content_client_ = std::make_unique<AtomContentClient>();
+  SetContentClient(content_client_.get());
+
+  return false;
+}
+
+void AtomMainDelegate::PostEarlyInitialization(bool is_running_tests) {
+  std::string custom_locale;
+  ui::ResourceBundle::InitSharedInstanceWithLocale(
+      custom_locale, nullptr, ui::ResourceBundle::LOAD_COMMON_RESOURCES);
+  auto* cmd_line = base::CommandLine::ForCurrentProcess();
+  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, true);
+    if (!locale_file_path.empty()) {
+      custom_locale = locale;
+#if defined(OS_LINUX)
+      /* When built with USE_GLIB, libcc's GetApplicationLocaleInternal() uses
+       * glib's g_get_language_names(), which keys off of getenv("LC_ALL") */
+      g_setenv("LC_ALL", custom_locale.c_str(), TRUE);
+#endif
+    }
+  }
+
+#if defined(OS_MACOSX)
+  if (custom_locale.empty())
+    l10n_util::OverrideLocaleWithCocoaLocale();
+#endif
+
+  LoadResourceBundle(custom_locale);
+
+  AtomBrowserClient::SetApplicationLocale(
+      l10n_util::GetApplicationLocale(custom_locale));
 }
 
 void AtomMainDelegate::PreSandboxStartup() {
-  brightray::MainDelegate::PreSandboxStartup();
+  auto* command_line = base::CommandLine::ForCurrentProcess();
 
-  // Set google API key.
-  std::unique_ptr<base::Environment> env(base::Environment::Create());
-  if (!env->HasVar("GOOGLE_API_KEY"))
-    env->SetVar("GOOGLE_API_KEY", GOOGLEAPIS_API_KEY);
+  std::string process_type =
+      command_line->GetSwitchValueASCII(::switches::kProcessType);
 
-  auto command_line = base::CommandLine::ForCurrentProcess();
-  std::string process_type = command_line->GetSwitchValueASCII(
-      ::switches::kProcessType);
+  // Initialize ResourceBundle which handles files loaded from external
+  // sources. The language should have been passed in to us from the
+  // browser process as a command line flag.
+  if (SubprocessNeedsResourceBundle(process_type)) {
+    std::string locale = command_line->GetSwitchValueASCII(::switches::kLang);
+    LoadResourceBundle(locale);
+  }
 
   // Only append arguments for browser process.
   if (!IsBrowserProcess(command_line))
     return;
 
-  if (!command_line->HasSwitch(switches::kEnableMixedSandbox)) {
-    if (command_line->HasSwitch(switches::kEnableSandbox)) {
-      // Disable setuid sandbox since it is not longer required on
-      // linux(namespace sandbox is available on most distros).
-      command_line->AppendSwitch(::switches::kDisableSetuidSandbox);
-    } else {
-      // Disable renderer sandbox for most of node's functions.
-      command_line->AppendSwitch(::switches::kNoSandbox);
-    }
-  }
-
   // Allow file:// URIs to read other file:// URIs by default.
   command_line->AppendSwitch(::switches::kAllowFileAccessFromFiles);
 
@@ -156,17 +259,22 @@ void AtomMainDelegate::PreSandboxStartup() {
 #endif
 }
 
+void AtomMainDelegate::PreCreateMainMessageLoop() {
+#if defined(OS_MACOSX)
+  RegisterAtomCrApp();
+#endif
+}
+
 content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
   browser_client_.reset(new AtomBrowserClient);
   return browser_client_.get();
 }
 
 content::ContentRendererClient*
-    AtomMainDelegate::CreateContentRendererClient() {
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-        switches::kEnableSandbox) ||
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-        ::switches::kNoSandbox)) {
+AtomMainDelegate::CreateContentRendererClient() {
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+
+  if (IsSandboxEnabled(command_line)) {
     renderer_client_.reset(new AtomSandboxedRendererClient);
   } else {
     renderer_client_.reset(new AtomRendererClient);
@@ -200,9 +308,12 @@ bool AtomMainDelegate::DelaySandboxInitialization(
 }
 #endif
 
-std::unique_ptr<brightray::ContentClient>
-AtomMainDelegate::CreateContentClient() {
-  return std::unique_ptr<brightray::ContentClient>(new AtomContentClient);
+bool AtomMainDelegate::ShouldLockSchemeRegistry() {
+  return false;
+}
+
+bool AtomMainDelegate::ShouldCreateFeatureList() {
+  return false;
 }
 
 }  // namespace atom

atom/app/atom_main_delegate.h

@@ -5,22 +5,27 @@
 #ifndef ATOM_APP_ATOM_MAIN_DELEGATE_H_
 #define ATOM_APP_ATOM_MAIN_DELEGATE_H_
 
+#include <memory>
 #include <string>
 
-#include "brightray/common/content_client.h"
-#include "brightray/common/main_delegate.h"
+#include "content/public/app/content_main_delegate.h"
+#include "content/public/common/content_client.h"
 
 namespace atom {
 
-class AtomMainDelegate : public brightray::MainDelegate {
+void LoadResourceBundle(const std::string& locale);
+
+class AtomMainDelegate : public content::ContentMainDelegate {
  public:
   AtomMainDelegate();
-  ~AtomMainDelegate();
+  ~AtomMainDelegate() override;
 
  protected:
   // content::ContentMainDelegate:
   bool BasicStartupComplete(int* exit_code) override;
   void PreSandboxStartup() override;
+  void PreCreateMainMessageLoop() override;
+  void PostEarlyInitialization(bool is_running_tests) override;
   content::ContentBrowserClient* CreateContentBrowserClient() override;
   content::ContentRendererClient* CreateContentRendererClient() override;
   content::ContentUtilityClient* CreateContentUtilityClient() override;
@@ -31,20 +36,18 @@ class AtomMainDelegate : public brightray::MainDelegate {
   bool ShouldSendMachPort(const std::string& process_type) override;
   bool DelaySandboxInitialization(const std::string& process_type) override;
 #endif
-
-  // brightray::MainDelegate:
-  std::unique_ptr<brightray::ContentClient> CreateContentClient() override;
-#if defined(OS_MACOSX)
-  void OverrideChildProcessPath() override;
-  void OverrideFrameworkBundlePath() override;
-#endif
+  bool ShouldLockSchemeRegistry() override;
+  bool ShouldCreateFeatureList() override;
 
  private:
 #if defined(OS_MACOSX)
+  void OverrideChildProcessPath();
+  void OverrideFrameworkBundlePath();
   void SetUpBundleOverrides();
 #endif
 
   std::unique_ptr<content::ContentBrowserClient> browser_client_;
+  std::unique_ptr<content::ContentClient> content_client_;
   std::unique_ptr<content::ContentRendererClient> renderer_client_;
   std::unique_ptr<content::ContentUtilityClient> utility_client_;
 

atom/app/atom_main_delegate_mac.h

@@ -0,0 +1,15 @@
+// Copyright 2013 Slack Technologies, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_MAC_H_
+#define ATOM_APP_ATOM_MAIN_DELEGATE_MAC_H_
+
+namespace atom {
+
+// Initializes NSApplication.
+void RegisterAtomCrApp();
+
+}  // namespace atom
+
+#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_MAC_H_

atom/app/atom_main_delegate_mac.mm

@@ -4,15 +4,16 @@
 
 #include "atom/app/atom_main_delegate.h"
 
-#include "base/mac/bundle_locations.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"
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/path_service.h"
 #include "base/strings/sys_string_conversions.h"
-#include "brightray/common/application_info.h"
-#include "brightray/common/mac/main_application_bundle.h"
 #include "content/public/common/content_paths.h"
 
 namespace atom {
@@ -20,16 +21,15 @@ namespace atom {
 namespace {
 
 base::FilePath GetFrameworksPath() {
-  return brightray::MainApplicationBundlePath().Append("Contents")
-                                               .Append("Frameworks");
+  return MainApplicationBundlePath().Append("Contents").Append("Frameworks");
 }
 
 base::FilePath GetHelperAppPath(const base::FilePath& frameworks_path,
                                 const std::string& name) {
   return frameworks_path.Append(name + " Helper.app")
-                        .Append("Contents")
-                        .Append("MacOS")
-                        .Append(name + " Helper");
+      .Append("Contents")
+      .Append("MacOS")
+      .Append(name + " Helper");
 }
 
 }  // namespace
@@ -41,19 +41,18 @@ void AtomMainDelegate::OverrideFrameworkBundlePath() {
 
 void AtomMainDelegate::OverrideChildProcessPath() {
   base::FilePath frameworks_path = GetFrameworksPath();
-  base::FilePath helper_path = GetHelperAppPath(frameworks_path,
-                                                ATOM_PRODUCT_NAME);
+  base::FilePath helper_path =
+      GetHelperAppPath(frameworks_path, ATOM_PRODUCT_NAME);
   if (!base::PathExists(helper_path))
-    helper_path = GetHelperAppPath(frameworks_path,
-                                   brightray::GetApplicationName());
+    helper_path = GetHelperAppPath(frameworks_path, GetApplicationName());
   if (!base::PathExists(helper_path))
     LOG(FATAL) << "Unable to find helper app";
-  PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
+  base::PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
 }
 
 void AtomMainDelegate::SetUpBundleOverrides() {
   base::mac::ScopedNSAutoreleasePool pool;
-  NSBundle* bundle = brightray::MainApplicationBundle();
+  NSBundle* bundle = MainApplicationBundle();
   std::string base_bundle_id =
       base::SysNSStringToUTF8([bundle bundleIdentifier]);
   NSString* team_id = [bundle objectForInfoDictionaryKey:@"ElectronTeamID"];
@@ -62,4 +61,9 @@ void AtomMainDelegate::SetUpBundleOverrides() {
   base::mac::SetBaseBundleID(base_bundle_id.c_str());
 }
 
+void RegisterAtomCrApp() {
+  // Force the NSApplication subclass to be used.
+  [AtomApplication sharedApplication];
+}
+
 }  // namespace atom

atom/app/command_line_args.h

@@ -14,4 +14,3 @@ bool CheckCommandLineArguments(int argc, base::CommandLine::CharType** argv);
 }  // namespace atom
 
 #endif  // ATOM_APP_COMMAND_LINE_ARGS_H_
-

atom/app/manifests.cc

@@ -0,0 +1,44 @@
+// 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 "printing/buildflags/buildflags.h"
+#include "services/proxy_resolver/proxy_resolver_manifest.h"
+#include "services/service_manager/public/cpp/manifest_builder.h"
+
+#if BUILDFLAG(ENABLE_PRINTING)
+#include "components/services/pdf_compositor/pdf_compositor_manifest.h"
+#endif
+
+#if BUILDFLAG(ENABLE_PRINT_PREVIEW)
+#include "chrome/services/printing/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")
+          .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)
+      pdf_compositor::GetManifest(),
+#endif
+#if BUILDFLAG(ENABLE_PRINT_PREVIEW)
+      chrome_printing::GetManifest(),
+#endif
+  }};
+  return *manifests;
+}

atom/app/manifests.h

@@ -0,0 +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 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,19 +2,21 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifdef ENABLE_RUN_AS_NODE
-
 #include "atom/app/node_main.h"
 
+#include <memory>
+#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/atom_bindings.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 "base/command_line.h"
 #include "base/feature_list.h"
-#include "base/task_scheduler/task_scheduler.h"
+#include "base/task/task_scheduler/task_scheduler.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
@@ -25,7 +27,7 @@
 
 namespace atom {
 
-int NodeMain(int argc, char *argv[]) {
+int NodeMain(int argc, char* argv[]) {
   base::CommandLine::Init(argc, argv);
 
   int exit_code = 1;
@@ -37,31 +39,34 @@ int NodeMain(int argc, char *argv[]) {
     base::ThreadTaskRunnerHandle handle(uv_task_runner);
 
     // Initialize feature list.
-    std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+    auto feature_list = std::make_unique<base::FeatureList>();
     feature_list->InitializeFromCommandLine("", "");
     base::FeatureList::SetInstance(std::move(feature_list));
 
-    gin::V8Initializer::LoadV8Snapshot();
+    gin::V8Initializer::LoadV8Snapshot(
+        gin::V8Initializer::V8SnapshotFileType::kWithAdditionalContext);
     gin::V8Initializer::LoadV8Natives();
 
     // V8 requires a task scheduler apparently
     base::TaskScheduler::CreateAndStartWithDefaultParams("Electron");
 
     // Initialize gin::IsolateHolder.
-    JavascriptEnvironment gin_env;
+    JavascriptEnvironment gin_env(loop);
+
+    // Explicitly register electron's builtin modules.
+    NodeBindings::RegisterBuiltinModules();
 
     int exec_argc;
     const char** exec_argv;
     node::Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv);
 
-    node::IsolateData isolate_data(gin_env.isolate(), loop);
     node::Environment* env = node::CreateEnvironment(
-        &isolate_data, gin_env.context(), argc, argv,
-        exec_argc, exec_argv);
+        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_env.platform());
+    node_debugger.Start();
 
     mate::Dictionary process(gin_env.isolate(), env->process_object());
 #if defined(OS_WIN)
@@ -79,6 +84,7 @@ int NodeMain(int argc, char *argv[]) {
     bool more;
     do {
       more = uv_run(env->event_loop(), UV_RUN_ONCE);
+      gin_env.platform()->DrainTasks(env->isolate());
       if (more == false) {
         node::EmitBeforeExit(env);
 
@@ -90,8 +96,12 @@ int NodeMain(int argc, char *argv[]) {
       }
     } while (more == true);
 
+    node_debugger.Stop();
     exit_code = node::EmitExit(env);
     node::RunAtExit(env);
+    gin_env.platform()->DrainTasks(env->isolate());
+    gin_env.platform()->CancelPendingDelayedTasks(env->isolate());
+    gin_env.platform()->UnregisterIsolate(env->isolate());
 
     node::FreeEnvironment(env);
   }
@@ -109,5 +119,3 @@ int NodeMain(int argc, char *argv[]) {
 }
 
 }  // namespace atom
-
-#endif  // ENABLE_RUN_AS_NODE

atom/app/node_main.h

@@ -5,14 +5,10 @@
 #ifndef ATOM_APP_NODE_MAIN_H_
 #define ATOM_APP_NODE_MAIN_H_
 
-#ifdef ENABLE_RUN_AS_NODE
-
 namespace atom {
 
-int NodeMain(int argc, char *argv[]);
+int NodeMain(int argc, char* argv[]);
 
 }  // namespace atom
 
-#endif  // ENABLE_RUN_AS_NODE
-
 #endif  // ATOM_APP_NODE_MAIN_H_

atom/app/uv_task_runner.cc

@@ -10,8 +10,7 @@
 
 namespace atom {
 
-UvTaskRunner::UvTaskRunner(uv_loop_t* loop) : loop_(loop) {
-}
+UvTaskRunner::UvTaskRunner(uv_loop_t* loop) : loop_(loop) {}
 
 UvTaskRunner::~UvTaskRunner() {
   for (auto& iter : tasks_) {
@@ -20,7 +19,7 @@ UvTaskRunner::~UvTaskRunner() {
   }
 }
 
-bool UvTaskRunner::PostDelayedTask(const tracked_objects::Location& from_here,
+bool UvTaskRunner::PostDelayedTask(const base::Location& from_here,
                                    base::OnceClosure task,
                                    base::TimeDelta delay) {
   auto* timer = new uv_timer_t;
@@ -35,10 +34,9 @@ bool UvTaskRunner::RunsTasksInCurrentSequence() const {
   return true;
 }
 
-bool UvTaskRunner::PostNonNestableDelayedTask(
-    const tracked_objects::Location& from_here,
-    base::OnceClosure task,
-    base::TimeDelta delay) {
+bool UvTaskRunner::PostNonNestableDelayedTask(const base::Location& from_here,
+                                              base::OnceClosure task,
+                                              base::TimeDelta delay) {
   return PostDelayedTask(from_here, std::move(task), delay);
 }
 

atom/app/uv_task_runner.h

@@ -8,8 +8,9 @@
 #include <map>
 
 #include "base/callback.h"
+#include "base/location.h"
 #include "base/single_thread_task_runner.h"
-#include "vendor/node/deps/uv/include/uv.h"
+#include "uv.h"  // NOLINT(build/include)
 
 namespace atom {
 
@@ -17,19 +18,18 @@ namespace atom {
 class UvTaskRunner : public base::SingleThreadTaskRunner {
  public:
   explicit UvTaskRunner(uv_loop_t* loop);
-  ~UvTaskRunner() override;
 
   // base::SingleThreadTaskRunner:
-  bool PostDelayedTask(const tracked_objects::Location& from_here,
+  bool PostDelayedTask(const base::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override;
   bool RunsTasksInCurrentSequence() const override;
-  bool PostNonNestableDelayedTask(
-      const tracked_objects::Location& from_here,
-      base::OnceClosure task,
-      base::TimeDelta delay) override;
+  bool PostNonNestableDelayedTask(const base::Location& from_here,
+                                  base::OnceClosure task,
+                                  base::TimeDelta delay) override;
 
  private:
+  ~UvTaskRunner() override;
   static void OnTimeout(uv_timer_t* timer);
   static void OnClose(uv_handle_t* handle);
 

atom/browser/api/atom_api_app.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -15,6 +16,7 @@
 #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/task/cancelable_task_tracker.h"
 #include "chrome/browser/icon_manager.h"
@@ -52,11 +54,8 @@ struct ProcessMetric {
 
   ProcessMetric(int type,
                 base::ProcessId pid,
-                std::unique_ptr<base::ProcessMetrics> metrics) {
-    this->type = type;
-    this->pid = pid;
-    this->metrics = std::move(metrics);
-  }
+                std::unique_ptr<base::ProcessMetrics> metrics);
+  ~ProcessMetric();
 };
 
 namespace api {
@@ -67,8 +66,8 @@ class App : public AtomBrowserClient::Delegate,
             public content::GpuDataManagerObserver,
             public content::BrowserChildProcessObserver {
  public:
-  using FileIconCallback = base::Callback<void(v8::Local<v8::Value>,
-                                               const gfx::Image&)>;
+  using FileIconCallback =
+      base::Callback<void(v8::Local<v8::Value>, const gfx::Image&)>;
 
   static mate::Handle<App> Create(v8::Isolate* isolate);
 
@@ -101,21 +100,18 @@ class App : public AtomBrowserClient::Delegate,
   void OnActivate(bool has_visible_windows) override;
   void OnWillFinishLaunching() override;
   void OnFinishLaunching(const base::DictionaryValue& launch_info) override;
-  void OnLogin(LoginHandler* login_handler,
+  void OnLogin(scoped_refptr<LoginHandler> login_handler,
                const base::DictionaryValue& request_details) override;
   void OnAccessibilitySupportChanged() override;
   void OnPreMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
-  void OnWillContinueUserActivity(
-      bool* prevent_default,
-      const std::string& type) override;
-  void OnDidFailToContinueUserActivity(
-      const std::string& type,
-      const std::string& error) override;
-  void OnContinueUserActivity(
-      bool* prevent_default,
-      const std::string& type,
-      const base::DictionaryValue& user_info) override;
+  void OnWillContinueUserActivity(bool* prevent_default,
+                                  const std::string& type) override;
+  void OnDidFailToContinueUserActivity(const std::string& type,
+                                       const std::string& error) override;
+  void OnContinueUserActivity(bool* prevent_default,
+                              const std::string& type,
+                              const base::DictionaryValue& user_info) override;
   void OnUserActivityWasContinued(
       const std::string& type,
       const base::DictionaryValue& user_info) override;
@@ -133,7 +129,6 @@ class App : public AtomBrowserClient::Delegate,
       const net::SSLInfo& ssl_info,
       const GURL& request_url,
       content::ResourceType resource_type,
-      bool overridable,
       bool strict_enforcement,
       bool expired_previous_decision,
       const base::Callback<void(content::CertificateRequestResultType)>&
@@ -146,7 +141,7 @@ class App : public AtomBrowserClient::Delegate,
   bool CanCreateWindow(content::RenderFrameHost* opener,
                        const GURL& opener_url,
                        const GURL& opener_top_level_frame_url,
-                       const GURL& source_origin,
+                       const url::Origin& source_origin,
                        content::mojom::WindowContainerType container_type,
                        const GURL& target_url,
                        const content::Referrer& referrer,
@@ -154,7 +149,7 @@ class App : public AtomBrowserClient::Delegate,
                        WindowOpenDisposition disposition,
                        const blink::mojom::WindowFeatures& features,
                        const std::vector<std::string>& additional_features,
-                       const scoped_refptr<content::ResourceRequestBody>& body,
+                       const scoped_refptr<network::ResourceRequestBody>& body,
                        bool user_gesture,
                        bool opener_suppressed,
                        bool* no_javascript_access) override;
@@ -168,9 +163,11 @@ class App : public AtomBrowserClient::Delegate,
   void BrowserChildProcessHostDisconnected(
       const content::ChildProcessData& data) override;
   void BrowserChildProcessCrashed(
-      const content::ChildProcessData& data, int exit_code) override;
+      const content::ChildProcessData& data,
+      const content::ChildProcessTerminationInfo& info) override;
   void BrowserChildProcessKilled(
-      const content::ChildProcessData& data, int exit_code) override;
+      const content::ChildProcessData& data,
+      const content::ChildProcessTerminationInfo& info) override;
 
  private:
   void SetAppPath(const base::FilePath& app_path);
@@ -185,25 +182,30 @@ class App : public AtomBrowserClient::Delegate,
 
   void SetDesktopName(const std::string& desktop_name);
   std::string GetLocale();
-  bool MakeSingleInstance(
-      const ProcessSingleton::NotificationCallback& callback);
-  void ReleaseSingleInstance();
+  std::string GetLocaleCountryCode();
+  void OnSecondInstance(const base::CommandLine::StringVector& cmd,
+                        const base::FilePath& cwd);
+  bool HasSingleInstanceLock() const;
+  bool RequestSingleInstanceLock();
+  void ReleaseSingleInstanceLock();
   bool Relaunch(mate::Arguments* args);
   void DisableHardwareAcceleration(mate::Arguments* args);
   void DisableDomainBlockingFor3DAPIs(mate::Arguments* args);
   bool IsAccessibilitySupportEnabled();
-  void SetAccessibilitySupportEnabled(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,
                          const net::CompletionCallback& callback);
 #endif
-  void GetFileIcon(const base::FilePath& path,
-                   mate::Arguments* args);
+  v8::Local<v8::Promise> GetFileIcon(const base::FilePath& path,
+                                     mate::Arguments* args);
 
   std::vector<mate::Dictionary> GetAppMetrics(v8::Isolate* isolate);
   v8::Local<v8::Value> GetGPUFeatureStatus(v8::Isolate* isolate);
-  void EnableMixedSandbox(mate::Arguments* args);
+  v8::Local<v8::Promise> GetGPUInfo(v8::Isolate* isolate,
+                                    const std::string& info_type);
+  void EnableSandbox(mate::Arguments* args);
 
 #if defined(OS_MACOSX)
   bool MoveToApplicationsFolder(mate::Arguments* args);
@@ -211,7 +213,7 @@ class App : public AtomBrowserClient::Delegate,
 #endif
 #if defined(MAS_BUILD)
   base::Callback<void()> StartAccessingSecurityScopedResource(
-    mate::Arguments* args);
+      mate::Arguments* args);
 #endif
 
 #if defined(OS_WIN)
@@ -234,8 +236,7 @@ class App : public AtomBrowserClient::Delegate,
   base::FilePath app_path_;
 
   using ProcessMetricMap =
-      std::unordered_map<base::ProcessId,
-                         std::unique_ptr<atom::ProcessMetric>>;
+      std::unordered_map<base::ProcessId, std::unique_ptr<atom::ProcessMetric>>;
   ProcessMetricMap app_metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(App);

atom/browser/api/atom_api_app_mas.mm

@@ -19,23 +19,27 @@ void OnStopAccessingSecurityScopedResource(NSURL* bookmarkUrl) {
 }
 
 // Get base64 encoded NSData, create a bookmark for it and start accessing it.
-base::Callback<void ()> App::StartAccessingSecurityScopedResource(mate::Arguments* args) {
+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];
+  NSString* base64str = base::SysUTF8ToNSString(data);
+  NSData* bookmarkData =
+      [[NSData alloc] initWithBase64EncodedString:base64str options:0];
 
   // Create bookmarkUrl from NSData.
   BOOL isStale = false;
-  NSError *error = nil;
-  NSURL *bookmarkUrl = [NSURL URLByResolvingBookmarkData: bookmarkData
-                                                 options: NSURLBookmarkResolutionWithSecurityScope
-                                           relativeToURL: nil
-                                     bookmarkDataIsStale: &isStale
-                                                   error: &error];
+  NSError* error = nil;
+  NSURL* bookmarkUrl =
+      [NSURL URLByResolvingBookmarkData:bookmarkData
+                                options:NSURLBookmarkResolutionWithSecurityScope
+                          relativeToURL:nil
+                    bookmarkDataIsStale:&isStale
+                                  error:&error];
 
   if (error != nil) {
-    NSString *err = [NSString stringWithFormat: @"NSError: %@ %@", error, [error userInfo]];
+    NSString* err =
+        [NSString stringWithFormat:@"NSError: %@ %@", error, [error userInfo]];
     args->ThrowError(base::SysNSStringToUTF8(err));
   }
 
@@ -54,6 +58,6 @@ base::Callback<void ()> App::StartAccessingSecurityScopedResource(mate::Argument
   return base::Bind(&OnStopAccessingSecurityScopedResource, bookmarkUrl);
 }
 
-} // namespace atom
+}  // namespace atom
 
-} // namespace api
+}  // namespace api

atom/browser/api/atom_api_auto_updater.cc

@@ -16,12 +16,12 @@
 
 namespace mate {
 
-template<>
+template <>
 struct Converter<base::Time> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    const base::Time& val) {
-    v8::MaybeLocal<v8::Value> date = v8::Date::New(
-        isolate->GetCurrentContext(), val.ToJsTime());
+    v8::MaybeLocal<v8::Value> date =
+        v8::Date::New(isolate->GetCurrentContext(), val.ToJsTime());
     if (date.IsEmpty())
       return v8::Null(isolate);
     else
@@ -49,21 +49,20 @@ void AutoUpdater::OnError(const std::string& message) {
   v8::HandleScope handle_scope(isolate());
   auto error = v8::Exception::Error(mate::StringToV8(isolate(), message));
   mate::EmitEvent(
-      isolate(),
-      GetWrapper(),
-      "error",
+      isolate(), GetWrapper(), "error",
       error->ToObject(isolate()->GetCurrentContext()).ToLocalChecked(),
       // Message is also emitted to keep compatibility with old code.
       message);
 }
 
 void AutoUpdater::OnError(const std::string& message,
-                          const int code, const std::string& domain) {
+                          const int code,
+                          const std::string& domain) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
   auto error = v8::Exception::Error(mate::StringToV8(isolate(), message));
-  auto errorObject = error->ToObject(
-    isolate()->GetCurrentContext()).ToLocalChecked();
+  auto errorObject =
+      error->ToObject(isolate()->GetCurrentContext()).ToLocalChecked();
 
   // add two new params for better error handling
   errorObject->Set(mate::StringToV8(isolate(), "code"),
@@ -104,6 +103,8 @@ void AutoUpdater::SetFeedURL(mate::Arguments* args) {
 }
 
 void AutoUpdater::QuitAndInstall() {
+  Emit("before-quit-for-update");
+
   // If we don't have any window then quitAndInstall immediately.
   if (WindowList::IsEmpty()) {
     auto_updater::AutoUpdater::QuitAndInstall();
@@ -121,8 +122,8 @@ mate::Handle<AutoUpdater> AutoUpdater::Create(v8::Isolate* isolate) {
 }
 
 // static
-void AutoUpdater::BuildPrototype(
-    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
+void AutoUpdater::BuildPrototype(v8::Isolate* isolate,
+                                 v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "AutoUpdater"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("checkForUpdates", &auto_updater::AutoUpdater::CheckForUpdates)
@@ -135,19 +136,22 @@ void AutoUpdater::BuildPrototype(
 
 }  // namespace atom
 
-
 namespace {
 
 using atom::api::AutoUpdater;
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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.Set("autoUpdater", AutoUpdater::Create(isolate));
-  dict.Set("AutoUpdater", AutoUpdater::GetConstructor(isolate)->GetFunction());
+  dict.Set("AutoUpdater", AutoUpdater::GetConstructor(isolate)
+                              ->GetFunction(context)
+                              .ToLocalChecked());
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_auto_updater, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_auto_updater, Initialize)

atom/browser/api/atom_api_auto_updater.h

@@ -32,8 +32,9 @@ class AutoUpdater : public mate::EventEmitter<AutoUpdater>,
 
   // Delegate implementations.
   void OnError(const std::string& error) override;
-  void OnError(const std::string& message, const int code,
-               const std::string& domain);
+  void OnError(const std::string& message,
+               const int code,
+               const std::string& domain) override;
   void OnCheckingForUpdate() override;
   void OnUpdateAvailable() override;
   void OnUpdateNotAvailable() override;

atom/browser/api/atom_api_browser_view.cc

@@ -51,8 +51,7 @@ namespace api {
 
 BrowserView::BrowserView(v8::Isolate* isolate,
                          v8::Local<v8::Object> wrapper,
-                         const mate::Dictionary& options)
-    : api_web_contents_(nullptr) {
+                         const mate::Dictionary& options) {
   Init(isolate, wrapper, options);
 }
 
@@ -67,15 +66,25 @@ void BrowserView::Init(v8::Isolate* isolate,
 
   web_contents_.Reset(isolate, web_contents.ToV8());
   api_web_contents_ = web_contents.get();
+  Observe(web_contents->web_contents());
 
-  view_.reset(NativeBrowserView::Create(
-      api_web_contents_->managed_web_contents()->GetView()));
+  view_.reset(
+      NativeBrowserView::Create(api_web_contents_->managed_web_contents()));
 
   InitWith(isolate, wrapper);
 }
 
 BrowserView::~BrowserView() {
-  api_web_contents_->DestroyWebContents(true /* async */);
+  if (api_web_contents_) {  // destroy() is called
+    // Destroy WebContents asynchronously unless app is shutting down,
+    // because destroy() might be called inside WebContents's event handler.
+    api_web_contents_->DestroyWebContents(!Browser::Get()->is_shutting_down());
+  }
+}
+
+void BrowserView::WebContentsDestroyed() {
+  api_web_contents_ = nullptr;
+  web_contents_.Reset();
 }
 
 // static
@@ -150,16 +159,17 @@ void Initialize(v8::Local<v8::Object> exports,
   v8::Isolate* isolate = context->GetIsolate();
   BrowserView::SetConstructor(isolate, base::Bind(&BrowserView::New));
 
-  mate::Dictionary browser_view(
-      isolate, BrowserView::GetConstructor(isolate)->GetFunction());
+  mate::Dictionary browser_view(isolate, BrowserView::GetConstructor(isolate)
+                                             ->GetFunction(context)
+                                             .ToLocalChecked());
   browser_view.SetMethod("fromId",
-                          &mate::TrackableObject<BrowserView>::FromWeakMapID);
+                         &mate::TrackableObject<BrowserView>::FromWeakMapID);
   browser_view.SetMethod("getAllViews",
-                          &mate::TrackableObject<BrowserView>::GetAll);
+                         &mate::TrackableObject<BrowserView>::GetAll);
   mate::Dictionary dict(isolate, exports);
   dict.Set("BrowserView", browser_view);
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_browser_view, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_browser_view, Initialize)

atom/browser/api/atom_api_browser_view.h

@@ -10,6 +10,7 @@
 
 #include "atom/browser/api/trackable_object.h"
 #include "atom/browser/native_browser_view.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "native_mate/handle.h"
 
 namespace gfx {
@@ -29,7 +30,8 @@ namespace api {
 
 class WebContents;
 
-class BrowserView : public mate::TrackableObject<BrowserView> {
+class BrowserView : public mate::TrackableObject<BrowserView>,
+                    public content::WebContentsObserver {
  public:
   static mate::WrappableBase* New(mate::Arguments* args);
 
@@ -47,6 +49,9 @@ class BrowserView : public mate::TrackableObject<BrowserView> {
               const mate::Dictionary& options);
   ~BrowserView() override;
 
+  // content::WebContentsObserver:
+  void WebContentsDestroyed() override;
+
  private:
   void Init(v8::Isolate* isolate,
             v8::Local<v8::Object> wrapper,
@@ -59,7 +64,7 @@ class BrowserView : public mate::TrackableObject<BrowserView> {
   v8::Local<v8::Value> GetWebContents();
 
   v8::Global<v8::Value> web_contents_;
-  class WebContents* api_web_contents_;
+  class WebContents* api_web_contents_ = nullptr;
 
   std::unique_ptr<NativeBrowserView> view_;
 

atom/browser/api/atom_api_browser_window.cc

@@ -0,0 +1,496 @@
+// 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_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/options_switches.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/renderer_host/render_widget_host_owner_delegate.h"
+#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 "ui/gl/gpu_switching_manager.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+BrowserWindow::BrowserWindow(v8::Isolate* isolate,
+                             v8::Local<v8::Object> wrapper,
+                             const mate::Dictionary& options)
+    : TopLevelWindow(isolate, options), weak_factory_(this) {
+  mate::Handle<class WebContents> web_contents;
+
+  // Use options.webPreferences in WebContents.
+  mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
+  options.Get(options::kWebPreferences, &web_preferences);
+
+  // Copy the backgroundColor to webContents.
+  v8::Local<v8::Value> value;
+  if (options.Get(options::kBackgroundColor, &value))
+    web_preferences.Set(options::kBackgroundColor, value);
+
+  v8::Local<v8::Value> transparent;
+  if (options.Get("transparent", &transparent))
+    web_preferences.Set("transparent", transparent);
+
+  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
+    // render processes.
+    auto* existing_preferences =
+        WebContentsPreferences::From(web_contents->web_contents());
+    base::DictionaryValue web_preferences_dict;
+    if (mate::ConvertFromV8(isolate, web_preferences.GetHandle(),
+                            &web_preferences_dict)) {
+      existing_preferences->Clear();
+      existing_preferences->Merge(web_preferences_dict);
+    }
+  } else {
+    // Creates the WebContents used by BrowserWindow.
+    web_contents = WebContents::Create(isolate, web_preferences);
+  }
+
+  web_contents_.Reset(isolate, web_contents.ToV8());
+  api_web_contents_ = web_contents->GetWeakPtr();
+  api_web_contents_->AddObserver(this);
+  Observe(api_web_contents_->web_contents());
+
+  // Keep a copy of the options for later use.
+  mate::Dictionary(isolate, web_contents->GetWrapper())
+      .Set("browserWindowOptions", options);
+
+  // Associate with BrowserWindow.
+  web_contents->SetOwnerWindow(window());
+
+  auto* host = web_contents->web_contents()->GetRenderViewHost();
+  if (host)
+    host->GetWidget()->AddInputEventObserver(this);
+
+  InitWith(isolate, wrapper);
+
+#if defined(OS_MACOSX)
+  OverrideNSWindowContentView(web_contents->managed_web_contents());
+#endif
+
+  // Init window after everything has been setup.
+  window()->InitFromOptions(options);
+}
+
+BrowserWindow::~BrowserWindow() {
+  // FIXME This is a hack rather than a proper fix preventing shutdown crashes.
+  if (api_web_contents_)
+    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())
+    Cleanup();
+}
+
+void BrowserWindow::OnInputEvent(const blink::WebInputEvent& event) {
+  switch (event.GetType()) {
+    case blink::WebInputEvent::kGestureScrollBegin:
+    case blink::WebInputEvent::kGestureScrollUpdate:
+    case blink::WebInputEvent::kGestureScrollEnd:
+      Emit("scroll-touch-edge");
+      break;
+    default:
+      break;
+  }
+}
+
+void BrowserWindow::RenderViewHostChanged(content::RenderViewHost* old_host,
+                                          content::RenderViewHost* new_host) {
+  if (old_host)
+    old_host->GetWidget()->RemoveInputEventObserver(this);
+  if (new_host)
+    new_host->GetWidget()->AddInputEventObserver(this);
+}
+
+void BrowserWindow::RenderViewCreated(
+    content::RenderViewHost* render_view_host) {
+  if (!window()->transparent())
+    return;
+
+  content::RenderWidgetHostImpl* impl = content::RenderWidgetHostImpl::FromID(
+      render_view_host->GetProcess()->GetID(),
+      render_view_host->GetRoutingID());
+  if (impl)
+    impl->owner_delegate()->SetBackgroundOpaque(false);
+}
+
+void BrowserWindow::DidFirstVisuallyNonEmptyPaint() {
+  if (window()->IsVisible())
+    return;
+
+  // When there is a non-empty first paint, resize the RenderWidget to force
+  // Chromium to draw.
+  auto* const view = web_contents()->GetRenderWidgetHostView();
+  view->Show();
+  view->SetSize(window()->GetContentSize());
+
+  // Emit the ReadyToShow event in next tick in case of pending drawing work.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(
+                     [](base::WeakPtr<BrowserWindow> self) {
+                       if (self)
+                         self->Emit("ready-to-show");
+                     },
+                     GetWeakPtr()));
+}
+
+void BrowserWindow::BeforeUnloadDialogCancelled() {
+  WindowList::WindowCloseCancelled(window());
+  // Cancel unresponsive event when window close is cancelled.
+  window_unresponsive_closure_.Cancel();
+}
+
+void BrowserWindow::OnRendererUnresponsive(content::RenderProcessHost*) {
+  // Schedule the unresponsive shortly later, since we may receive the
+  // responsive event soon. This could happen after the whole application had
+  // blocked for a while.
+  // Also notice that when closing this event would be ignored because we have
+  // explicitly started a close timeout counter. This is on purpose because we
+  // don't want the unresponsive event to be sent too early when user is closing
+  // the window.
+  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.
+  // https://github.com/electron/electron/issues/16202.
+  //
+  // TODO(zcbenz): We should find out the root cause and improve the closing
+  // procedure of BrowserWindow.
+  if (!web_contents())
+    return;
+
+  // Close all child windows before closing current window.
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  for (v8::Local<v8::Value> value : child_windows_.Values(isolate())) {
+    mate::Handle<BrowserWindow> child;
+    if (mate::ConvertFromV8(isolate(), value, &child) && !child.IsEmpty())
+      child->window()->CloseImmediately();
+  }
+
+  // When the web contents is gone, close the window immediately, but the
+  // memory will not be freed until you call delete.
+  // In this way, it would be safe to manage windows via smart pointers. If you
+  // want to free memory when the window is closed, you can do deleting by
+  // overriding the OnWindowClosed method in the observer.
+  window()->CloseImmediately();
+
+  // Do not sent "unresponsive" event after window is closed.
+  window_unresponsive_closure_.Cancel();
+}
+
+void BrowserWindow::OnRendererResponsive() {
+  window_unresponsive_closure_.Cancel();
+  Emit("responsive");
+}
+
+void BrowserWindow::RequestPreferredWidth(int* width) {
+  *width = web_contents()->GetPreferredSize().width();
+}
+
+void BrowserWindow::OnCloseButtonClicked(bool* prevent_default) {
+  // When user tries to close the window by clicking the close button, we do
+  // not close the window immediately, instead we try to close the web page
+  // first, and when the web page is closed the window will also be closed.
+  *prevent_default = true;
+
+  // Assume the window is not responding if it doesn't cancel the close and is
+  // not closed in 5s, in this way we can quickly show the unresponsive
+  // dialog when the window is busy executing some script withouth waiting for
+  // the unresponsive timeout.
+  if (window_unresponsive_closure_.IsCancelled())
+    ScheduleUnresponsiveEvent(5000);
+
+  if (!web_contents())
+    // Already closed by renderer
+    return;
+
+  if (web_contents()->NeedToFireBeforeUnload())
+    web_contents()->DispatchBeforeUnload(false /* auto_cancel */);
+  else
+    web_contents()->Close();
+}
+
+void BrowserWindow::OnWindowClosed() {
+  Cleanup();
+  TopLevelWindow::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)
+  auto* rwhv = web_contents()->GetRenderWidgetHostView();
+  if (rwhv)
+    rwhv->SetActive(true);
+#else
+  if (!api_web_contents_->IsDevToolsOpened())
+    web_contents()->Focus();
+#endif
+
+  TopLevelWindow::OnWindowFocus();
+}
+
+void BrowserWindow::OnWindowResize() {
+#if defined(OS_MACOSX)
+  if (!draggable_regions_.empty())
+    UpdateDraggableRegions(nullptr, draggable_regions_);
+#endif
+  TopLevelWindow::OnWindowResize();
+}
+
+void BrowserWindow::OnWindowLeaveFullScreen() {
+  TopLevelWindow::OnWindowLeaveFullScreen();
+#if defined(OS_MACOSX)
+  if (web_contents()->IsFullscreenForCurrentTab())
+    web_contents()->ExitFullscreen(true);
+#endif
+}
+
+void BrowserWindow::Focus() {
+  if (api_web_contents_->IsOffScreen())
+    FocusOnWebView();
+  else
+    TopLevelWindow::Focus();
+}
+
+void BrowserWindow::Blur() {
+  if (api_web_contents_->IsOffScreen())
+    BlurWebView();
+  else
+    TopLevelWindow::Blur();
+}
+
+void BrowserWindow::SetBackgroundColor(const std::string& color_name) {
+  TopLevelWindow::SetBackgroundColor(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()->SetKey(options::kBackgroundColor,
+                                            base::Value(color_name));
+    }
+  }
+}
+
+void BrowserWindow::SetBrowserView(v8::Local<v8::Value> value) {
+  TopLevelWindow::ResetBrowserViews();
+  TopLevelWindow::AddBrowserView(value);
+#if defined(OS_MACOSX)
+  UpdateDraggableRegions(nullptr, draggable_regions_);
+#endif
+}
+
+void BrowserWindow::AddBrowserView(v8::Local<v8::Value> value) {
+  TopLevelWindow::AddBrowserView(value);
+#if defined(OS_MACOSX)
+  UpdateDraggableRegions(nullptr, draggable_regions_);
+#endif
+}
+
+void BrowserWindow::RemoveBrowserView(v8::Local<v8::Value> value) {
+  TopLevelWindow::RemoveBrowserView(value);
+#if defined(OS_MACOSX)
+  UpdateDraggableRegions(nullptr, draggable_regions_);
+#endif
+}
+
+void BrowserWindow::ResetBrowserViews() {
+  TopLevelWindow::ResetBrowserViews();
+#if defined(OS_MACOSX)
+  UpdateDraggableRegions(nullptr, draggable_regions_);
+#endif
+}
+
+void BrowserWindow::SetVibrancy(v8::Isolate* isolate,
+                                v8::Local<v8::Value> value) {
+  std::string type = gin::V8ToString(isolate, value);
+
+  auto* render_view_host = web_contents()->GetRenderViewHost();
+  if (render_view_host) {
+    auto* impl = content::RenderWidgetHostImpl::FromID(
+        render_view_host->GetProcess()->GetID(),
+        render_view_host->GetRoutingID());
+    if (impl)
+      impl->owner_delegate()->SetBackgroundOpaque(
+          type.empty() ? !window_->transparent() : false);
+  }
+
+  TopLevelWindow::SetVibrancy(isolate, value);
+}
+
+void BrowserWindow::FocusOnWebView() {
+  web_contents()->GetRenderViewHost()->GetWidget()->Focus();
+}
+
+void BrowserWindow::BlurWebView() {
+  web_contents()->GetRenderViewHost()->GetWidget()->Blur();
+}
+
+bool BrowserWindow::IsWebViewFocused() {
+  auto* host_view = web_contents()->GetRenderViewHost()->GetWidget()->GetView();
+  return host_view && host_view->HasFocus();
+}
+
+v8::Local<v8::Value> BrowserWindow::GetWebContents(v8::Isolate* isolate) {
+  if (web_contents_.IsEmpty())
+    return v8::Null(isolate);
+  return v8::Local<v8::Value>::New(isolate, web_contents_);
+}
+
+// Convert draggable regions in raw format to SkRegion format.
+std::unique_ptr<SkRegion> BrowserWindow::DraggableRegionsToSkRegion(
+    const std::vector<DraggableRegion>& regions) {
+  auto sk_region = std::make_unique<SkRegion>();
+  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);
+  }
+  return sk_region;
+}
+
+void BrowserWindow::ScheduleUnresponsiveEvent(int ms) {
+  if (!window_unresponsive_closure_.IsCancelled())
+    return;
+
+  window_unresponsive_closure_.Reset(
+      base::Bind(&BrowserWindow::NotifyWindowUnresponsive, GetWeakPtr()));
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, window_unresponsive_closure_.callback(),
+      base::TimeDelta::FromMilliseconds(ms));
+}
+
+void BrowserWindow::NotifyWindowUnresponsive() {
+  window_unresponsive_closure_.Cancel();
+  if (!window_->IsClosed() && window_->IsEnabled() &&
+      !IsUnresponsiveEventSuppressed()) {
+    Emit("unresponsive");
+  }
+}
+
+void BrowserWindow::Cleanup() {
+  auto* host = web_contents()->GetRenderViewHost();
+  if (host)
+    host->GetWidget()->RemoveInputEventObserver(this);
+
+  // Destroy WebContents asynchronously unless app is shutting down,
+  // because destroy() might be called inside WebContents's event handler.
+  api_web_contents_->DestroyWebContents(!Browser::Get()->is_shutting_down());
+  Observe(nullptr);
+}
+
+// static
+mate::WrappableBase* BrowserWindow::New(mate::Arguments* args) {
+  if (!Browser::Get()->is_ready()) {
+    args->ThrowError("Cannot create BrowserWindow before app is ready");
+    return nullptr;
+  }
+
+  if (args->Length() > 1) {
+    args->ThrowError();
+    return nullptr;
+  }
+
+  mate::Dictionary options;
+  if (!(args->Length() == 1 && args->GetNext(&options))) {
+    options = mate::Dictionary::CreateEmpty(args->isolate());
+  }
+
+  return new BrowserWindow(args->isolate(), args->GetThis(), options);
+}
+
+// static
+void BrowserWindow::BuildPrototype(v8::Isolate* isolate,
+                                   v8::Local<v8::FunctionTemplate> prototype) {
+  prototype->SetClassName(mate::StringToV8(isolate, "BrowserWindow"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .SetMethod("focusOnWebView", &BrowserWindow::FocusOnWebView)
+      .SetMethod("blurWebView", &BrowserWindow::BlurWebView)
+      .SetMethod("isWebViewFocused", &BrowserWindow::IsWebViewFocused)
+      .SetProperty("webContents", &BrowserWindow::GetWebContents);
+}
+
+// static
+v8::Local<v8::Value> BrowserWindow::From(v8::Isolate* isolate,
+                                         NativeWindow* native_window) {
+  auto* existing = TrackableObject::FromWrappedClass(isolate, native_window);
+  if (existing)
+    return existing->GetWrapper();
+  else
+    return v8::Null(isolate);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+using atom::api::BrowserWindow;
+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();
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("BrowserWindow", mate::CreateConstructor<BrowserWindow>(
+                                isolate, base::Bind(&BrowserWindow::New)));
+}
+
+}  // namespace
+
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_window, Initialize)

atom/browser/api/atom_api_browser_window.h

@@ -0,0 +1,130 @@
+// 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_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"
+
+namespace atom {
+
+namespace api {
+
+class BrowserWindow : public TopLevelWindow,
+                      public content::RenderWidgetHost::InputEventObserver,
+                      public content::WebContentsObserver,
+                      public ExtendedWebContentsObserver {
+ public:
+  static mate::WrappableBase* New(mate::Arguments* args);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
+
+  // Returns the BrowserWindow object from |native_window|.
+  static v8::Local<v8::Value> From(v8::Isolate* isolate,
+                                   NativeWindow* native_window);
+
+  base::WeakPtr<BrowserWindow> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
+ protected:
+  BrowserWindow(v8::Isolate* isolate,
+                v8::Local<v8::Object> wrapper,
+                const mate::Dictionary& options);
+  ~BrowserWindow() override;
+
+  // content::RenderWidgetHost::InputEventObserver:
+  void OnInputEvent(const blink::WebInputEvent& event) override;
+
+  // content::WebContentsObserver:
+  void RenderViewHostChanged(content::RenderViewHost* old_host,
+                             content::RenderViewHost* new_host) override;
+  void RenderViewCreated(content::RenderViewHost* render_view_host) override;
+  void DidFirstVisuallyNonEmptyPaint() 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;
+
+  // NativeWindowObserver:
+  void RequestPreferredWidth(int* width) override;
+  void OnCloseButtonClicked(bool* prevent_default) override;
+
+  // TopLevelWindow:
+  void OnWindowClosed() override;
+  void OnWindowBlur() override;
+  void OnWindowFocus() override;
+  void OnWindowResize() override;
+  void OnWindowLeaveFullScreen() override;
+  void Focus() override;
+  void Blur() override;
+  void SetBackgroundColor(const std::string& color_name) override;
+  void SetBrowserView(v8::Local<v8::Value> value) override;
+  void AddBrowserView(v8::Local<v8::Value> value) override;
+  void RemoveBrowserView(v8::Local<v8::Value> value) override;
+  void ResetBrowserViews() override;
+  void SetVibrancy(v8::Isolate* isolate, v8::Local<v8::Value> value) override;
+
+  // BrowserWindow APIs.
+  void FocusOnWebView();
+  void BlurWebView();
+  bool IsWebViewFocused();
+  v8::Local<v8::Value> GetWebContents(v8::Isolate* isolate);
+
+ private:
+#if defined(OS_MACOSX)
+  void OverrideNSWindowContentView(InspectableWebContents* iwc);
+#endif
+
+  // Helpers.
+
+  // Called when the window needs to update its draggable region.
+  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<DraggableRegion>& regions);
+
+  // Schedule a notification unresponsive event.
+  void ScheduleUnresponsiveEvent(int ms);
+
+  // Dispatch unresponsive event to observers.
+  void NotifyWindowUnresponsive();
+
+  // Cleanup our WebContents observers.
+  void Cleanup();
+
+  // Closure that would be called when window is unresponsive when closing,
+  // it should be cancelled when we can prove that the window is responsive.
+  base::CancelableClosure window_unresponsive_closure_;
+
+#if defined(OS_MACOSX)
+  std::vector<DraggableRegion> draggable_regions_;
+#endif
+
+  v8::Global<v8::Value> web_contents_;
+  base::WeakPtr<api::WebContents> api_web_contents_;
+
+  base::WeakPtrFactory<BrowserWindow> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(BrowserWindow);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_BROWSER_WINDOW_H_

atom/browser/api/atom_api_browser_window_mac.mm

@@ -0,0 +1,137 @@
+// 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_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"
+
+@interface NSView (WebContentsView)
+- (void)setMouseDownCanMoveWindow:(BOOL)can_move;
+@end
+
+@interface ControlRegionView : NSView
+@end
+
+@implementation ControlRegionView
+
+- (BOOL)mouseDownCanMoveWindow {
+  return NO;
+}
+
+- (NSView*)hitTest:(NSPoint)aPoint {
+  return nil;
+}
+
+@end
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+// Return a vector of non-draggable regions that fill a window of size
+// |width| by |height|, but leave gaps where the window should be draggable.
+std::vector<gfx::Rect> CalculateNonDraggableRegions(
+    std::unique_ptr<SkRegion> draggable,
+    int width,
+    int height) {
+  std::vector<gfx::Rect> result;
+  SkRegion non_draggable;
+  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()));
+  }
+  return result;
+}
+
+}  // namespace
+
+void BrowserWindow::OverrideNSWindowContentView(InspectableWebContents* iwc) {
+  // Make NativeWindow use a NSView as content view.
+  static_cast<NativeWindowMac*>(window())->OverrideNSWindowContentView();
+  // Add webview to contentView.
+  NSView* webView = iwc->GetView()->GetNativeView().GetNativeNSView();
+  NSView* contentView =
+      [window()->GetNativeWindow().GetNativeNSWindow() contentView];
+  [webView setFrame:[contentView bounds]];
+
+  // ensure that buttons view is floated to top of view hierarchy
+  NSArray* subviews = [contentView subviews];
+  NSView* last = subviews.lastObject;
+  [contentView addSubview:webView positioned:NSWindowBelow relativeTo:last];
+
+  [contentView viewDidMoveToWindow];
+}
+
+void BrowserWindow::UpdateDraggableRegions(
+    content::RenderFrameHost* rfh,
+    const std::vector<DraggableRegion>& regions) {
+  if (window_->has_frame())
+    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.
+  NSView* webView = web_contents()->GetNativeView().GetNativeNSView();
+  NSInteger webViewWidth = NSWidth([webView bounds]);
+  NSInteger webViewHeight = NSHeight([webView bounds]);
+
+  if ([webView respondsToSelector:@selector(setMouseDownCanMoveWindow:)]) {
+    [webView setMouseDownCanMoveWindow:YES];
+  }
+
+  // Remove all ControlRegionViews that are added last time.
+  // Note that [webView subviews] returns the view's mutable internal array and
+  // it should be copied to avoid mutating the original array while enumerating
+  // it.
+  base::scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
+  for (NSView* subview in subviews.get())
+    if ([subview isKindOfClass:[ControlRegionView class]])
+      [subview removeFromSuperview];
+
+  // Draggable regions is implemented by having the whole web view draggable
+  // (mouseDownCanMoveWindow) and overlaying regions that are not draggable.
+  draggable_regions_ = regions;
+  std::vector<gfx::Rect> drag_exclude_rects;
+  if (regions.empty()) {
+    drag_exclude_rects.push_back(gfx::Rect(0, 0, webViewWidth, webViewHeight));
+  } else {
+    drag_exclude_rects = CalculateNonDraggableRegions(
+        DraggableRegionsToSkRegion(regions), webViewWidth, webViewHeight);
+  }
+
+  auto browser_views = window_->browser_views();
+  for (NativeBrowserView* view : browser_views) {
+    (view)->UpdateDraggableRegions(drag_exclude_rects);
+  }
+
+  // Create and add a ControlRegionView for each region that needs to be
+  // excluded from the dragging.
+  for (const auto& rect : drag_exclude_rects) {
+    base::scoped_nsobject<NSView> controlRegion(
+        [[ControlRegionView alloc] initWithFrame:NSZeroRect]);
+    [controlRegion setFrame:NSMakeRect(rect.x(), webViewHeight - rect.bottom(),
+                                       rect.width(), rect.height())];
+    [webView addSubview:controlRegion];
+  }
+
+  // AppKit will not update its cache of mouseDownCanMoveWindow unless something
+  // changes. Previously we tried adding an NSView and removing it, but for some
+  // reason it required reposting the mouse-down event, and didn't always work.
+  // Calling the below seems to be an effective solution.
+  [[webView window] setMovableByWindowBackground:NO];
+  [[webView window] setMovableByWindowBackground:YES];
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_browser_window_views.cc

@@ -0,0 +1,24 @@
+// 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_browser_window.h"
+
+#include "atom/browser/native_window_views.h"
+
+namespace atom {
+
+namespace api {
+
+void BrowserWindow::UpdateDraggableRegions(
+    content::RenderFrameHost* rfh,
+    const std::vector<DraggableRegion>& regions) {
+  if (window_->has_frame())
+    return;
+  static_cast<NativeWindowViews*>(window_.get())
+      ->UpdateDraggableRegions(DraggableRegionsToSkRegion(regions));
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_content_tracing.cc

@@ -7,8 +7,11 @@
 
 #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/promise_util.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
+#include "base/threading/thread_restrictions.h"
 #include "content/public/browser/tracing_controller.h"
 #include "native_mate/dictionary.h"
 
@@ -18,20 +21,32 @@ using content::TracingController;
 
 namespace mate {
 
-template<>
+template <>
 struct Converter<base::trace_event::TraceConfig> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
                      base::trace_event::TraceConfig* out) {
+    // (alexeykuzmin): A combination of "categoryFilter" and "traceOptions"
+    // has to be checked first because none of the fields
+    // in the `memory_dump_config` dict below are mandatory
+    // and we cannot check the config format.
     Dictionary options;
-    if (!ConvertFromV8(isolate, val, &options))
-      return false;
-    std::string category_filter, trace_options;
-    if (!options.Get("categoryFilter", &category_filter) ||
-        !options.Get("traceOptions", &trace_options))
-      return false;
-    *out = base::trace_event::TraceConfig(category_filter, trace_options);
-    return true;
+    if (ConvertFromV8(isolate, val, &options)) {
+      std::string category_filter, trace_options;
+      if (options.Get("categoryFilter", &category_filter) &&
+          options.Get("traceOptions", &trace_options)) {
+        *out = base::trace_event::TraceConfig(category_filter, trace_options);
+        return true;
+      }
+    }
+
+    base::DictionaryValue memory_dump_config;
+    if (ConvertFromV8(isolate, val, &memory_dump_config)) {
+      *out = base::trace_event::TraceConfig(memory_dump_config);
+      return true;
+    }
+
+    return false;
   }
 };
 
@@ -41,36 +56,88 @@ namespace {
 
 using CompletionCallback = base::Callback<void(const base::FilePath&)>;
 
-scoped_refptr<TracingController::TraceDataSink> GetTraceDataSink(
-    const base::FilePath& path, const CompletionCallback& callback) {
+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::CreateFileSink(result_file_path,
-                                           base::Bind(callback,
-                                                      result_file_path));
+  return TracingController::CreateFileEndpoint(
+      result_file_path, base::Bind(callback, result_file_path));
 }
 
-void StopRecording(const base::FilePath& path,
-                   const CompletionCallback& callback) {
-  TracingController::GetInstance()->StopTracing(
-      GetTraceDataSink(path, callback));
+void OnRecordingStopped(const atom::util::CopyablePromise& promise,
+                        const base::FilePath& path) {
+  promise.GetPromise().Resolve(path);
 }
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  auto controller = base::Unretained(TracingController::GetInstance());
+v8::Local<v8::Promise> StopRecording(v8::Isolate* isolate,
+                                     const base::FilePath& path) {
+  atom::util::Promise promise(isolate);
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  // TODO(zcbenz): Remove the use of CopyablePromise when the
+  // CreateFileEndpoint API accepts OnceCallback.
+  TracingController::GetInstance()->StopTracing(GetTraceDataEndpoint(
+      path,
+      base::Bind(&OnRecordingStopped, atom::util::CopyablePromise(promise))));
+  return handle;
+}
+
+void OnCategoriesAvailable(atom::util::Promise promise,
+                           const std::set<std::string>& categories) {
+  promise.Resolve(categories);
+}
+
+v8::Local<v8::Promise> GetCategories(v8::Isolate* isolate) {
+  atom::util::Promise promise(isolate);
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  // Note: This method always succeeds.
+  TracingController::GetInstance()->GetCategories(
+      base::BindOnce(&OnCategoriesAvailable, std::move(promise)));
+  return handle;
+}
+
+void OnTracingStarted(atom::util::Promise promise) {
+  promise.Resolve();
+}
+
+v8::Local<v8::Promise> StartTracing(
+    v8::Isolate* isolate,
+    const base::trace_event::TraceConfig& trace_config) {
+  atom::util::Promise promise(isolate);
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  // Note: This method always succeeds.
+  TracingController::GetInstance()->StartTracing(
+      trace_config, base::BindOnce(&OnTracingStarted, std::move(promise)));
+  return handle;
+}
+
+bool GetTraceBufferUsage(
+    const base::RepeatingCallback<void(float, size_t)>& callback) {
+  return TracingController::GetInstance()->GetTraceBufferUsage(
+      base::BindOnce(callback));
+}
+
+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("getCategories", base::Bind(
-      &TracingController::GetCategories, controller));
-  dict.SetMethod("startRecording", base::Bind(
-      &TracingController::StartTracing, controller));
+  dict.SetMethod("getCategories", &GetCategories);
+  dict.SetMethod("startRecording", &StartTracing);
   dict.SetMethod("stopRecording", &StopRecording);
-  dict.SetMethod("getTraceBufferUsage", base::Bind(
-      &TracingController::GetTraceBufferUsage, controller));
+  dict.SetMethod("getTraceBufferUsage", &GetTraceBufferUsage);
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_content_tracing, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_content_tracing, Initialize)

atom/browser/api/atom_api_cookies.cc

@@ -4,28 +4,33 @@
 
 #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/cookie_monster.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 atom::AtomCookieDelegate;
 using content::BrowserThread;
 
 namespace mate {
 
-template<>
+template <>
 struct Converter<atom::api::Cookies::Error> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    atom::api::Cookies::Error val) {
@@ -36,7 +41,7 @@ struct Converter<atom::api::Cookies::Error> {
   }
 };
 
-template<>
+template <>
 struct Converter<net::CanonicalCookie> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    const net::CanonicalCookie& val) {
@@ -55,25 +60,22 @@ struct Converter<net::CanonicalCookie> {
   }
 };
 
-template<>
-struct Converter<net::CookieStore::ChangeCause> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const net::CookieStore::ChangeCause& val) {
+template <>
+struct Converter<network::mojom::CookieChangeCause> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const network::mojom::CookieChangeCause& val) {
     switch (val) {
-      case net::CookieStore::ChangeCause::INSERTED:
-      case net::CookieStore::ChangeCause::EXPLICIT:
-      case net::CookieStore::ChangeCause::EXPLICIT_DELETE_BETWEEN:
-      case net::CookieStore::ChangeCause::EXPLICIT_DELETE_PREDICATE:
-      case net::CookieStore::ChangeCause::EXPLICIT_DELETE_SINGLE:
-      case net::CookieStore::ChangeCause::EXPLICIT_DELETE_CANONICAL:
+      case network::mojom::CookieChangeCause::INSERTED:
+      case network::mojom::CookieChangeCause::EXPLICIT:
         return mate::StringToV8(isolate, "explicit");
-      case net::CookieStore::ChangeCause::OVERWRITE:
+      case network::mojom::CookieChangeCause::OVERWRITE:
         return mate::StringToV8(isolate, "overwrite");
-      case net::CookieStore::ChangeCause::EXPIRED:
+      case network::mojom::CookieChangeCause::EXPIRED:
         return mate::StringToV8(isolate, "expired");
-      case net::CookieStore::ChangeCause::EVICTED:
+      case network::mojom::CookieChangeCause::EVICTED:
         return mate::StringToV8(isolate, "evicted");
-      case net::CookieStore::ChangeCause::EXPIRED_OVERWRITE:
+      case network::mojom::CookieChangeCause::EXPIRED_OVERWRITE:
         return mate::StringToV8(isolate, "expired-overwrite");
       default:
         return mate::StringToV8(isolate, "unknown");
@@ -134,73 +136,103 @@ inline net::CookieStore* GetCookieStore(
   return getter->GetURLRequestContext()->cookie_store();
 }
 
+void ResolvePromiseWithCookies(util::Promise promise,
+                               const net::CookieList& cookie_list) {
+  promise.Resolve(cookie_list);
+}
+
+void ResolvePromise(util::Promise promise) {
+  promise.Resolve();
+}
+
+// Resolve |promise| in UI thread.
+void ResolvePromiseInUI(util::Promise promise) {
+  base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI},
+                           base::BindOnce(ResolvePromise, std::move(promise)));
+}
+
 // Run |callback| on UI thread.
-void RunCallbackInUI(const base::Closure& callback) {
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
+void RunCallbackInUI(base::OnceClosure callback) {
+  base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI}, std::move(callback));
 }
 
 // Remove cookies from |list| not matching |filter|, and pass it to |callback|.
 void FilterCookies(std::unique_ptr<base::DictionaryValue> filter,
-                   const Cookies::GetCallback& callback,
+                   util::Promise promise,
                    const net::CookieList& list) {
   net::CookieList result;
   for (const auto& cookie : list) {
     if (MatchesCookie(filter.get(), cookie))
       result.push_back(cookie);
   }
-  RunCallbackInUI(base::Bind(callback, Cookies::SUCCESS, result));
+
+  base::PostTaskWithTraits(
+      FROM_HERE, {BrowserThread::UI},
+      base::BindOnce(ResolvePromiseWithCookies, std::move(promise), result));
 }
 
 // Receives cookies matching |filter| in IO thread.
 void GetCookiesOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
                     std::unique_ptr<base::DictionaryValue> filter,
-                    const Cookies::GetCallback& callback) {
+                    util::Promise promise) {
   std::string url;
   filter->GetString("url", &url);
 
   auto filtered_callback =
-      base::Bind(FilterCookies, base::Passed(&filter), callback);
+      base::BindOnce(FilterCookies, std::move(filter), std::move(promise));
 
   // Empty url will match all url cookies.
   if (url.empty())
-    GetCookieStore(getter)->GetAllCookiesAsync(filtered_callback);
+    GetCookieStore(getter)->GetAllCookiesAsync(std::move(filtered_callback));
   else
-    GetCookieStore(getter)->GetAllCookiesForURLAsync(GURL(url),
-        filtered_callback);
+    GetCookieStore(getter)->GetAllCookiesForURLAsync(
+        GURL(url), std::move(filtered_callback));
 }
 
 // Removes cookie with |url| and |name| in IO thread.
-void RemoveCookieOnIOThread(scoped_refptr<net::URLRequestContextGetter> getter,
-                            const GURL& url, const std::string& name,
-                            const base::Closure& callback) {
+void RemoveCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
+                      const GURL& url,
+                      const std::string& name,
+                      util::Promise promise) {
   GetCookieStore(getter)->DeleteCookieAsync(
-      url, name, base::Bind(RunCallbackInUI, callback));
+      url, name, base::BindOnce(ResolvePromiseInUI, std::move(promise)));
+}
+
+// Resolves/rejects the |promise| in UI thread.
+void SettlePromiseInUI(util::Promise promise, const std::string& errmsg) {
+  if (errmsg.empty()) {
+    promise.Resolve();
+  } else {
+    promise.RejectWithErrorMessage(errmsg);
+  }
 }
 
 // Callback of SetCookie.
-void OnSetCookie(const Cookies::SetCallback& callback, bool success) {
+void OnSetCookie(util::Promise promise, bool success) {
+  const std::string errmsg = success ? "" : "Setting cookie failed";
   RunCallbackInUI(
-      base::Bind(callback, success ? Cookies::SUCCESS : Cookies::FAILED));
+      base::BindOnce(SettlePromiseInUI, std::move(promise), errmsg));
 }
 
 // Flushes cookie store in IO thread.
 void FlushCookieStoreOnIOThread(
     scoped_refptr<net::URLRequestContextGetter> getter,
-    const base::Closure& callback) {
-  GetCookieStore(getter)->FlushStore(base::Bind(RunCallbackInUI, callback));
+    util::Promise promise) {
+  GetCookieStore(getter)->FlushStore(
+      base::BindOnce(ResolvePromiseInUI, std::move(promise)));
 }
 
 // Sets cookie with |details| in IO thread.
 void SetCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
                    std::unique_ptr<base::DictionaryValue> details,
-                   const Cookies::SetCallback& callback) {
-  std::string url, name, value, domain, path;
+                   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);
+  details->GetString("url", &url_string);
   details->GetString("name", &name);
   details->GetString("value", &value);
   details->GetString("domain", &domain);
@@ -210,90 +242,127 @@ void SetCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
 
   base::Time creation_time;
   if (details->GetDouble("creationDate", &creation_date)) {
-    creation_time = (creation_date == 0) ?
-        base::Time::UnixEpoch() :
-        base::Time::FromDoubleT(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);
+    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);
+    last_access_time = (last_access_date == 0)
+                           ? base::Time::UnixEpoch()
+                           : base::Time::FromDoubleT(last_access_date);
   }
 
-  GetCookieStore(getter)->SetCookieWithDetailsAsync(
-      GURL(url), name, value, domain, path, creation_time,
-      expiration_time, last_access_time, secure, http_only,
-      net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT,
-      base::Bind(OnSetCookie, callback));
+  auto completion_callback = base::BindOnce(OnSetCookie, std::move(promise));
+  GURL url(url_string);
+  if (!url.is_valid()) {
+    std::move(completion_callback).Run(false);
+    return;
+  }
+
+  if (name.empty()) {
+    std::move(completion_callback).Run(false);
+    return;
+  }
+
+  std::unique_ptr<net::CanonicalCookie> canonical_cookie(
+      net::CanonicalCookie::CreateSanitizedCookie(
+          url, name, value, domain, path, creation_time, expiration_time,
+          last_access_time, secure, http_only,
+          net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT));
+  if (!canonical_cookie || !canonical_cookie->IsCanonical()) {
+    std::move(completion_callback).Run(false);
+    return;
+  }
+  GetCookieStore(getter)->SetCanonicalCookieAsync(
+      std::move(canonical_cookie), secure, http_only,
+      std::move(completion_callback));
 }
 
 }  // namespace
 
-Cookies::Cookies(v8::Isolate* isolate,
-                 AtomBrowserContext* browser_context)
-      : request_context_getter_(browser_context->url_request_context_getter()),
-        cookie_delegate_(browser_context->cookie_delegate()) {
+Cookies::Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context)
+    : browser_context_(browser_context) {
   Init(isolate);
-  cookie_delegate_->AddObserver(this);
+  cookie_change_subscription_ =
+      browser_context_->cookie_change_notifier()->RegisterCookieChangeCallback(
+          base::Bind(&Cookies::OnCookieChanged, base::Unretained(this)));
 }
 
-Cookies::~Cookies() {
-  cookie_delegate_->RemoveObserver(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;
 }
 
-void Cookies::Get(const base::DictionaryValue& filter,
-                  const GetCallback& callback) {
-  std::unique_ptr<base::DictionaryValue> copied(filter.CreateDeepCopy());
-  auto getter = make_scoped_refptr(request_context_getter_);
-  content::BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(GetCookiesOnIO, getter, Passed(&copied), callback));
+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;
 }
 
-void Cookies::Remove(const GURL& url, const std::string& name,
-                     const base::Closure& callback) {
-  auto getter = make_scoped_refptr(request_context_getter_);
-  content::BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(RemoveCookieOnIOThread, getter, url, name, callback));
+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;
 }
 
-void Cookies::Set(const base::DictionaryValue& details,
-                  const SetCallback& callback) {
-  std::unique_ptr<base::DictionaryValue> copied(details.CreateDeepCopy());
-  auto getter = make_scoped_refptr(request_context_getter_);
-  content::BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(SetCookieOnIO, getter, Passed(&copied), callback));
+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::FlushStore(const base::Closure& callback) {
-  auto getter = make_scoped_refptr(request_context_getter_);
-  content::BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(FlushCookieStoreOnIOThread, getter, callback));
+void Cookies::OnCookieChanged(const CookieDetails* details) {
+  Emit("changed", *(details->cookie), details->cause, details->removed);
 }
 
-void Cookies::OnCookieChanged(const net::CanonicalCookie& cookie,
-                              bool removed,
-                              net::CookieStore::ChangeCause cause) {
-  Emit("changed", cookie, cause, removed);
-}
-
-
 // static
-mate::Handle<Cookies> Cookies::Create(
-    v8::Isolate* isolate,
-    AtomBrowserContext* browser_context) {
+mate::Handle<Cookies> Cookies::Create(v8::Isolate* isolate,
+                                      AtomBrowserContext* browser_context) {
   return mate::CreateHandle(isolate, new Cookies(isolate, browser_context));
 }
 

atom/browser/api/atom_api_cookies.h

@@ -5,11 +5,13 @@
 #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/atom_cookie_delegate.h"
-#include "base/callback.h"
+#include "atom/browser/net/cookie_details.h"
+#include "atom/common/promise_util.h"
+#include "base/callback_list.h"
 #include "native_mate/handle.h"
 #include "net/cookies/canonical_cookie.h"
 
@@ -27,17 +29,13 @@ class AtomBrowserContext;
 
 namespace api {
 
-class Cookies : public mate::TrackableObject<Cookies>,
-                public AtomCookieDelegate::Observer {
+class Cookies : public mate::TrackableObject<Cookies> {
  public:
   enum Error {
     SUCCESS,
     FAILED,
   };
 
-  using GetCallback = base::Callback<void(Error, const net::CookieList&)>;
-  using SetCallback = base::Callback<void(Error)>;
-
   static mate::Handle<Cookies> Create(v8::Isolate* isolate,
                                       AtomBrowserContext* browser_context);
 
@@ -49,20 +47,18 @@ class Cookies : public mate::TrackableObject<Cookies>,
   Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context);
   ~Cookies() override;
 
-  void Get(const base::DictionaryValue& filter, const GetCallback& callback);
-  void Remove(const GURL& url, const std::string& name,
-              const base::Closure& callback);
-  void Set(const base::DictionaryValue& details, const SetCallback& callback);
-  void FlushStore(const base::Closure& callback);
+  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();
 
-  // AtomCookieDelegate::Observer:
-  void OnCookieChanged(const net::CanonicalCookie& cookie,
-                       bool removed,
-                       net::CookieStore::ChangeCause cause) override;
+  // CookieChangeNotifier subscription:
+  void OnCookieChanged(const CookieDetails*);
 
  private:
-  net::URLRequestContextGetter* request_context_getter_;
-  scoped_refptr<AtomCookieDelegate> cookie_delegate_;
+  std::unique_ptr<base::CallbackList<void(const CookieDetails*)>::Subscription>
+      cookie_change_subscription_;
+  scoped_refptr<AtomBrowserContext> browser_context_;
 
   DISALLOW_COPY_AND_ASSIGN(Cookies);
 };

atom/browser/api/atom_api_debugger.cc

@@ -4,18 +4,17 @@
 
 #include "atom/browser/api/atom_api_debugger.h"
 
+#include <memory>
 #include <string>
+#include <utility>
 
-#include "atom/browser/atom_browser_main_parts.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/web_contents.h"
 #include "native_mate/dictionary.h"
-#include "native_mate/object_template_builder.h"
 
 #include "atom/common/node_includes.h"
 
@@ -26,25 +25,22 @@ namespace atom {
 namespace api {
 
 Debugger::Debugger(v8::Isolate* isolate, content::WebContents* web_contents)
-    : web_contents_(web_contents),
-      previous_request_id_(0) {
+    : content::WebContentsObserver(web_contents), web_contents_(web_contents) {
   Init(isolate);
 }
 
-Debugger::~Debugger() {
-}
+Debugger::~Debugger() {}
 
-void Debugger::AgentHostClosed(DevToolsAgentHost* agent_host,
-                               bool replaced_with_another_client) {
-  std::string detach_reason = "target closed";
-  if (replaced_with_another_client)
-    detach_reason = "replaced with devtools";
-  Emit("detach", detach_reason);
+void Debugger::AgentHostClosed(DevToolsAgentHost* agent_host) {
+  DCHECK(agent_host == agent_host_);
+  agent_host_ = nullptr;
+  ClearPendingRequests();
+  Emit("detach", "target closed");
 }
 
 void Debugger::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                        const std::string& message) {
-  DCHECK(agent_host == agent_host_.get());
+  DCHECK(agent_host == agent_host_);
 
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
@@ -65,20 +61,35 @@ void Debugger::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
       params.Swap(params_value);
     Emit("message", method, params);
   } else {
-    auto send_command_callback = pending_requests_[id];
-    pending_requests_.erase(id);
-    if (send_command_callback.is_null())
+    auto it = pending_requests_.find(id);
+    if (it == pending_requests_.end())
       return;
-    base::DictionaryValue* error_body = nullptr;
-    base::DictionaryValue error;
-    if (dict->GetDictionary("error", &error_body))
-      error.Swap(error_body);
 
-    base::DictionaryValue* result_body = nullptr;
-    base::DictionaryValue result;
-    if (dict->GetDictionary("result", &result_body))
-      result.Swap(result_body);
-    send_command_callback.Run(error, result);
+    atom::util::Promise promise = std::move(it->second);
+    pending_requests_.erase(it);
+
+    base::DictionaryValue* error = nullptr;
+    if (dict->GetDictionary("error", &error)) {
+      std::string message;
+      error->GetString("message", &message);
+      promise.RejectWithErrorMessage(message);
+    } else {
+      base::DictionaryValue* result_body = nullptr;
+      base::DictionaryValue result;
+      if (dict->GetDictionary("result", &result_body)) {
+        result.Swap(result_body);
+      }
+      promise.Resolve(result);
+    }
+  }
+}
+
+void Debugger::RenderFrameHostChanged(content::RenderFrameHost* old_rfh,
+                                      content::RenderFrameHost* new_rfh) {
+  if (agent_host_) {
+    agent_host_->DisconnectWebContents();
+    auto* web_contents = content::WebContents::FromRenderFrameHost(new_rfh);
+    agent_host_->ConnectWebContents(web_contents);
   }
 }
 
@@ -86,67 +97,79 @@ void Debugger::Attach(mate::Arguments* args) {
   std::string protocol_version;
   args->GetNext(&protocol_version);
 
+  if (agent_host_) {
+    args->ThrowError("Debugger is already attached to the target");
+    return;
+  }
+
   if (!protocol_version.empty() &&
       !DevToolsAgentHost::IsSupportedProtocolVersion(protocol_version)) {
     args->ThrowError("Requested protocol version is not supported");
     return;
   }
+
   agent_host_ = DevToolsAgentHost::GetOrCreateFor(web_contents_);
-  if (!agent_host_.get()) {
+  if (!agent_host_) {
     args->ThrowError("No target available");
     return;
   }
-  if (agent_host_->IsAttached()) {
-    args->ThrowError("Another debugger is already attached to this target");
-    return;
-  }
 
   agent_host_->AttachClient(this);
 }
 
 bool Debugger::IsAttached() {
-  return agent_host_.get() ? agent_host_->IsAttached() : false;
+  return agent_host_ && agent_host_->IsAttached();
 }
 
 void Debugger::Detach() {
-  if (!agent_host_.get())
+  if (!agent_host_)
     return;
   agent_host_->DetachClient(this);
-  AgentHostClosed(agent_host_.get(), false);
-  agent_host_ = nullptr;
+  AgentHostClosed(agent_host_.get());
 }
 
-void Debugger::SendCommand(mate::Arguments* args) {
-  if (!agent_host_.get())
-    return;
+v8::Local<v8::Promise> Debugger::SendCommand(mate::Arguments* args) {
+  atom::util::Promise promise(isolate());
+  v8::Local<v8::Promise> handle = promise.GetHandle();
+
+  if (!agent_host_) {
+    promise.RejectWithErrorMessage("No target available");
+    return handle;
+  }
 
   std::string method;
   if (!args->GetNext(&method)) {
-    args->ThrowError();
-    return;
+    promise.RejectWithErrorMessage("Invalid method");
+    return handle;
   }
+
   base::DictionaryValue command_params;
   args->GetNext(&command_params);
-  SendCommandCallback callback;
-  args->GetNext(&callback);
 
   base::DictionaryValue request;
   int request_id = ++previous_request_id_;
-  pending_requests_[request_id] = callback;
+  pending_requests_.emplace(request_id, std::move(promise));
   request.SetInteger("id", request_id);
   request.SetString("method", method);
   if (!command_params.empty())
-    request.Set("params", base::WrapUnique(command_params.DeepCopy()));
+    request.Set("params",
+                base::Value::ToUniquePtrValue(command_params.Clone()));
 
   std::string json_args;
   base::JSONWriter::Write(request, &json_args);
   agent_host_->DispatchProtocolMessage(this, json_args);
+
+  return handle;
+}
+
+void Debugger::ClearPendingRequests() {
+  for (auto& it : pending_requests_)
+    it.second.RejectWithErrorMessage("target closed while handling command");
 }
 
 // static
-mate::Handle<Debugger> Debugger::Create(
-    v8::Isolate* isolate,
-    content::WebContents* web_contents) {
+mate::Handle<Debugger> Debugger::Create(v8::Isolate* isolate,
+                                        content::WebContents* web_contents) {
   return mate::CreateHandle(isolate, new Debugger(isolate, web_contents));
 }
 
@@ -169,13 +192,17 @@ namespace {
 
 using atom::api::Debugger;
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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(isolate, exports)
-      .Set("Debugger", Debugger::GetConstructor(isolate)->GetFunction());
+      .Set("Debugger", Debugger::GetConstructor(isolate)
+                           ->GetFunction(context)
+                           .ToLocalChecked());
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_debugger, Initialize);
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_debugger, Initialize);

atom/browser/api/atom_api_debugger.h

@@ -9,15 +9,17 @@
 #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"
 
 namespace content {
 class DevToolsAgentHost;
 class WebContents;
-}
+}  // namespace content
 
 namespace mate {
 class Arguments;
@@ -27,15 +29,12 @@ namespace atom {
 
 namespace api {
 
-class Debugger: public mate::TrackableObject<Debugger>,
-                public content::DevToolsAgentHostClient {
+class Debugger : public mate::TrackableObject<Debugger>,
+                 public content::DevToolsAgentHostClient,
+                 public content::WebContentsObserver {
  public:
-  using SendCommandCallback =
-      base::Callback<void(const base::DictionaryValue&,
-                          const base::DictionaryValue&)>;
-
-  static mate::Handle<Debugger> Create(
-      v8::Isolate* isolate, content::WebContents* web_contents);
+  static mate::Handle<Debugger> Create(v8::Isolate* isolate,
+                                       content::WebContents* web_contents);
 
   // mate::TrackableObject:
   static void BuildPrototype(v8::Isolate* isolate,
@@ -46,24 +45,28 @@ class Debugger: public mate::TrackableObject<Debugger>,
   ~Debugger() override;
 
   // content::DevToolsAgentHostClient:
-  void AgentHostClosed(content::DevToolsAgentHost* agent_host,
-                       bool replaced_with_another_client) override;
+  void AgentHostClosed(content::DevToolsAgentHost* agent_host) override;
   void DispatchProtocolMessage(content::DevToolsAgentHost* agent_host,
                                const std::string& message) override;
 
+  // content::WebContentsObserver:
+  void RenderFrameHostChanged(content::RenderFrameHost* old_rfh,
+                              content::RenderFrameHost* new_rfh) override;
+
  private:
-  using PendingRequestMap = std::map<int, SendCommandCallback>;
+  using PendingRequestMap = std::map<int, atom::util::Promise>;
 
   void Attach(mate::Arguments* args);
   bool IsAttached();
   void Detach();
-  void SendCommand(mate::Arguments* args);
+  v8::Local<v8::Promise> SendCommand(mate::Arguments* args);
+  void ClearPendingRequests();
 
   content::WebContents* web_contents_;  // Weak Reference.
   scoped_refptr<content::DevToolsAgentHost> agent_host_;
 
   PendingRequestMap pending_requests_;
-  int previous_request_id_;
+  int previous_request_id_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };

atom/browser/api/atom_api_desktop_capturer.cc

@@ -4,32 +4,51 @@
 
 #include "atom/browser/api/atom_api_desktop_capturer.h"
 
-using base::PlatformThreadRef;
+#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 "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/media/desktop_media_list.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 "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"
 
+#if defined(OS_WIN)
+#include "third_party/webrtc/modules/desktop_capture/win/dxgi_duplicator_controller.h"
+#include "third_party/webrtc/modules/desktop_capture/win/screen_capturer_win_directx.h"
+#include "ui/display/win/display_info.h"
+#endif  // defined(OS_WIN)
+
 #include "atom/common/node_includes.h"
 
 namespace mate {
 
-template<>
-struct Converter<DesktopMediaList::Source> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const DesktopMediaList::Source& source) {
+template <>
+struct Converter<atom::api::DesktopCapturer::Source> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const atom::api::DesktopCapturer::Source& source) {
     mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    content::DesktopMediaID id = source.id;
-    dict.Set("name", base::UTF16ToUTF8(source.name));
+    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",
-        atom::api::NativeImage::Create(isolate, gfx::Image(source.thumbnail)));
+    dict.Set("thumbnail",
+             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",
+          atom::api::NativeImage::Create(
+              isolate, gfx::Image(GetWindowIcon(source.media_list_source.id))));
+    }
     return ConvertToV8(isolate, dict);
   }
 };
@@ -44,48 +63,138 @@ DesktopCapturer::DesktopCapturer(v8::Isolate* isolate) {
   Init(isolate);
 }
 
-DesktopCapturer::~DesktopCapturer() {
-}
+DesktopCapturer::~DesktopCapturer() {}
 
 void DesktopCapturer::StartHandling(bool capture_window,
                                     bool capture_screen,
-                                    const gfx::Size& thumbnail_size) {
-  webrtc::DesktopCaptureOptions options =
-    content::CreateDesktopCaptureOptions();
+                                    const gfx::Size& thumbnail_size,
+                                    bool fetch_window_icons) {
+  fetch_window_icons_ = fetch_window_icons;
+#if defined(OS_WIN)
+  if (content::desktop_capture::CreateDesktopCaptureOptions()
+          .allow_directx_capturer()) {
+    // DxgiDuplicatorController should be alive in this scope according to
+    // screen_capturer_win.cc.
+    auto duplicator = webrtc::DxgiDuplicatorController::Instance();
+    using_directx_capturer_ = webrtc::ScreenCapturerWinDirectx::IsSupported();
+  }
+#endif  // defined(OS_WIN)
 
-  std::unique_ptr<webrtc::DesktopCapturer> screen_capturer(
-      capture_screen ? webrtc::DesktopCapturer::CreateScreenCapturer(options)
-                     : nullptr);
-  std::unique_ptr<webrtc::DesktopCapturer> window_capturer(
-      capture_window ? webrtc::DesktopCapturer::CreateWindowCapturer(options)
-                     : nullptr);
-  media_list_.reset(new NativeDesktopMediaList(
-      std::move(screen_capturer), std::move(window_capturer)));
+  // clear any existing captured sources.
+  captured_sources_.clear();
 
-  media_list_->SetThumbnailSize(thumbnail_size);
-  media_list_->StartUpdating(this);
+  // Start listening for captured sources.
+  capture_window_ = capture_window;
+  capture_screen_ = capture_screen;
+
+  {
+    // Initialize the source list.
+    // Apply the new thumbnail size and restart capture.
+    if (capture_window) {
+      window_capturer_.reset(new NativeDesktopMediaList(
+          content::DesktopMediaID::TYPE_WINDOW,
+          content::desktop_capture::CreateWindowCapturer()));
+      window_capturer_->SetThumbnailSize(thumbnail_size);
+      window_capturer_->AddObserver(this);
+      window_capturer_->StartUpdating();
+    }
+
+    if (capture_screen) {
+      screen_capturer_.reset(new NativeDesktopMediaList(
+          content::DesktopMediaID::TYPE_SCREEN,
+          content::desktop_capture::CreateScreenCapturer()));
+      screen_capturer_->SetThumbnailSize(thumbnail_size);
+      screen_capturer_->AddObserver(this);
+      screen_capturer_->StartUpdating();
+    }
+  }
 }
 
-void DesktopCapturer::OnSourceAdded(int index) {
+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);
 }
 
-void DesktopCapturer::OnSourceRemoved(int index) {
-}
-
-void DesktopCapturer::OnSourceMoved(int old_index, int new_index) {
-}
-
-void DesktopCapturer::OnSourceNameChanged(int index) {
-}
-
-void DesktopCapturer::OnSourceThumbnailChanged(int index) {
-}
-
-bool DesktopCapturer::OnRefreshFinished() {
-  Emit("finished", media_list_->GetSources());
+bool DesktopCapturer::ShouldScheduleNextRefresh(DesktopMediaList* list) {
+  UpdateSourcesList(list);
   return false;
 }
 
+void DesktopCapturer::UpdateSourcesList(DesktopMediaList* list) {
+  std::vector<DesktopCapturer::Source> window_sources;
+  if (capture_window_ &&
+      list->GetMediaListType() == content::DesktopMediaID::TYPE_WINDOW) {
+    capture_window_ = false;
+    const auto& media_list_sources = list->GetSources();
+    for (const auto& media_list_source : media_list_sources) {
+      window_sources.emplace_back(DesktopCapturer::Source{
+          media_list_source, std::string(), fetch_window_icons_});
+    }
+    std::move(window_sources.begin(), window_sources.end(),
+              std::back_inserter(captured_sources_));
+  }
+
+  std::vector<DesktopCapturer::Source> screen_sources;
+  if (capture_screen_ &&
+      list->GetMediaListType() == content::DesktopMediaID::TYPE_SCREEN) {
+    capture_screen_ = false;
+    const auto& media_list_sources = list->GetSources();
+    for (const auto& media_list_source : media_list_sources) {
+      screen_sources.emplace_back(
+          DesktopCapturer::Source{media_list_source, std::string()});
+    }
+#if defined(OS_WIN)
+    // Gather the same unique screen IDs used by the electron.screen API in
+    // order to provide an association between it and
+    // desktopCapturer/getUserMedia. This is only required when using the
+    // DirectX capturer, otherwise the IDs across the APIs already match.
+    if (using_directx_capturer_) {
+      std::vector<std::string> device_names;
+      // Crucially, this list of device names will be in the same order as
+      // |media_list_sources|.
+      webrtc::DxgiDuplicatorController::Instance()->GetDeviceNames(
+          &device_names);
+      int device_name_index = 0;
+      for (auto& source : screen_sources) {
+        const auto& device_name = device_names[device_name_index++];
+        std::wstring wide_device_name;
+        base::UTF8ToWide(device_name.c_str(), device_name.size(),
+                         &wide_device_name);
+        const int64_t device_id =
+            display::win::DisplayInfo::DeviceIdFromDeviceName(
+                wide_device_name.c_str());
+        source.display_id = base::Int64ToString(device_id);
+      }
+    }
+#elif defined(OS_MACOSX)
+    // On Mac, the IDs across the APIs match.
+    for (auto& source : screen_sources) {
+      source.display_id = base::Int64ToString(source.media_list_source.id.id);
+    }
+#endif  // defined(OS_WIN)
+    // TODO(ajmacd): Add Linux support. The IDs across APIs differ but Chrome
+    // only supports capturing the entire desktop on Linux. Revisit this if
+    // individual screen support is added.
+    std::move(screen_sources.begin(), screen_sources.end(),
+              std::back_inserter(captured_sources_));
+  }
+
+  if (!capture_window_ && !capture_screen_)
+    Emit("finished", captured_sources_, fetch_window_icons_);
+}
+
 // static
 mate::Handle<DesktopCapturer> DesktopCapturer::Create(v8::Isolate* isolate) {
   return mate::CreateHandle(isolate, new DesktopCapturer(isolate));
@@ -93,7 +202,8 @@ mate::Handle<DesktopCapturer> DesktopCapturer::Create(v8::Isolate* isolate) {
 
 // static
 void DesktopCapturer::BuildPrototype(
-    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
+    v8::Isolate* isolate,
+    v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "DesktopCapturer"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("startHandling", &DesktopCapturer::StartHandling);
@@ -105,8 +215,10 @@ void DesktopCapturer::BuildPrototype(
 
 namespace {
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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.Set("desktopCapturer", atom::api::DesktopCapturer::Create(isolate));
@@ -114,4 +226,4 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_desktop_capturer, Initialize);
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_desktop_capturer, Initialize);

atom/browser/api/atom_api_desktop_capturer.h

@@ -5,18 +5,31 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_DESKTOP_CAPTURER_H_
 #define ATOM_BROWSER_API_ATOM_API_DESKTOP_CAPTURER_H_
 
-#include "atom/browser/api/event_emitter.h"
-#include "chrome/browser/media/desktop_media_list_observer.h"
-#include "chrome/browser/media/native_desktop_media_list.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 "native_mate/handle.h"
 
 namespace atom {
 
 namespace api {
 
-class DesktopCapturer: public mate::EventEmitter<DesktopCapturer>,
-                       public DesktopMediaListObserver {
+class DesktopCapturer : public mate::TrackableObject<DesktopCapturer>,
+                        public DesktopMediaListObserver {
  public:
+  struct Source {
+    DesktopMediaList::Source media_list_source;
+    // Will be an empty string if not available.
+    std::string display_id;
+
+    // Whether or not this source should provide an icon.
+    bool fetch_icon = false;
+  };
+
   static mate::Handle<DesktopCapturer> Create(v8::Isolate* isolate);
 
   static void BuildPrototype(v8::Isolate* isolate,
@@ -24,22 +37,36 @@ class DesktopCapturer: public mate::EventEmitter<DesktopCapturer>,
 
   void StartHandling(bool capture_window,
                      bool capture_screen,
-                     const gfx::Size& thumbnail_size);
+                     const gfx::Size& thumbnail_size,
+                     bool fetch_window_icons);
 
  protected:
   explicit DesktopCapturer(v8::Isolate* isolate);
   ~DesktopCapturer() override;
 
   // DesktopMediaListObserver overrides.
-  void OnSourceAdded(int index) override;
-  void OnSourceRemoved(int index) override;
-  void OnSourceMoved(int old_index, int new_index) override;
-  void OnSourceNameChanged(int index) override;
-  void OnSourceThumbnailChanged(int index) override;
-  bool OnRefreshFinished() override;
+  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;
+  void OnSourceUnchanged(DesktopMediaList* list) override;
+  bool ShouldScheduleNextRefresh(DesktopMediaList* list) override;
 
  private:
-  std::unique_ptr<DesktopMediaList> media_list_;
+  void UpdateSourcesList(DesktopMediaList* list);
+
+  std::unique_ptr<DesktopMediaList> window_capturer_;
+  std::unique_ptr<DesktopMediaList> screen_capturer_;
+  std::vector<DesktopCapturer::Source> captured_sources_;
+  bool capture_window_ = false;
+  bool capture_screen_ = false;
+  bool fetch_window_icons_ = false;
+#if defined(OS_WIN)
+  bool using_directx_capturer_ = false;
+#endif  // defined(OS_WIN)
 
   DISALLOW_COPY_AND_ASSIGN(DesktopCapturer);
 };

atom/browser/api/atom_api_dialog.cc

@@ -6,12 +6,13 @@
 #include <utility>
 #include <vector>
 
-#include "atom/browser/api/atom_api_window.h"
+#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"
@@ -19,50 +20,6 @@
 
 #include "atom/common/node_includes.h"
 
-namespace mate {
-
-template<>
-struct Converter<file_dialog::Filter> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     file_dialog::Filter* out) {
-    mate::Dictionary dict;
-    if (!ConvertFromV8(isolate, val, &dict))
-      return false;
-    if (!dict.Get("name", &(out->first)))
-      return false;
-    if (!dict.Get("extensions", &(out->second)))
-      return false;
-    return true;
-  }
-};
-
-template<>
-struct Converter<file_dialog::DialogSettings> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     file_dialog::DialogSettings* out) {
-    mate::Dictionary dict;
-    if (!ConvertFromV8(isolate, val, &dict))
-      return false;
-    dict.Get("window", &(out->parent_window));
-    dict.Get("title", &(out->title));
-    dict.Get("message", &(out->message));
-    dict.Get("buttonLabel", &(out->button_label));
-    dict.Get("nameFieldLabel", &(out->name_field_label));
-    dict.Get("defaultPath", &(out->default_path));
-    dict.Get("filters", &(out->filters));
-    dict.Get("properties", &(out->properties));
-    dict.Get("showsTagField", &(out->shows_tag_field));
-    #if defined(MAS_BUILD)
-    dict.Get("securityScopedBookmarks", &(out->security_scoped_bookmarks));
-    #endif
-    return true;
-  }
-};
-
-}  // namespace mate
-
 namespace {
 
 void ShowMessageBox(int type,
@@ -80,8 +37,7 @@ void ShowMessageBox(int type,
                     mate::Arguments* args) {
   v8::Local<v8::Value> peek = args->PeekNext();
   atom::MessageBoxCallback callback;
-  if (mate::Converter<atom::MessageBoxCallback>::FromV8(args->isolate(),
-                                                        peek,
+  if (mate::Converter<atom::MessageBoxCallback>::FromV8(args->isolate(), peek,
                                                         &callback)) {
     atom::ShowMessageBox(window, static_cast<atom::MessageBoxType>(type),
                          buttons, default_id, cancel_id, options, title,
@@ -99,9 +55,8 @@ void ShowOpenDialog(const file_dialog::DialogSettings& settings,
                     mate::Arguments* args) {
   v8::Local<v8::Value> peek = args->PeekNext();
   file_dialog::OpenDialogCallback callback;
-  if (mate::Converter<file_dialog::OpenDialogCallback>::FromV8(args->isolate(),
-                                                               peek,
-                                                               &callback)) {
+  if (mate::Converter<file_dialog::OpenDialogCallback>::FromV8(
+          args->isolate(), peek, &callback)) {
     file_dialog::ShowOpenDialog(settings, callback);
   } else {
     std::vector<base::FilePath> paths;
@@ -114,9 +69,8 @@ void ShowSaveDialog(const file_dialog::DialogSettings& settings,
                     mate::Arguments* args) {
   v8::Local<v8::Value> peek = args->PeekNext();
   file_dialog::SaveDialogCallback callback;
-  if (mate::Converter<file_dialog::SaveDialogCallback>::FromV8(args->isolate(),
-                                                               peek,
-                                                               &callback)) {
+  if (mate::Converter<file_dialog::SaveDialogCallback>::FromV8(
+          args->isolate(), peek, &callback)) {
     file_dialog::ShowSaveDialog(settings, callback);
   } else {
     base::FilePath path;
@@ -125,8 +79,10 @@ void ShowSaveDialog(const file_dialog::DialogSettings& settings,
   }
 }
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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("showMessageBox", &ShowMessageBox);
   dict.SetMethod("showErrorBox", &atom::ShowErrorBox);
@@ -140,4 +96,4 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_dialog, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_dialog, Initialize)

atom/browser/api/atom_api_download_item.cc

@@ -8,6 +8,7 @@
 
 #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 "base/strings/utf_string_conversions.h"
@@ -19,22 +20,23 @@
 
 namespace mate {
 
-template<>
-struct Converter<content::DownloadItem::DownloadState> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   content::DownloadItem::DownloadState state) {
+template <>
+struct Converter<download::DownloadItem::DownloadState> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      download::DownloadItem::DownloadState state) {
     std::string download_state;
     switch (state) {
-      case content::DownloadItem::IN_PROGRESS:
+      case download::DownloadItem::IN_PROGRESS:
         download_state = "progressing";
         break;
-      case content::DownloadItem::COMPLETE:
+      case download::DownloadItem::COMPLETE:
         download_state = "completed";
         break;
-      case content::DownloadItem::CANCELLED:
+      case download::DownloadItem::CANCELLED:
         download_state = "cancelled";
         break;
-      case content::DownloadItem::INTERRUPTED:
+      case download::DownloadItem::INTERRUPTED:
         download_state = "interrupted";
         break;
       default:
@@ -57,7 +59,7 @@ std::map<uint32_t, v8::Global<v8::Object>> g_download_item_objects;
 }  // namespace
 
 DownloadItem::DownloadItem(v8::Isolate* isolate,
-                           content::DownloadItem* download_item)
+                           download::DownloadItem* download_item)
     : download_item_(download_item) {
   download_item_->AddObserver(this);
   Init(isolate);
@@ -75,18 +77,18 @@ DownloadItem::~DownloadItem() {
   g_download_item_objects.erase(weak_map_id());
 }
 
-void DownloadItem::OnDownloadUpdated(content::DownloadItem* item) {
+void DownloadItem::OnDownloadUpdated(download::DownloadItem* item) {
   if (download_item_->IsDone()) {
     Emit("done", item->GetState());
     // Destroy the item once item is downloaded.
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, GetDestroyClosure());
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  GetDestroyClosure());
   } else {
     Emit("updated", item->GetState());
   }
 }
 
-void DownloadItem::OnDownloadDestroyed(content::DownloadItem* download_item) {
+void DownloadItem::OnDownloadDestroyed(download::DownloadItem* download_item) {
   download_item_ = nullptr;
   // Destroy the native class immediately when downloadItem is destroyed.
   delete this;
@@ -101,7 +103,7 @@ bool DownloadItem::IsPaused() const {
 }
 
 void DownloadItem::Resume() {
-  download_item_->Resume();
+  download_item_->Resume(true /* user_gesture */);
 }
 
 bool DownloadItem::CanResume() const {
@@ -129,12 +131,11 @@ bool DownloadItem::HasUserGesture() const {
 }
 
 std::string DownloadItem::GetFilename() const {
-  return base::UTF16ToUTF8(net::GenerateFileName(GetURL(),
-                           GetContentDisposition(),
-                           std::string(),
-                           download_item_->GetSuggestedFilename(),
-                           GetMimeType(),
-                           "download").LossyDisplayName());
+  return base::UTF16ToUTF8(
+      net::GenerateFileName(GetURL(), GetContentDisposition(), std::string(),
+                            download_item_->GetSuggestedFilename(),
+                            GetMimeType(), "download")
+          .LossyDisplayName());
 }
 
 std::string DownloadItem::GetContentDisposition() const {
@@ -149,7 +150,7 @@ const std::vector<GURL>& DownloadItem::GetURLChain() const {
   return download_item_->GetUrlChain();
 }
 
-content::DownloadItem::DownloadState DownloadItem::GetState() const {
+download::DownloadItem::DownloadState DownloadItem::GetState() const {
   return download_item_->GetState();
 }
 
@@ -165,6 +166,15 @@ base::FilePath DownloadItem::GetSavePath() const {
   return save_path_;
 }
 
+file_dialog::DialogSettings DownloadItem::GetSaveDialogOptions() const {
+  return dialog_options_;
+}
+
+void DownloadItem::SetSaveDialogOptions(
+    const file_dialog::DialogSettings& options) {
+  dialog_options_ = options;
+}
+
 std::string DownloadItem::GetLastModifiedTime() const {
   return download_item_->GetLastModifiedTime();
 }
@@ -200,15 +210,17 @@ void DownloadItem::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("isDone", &DownloadItem::IsDone)
       .SetMethod("setSavePath", &DownloadItem::SetSavePath)
       .SetMethod("getSavePath", &DownloadItem::GetSavePath)
+      .SetMethod("setSaveDialogOptions", &DownloadItem::SetSaveDialogOptions)
+      .SetMethod("getSaveDialogOptions", &DownloadItem::GetSaveDialogOptions)
       .SetMethod("getLastModifiedTime", &DownloadItem::GetLastModifiedTime)
       .SetMethod("getETag", &DownloadItem::GetETag)
       .SetMethod("getStartTime", &DownloadItem::GetStartTime);
 }
 
 // static
-mate::Handle<DownloadItem> DownloadItem::Create(
-    v8::Isolate* isolate, content::DownloadItem* item) {
-  auto existing = TrackableObject::FromWrappedClass(isolate, item);
+mate::Handle<DownloadItem> DownloadItem::Create(v8::Isolate* isolate,
+                                                download::DownloadItem* item) {
+  auto* existing = TrackableObject::FromWrappedClass(isolate, item);
   if (existing)
     return mate::CreateHandle(isolate, static_cast<DownloadItem*>(existing));
 
@@ -226,14 +238,17 @@ mate::Handle<DownloadItem> DownloadItem::Create(
 
 namespace {
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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(isolate, exports)
-      .Set("DownloadItem",
-           atom::api::DownloadItem::GetConstructor(isolate)->GetFunction());
+      .Set("DownloadItem", atom::api::DownloadItem::GetConstructor(isolate)
+                               ->GetFunction(context)
+                               .ToLocalChecked());
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_download_item, Initialize);
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_download_item, Initialize);

atom/browser/api/atom_api_download_item.h

@@ -9,8 +9,9 @@
 #include <vector>
 
 #include "atom/browser/api/trackable_object.h"
+#include "atom/browser/ui/file_dialog.h"
 #include "base/files/file_path.h"
-#include "content/public/browser/download_item.h"
+#include "components/download/public/common/download_item.h"
 #include "native_mate/handle.h"
 #include "url/gurl.h"
 
@@ -19,10 +20,10 @@ namespace atom {
 namespace api {
 
 class DownloadItem : public mate::TrackableObject<DownloadItem>,
-                     public content::DownloadItem::Observer {
+                     public download::DownloadItem::Observer {
  public:
   static mate::Handle<DownloadItem> Create(v8::Isolate* isolate,
-                                           content::DownloadItem* item);
+                                           download::DownloadItem* item);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
@@ -40,25 +41,28 @@ class DownloadItem : public mate::TrackableObject<DownloadItem>,
   std::string GetContentDisposition() const;
   const GURL& GetURL() const;
   const std::vector<GURL>& GetURLChain() const;
-  content::DownloadItem::DownloadState GetState() const;
+  download::DownloadItem::DownloadState GetState() const;
   bool IsDone() const;
   void SetSavePath(const base::FilePath& path);
   base::FilePath GetSavePath() const;
+  file_dialog::DialogSettings GetSaveDialogOptions() const;
+  void SetSaveDialogOptions(const file_dialog::DialogSettings& options);
   std::string GetLastModifiedTime() const;
   std::string GetETag() const;
   double GetStartTime() const;
 
  protected:
-  DownloadItem(v8::Isolate* isolate, content::DownloadItem* download_item);
-  ~DownloadItem();
+  DownloadItem(v8::Isolate* isolate, download::DownloadItem* download_item);
+  ~DownloadItem() override;
 
-  // Override content::DownloadItem::Observer methods
-  void OnDownloadUpdated(content::DownloadItem* download) override;
-  void OnDownloadDestroyed(content::DownloadItem* download) override;
+  // Override download::DownloadItem::Observer methods
+  void OnDownloadUpdated(download::DownloadItem* download) override;
+  void OnDownloadDestroyed(download::DownloadItem* download) override;
 
  private:
   base::FilePath save_path_;
-  content::DownloadItem* download_item_;
+  file_dialog::DialogSettings dialog_options_;
+  download::DownloadItem* download_item_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItem);
 };

atom/browser/api/atom_api_event.cc

@@ -0,0 +1,26 @@
+// 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/event_emitter.h"
+#include "atom/common/node_includes.h"
+#include "native_mate/dictionary.h"
+
+namespace {
+
+v8::Local<v8::Object> CreateWithSender(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> sender) {
+  return mate::internal::CreateJSEvent(isolate, sender, nullptr, nullptr);
+}
+
+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);
+}
+
+}  // namespace
+
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_event, Initialize)

atom/browser/api/atom_api_global_shortcut.cc

@@ -5,16 +5,46 @@
 #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 "base/stl_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "native_mate/dictionary.h"
 
 #include "atom/common/node_includes.h"
 
+#if defined(OS_MACOSX)
+#include "base/mac/mac_util.h"
+#endif
+
 using extensions::GlobalShortcutListener;
 
+namespace {
+
+#if defined(OS_MACOSX)
+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};
+
+    if (std::find(std::begin(mediaKeys), std::end(mediaKeys),
+                  accelerator.key_code()) != std::end(mediaKeys)) {
+      bool trusted =
+          atom::api::SystemPreferences::IsTrustedAccessibilityClient(false);
+      if (!trusted)
+        return true;
+    }
+  }
+  return false;
+}
+#endif
+
+}  // namespace
+
 namespace atom {
 
 namespace api {
@@ -31,17 +61,45 @@ 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, GlobalGlobalShortcutListener
-    // notifes us with wrong accelerator.
+    // notifies us with wrong accelerator.
     NOTREACHED();
     return;
   }
   accelerator_callback_map_[accelerator].Run();
 }
 
+bool GlobalShortcut::RegisterAll(
+    const std::vector<ui::Accelerator>& accelerators,
+    const base::Closure& callback) {
+  std::vector<ui::Accelerator> registered;
+
+  for (auto& accelerator : accelerators) {
+#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;
+}
+
 bool GlobalShortcut::Register(const ui::Accelerator& accelerator,
                               const base::Closure& callback) {
-  if (!GlobalShortcutListener::GetInstance()->RegisterAccelerator(
-      accelerator, this)) {
+#if defined(OS_MACOSX)
+  if (RegisteringMediaKeyForUntrustedClient(accelerator))
+    return false;
+#endif
+
+  if (!GlobalShortcutListener::GetInstance()->RegisterAccelerator(accelerator,
+                                                                  this)) {
     return false;
   }
 
@@ -54,8 +112,15 @@ void GlobalShortcut::Unregister(const ui::Accelerator& accelerator) {
     return;
 
   accelerator_callback_map_.erase(accelerator);
-  GlobalShortcutListener::GetInstance()->UnregisterAccelerator(
-      accelerator, this);
+  GlobalShortcutListener::GetInstance()->UnregisterAccelerator(accelerator,
+                                                               this);
+}
+
+void GlobalShortcut::UnregisterSome(
+    const std::vector<ui::Accelerator>& accelerators) {
+  for (auto& accelerator : accelerators) {
+    Unregister(accelerator);
+  }
 }
 
 bool GlobalShortcut::IsRegistered(const ui::Accelerator& accelerator) {
@@ -73,10 +138,11 @@ mate::Handle<GlobalShortcut> GlobalShortcut::Create(v8::Isolate* isolate) {
 }
 
 // static
-void GlobalShortcut::BuildPrototype(
-    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
+void GlobalShortcut::BuildPrototype(v8::Isolate* isolate,
+                                    v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "GlobalShortcut"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .SetMethod("registerAll", &GlobalShortcut::RegisterAll)
       .SetMethod("register", &GlobalShortcut::Register)
       .SetMethod("isRegistered", &GlobalShortcut::IsRegistered)
       .SetMethod("unregister", &GlobalShortcut::Unregister)
@@ -89,8 +155,10 @@ void GlobalShortcut::BuildPrototype(
 
 namespace {
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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.Set("globalShortcut", atom::api::GlobalShortcut::Create(isolate));
@@ -98,4 +166,4 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_global_shortcut, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_global_shortcut, Initialize)

atom/browser/api/atom_api_global_shortcut.h

@@ -7,6 +7,7 @@
 
 #include <map>
 #include <string>
+#include <vector>
 
 #include "atom/browser/api/trackable_object.h"
 #include "base/callback.h"
@@ -33,10 +34,13 @@ class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
  private:
   typedef std::map<ui::Accelerator, base::Closure> AcceleratorCallbackMap;
 
+  bool RegisterAll(const std::vector<ui::Accelerator>& accelerators,
+                   const base::Closure& callback);
   bool Register(const ui::Accelerator& accelerator,
                 const base::Closure& callback);
   bool IsRegistered(const ui::Accelerator& accelerator);
   void Unregister(const ui::Accelerator& accelerator);
+  void UnregisterSome(const std::vector<ui::Accelerator>& accelerators);
   void UnregisterAll();
 
   // GlobalShortcutListener::Observer implementation.

atom/browser/api/atom_api_in_app_purchase.cc

@@ -45,6 +45,29 @@ struct Converter<in_app_purchase::Transaction> {
   }
 };
 
+template <>
+struct Converter<in_app_purchase::Product> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const in_app_purchase::Product& val) {
+    mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+    dict.SetHidden("simple", true);
+    dict.Set("productIdentifier", val.productIdentifier);
+    dict.Set("localizedDescription", val.localizedDescription);
+    dict.Set("localizedTitle", val.localizedTitle);
+    dict.Set("contentVersion", val.localizedTitle);
+    dict.Set("contentLengths", val.contentLengths);
+
+    // Pricing Information
+    dict.Set("price", val.price);
+    dict.Set("formattedPrice", val.formattedPrice);
+
+    // Downloadable Content Information
+    dict.Set("isDownloadable", val.isDownloadable);
+
+    return dict.GetHandle();
+  }
+};
+
 }  // namespace mate
 
 namespace atom {
@@ -64,15 +87,19 @@ void InAppPurchase::BuildPrototype(v8::Isolate* isolate,
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("canMakePayments", &in_app_purchase::CanMakePayments)
       .SetMethod("getReceiptURL", &in_app_purchase::GetReceiptURL)
-      .SetMethod("purchaseProduct", &InAppPurchase::PurchaseProduct);
+      .SetMethod("purchaseProduct", &InAppPurchase::PurchaseProduct)
+      .SetMethod("finishAllTransactions",
+                 &in_app_purchase::FinishAllTransactions)
+      .SetMethod("finishTransactionByDate",
+                 &in_app_purchase::FinishTransactionByDate)
+      .SetMethod("getProducts", &in_app_purchase::GetProducts);
 }
 
 InAppPurchase::InAppPurchase(v8::Isolate* isolate) {
   Init(isolate);
 }
 
-InAppPurchase::~InAppPurchase() {
-}
+InAppPurchase::~InAppPurchase() {}
 
 void InAppPurchase::PurchaseProduct(const std::string& product_id,
                                     mate::Arguments* args) {
@@ -105,11 +132,12 @@ void Initialize(v8::Local<v8::Object> exports,
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("inAppPurchase", InAppPurchase::Create(isolate));
-  dict.Set("InAppPurchase",
-           InAppPurchase::GetConstructor(isolate)->GetFunction());
+  dict.Set("InAppPurchase", InAppPurchase::GetConstructor(isolate)
+                                ->GetFunction(context)
+                                .ToLocalChecked());
 #endif
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_in_app_purchase, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_in_app_purchase, Initialize)

atom/browser/api/atom_api_in_app_purchase.h

@@ -11,14 +11,15 @@
 #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 "native_mate/handle.h"
 
 namespace atom {
 
 namespace api {
 
-class InAppPurchase: public mate::EventEmitter<InAppPurchase>,
-                     public in_app_purchase::TransactionObserver {
+class InAppPurchase : public mate::EventEmitter<InAppPurchase>,
+                      public in_app_purchase::TransactionObserver {
  public:
   static mate::Handle<InAppPurchase> Create(v8::Isolate* isolate);
 

atom/browser/api/atom_api_menu.cc

@@ -4,10 +4,12 @@
 
 #include "atom/browser/api/atom_api_menu.h"
 
+#include <utility>
+
 #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/once_callback.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
@@ -20,8 +22,7 @@ namespace atom {
 namespace api {
 
 Menu::Menu(v8::Isolate* isolate, v8::Local<v8::Object> wrapper)
-    : model_(new AtomMenuModel(this)),
-      parent_(nullptr) {
+    : model_(new AtomMenuModel(this)) {
   InitWith(isolate, wrapper);
   model_->AddObserver(this);
 }
@@ -42,6 +43,8 @@ void Menu::AfterInit(v8::Isolate* isolate) {
   delegate.Get("isCommandIdEnabled", &is_enabled_);
   delegate.Get("isCommandIdVisible", &is_visible_);
   delegate.Get("getAcceleratorForCommandId", &get_accelerator_);
+  delegate.Get("shouldRegisterAcceleratorForCommandId",
+               &should_register_accelerator_);
   delegate.Get("executeCommand", &execute_command_);
   delegate.Get("menuWillShow", &menu_will_show_);
 }
@@ -70,28 +73,34 @@ bool Menu::GetAcceleratorForCommandIdWithParams(
     ui::Accelerator* accelerator) const {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  v8::Local<v8::Value> val = get_accelerator_.Run(
-      GetWrapper(), command_id, use_default_accelerator);
+  v8::Local<v8::Value> val =
+      get_accelerator_.Run(GetWrapper(), command_id, use_default_accelerator);
   return mate::ConvertFromV8(isolate(), val, accelerator);
 }
 
+bool Menu::ShouldRegisterAcceleratorForCommandId(int command_id) const {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  return should_register_accelerator_.Run(GetWrapper(), command_id);
+}
+
 void Menu::ExecuteCommand(int command_id, int flags) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  execute_command_.Run(
-      GetWrapper(),
-      mate::internal::CreateEventFromFlags(isolate(), flags),
-      command_id);
+  execute_command_.Run(GetWrapper(),
+                       mate::internal::CreateEventFromFlags(isolate(), flags),
+                       command_id);
 }
 
-void Menu::MenuWillShow(ui::SimpleMenuModel* source) {
+void Menu::OnMenuWillShow(ui::SimpleMenuModel* source) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
   menu_will_show_.Run(GetWrapper());
 }
 
-void Menu::InsertItemAt(
-    int index, int command_id, const base::string16& label) {
+void Menu::InsertItemAt(int index,
+                        int command_id,
+                        const base::string16& label) {
   model_->InsertItemAt(index, command_id, label);
 }
 
@@ -156,6 +165,12 @@ base::string16 Menu::GetSublabelAt(int index) const {
   return model_->GetSublabelAt(index);
 }
 
+base::string16 Menu::GetAcceleratorTextAt(int index) const {
+  ui::Accelerator accelerator;
+  model_->GetAcceleratorAtWithParams(index, true, &accelerator);
+  return accelerator.GetShortcutText();
+}
+
 bool Menu::IsItemCheckedAt(int index) const {
   return model_->IsItemCheckedAt(index);
 }
@@ -176,6 +191,16 @@ void Menu::OnMenuWillShow() {
   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) {
@@ -196,6 +221,7 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getCommandIdAt", &Menu::GetCommandIdAt)
       .SetMethod("getLabelAt", &Menu::GetLabelAt)
       .SetMethod("getSublabelAt", &Menu::GetSublabelAt)
+      .SetMethod("getAcceleratorTextAt", &Menu::GetAcceleratorTextAt)
       .SetMethod("isItemCheckedAt", &Menu::IsItemCheckedAt)
       .SetMethod("isEnabledAt", &Menu::IsEnabledAt)
       .SetMethod("isVisibleAt", &Menu::IsVisibleAt)
@@ -207,18 +233,21 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace atom
 
-
 namespace {
 
 using atom::api::Menu;
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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::Bind(&Menu::New));
 
   mate::Dictionary dict(isolate, exports);
-  dict.Set("Menu", Menu::GetConstructor(isolate)->GetFunction());
+  dict.Set(
+      "Menu",
+      Menu::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());
 #if defined(OS_MACOSX)
   dict.SetMethod("setApplicationMenu", &Menu::SetApplicationMenu);
   dict.SetMethod("sendActionToFirstResponder",
@@ -228,4 +257,4 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_menu, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_menu, Initialize)

atom/browser/api/atom_api_menu.h

@@ -8,9 +8,10 @@
 #include <memory>
 #include <string>
 
-#include "atom/browser/api/atom_api_window.h"
+#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 "atom/common/api/locker.h"
 #include "base/callback.h"
 
 namespace atom {
@@ -18,8 +19,8 @@ namespace atom {
 namespace api {
 
 class Menu : public mate::TrackableObject<Menu>,
-              public AtomMenuModel::Delegate,
-              public AtomMenuModel::Observer {
+             public AtomMenuModel::Delegate,
+             public AtomMenuModel::Observer {
  public:
   static mate::WrappableBase* New(mate::Arguments* args);
 
@@ -51,20 +52,29 @@ class Menu : public mate::TrackableObject<Menu>,
       int command_id,
       bool use_default_accelerator,
       ui::Accelerator* accelerator) const override;
+  bool ShouldRegisterAcceleratorForCommandId(int command_id) const override;
   void ExecuteCommand(int command_id, int event_flags) override;
-  void MenuWillShow(ui::SimpleMenuModel* source) override;
+  void OnMenuWillShow(ui::SimpleMenuModel* source) override;
 
-  virtual void PopupAt(Window* window, int x, int y, int positioning_item,
-                       const base::Closure& callback) = 0;
+  virtual void PopupAt(TopLevelWindow* window,
+                       int x,
+                       int y,
+                       int positioning_item,
+                       base::OnceClosure callback) = 0;
   virtual void ClosePopupAt(int32_t window_id) = 0;
 
   std::unique_ptr<AtomMenuModel> model_;
-  Menu* parent_;
+  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);
@@ -88,6 +98,7 @@ 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 GetAcceleratorTextAt(int index) const;
   bool IsItemCheckedAt(int index) const;
   bool IsEnabledAt(int index) const;
   bool IsVisibleAt(int index) const;
@@ -98,6 +109,7 @@ class Menu : public mate::TrackableObject<Menu>,
   base::Callback<bool(v8::Local<v8::Value>, int)> is_visible_;
   base::Callback<v8::Local<v8::Value>(v8::Local<v8::Value>, int, bool)>
       get_accelerator_;
+  base::Callback<bool(v8::Local<v8::Value>, int)> should_register_accelerator_;
   base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>, int)>
       execute_command_;
   base::Callback<void(v8::Local<v8::Value>)> menu_will_show_;
@@ -109,12 +121,12 @@ class Menu : public mate::TrackableObject<Menu>,
 
 }  // namespace atom
 
-
 namespace mate {
 
-template<>
+template <>
 struct Converter<atom::AtomMenuModel*> {
-  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
                      atom::AtomMenuModel** out) {
     // null would be tranfered to NULL.
     if (val->IsNull()) {

atom/browser/api/atom_api_menu_mac.h

@@ -21,21 +21,25 @@ namespace api {
 class MenuMac : public Menu {
  protected:
   MenuMac(v8::Isolate* isolate, v8::Local<v8::Object> wrapper);
+  ~MenuMac() override;
 
-  void PopupAt(Window* window, int x, int y, int positioning_item,
-               const base::Closure& callback) override;
+  void PopupAt(TopLevelWindow* window,
+               int x,
+               int y,
+               int positioning_item,
+               base::OnceClosure callback) override;
   void PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
                  int32_t window_id,
                  int x,
                  int y,
                  int positioning_item,
-                 base::Closure callback);
+                 base::OnceClosure callback);
   void ClosePopupAt(int32_t window_id) override;
 
  private:
   friend class Menu;
 
-  void OnClosed(int32_t window_id, base::Closure callback);
+  void OnClosed(int32_t window_id, base::OnceClosure callback);
 
   scoped_nsobject<AtomMenuController> menu_controller_;
 

atom/browser/api/atom_api_menu_mac.mm

@@ -9,8 +9,8 @@
 #include "base/mac/scoped_sending_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
-#include "brightray/browser/inspectable_web_contents.h"
-#include "brightray/browser/inspectable_web_contents_view.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"
 
@@ -18,25 +18,39 @@
 
 using content::BrowserThread;
 
+namespace {
+
+static scoped_nsobject<NSMenu> applicationMenu_;
+
+}  // namespace
+
 namespace atom {
 
 namespace api {
 
 MenuMac::MenuMac(v8::Isolate* isolate, v8::Local<v8::Object> wrapper)
-    : Menu(isolate, wrapper),
-      weak_factory_(this) {
-}
+    : Menu(isolate, wrapper), weak_factory_(this) {}
 
-void MenuMac::PopupAt(Window* window, int x, int y, int positioning_item,
-                      const base::Closure& callback) {
+MenuMac::~MenuMac() = default;
+
+void MenuMac::PopupAt(TopLevelWindow* window,
+                      int x,
+                      int y,
+                      int positioning_item,
+                      base::OnceClosure callback) {
   NativeWindow* native_window = window->window();
   if (!native_window)
     return;
 
-  auto popup = base::Bind(&MenuMac::PopupOnUI, weak_factory_.GetWeakPtr(),
-                          native_window->GetWeakPtr(), window->ID(), x, y,
-                          positioning_item, callback);
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, popup);
+  // 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::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI}, std::move(popup));
 }
 
 void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
@@ -44,21 +58,19 @@ void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
                         int x,
                         int y,
                         int positioning_item,
-                        base::Closure callback) {
+                        base::OnceClosure callback) {
   if (!native_window)
     return;
-  brightray::InspectableWebContents* web_contents =
-      native_window->inspectable_web_contents();
-  if (!web_contents)
-    return;
+  NSWindow* nswindow = native_window->GetNativeWindow().GetNativeNSWindow();
 
-  auto close_callback = base::Bind(
-      &MenuMac::OnClosed, weak_factory_.GetWeakPtr(), window_id, callback);
+  base::OnceClosure close_callback =
+      base::BindOnce(&MenuMac::OnClosed, weak_factory_.GetWeakPtr(), window_id,
+                     std::move(callback));
   popup_controllers_[window_id] = base::scoped_nsobject<AtomMenuController>(
       [[AtomMenuController alloc] initWithModel:model()
                           useDefaultAccelerator:NO]);
   NSMenu* menu = [popup_controllers_[window_id] menu];
-  NSView* view = web_contents->GetView()->GetNativeView();
+  NSView* view = [nswindow contentView];
 
   // Which menu item to show.
   NSMenuItem* item = nil;
@@ -68,7 +80,6 @@ void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
   // (-1, -1) means showing on mouse location.
   NSPoint position;
   if (x == -1 || y == -1) {
-    NSWindow* nswindow = native_window->GetNativeWindow();
     position = [view convertPoint:[nswindow mouseLocationOutsideOfEventStream]
                          fromView:nil];
   } else {
@@ -92,10 +103,9 @@ void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
   if (rightmostMenuPoint > screenRight)
     position.x = position.x - [menu size].width;
 
-  [popup_controllers_[window_id] setCloseCallback:close_callback];
+  [popup_controllers_[window_id] setCloseCallback:std::move(close_callback)];
   // Make sure events can be pumped while the menu is up.
-  base::MessageLoop::ScopedNestableTaskAllower allow(
-      base::MessageLoop::current());
+  base::MessageLoopCurrent::ScopedNestableTaskAllower allow;
 
   // One of the events that could be pumped is |window.close()|.
   // User-initiated event-tracking loops protect against this by
@@ -124,9 +134,9 @@ void MenuMac::ClosePopupAt(int32_t window_id) {
   }
 }
 
-void MenuMac::OnClosed(int32_t window_id, base::Closure callback) {
+void MenuMac::OnClosed(int32_t window_id, base::OnceClosure callback) {
   popup_controllers_.erase(window_id);
-  callback.Run();
+  std::move(callback).Run();
 }
 
 // static
@@ -135,7 +145,18 @@ void Menu::SetApplicationMenu(Menu* base_menu) {
   base::scoped_nsobject<AtomMenuController> menu_controller(
       [[AtomMenuController alloc] initWithModel:menu->model_.get()
                           useDefaultAccelerator:YES]);
-  [NSApp setMainMenu:[menu_controller menu]];
+
+  NSRunLoop* currentRunLoop = [NSRunLoop currentRunLoop];
+  [currentRunLoop cancelPerformSelector:@selector(setMainMenu:)
+                                 target:NSApp
+                               argument:applicationMenu_];
+  applicationMenu_.reset([[menu_controller menu] retain]);
+  [[NSRunLoop currentRunLoop]
+      performSelector:@selector(setMainMenu:)
+               target:NSApp
+             argument:applicationMenu_
+                order:0
+                modes:[NSArray arrayWithObject:NSDefaultRunLoopMode]];
 
   // Ensure the menu_controller_ is destroyed after main menu is set.
   menu_controller.swap(menu->menu_controller_);

atom/browser/api/atom_api_menu_views.cc

@@ -4,10 +4,11 @@
 
 #include "atom/browser/api/atom_api_menu_views.h"
 
+#include <memory>
+#include <utility>
+
 #include "atom/browser/native_window_views.h"
 #include "atom/browser/unresponsive_suppressor.h"
-#include "brightray/browser/inspectable_web_contents.h"
-#include "brightray/browser/inspectable_web_contents_view.h"
 #include "ui/display/screen.h"
 
 using views::MenuRunner;
@@ -17,26 +18,25 @@ namespace atom {
 namespace api {
 
 MenuViews::MenuViews(v8::Isolate* isolate, v8::Local<v8::Object> wrapper)
-    : Menu(isolate, wrapper),
-      weak_factory_(this) {
-}
+    : Menu(isolate, wrapper), weak_factory_(this) {}
 
-void MenuViews::PopupAt(Window* window, int x, int y, int positioning_item,
-                        const base::Closure& callback) {
-  NativeWindow* native_window = static_cast<NativeWindow*>(window->window());
+MenuViews::~MenuViews() = default;
+
+void MenuViews::PopupAt(TopLevelWindow* window,
+                        int x,
+                        int y,
+                        int positioning_item,
+                        base::OnceClosure callback) {
+  auto* native_window = static_cast<NativeWindowViews*>(window->window());
   if (!native_window)
     return;
-  auto* web_contents = native_window->inspectable_web_contents();
-  if (!web_contents)
-    return;
 
   // (-1, -1) means showing on mouse location.
   gfx::Point location;
   if (x == -1 || y == -1) {
     location = display::Screen::GetScreen()->GetCursorScreenPoint();
   } else {
-    auto* view = web_contents->GetView()->GetWebView();
-    gfx::Point origin = view->bounds().origin();
+    gfx::Point origin = native_window->GetContentBounds().origin();
     location = gfx::Point(origin.x() + x, origin.y() + y);
   }
 
@@ -45,18 +45,24 @@ void MenuViews::PopupAt(Window* window, int x, int y, int positioning_item,
   // Don't emit unresponsive event when showing menu.
   atom::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));
+
   // Show the menu.
-  int32_t window_id = window->ID();
-  auto close_callback = base::Bind(
-      &MenuViews::OnClosed, weak_factory_.GetWeakPtr(), window_id, callback);
-  menu_runners_[window_id] = std::unique_ptr<MenuRunner>(new MenuRunner(
-      model(), flags, close_callback));
+  //
+  // 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)));
+  menu_runners_[window_id] =
+      std::make_unique<MenuRunner>(model(), flags, std::move(close_callback));
   menu_runners_[window_id]->RunMenuAt(
-      static_cast<NativeWindowViews*>(window->window())->widget(),
-      NULL,
-      gfx::Rect(location, gfx::Size()),
-      views::MENU_ANCHOR_TOPLEFT,
-      ui::MENU_SOURCE_MOUSE);
+      native_window->widget(), NULL, gfx::Rect(location, gfx::Size()),
+      views::MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_MOUSE);
 }
 
 void MenuViews::ClosePopupAt(int32_t window_id) {
@@ -73,9 +79,9 @@ void MenuViews::ClosePopupAt(int32_t window_id) {
   }
 }
 
-void MenuViews::OnClosed(int32_t window_id, base::Closure callback) {
+void MenuViews::OnClosed(int32_t window_id, base::OnceClosure callback) {
   menu_runners_.erase(window_id);
-  callback.Run();
+  std::move(callback).Run();
 }
 
 // static

atom/browser/api/atom_api_menu_views.h

@@ -6,6 +6,7 @@
 #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"
@@ -19,14 +20,18 @@ namespace api {
 class MenuViews : public Menu {
  public:
   MenuViews(v8::Isolate* isolate, v8::Local<v8::Object> wrapper);
+  ~MenuViews() override;
 
  protected:
-  void PopupAt(Window* window, int x, int y, int positioning_item,
-               const base::Closure& callback) override;
+  void PopupAt(TopLevelWindow* window,
+               int x,
+               int y,
+               int positioning_item,
+               base::OnceClosure callback) override;
   void ClosePopupAt(int32_t window_id) override;
 
  private:
-  void OnClosed(int32_t window_id, base::Closure callback);
+  void OnClosed(int32_t window_id, base::OnceClosure callback);
 
   // window ID -> open context menu
   std::map<int32_t, std::unique_ptr<views::MenuRunner>> menu_runners_;

atom/browser/api/atom_api_net.cc

@@ -31,7 +31,9 @@ void Net::BuildPrototype(v8::Isolate* isolate,
 }
 
 v8::Local<v8::Value> Net::URLRequest(v8::Isolate* isolate) {
-  return URLRequest::GetConstructor(isolate)->GetFunction();
+  return URLRequest::GetConstructor(isolate)
+      ->GetFunction(isolate->GetCurrentContext())
+      .ToLocalChecked();
 }
 
 }  // namespace api
@@ -53,9 +55,10 @@ void Initialize(v8::Local<v8::Object> exports,
 
   mate::Dictionary dict(isolate, exports);
   dict.Set("net", Net::Create(isolate));
-  dict.Set("Net", Net::GetConstructor(isolate)->GetFunction());
+  dict.Set("Net",
+           Net::GetConstructor(isolate)->GetFunction(context).ToLocalChecked());
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_net, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_net, Initialize)

atom/browser/api/atom_api_net_log.cc

@@ -0,0 +1,139 @@
+// 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 "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"
+
+#include "atom/common/node_includes.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();
+}
+
+void NetLog::StopLogging(mate::Arguments* args) {
+  net_log::NetExportFileWriter::FilePathCallback callback;
+  if (!args->GetNext(&callback)) {
+    args->ThrowError("Invalid callback function");
+    return;
+  }
+
+  if (IsCurrentlyLogging()) {
+    stop_callback_queue_.emplace_back(callback);
+    net_log_writer_->StopNetLog(nullptr);
+  } else {
+    callback.Run(base::FilePath());
+  }
+}
+
+void NetLog::OnNewState(const base::DictionaryValue& state) {
+  net_log_state_ = state.CreateDeepCopy();
+
+  if (stop_callback_queue_.empty())
+    return;
+
+  if (GetLoggingState() == "NOT_LOGGING") {
+    for (auto& callback : stop_callback_queue_) {
+      if (!callback.is_null())
+        net_log_writer_->GetFilePathToCompletedLog(callback);
+    }
+    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 "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;
+  void 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<net_log::NetExportFileWriter::FilePathCallback>
+      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

@@ -5,12 +5,13 @@
 #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 "base/guid.h"
 #include "base/strings/utf_string_conversions.h"
-#include "brightray/browser/browser_client.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
@@ -20,10 +21,11 @@
 #include "atom/common/node_includes.h"
 
 namespace mate {
-template<>
-struct Converter<brightray::NotificationAction> {
-  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
-                      brightray::NotificationAction* out) {
+template <>
+struct Converter<atom::NotificationAction> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     atom::NotificationAction* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
       return false;
@@ -36,7 +38,7 @@ struct Converter<brightray::NotificationAction> {
   }
 
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                    brightray::NotificationAction val) {
+                                   atom::NotificationAction val) {
     mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
     dict.Set("text", val.text);
     dict.Set("type", val.type);
@@ -54,7 +56,8 @@ Notification::Notification(v8::Isolate* isolate,
                            mate::Arguments* args) {
   InitWith(isolate, wrapper);
 
-  presenter_ = brightray::BrowserClient::Get()->GetNotificationPresenter();
+  presenter_ = static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())
+                   ->GetNotificationPresenter();
 
   mate::Dictionary opts;
   if (args->GetNext(&opts)) {
@@ -117,7 +120,7 @@ base::string16 Notification::GetSound() const {
   return sound_;
 }
 
-std::vector<brightray::NotificationAction> Notification::GetActions() const {
+std::vector<atom::NotificationAction> Notification::GetActions() const {
   return actions_;
 }
 
@@ -155,7 +158,7 @@ void Notification::SetSound(const base::string16& new_sound) {
 }
 
 void Notification::SetActions(
-  const std::vector<brightray::NotificationAction>& actions) {
+    const std::vector<atom::NotificationAction>& actions) {
   actions_ = actions;
 }
 
@@ -179,8 +182,7 @@ void Notification::NotificationDisplayed() {
   Emit("show");
 }
 
-void Notification::NotificationDestroyed() {
-}
+void Notification::NotificationDestroyed() {}
 
 void Notification::NotificationClosed() {
   Emit("close");
@@ -197,9 +199,9 @@ void Notification::Close() {
 void Notification::Show() {
   Close();
   if (presenter_) {
-    notification_ = presenter_->CreateNotification(this);
+    notification_ = presenter_->CreateNotification(this, base::GenerateGUID());
     if (notification_) {
-      brightray::NotificationOptions options;
+      atom::NotificationOptions options;
       options.title = title_;
       options.subtitle = subtitle_;
       options.msg = body_;
@@ -217,7 +219,8 @@ void Notification::Show() {
 }
 
 bool Notification::IsSupported() {
-  return !!brightray::BrowserClient::Get()->GetNotificationPresenter();
+  return !!static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())
+               ->GetNotificationPresenter();
 }
 
 // static
@@ -232,14 +235,12 @@ void Notification::BuildPrototype(v8::Isolate* isolate,
       .SetProperty("subtitle", &Notification::GetSubtitle,
                    &Notification::SetSubtitle)
       .SetProperty("body", &Notification::GetBody, &Notification::SetBody)
-      .SetProperty("silent", &Notification::GetSilent,
-                   &Notification::SetSilent)
+      .SetProperty("silent", &Notification::GetSilent, &Notification::SetSilent)
       .SetProperty("hasReply", &Notification::GetHasReply,
                    &Notification::SetHasReply)
       .SetProperty("replyPlaceholder", &Notification::GetReplyPlaceholder,
                    &Notification::SetReplyPlaceholder)
-      .SetProperty("sound", &Notification::GetSound,
-                   &Notification::SetSound)
+      .SetProperty("sound", &Notification::GetSound, &Notification::SetSound)
       .SetProperty("actions", &Notification::GetActions,
                    &Notification::SetActions)
       .SetProperty("closeButtonText", &Notification::GetCloseButtonText,
@@ -262,12 +263,13 @@ void Initialize(v8::Local<v8::Object> exports,
   Notification::SetConstructor(isolate, base::Bind(&Notification::New));
 
   mate::Dictionary dict(isolate, exports);
-  dict.Set("Notification",
-           Notification::GetConstructor(isolate)->GetFunction());
+  dict.Set("Notification", Notification::GetConstructor(isolate)
+                               ->GetFunction(context)
+                               .ToLocalChecked());
 
   dict.SetMethod("isSupported", &Notification::IsSupported);
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_notification, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_common_notification, Initialize)

atom/browser/api/atom_api_notification.h

@@ -10,10 +10,10 @@
 #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 "brightray/browser/notification.h"
-#include "brightray/browser/notification_delegate.h"
-#include "brightray/browser/notification_presenter.h"
 #include "native_mate/handle.h"
 #include "ui/gfx/image/image.h"
 
@@ -22,7 +22,7 @@ namespace atom {
 namespace api {
 
 class Notification : public mate::TrackableObject<Notification>,
-                     public brightray::NotificationDelegate {
+                     public NotificationDelegate {
  public:
   static mate::WrappableBase* New(mate::Arguments* args);
   static bool IsSupported();
@@ -55,7 +55,7 @@ class Notification : public mate::TrackableObject<Notification>,
   bool GetHasReply() const;
   base::string16 GetReplyPlaceholder() const;
   base::string16 GetSound() const;
-  std::vector<brightray::NotificationAction> GetActions() const;
+  std::vector<atom::NotificationAction> GetActions() const;
   base::string16 GetCloseButtonText() const;
 
   // Prop Setters
@@ -66,7 +66,7 @@ class Notification : public mate::TrackableObject<Notification>,
   void SetHasReply(bool new_has_reply);
   void SetReplyPlaceholder(const base::string16& new_reply_placeholder);
   void SetSound(const base::string16& sound);
-  void SetActions(const std::vector<brightray::NotificationAction>& actions);
+  void SetActions(const std::vector<atom::NotificationAction>& actions);
   void SetCloseButtonText(const base::string16& text);
 
  private:
@@ -80,12 +80,12 @@ class Notification : public mate::TrackableObject<Notification>,
   bool has_reply_ = false;
   base::string16 reply_placeholder_;
   base::string16 sound_;
-  std::vector<brightray::NotificationAction> actions_;
+  std::vector<atom::NotificationAction> actions_;
   base::string16 close_button_text_;
 
-  brightray::NotificationPresenter* presenter_;
+  atom::NotificationPresenter* presenter_;
 
-  base::WeakPtr<brightray::Notification> notification_;
+  base::WeakPtr<atom::Notification> notification_;
 
   DISALLOW_COPY_AND_ASSIGN(Notification);
 };

atom/browser/api/atom_api_power_monitor.cc

@@ -5,26 +5,50 @@
 #include "atom/browser/api/atom_api_power_monitor.h"
 
 #include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/callback.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "native_mate/dictionary.h"
 
 #include "atom/common/node_includes.h"
 
+namespace mate {
+template <>
+struct Converter<ui::IdleState> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const ui::IdleState& in) {
+    switch (in) {
+      case ui::IDLE_STATE_ACTIVE:
+        return mate::StringToV8(isolate, "active");
+      case ui::IDLE_STATE_IDLE:
+        return mate::StringToV8(isolate, "idle");
+      case ui::IDLE_STATE_LOCKED:
+        return mate::StringToV8(isolate, "locked");
+      case ui::IDLE_STATE_UNKNOWN:
+      default:
+        return mate::StringToV8(isolate, "unknown");
+    }
+  }
+};
+}  // namespace mate
+
 namespace atom {
 
 namespace api {
 
 PowerMonitor::PowerMonitor(v8::Isolate* isolate) {
 #if defined(OS_LINUX)
-  SetShutdownHandler(base::Bind(&PowerMonitor::ShouldShutdown,
-                                base::Unretained(this)));
+  SetShutdownHandler(
+      base::Bind(&PowerMonitor::ShouldShutdown, base::Unretained(this)));
 #elif defined(OS_MACOSX)
-  Browser::Get()->SetShutdownHandler(base::Bind(&PowerMonitor::ShouldShutdown,
-                                                base::Unretained(this)));
+  Browser::Get()->SetShutdownHandler(
+      base::Bind(&PowerMonitor::ShouldShutdown, base::Unretained(this)));
 #endif
   base::PowerMonitor::Get()->AddObserver(this);
   Init(isolate);
+#if defined(OS_MACOSX) || defined(OS_WIN)
+  InitPlatformSpecificMonitors();
+#endif
 }
 
 PowerMonitor::~PowerMonitor() {
@@ -60,6 +84,21 @@ void PowerMonitor::OnResume() {
   Emit("resume");
 }
 
+ui::IdleState PowerMonitor::QuerySystemIdleState(v8::Isolate* isolate,
+                                                 int idle_threshold) {
+  if (idle_threshold > 0) {
+    return ui::CalculateIdleState(idle_threshold);
+  } else {
+    isolate->ThrowException(v8::Exception::TypeError(mate::StringToV8(
+        isolate, "Invalid idle threshold, must be greater than 0")));
+    return ui::IDLE_STATE_UNKNOWN;
+  }
+}
+
+int PowerMonitor::QuerySystemIdleTime() {
+  return ui::CalculateIdleTime();
+}
+
 // static
 v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
@@ -73,34 +112,40 @@ v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
 }
 
 // static
-void PowerMonitor::BuildPrototype(
-    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
+void PowerMonitor::BuildPrototype(v8::Isolate* isolate,
+                                  v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "PowerMonitor"));
-#if defined(OS_LINUX)
+
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
+#if defined(OS_LINUX)
       .SetMethod("blockShutdown", &PowerMonitor::BlockShutdown)
-      .SetMethod("unblockShutdown", &PowerMonitor::UnblockShutdown);
+      .SetMethod("unblockShutdown", &PowerMonitor::UnblockShutdown)
 #endif
+      .SetMethod("_querySystemIdleState", &PowerMonitor::QuerySystemIdleState)
+      .SetMethod("_querySystemIdleTime", &PowerMonitor::QuerySystemIdleTime);
 }
 
 }  // namespace api
 
 }  // namespace atom
 
-
 namespace {
 
 using atom::api::PowerMonitor;
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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.Set("powerMonitor", PowerMonitor::Create(isolate));
-  dict.Set("PowerMonitor",
-           PowerMonitor::GetConstructor(isolate)->GetFunction());
+  dict.Set("PowerMonitor", PowerMonitor::GetConstructor(isolate)
+                               ->GetFunction(context)
+                               .ToLocalChecked());
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_power_monitor, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_power_monitor, Initialize)

atom/browser/api/atom_api_power_monitor.h

@@ -9,6 +9,7 @@
 #include "atom/browser/lib/power_observer.h"
 #include "base/compiler_specific.h"
 #include "native_mate/handle.h"
+#include "ui/base/idle/idle.h"
 
 namespace atom {
 
@@ -35,12 +36,41 @@ class PowerMonitor : public mate::TrackableObject<PowerMonitor>,
   void UnblockShutdown();
 #endif
 
+#if defined(OS_MACOSX) || defined(OS_WIN)
+  void InitPlatformSpecificMonitors();
+#endif
+
   // base::PowerObserver implementations:
   void OnPowerStateChange(bool on_battery_power) override;
   void OnSuspend() override;
   void OnResume() override;
 
  private:
+  ui::IdleState QuerySystemIdleState(v8::Isolate* isolate, int idle_threshold);
+  int QuerySystemIdleTime();
+
+#if defined(OS_WIN)
+  // Static callback invoked when a message comes in to our messaging window.
+  static LRESULT CALLBACK WndProcStatic(HWND hwnd,
+                                        UINT message,
+                                        WPARAM wparam,
+                                        LPARAM lparam);
+
+  LRESULT CALLBACK WndProc(HWND hwnd,
+                           UINT message,
+                           WPARAM wparam,
+                           LPARAM lparam);
+
+  // The window class of |window_|.
+  ATOM atom_;
+
+  // The handle of the module that contains the window procedure of |window_|.
+  HMODULE instance_;
+
+  // The window used for processing events.
+  HWND window_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
 };
 

atom/browser/api/atom_api_power_monitor_mac.mm

@@ -0,0 +1,74 @@
+// 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_power_monitor.h"
+
+#include <ApplicationServices/ApplicationServices.h>
+#import <Cocoa/Cocoa.h>
+
+@interface MacLockMonitor : NSObject {
+ @private
+  std::vector<atom::api::PowerMonitor*> emitters;
+}
+
+- (void)addEmitter:(atom::api::PowerMonitor*)monitor_;
+
+@end
+
+@implementation MacLockMonitor
+
+- (id)init {
+  if ((self = [super init])) {
+    NSDistributedNotificationCenter* distCenter =
+        [NSDistributedNotificationCenter defaultCenter];
+    [distCenter addObserver:self
+                   selector:@selector(onScreenLocked:)
+                       name:@"com.apple.screenIsLocked"
+                     object:nil];
+    [distCenter addObserver:self
+                   selector:@selector(onScreenUnlocked:)
+                       name:@"com.apple.screenIsUnlocked"
+                     object:nil];
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [[NSDistributedNotificationCenter defaultCenter] removeObserver:self];
+  [super dealloc];
+}
+
+- (void)addEmitter:(atom::api::PowerMonitor*)monitor_ {
+  self->emitters.push_back(monitor_);
+}
+
+- (void)onScreenLocked:(NSNotification*)notification {
+  for (auto*& emitter : self->emitters) {
+    emitter->Emit("lock-screen");
+  }
+}
+
+- (void)onScreenUnlocked:(NSNotification*)notification {
+  for (auto*& emitter : self->emitters) {
+    emitter->Emit("unlock-screen");
+  }
+}
+
+@end
+
+namespace atom {
+
+namespace api {
+
+static MacLockMonitor* g_lock_monitor = nil;
+
+void PowerMonitor::InitPlatformSpecificMonitors() {
+  if (!g_lock_monitor)
+    g_lock_monitor = [[MacLockMonitor alloc] init];
+  [g_lock_monitor addEmitter:this];
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_power_monitor_win.cc

@@ -0,0 +1,72 @@
+// 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_power_monitor.h"
+
+#include <windows.h>
+#include <wtsapi32.h>
+
+#include "base/win/wrapped_window_proc.h"
+#include "ui/base/win/shell.h"
+#include "ui/gfx/win/hwnd_util.h"
+
+namespace atom {
+
+namespace {
+
+const wchar_t kPowerMonitorWindowClass[] = L"Electron_PowerMonitorHostWindow";
+
+}  // namespace
+
+namespace api {
+
+void PowerMonitor::InitPlatformSpecificMonitors() {
+  WNDCLASSEX window_class;
+  base::win::InitializeWindowClass(
+      kPowerMonitorWindowClass,
+      &base::win::WrappedWindowProc<PowerMonitor::WndProcStatic>, 0, 0, 0, NULL,
+      NULL, NULL, NULL, NULL, &window_class);
+  instance_ = window_class.hInstance;
+  atom_ = RegisterClassEx(&window_class);
+
+  // Create an offscreen window for receiving broadcast messages for the
+  // session lock and unlock events.
+  window_ = CreateWindow(MAKEINTATOM(atom_), 0, 0, 0, 0, 0, 0, HWND_MESSAGE, 0,
+                         instance_, 0);
+  gfx::CheckWindowCreated(window_);
+  gfx::SetWindowUserData(window_, this);
+
+  // Tel windows we want to be notified with session events
+  WTSRegisterSessionNotification(window_, NOTIFY_FOR_THIS_SESSION);
+}
+
+LRESULT CALLBACK PowerMonitor::WndProcStatic(HWND hwnd,
+                                             UINT message,
+                                             WPARAM wparam,
+                                             LPARAM lparam) {
+  PowerMonitor* msg_wnd =
+      reinterpret_cast<PowerMonitor*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
+  if (msg_wnd)
+    return msg_wnd->WndProc(hwnd, message, wparam, lparam);
+  else
+    return ::DefWindowProc(hwnd, message, wparam, lparam);
+}
+
+LRESULT CALLBACK PowerMonitor::WndProc(HWND hwnd,
+                                       UINT message,
+                                       WPARAM wparam,
+                                       LPARAM lparam) {
+  if (message == WM_WTSSESSION_CHANGE) {
+    if (wparam == WTS_SESSION_LOCK) {
+      Emit("lock-screen");
+    } else if (wparam == WTS_SESSION_UNLOCK) {
+      Emit("unlock-screen");
+    }
+  }
+  return ::DefWindowProc(hwnd, message, wparam, lparam);
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_power_save_blocker.cc

@@ -6,28 +6,30 @@
 
 #include <string>
 
-#include "content/public/browser/browser_thread.h"
+#include "base/task/post_task.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "content/public/common/service_manager_connection.h"
 #include "native_mate/dictionary.h"
+#include "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 "atom/common/node_includes.h"
 
-using content::BrowserThread;
-
 namespace mate {
 
-template<>
-struct Converter<device::PowerSaveBlocker::PowerSaveBlockerType> {
+template <>
+struct Converter<device::mojom::WakeLockType> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     device::PowerSaveBlocker::PowerSaveBlockerType* out) {
-    using device::PowerSaveBlocker;
+                     device::mojom::WakeLockType* out) {
     std::string type;
     if (!ConvertFromV8(isolate, val, &type))
       return false;
     if (type == "prevent-app-suspension")
-      *out = PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension;
+      *out = device::mojom::WakeLockType::kPreventAppSuspension;
     else if (type == "prevent-display-sleep")
-      *out = PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep;
+      *out = device::mojom::WakeLockType::kPreventDisplaySleep;
     else
       return false;
     return true;
@@ -41,66 +43,79 @@ namespace atom {
 namespace api {
 
 PowerSaveBlocker::PowerSaveBlocker(v8::Isolate* isolate)
-    : current_blocker_type_(
-          device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension) {
+    : current_lock_type_(device::mojom::WakeLockType::kPreventAppSuspension),
+      is_wake_lock_active_(false) {
   Init(isolate);
 }
 
-PowerSaveBlocker::~PowerSaveBlocker() {
-}
+PowerSaveBlocker::~PowerSaveBlocker() {}
 
 void PowerSaveBlocker::UpdatePowerSaveBlocker() {
-  if (power_save_blocker_types_.empty()) {
-    power_save_blocker_.reset();
+  if (wake_lock_types_.empty()) {
+    if (is_wake_lock_active_) {
+      GetWakeLock()->CancelWakeLock();
+      is_wake_lock_active_ = false;
+    }
     return;
   }
 
-  // |kPowerSaveBlockPreventAppSuspension| keeps system active, but allows
+  // |WakeLockType::kPreventAppSuspension| keeps system active, but allows
   // screen to be turned off.
-  // |kPowerSaveBlockPreventDisplaySleep| keeps system and screen active, has a
-  // higher precedence level than |kPowerSaveBlockPreventAppSuspension|.
+  // |WakeLockType::kPreventDisplaySleep| keeps system and screen active, has a
+  // higher precedence level than |WakeLockType::kPreventAppSuspension|.
   //
   // Only the highest-precedence blocker type takes effect.
-  device::PowerSaveBlocker::PowerSaveBlockerType new_blocker_type =
-      device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension;
-  for (const auto& element : power_save_blocker_types_) {
-    if (element.second ==
-        device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep) {
-      new_blocker_type =
-          device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep;
+  device::mojom::WakeLockType new_lock_type =
+      device::mojom::WakeLockType::kPreventAppSuspension;
+  for (const auto& element : wake_lock_types_) {
+    if (element.second == device::mojom::WakeLockType::kPreventDisplaySleep) {
+      new_lock_type = device::mojom::WakeLockType::kPreventDisplaySleep;
       break;
     }
   }
 
-  if (!power_save_blocker_ || new_blocker_type != current_blocker_type_) {
-    std::unique_ptr<device::PowerSaveBlocker> new_blocker(
-        new device::PowerSaveBlocker(
-            new_blocker_type,
-            device::PowerSaveBlocker::kReasonOther,
-            ATOM_PRODUCT_NAME,
-            BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
-            BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
-    power_save_blocker_.swap(new_blocker);
-    current_blocker_type_ = new_blocker_type;
+  if (current_lock_type_ != new_lock_type) {
+    GetWakeLock()->ChangeType(new_lock_type, base::DoNothing());
+    current_lock_type_ = new_lock_type;
+  }
+  if (!is_wake_lock_active_) {
+    GetWakeLock()->RequestWakeLock();
+    is_wake_lock_active_ = true;
   }
 }
 
-int PowerSaveBlocker::Start(
-    device::PowerSaveBlocker::PowerSaveBlockerType type) {
+device::mojom::WakeLock* PowerSaveBlocker::GetWakeLock() {
+  if (!wake_lock_) {
+    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, ATOM_PRODUCT_NAME,
+        mojo::MakeRequest(&wake_lock_));
+  }
+  return wake_lock_.get();
+}
+
+int PowerSaveBlocker::Start(device::mojom::WakeLockType type) {
   static int count = 0;
-  power_save_blocker_types_[count] = type;
+  wake_lock_types_[count] = type;
   UpdatePowerSaveBlocker();
   return count++;
 }
 
 bool PowerSaveBlocker::Stop(int id) {
-  bool success = power_save_blocker_types_.erase(id) > 0;
+  bool success = wake_lock_types_.erase(id) > 0;
   UpdatePowerSaveBlocker();
   return success;
 }
 
 bool PowerSaveBlocker::IsStarted(int id) {
-  return power_save_blocker_types_.find(id) != power_save_blocker_types_.end();
+  return wake_lock_types_.find(id) != wake_lock_types_.end();
 }
 
 // static
@@ -110,7 +125,8 @@ mate::Handle<PowerSaveBlocker> PowerSaveBlocker::Create(v8::Isolate* isolate) {
 
 // static
 void PowerSaveBlocker::BuildPrototype(
-    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
+    v8::Isolate* isolate,
+    v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "PowerSaveBlocker"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("start", &PowerSaveBlocker::Start)
@@ -124,8 +140,10 @@ void PowerSaveBlocker::BuildPrototype(
 
 namespace {
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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.Set("powerSaveBlocker", atom::api::PowerSaveBlocker::Create(isolate));
@@ -133,4 +151,4 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_power_save_blocker, Initialize);
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_power_save_blocker, Initialize);

atom/browser/api/atom_api_power_save_blocker.h

@@ -10,7 +10,7 @@
 
 #include "atom/browser/api/trackable_object.h"
 #include "native_mate/handle.h"
-#include "services/device/wake_lock/power_save_blocker/power_save_blocker.h"
+#include "services/device/public/mojom/wake_lock.mojom.h"
 
 namespace mate {
 class Dictionary;
@@ -33,19 +33,23 @@ class PowerSaveBlocker : public mate::TrackableObject<PowerSaveBlocker> {
 
  private:
   void UpdatePowerSaveBlocker();
-  int Start(device::PowerSaveBlocker::PowerSaveBlockerType type);
+  int Start(device::mojom::WakeLockType type);
   bool Stop(int id);
   bool IsStarted(int id);
 
-  std::unique_ptr<device::PowerSaveBlocker> power_save_blocker_;
+  device::mojom::WakeLock* GetWakeLock();
 
-  // Currnet blocker type used by |power_save_blocker_|
-  device::PowerSaveBlocker::PowerSaveBlockerType current_blocker_type_;
+  // Current wake lock level.
+  device::mojom::WakeLockType current_lock_type_;
+
+  // Whether the wake lock is currently active.
+  bool is_wake_lock_active_;
 
   // Map from id to the corresponding blocker type for each request.
-  using PowerSaveBlockerTypeMap =
-      std::map<int, device::PowerSaveBlocker::PowerSaveBlockerType>;
-  PowerSaveBlockerTypeMap power_save_blocker_types_;
+  using WakeLockTypeMap = std::map<int, device::mojom::WakeLockType>;
+  WakeLockTypeMap wake_lock_types_;
+
+  device::mojom::WakeLockPtr wake_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerSaveBlocker);
 };

atom/browser/api/atom_api_protocol.cc

@@ -24,137 +24,201 @@
 
 using content::BrowserThread;
 
-namespace atom {
-
-namespace api {
-
 namespace {
 
 // List of registered custom standard schemes.
 std::vector<std::string> g_standard_schemes;
 
-// Clear protocol handlers in IO thread.
-void ClearJobFactoryInIO(
-    scoped_refptr<brightray::URLRequestContextGetter> request_context_getter) {
-  auto job_factory = static_cast<AtomURLRequestJobFactory*>(
-      request_context_getter->job_factory());
-  job_factory->Clear();
-}
+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 RegisterStandardSchemes(const std::vector<std::string>& schemes,
-                             mate::Arguments* args) {
-  g_standard_schemes = 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;
+  }
 
-  mate::Dictionary opts;
-  bool secure = false;
-  args->GetNext(&opts) && opts.Get("secure", &secure);
-
-  // Dynamically register the schemes.
-  auto* policy = content::ChildProcessSecurityPolicy::GetInstance();
-  for (const std::string& scheme : schemes) {
-    url::AddStandardScheme(scheme.c_str(), url::SCHEME_WITHOUT_PORT);
-    if (secure) {
-      url::AddSecureScheme(scheme.c_str());
+  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);
     }
-    policy->RegisterWebSafeScheme(scheme);
   }
 
-  // Add the schemes to command line switches, so child processes can also
-  // register them.
-  base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-      atom::switches::kStandardSchemes, base::JoinString(schemes, ","));
-  if (secure) {
+  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(
-      atom::switches::kSecureSchemes, base::JoinString(schemes, ","));
-  }
+        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)
-    : request_context_getter_(browser_context->GetRequestContext()),
-      weak_factory_(this) {
+    : browser_context_(browser_context), weak_factory_(this) {
   Init(isolate);
 }
 
-Protocol::~Protocol() {
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(ClearJobFactoryInIO, request_context_getter_));
-}
-
-void Protocol::RegisterServiceWorkerSchemes(
-    const std::vector<std::string>& schemes) {
-  atom::AtomBrowserClient::SetCustomServiceWorkerSchemes(schemes);
-}
-
-void Protocol::UnregisterProtocol(
-    const std::string& scheme, mate::Arguments* args) {
+Protocol::~Protocol() {}
+void Protocol::UnregisterProtocol(const std::string& scheme,
+                                  mate::Arguments* args) {
   CompletionCallback callback;
   args->GetNext(&callback);
-  content::BrowserThread::PostTaskAndReplyWithResult(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::UnregisterProtocolInIO,
-                 request_context_getter_, scheme),
-      base::Bind(&Protocol::OnIOCompleted,
-                 GetWeakPtr(), 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<brightray::URLRequestContextGetter> request_context_getter,
+    scoped_refptr<URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
-  auto job_factory = static_cast<AtomURLRequestJobFactory*>(
-      request_context_getter->job_factory());
+  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;
 }
 
-void Protocol::IsProtocolHandled(const std::string& scheme,
-                                 const BooleanCallback& callback) {
-  content::BrowserThread::PostTaskAndReplyWithResult(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::IsProtocolHandledInIO,
-                 request_context_getter_, scheme),
-      callback);
-}
-
-// static
-bool Protocol::IsProtocolHandledInIO(
-    scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+bool IsProtocolHandledInIO(
+    scoped_refptr<URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
-  return request_context_getter->job_factory()->IsHandledProtocol(scheme);
+  bool is_handled =
+      request_context_getter->job_factory()->IsHandledProtocol(scheme);
+  return is_handled;
 }
 
-void Protocol::UninterceptProtocol(
-    const std::string& scheme, mate::Arguments* args) {
+void PromiseCallback(util::Promise promise, bool handled) {
+  promise.Resolve(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(&PromiseCallback, std::move(promise)));
+
+  return handle;
+}
+
+void Protocol::UninterceptProtocol(const std::string& scheme,
+                                   mate::Arguments* args) {
   CompletionCallback callback;
   args->GetNext(&callback);
-  content::BrowserThread::PostTaskAndReplyWithResult(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::UninterceptProtocolInIO,
-                 request_context_getter_, scheme),
-      base::Bind(&Protocol::OnIOCompleted,
-                 GetWeakPtr(), 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<brightray::URLRequestContextGetter> request_context_getter,
+    scoped_refptr<URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
-  return static_cast<AtomURLRequestJobFactory*>(
-      request_context_getter->job_factory())->UninterceptProtocol(scheme) ?
-          PROTOCOL_OK : PROTOCOL_NOT_INTERCEPTED;
+  return request_context_getter->job_factory()->UninterceptProtocol(scheme)
+             ? PROTOCOL_OK
+             : PROTOCOL_NOT_INTERCEPTED;
 }
 
-void Protocol::OnIOCompleted(
-    const CompletionCallback& callback, ProtocolError error) {
+void Protocol::OnIOCompleted(const CompletionCallback& callback,
+                             ProtocolError error) {
   // The completion callback is optional.
   if (callback.is_null())
     return;
@@ -172,35 +236,32 @@ void Protocol::OnIOCompleted(
 
 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";
+    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";
   }
 }
 
-AtomURLRequestJobFactory* Protocol::GetJobFactoryInIO() const {
-  request_context_getter_->GetURLRequestContext();  // Force init.
-  return static_cast<AtomURLRequestJobFactory*>(
-      static_cast<brightray::URLRequestContextGetter*>(
-          request_context_getter_.get())->job_factory());
-}
-
 // static
-mate::Handle<Protocol> Protocol::Create(
-    v8::Isolate* isolate, AtomBrowserContext* browser_context) {
+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) {
+void Protocol::BuildPrototype(v8::Isolate* isolate,
+                              v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "Protocol"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
-      .SetMethod("registerServiceWorkerSchemes",
-                 &Protocol::RegisterServiceWorkerSchemes)
       .SetMethod("registerStringProtocol",
                  &Protocol::RegisterProtocol<URLRequestStringJob>)
       .SetMethod("registerBufferProtocol",
@@ -232,25 +293,28 @@ void Protocol::BuildPrototype(
 
 namespace {
 
-void RegisterStandardSchemes(
-    const std::vector<std::string>& schemes, mate::Arguments* args) {
+void RegisterSchemesAsPrivileged(v8::Local<v8::Value> val,
+                                 mate::Arguments* args) {
   if (atom::Browser::Get()->is_ready()) {
-    args->ThrowError("protocol.registerStandardSchemes should be called before "
-                     "app is ready");
+    args->ThrowError(
+        "protocol.registerSchemesAsPrivileged should be called before "
+        "app is ready");
     return;
   }
 
-  atom::api::RegisterStandardSchemes(schemes, args);
+  atom::api::RegisterSchemesAsPrivileged(val, args);
 }
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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("registerStandardSchemes", &RegisterStandardSchemes);
+  dict.SetMethod("registerSchemesAsPrivileged", &RegisterSchemesAsPrivileged);
   dict.SetMethod("getStandardSchemes", &atom::api::GetStandardSchemes);
 }
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_protocol, Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_protocol, Initialize)

atom/browser/api/atom_api_protocol.h

@@ -6,14 +6,19 @@
 #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"
@@ -29,30 +34,30 @@ namespace atom {
 namespace api {
 
 std::vector<std::string> GetStandardSchemes();
-void RegisterStandardSchemes(const std::vector<std::string>& schemes,
-                             mate::Arguments* args);
+
+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>)>;
-  using BooleanCallback = base::Callback<void(bool)>;
 
-  static mate::Handle<Protocol> Create(
-      v8::Isolate* isolate, AtomBrowserContext* browser_context);
+  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();
+  ~Protocol() override;
 
  private:
   // Possible errors.
   enum ProtocolError {
-    PROTOCOL_OK,  // no error
+    PROTOCOL_OK,    // no error
     PROTOCOL_FAIL,  // operation failed, should never occur
     PROTOCOL_REGISTERED,
     PROTOCOL_NOT_REGISTERED,
@@ -62,14 +67,13 @@ class Protocol : public mate::TrackableObject<Protocol> {
 
   // The protocol handler that will create a protocol handler for certain
   // request job.
-  template<typename RequestJob>
+  template <typename RequestJob>
   class CustomProtocolHandler
       : public net::URLRequestJobFactory::ProtocolHandler {
    public:
-    CustomProtocolHandler(
-        v8::Isolate* isolate,
-        net::URLRequestContextGetter* request_context,
-        const Handler& handler)
+    CustomProtocolHandler(v8::Isolate* isolate,
+                          net::URLRequestContextGetter* request_context,
+                          const Handler& handler)
         : isolate_(isolate),
           request_context_(request_context),
           handler_(handler) {}
@@ -79,48 +83,44 @@ class Protocol : public mate::TrackableObject<Protocol> {
         net::URLRequest* request,
         net::NetworkDelegate* network_delegate) const override {
       RequestJob* request_job = new RequestJob(request, network_delegate);
-      request_job->SetHandlerInfo(isolate_, request_context_.get(), handler_);
+      request_job->SetHandlerInfo(isolate_, request_context_, handler_);
       return request_job;
     }
 
    private:
     v8::Isolate* isolate_;
-    scoped_refptr<net::URLRequestContextGetter> request_context_;
+    net::URLRequestContextGetter* request_context_;
     Protocol::Handler handler_;
 
     DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
   };
 
-  // Register schemes that can handle service worker.
-  void RegisterServiceWorkerSchemes(const std::vector<std::string>& schemes);
-
   // Register the protocol with certain request job.
-  template<typename RequestJob>
+  template <typename RequestJob>
   void RegisterProtocol(const std::string& scheme,
                         const Handler& handler,
                         mate::Arguments* args) {
     CompletionCallback callback;
     args->GetNext(&callback);
-    content::BrowserThread::PostTaskAndReplyWithResult(
-        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&Protocol::RegisterProtocolInIO<RequestJob>,
-                   request_context_getter_, isolate(), scheme, handler),
-        base::Bind(&Protocol::OnIOCompleted,
-                   GetWeakPtr(), 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>
+  template <typename RequestJob>
   static ProtocolError RegisterProtocolInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       v8::Isolate* isolate,
       const std::string& scheme,
       const Handler& handler) {
-    auto job_factory = static_cast<AtomURLRequestJobFactory*>(
-        request_context_getter->job_factory());
+    auto* job_factory = request_context_getter->job_factory();
     if (job_factory->IsHandledProtocol(scheme))
       return PROTOCOL_REGISTERED;
-    std::unique_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
-        new CustomProtocolHandler<RequestJob>(
-            isolate, request_context_getter.get(), handler));
+    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
@@ -130,46 +130,41 @@ class Protocol : public mate::TrackableObject<Protocol> {
   // Unregister the protocol handler that handles |scheme|.
   void UnregisterProtocol(const std::string& scheme, mate::Arguments* args);
   static ProtocolError UnregisterProtocolInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       const std::string& scheme);
 
   // Whether the protocol has handler registered.
-  void IsProtocolHandled(const std::string& scheme,
-                         const BooleanCallback& callback);
-  static bool IsProtocolHandledInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
-      const std::string& scheme);
+  v8::Local<v8::Promise> IsProtocolHandled(const std::string& scheme);
 
   // Replace the protocol handler with a new one.
-  template<typename RequestJob>
+  template <typename RequestJob>
   void InterceptProtocol(const std::string& scheme,
                          const Handler& handler,
                          mate::Arguments* args) {
     CompletionCallback callback;
     args->GetNext(&callback);
-    content::BrowserThread::PostTaskAndReplyWithResult(
-        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&Protocol::InterceptProtocolInIO<RequestJob>,
-                   request_context_getter_, isolate(), scheme, handler),
-        base::Bind(&Protocol::OnIOCompleted,
-                   GetWeakPtr(), 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>
+  template <typename RequestJob>
   static ProtocolError InterceptProtocolInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       v8::Isolate* isolate,
       const std::string& scheme,
       const Handler& handler) {
-    auto job_factory = static_cast<AtomURLRequestJobFactory*>(
-        request_context_getter->job_factory());
+    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;
-    std::unique_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
-        new CustomProtocolHandler<RequestJob>(
-            isolate, request_context_getter.get(), handler));
+    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;
@@ -178,7 +173,7 @@ class Protocol : public mate::TrackableObject<Protocol> {
   // Restore the |scheme| to its original protocol handler.
   void UninterceptProtocol(const std::string& scheme, mate::Arguments* args);
   static ProtocolError UninterceptProtocolInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       const std::string& scheme);
 
   // Convert error code to JS exception and call the callback.
@@ -187,13 +182,9 @@ class Protocol : public mate::TrackableObject<Protocol> {
   // Convert error code to string.
   std::string ErrorCodeToString(ProtocolError error);
 
-  AtomURLRequestJobFactory* GetJobFactoryInIO() const;
+  base::WeakPtr<Protocol> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
 
-  base::WeakPtr<Protocol> GetWeakPtr() {
-    return weak_factory_.GetWeakPtr();
-  }
-
-  scoped_refptr<brightray::URLRequestContextGetter> request_context_getter_;
+  scoped_refptr<AtomBrowserContext> browser_context_;
   base::WeakPtrFactory<Protocol> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Protocol);

atom/browser/api/atom_api_render_process_preferences.cc

@@ -21,12 +21,12 @@ namespace {
 
 bool IsWebContents(v8::Isolate* isolate, content::RenderProcessHost* process) {
   content::WebContents* web_contents =
-      static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())->
-          GetWebContentsFromProcessID(process->GetID());
+      static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())
+          ->GetWebContentsFromProcessID(process->GetID());
   if (!web_contents)
     return false;
 
-  auto api_web_contents = WebContents::CreateFrom(isolate, web_contents);
+  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;
@@ -41,8 +41,7 @@ RenderProcessPreferences::RenderProcessPreferences(
   Init(isolate);
 }
 
-RenderProcessPreferences::~RenderProcessPreferences() {
-}
+RenderProcessPreferences::~RenderProcessPreferences() {}
 
 int RenderProcessPreferences::AddEntry(const base::DictionaryValue& entry) {
   return preferences_.AddEntry(entry);
@@ -54,7 +53,8 @@ void RenderProcessPreferences::RemoveEntry(int id) {
 
 // static
 void RenderProcessPreferences::BuildPrototype(
-    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
+    v8::Isolate* isolate,
+    v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(
       mate::StringToV8(isolate, "RenderProcessPreferences"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
@@ -65,10 +65,9 @@ void RenderProcessPreferences::BuildPrototype(
 // static
 mate::Handle<RenderProcessPreferences>
 RenderProcessPreferences::ForAllWebContents(v8::Isolate* isolate) {
-  return mate::CreateHandle(
-      isolate,
-      new RenderProcessPreferences(isolate,
-                                   base::Bind(&IsWebContents, isolate)));
+  return mate::CreateHandle(isolate,
+                            new RenderProcessPreferences(
+                                isolate, base::Bind(&IsWebContents, isolate)));
 }
 
 }  // namespace api
@@ -77,8 +76,10 @@ RenderProcessPreferences::ForAllWebContents(v8::Isolate* isolate) {
 
 namespace {
 
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
+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);
@@ -86,5 +87,5 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
 
 }  // namespace
 
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_render_process_preferences,
-                                  Initialize)
+NODE_LINKED_MODULE_CONTEXT_AWARE(atom_browser_render_process_preferences,
+                                 Initialize)

atom/browser/api/atom_api_render_process_preferences.h

@@ -16,8 +16,8 @@ namespace api {
 class RenderProcessPreferences
     : public mate::Wrappable<RenderProcessPreferences> {
  public:
-  static mate::Handle<RenderProcessPreferences>
-      ForAllWebContents(v8::Isolate* isolate);
+  static mate::Handle<RenderProcessPreferences> ForAllWebContents(
+      v8::Isolate* isolate);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);