Bump v2.0.2

* docs: Document missing events during shutdown

* docs: Better language

.circleci/config.yml

@@ -1,148 +1,103 @@
-build-steps: &build-steps
-  steps:
-    - checkout
-    - run:
-        name: Install Node.js 10 on MacOS
-        command: |
-          if [ "$INSTALL_MACOS_NODE" == "true" ]; then
-            echo 'Installing Node.js 10 for MacOS'
-            brew update
-            brew install node@10
-            echo 'export PATH="/usr/local/opt/node@10/bin:$PATH"' >> $BASH_ENV
-          fi
-    - run:
-        name: Check for release
-        command: |
-          if [ -n "${RUN_RELEASE_BUILD}" ]; then
-            echo 'release build triggered from api'
-            echo 'export ELECTRON_RELEASE=1 UPLOAD_TO_S3=1' >> $BASH_ENV
-          fi
-    - run:
-       name: Bootstrap
-       command: |
-        if [ "$ELECTRON_RELEASE" == "1" ]; then
-          echo "Bootstrapping Electron for release build for $TARGET_ARCH"
-          script/bootstrap.py --target_arch=$TARGET_ARCH
-        else
-          echo "Bootstrapping Electron for debug build for $TARGET_ARCH"
-          script/bootstrap.py --target_arch=$TARGET_ARCH --dev
-        fi
-    - run:
-        name: Lint
-        command: npm run lint
-    - run:
-       name: Build
-       command: |
-         if [ "$ELECTRON_RELEASE" == "1" ]; then
-           echo 'Building Electron for release'
-           script/build.py -c R
-         else
-           echo 'Building Electron for debug'
-           script/build.py -c D
-         fi
-    - run:
-        name: Create distribution
-        command: |
-          if [ "$ELECTRON_RELEASE" == "1" ]; then
-            echo 'Creating Electron release distribution'
-            script/create-dist.py
-          else
-            echo 'Skipping create distribution because build is not for release'
-          fi
-    - run:
-        name: Upload distribution
-        command: |
-          if [ "$ELECTRON_RELEASE" == "1" ] && [ "$UPLOAD_TO_S3" != "1" ]; then
-            echo 'Uploading Electron release distribution to github releases'
-            script/upload.py
-          elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$UPLOAD_TO_S3" == "1" ]; then
-            echo 'Uploading Electron release distribution to s3'
-            script/upload.py --upload_to_s3
-          else
-            echo 'Skipping upload distribution because build is not for release'
-          fi
-    - run:
-        name: Setup for headless testing
-        command: |
-          if [ "$RUN_HEADLESS_TESTS" == "true" ]; then
-            echo 'Setup for headless testing'
-            sh -e /etc/init.d/xvfb start
-          else
-            echo 'Headless testing not needed'
-          fi
-    - run:
-        name: Test
-        environment:
-          MOCHA_FILE: junit/test-results.xml
-          MOCHA_REPORTER: mocha-junit-reporter
-        command: |
-          if [ "$RUN_TESTS" == "true" ]; then
-            if [ "$ELECTRON_RELEASE" != "1" ]; then
-              echo 'Testing Electron debug build'
-              mkdir junit
-              script/test.py --ci --rebuild_native_modules
-            else
-              if [ "$UPLOAD_TO_S3" == "1" ]; then
-                echo 'Testing Electron release build'
-                mkdir junit
-                script/test.py --ci --rebuild_native_modules -c R
-              else
-                echo 'Skipping tests on GitHub release'
-              fi
-            fi
-          else
-           echo 'Skipping tests due to configuration'
-          fi
-    - run:
-        name: Verify FFmpeg
-        command: |
-          if [ "$RUN_TESTS" == "true" ]; then
-            if [ "$ELECTRON_RELEASE" != "1" ]; then
-              echo 'Verifying ffmpeg on debug build'
-              script/verify-ffmpeg.py
-            else
-              echo 'Verifying ffmpeg on release build'
-              script/verify-ffmpeg.py -R
-            fi
-          else
-            echo 'Skipping tests due to configuration'
-          fi
-
-    - run:
-        name: Generate Typescript Definitions
-        command: |
-          if [ "$CREATE_TYPESCRIPT_DEFS" == "true" ]; then
-            npm run create-typescript-definitions
-          fi
-    - persist_to_workspace:
-        root: out
-        paths:
-          - "*"
-    - store_test_results:
-        path: junit
-    - store_artifacts:
-        path: junit
-    - store_artifacts:
-        path: out
-
-build-defaults: &build-defaults
-  docker:
-    - image: electronbuilds/electron:0.0.8
-  <<: *build-steps
 
 version: 2
 jobs:
   electron-linux-arm:
-    environment:
-      TARGET_ARCH: arm
-    <<: *build-defaults
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: arm
     resource_class: 2xlarge
-
+    steps:
+      - checkout
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Optionally finish release
+          shell: /bin/sh
+          command: |
+            if [ "$ELECTRON_RELEASE" == "1" ] && [ "$AUTO_RELEASE" == "true" ]; then
+              echo 'Trying to finish release'
+              node script/release.js --validateRelease --automaticRelease
+              releaseExitCode=$?
+              if [ $releaseExitCode -eq 0 ]; then
+                echo 'Release is ready to go; releasing'
+                node script/release.js--automaticRelease
+                if [ $releaseExitCode -eq 0 ]; then
+                  echo 'Release successful, now publishing to npm'
+                  echo "//registry.npmjs.org/:_authToken=$ELECTRON_NPM_TOKEN" >> ~/.npmrc
+                  npm run publish-to-npm
+                  echo 'Release has been published to npm'
+                fi
+              else
+                echo 'Release is not complete, skipping publish for now'
+              fi
+            else
+              echo 'Skipping finishing release because build is not for release'
+            fi
+      - run:
+          name: Zip out directory
+          command: |
+            if [ "$ELECTRON_RELEASE" != "1" ]; then
+              zip -r electron.zip out/D
+            fi
+      - persist_to_workspace:
+          root: /home/builduser
+          paths:
+            - project/out
+      - store_artifacts:
+          path: electron.zip
   electron-linux-arm-test:
     machine: true
     steps:
       - attach_workspace:
-          at: /tmp/workspace/project/out
+          at: /tmp/workspace
       - checkout
       - run:
           name: Test in ARM docker container
@@ -162,25 +117,103 @@ jobs:
             else
               echo "Skipping test for release build"
             fi
-
-  electron-linux-arm-release-nightly:
-    environment:
-      TARGET_ARCH: arm
-      RUN_RELEASE_BUILD: true
-    <<: *build-defaults
-    resource_class: 2xlarge
-
   electron-linux-arm64:
-    environment:
-      TARGET_ARCH: arm64
-    <<: *build-defaults
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: arm64
     resource_class: 2xlarge
-
+    steps:
+      - checkout
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Optionally finish release
+          shell: /bin/sh
+          command: |
+            if [ "$ELECTRON_RELEASE" == "1" ] && [ "$AUTO_RELEASE" == "true" ]; then
+              echo 'Trying to finish release'
+              node script/release.js --validateRelease --automaticRelease
+              releaseExitCode=$?
+              if [ $releaseExitCode -eq 0 ]; then
+                echo 'Release is ready to go; releasing'
+                node script/release.js--automaticRelease
+                if [ $releaseExitCode -eq 0 ]; then
+                  echo 'Release successful, now publishing to npm'
+                  echo "//registry.npmjs.org/:_authToken=$ELECTRON_NPM_TOKEN" >> ~/.npmrc
+                  npm run publish-to-npm
+                  echo 'Release has been published to npm'
+                fi
+              else
+                echo 'Release is not complete, skipping publish for now'
+              fi
+            else
+              echo 'Skipping finishing release because build is not for release'
+            fi
+      - run:
+          name: Zip out directory
+          command: |
+            if [ "$ELECTRON_RELEASE" != "1" ]; then
+              zip -r electron.zip out/D
+            fi
+      - persist_to_workspace:
+          root: /home/builduser
+          paths:
+            - project/out
+      - store_artifacts:
+          path: electron.zip
   electron-linux-arm64-test:
     machine: true
     steps:
       - attach_workspace:
-          at: /tmp/workspace/project/out
+          at: /tmp/workspace
       - checkout
       - run:
           name: Test in ARM64 docker container
@@ -200,91 +233,508 @@ jobs:
             else
               echo "Skipping test for release build"
             fi
-
-  electron-linux-arm64-release-nightly:
-    environment:
-      TARGET_ARCH: arm64
-      RUN_RELEASE_BUILD: true
-    <<: *build-defaults
-    resource_class: 2xlarge
-
   electron-linux-ia32:
-    environment:
-      TARGET_ARCH: ia32
-      DISPLAY: ':99.0'
-      RUN_TESTS: true
-      RUN_HEADLESS_TESTS: true
-    <<: *build-defaults
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: ia32
+          DISPLAY: ':99.0'
     resource_class: xlarge
-
-  electron-linux-ia32-release-nightly:
-    environment:
-      TARGET_ARCH: ia32
-      RUN_RELEASE_BUILD: true
-    <<: *build-defaults
-    resource_class: xlarge
-
+    steps:
+      - checkout
+      - run:
+          name: Setup for headless testing
+          command: sh -e /etc/init.d/xvfb start
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Optionally finish release
+          shell: /bin/sh
+          command: |
+            if [ "$ELECTRON_RELEASE" == "1" ] && [ "$AUTO_RELEASE" == "true" ]; then
+              echo 'Trying to finish release'
+              node script/release.js --validateRelease --automaticRelease
+              releaseExitCode=$?
+              if [ $releaseExitCode -eq 0 ]; then
+                echo 'Release is ready to go; releasing'
+                node script/release.js--automaticRelease
+                if [ $releaseExitCode -eq 0 ]; then
+                  echo 'Release successful, now publishing to npm'
+                  echo "//registry.npmjs.org/:_authToken=$ELECTRON_NPM_TOKEN" >> ~/.npmrc
+                  npm run publish-to-npm
+                  echo 'Release has been published to npm'
+                fi
+              else
+                echo 'Release is not complete, skipping publish for now'
+              fi
+            else
+              echo 'Skipping finishing release because build is not for release'
+            fi
+      - run:
+          name: Test
+          environment:
+            MOCHA_FILE: junit/test-results.xml
+            MOCHA_REPORTER: mocha-junit-reporter
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Testing Electron debug build'
+                out/D/electron --version
+                mkdir junit
+                script/test.py --ci --rebuild_native_modules
+             else
+                echo 'Skipping testing on release build'
+             fi
+      - run:
+          name: Verify FFmpeg
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Verifying ffmpeg on debug build'
+                script/verify-ffmpeg.py
+             else
+                echo 'Skipping verify ffmpeg on release build'
+             fi
   electron-linux-mips64el:
-    environment:
-      TARGET_ARCH: mips64el
-    <<: *build-defaults
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: mips64el
     resource_class: xlarge
+    steps:
+      - checkout
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Optionally finish release
+          shell: /bin/sh
+          command: |
+            if [ "$ELECTRON_RELEASE" == "1" ] && [ "$AUTO_RELEASE" == "true" ]; then
+              echo 'Trying to finish release'
+              node script/release.js --validateRelease --automaticRelease
+              releaseExitCode=$?
+              if [ $releaseExitCode -eq 0 ]; then
+                echo 'Release is ready to go; releasing'
+                node script/release.js--automaticRelease
+                if [ $releaseExitCode -eq 0 ]; then
+                  echo 'Release successful, now publishing to npm'
+                  echo "//registry.npmjs.org/:_authToken=$ELECTRON_NPM_TOKEN" >> ~/.npmrc
+                  npm run publish-to-npm
+                  echo 'Release has been published to npm'
+                fi
+              else
+                echo 'Release is not complete, skipping publish for now'
+              fi
+            else
+              echo 'Skipping finishing release because build is not for release'
+            fi
 
   electron-linux-x64:
-    environment:
-      TARGET_ARCH: x64
-      DISPLAY: ':99.0'
-      RUN_TESTS: true
-      RUN_HEADLESS_TESTS: true
-      CREATE_TYPESCRIPT_DEFS: true
-    <<: *build-defaults
-    resource_class: xlarge
-
-  electron-linux-x64-release-nightly:
-    environment:
-      TARGET_ARCH: x64
-      RUN_RELEASE_BUILD: true
-    <<: *build-defaults
+    docker:
+      - image: electronbuilds/electron:0.0.7
+        environment:
+          TARGET_ARCH: x64
+          DISPLAY: ':99.0'
     resource_class: xlarge
+    steps:
+      - checkout
+      - run:
+          name: Setup for headless testing
+          command: sh -e /etc/init.d/xvfb start
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Optionally finish release
+          shell: /bin/sh
+          command: |
+            if [ "$ELECTRON_RELEASE" == "1" ] && [ "$AUTO_RELEASE" == "true" ]; then
+              echo 'Trying to finish release'
+              node script/release.js --validateRelease --automaticRelease
+              releaseExitCode=$?
+              if [ $releaseExitCode -eq 0 ]; then
+                echo 'Release is ready to go; releasing'
+                node script/release.js--automaticRelease
+                if [ $releaseExitCode -eq 0 ]; then
+                  echo 'Release successful, now publishing to npm'
+                  echo "//registry.npmjs.org/:_authToken=$ELECTRON_NPM_TOKEN" >> ~/.npmrc
+                  npm run publish-to-npm
+                  echo 'Release has been published to npm'
+                fi
+              else
+                echo 'Release is not complete, skipping publish for now'
+              fi
+            else
+              echo 'Skipping finishing release because build is not for release'
+            fi
+      - run:
+          name: Test
+          environment:
+            MOCHA_FILE: junit/test-results.xml
+            MOCHA_REPORTER: mocha-junit-reporter
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Testing Electron debug build'
+                mkdir junit
+                script/test.py --ci --rebuild_native_modules
+             else
+                echo 'Skipping testing on release build'
+             fi
+      - run:
+          name: Verify FFmpeg
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Verifying ffmpeg on debug build'
+                script/verify-ffmpeg.py
+             else
+                echo 'Skipping verify ffmpeg on release build'
+             fi
+      - run:
+          name: Generate Typescript Definitions
+          command: npm run create-typescript-definitions
+      - store_test_results:
+          path: junit
+      - store_artifacts:
+          path: junit
+      - store_artifacts:
+          path: out/electron.d.ts
+      - store_artifacts:
+          path: out/electron-api.json
 
   electron-osx-x64:
     environment:
       TARGET_ARCH: x64
-      RUN_TESTS: true
-      INSTALL_MACOS_NODE: true
     macos:
-      xcode: "8.3.3"
-    <<: *build-steps
-
-  electron-osx-x64-release-nightly:
-    environment:
-      TARGET_ARCH: x64
-      RUN_RELEASE_BUILD: true
-      INSTALL_MACOS_NODE: true
-    macos:
-      xcode: "8.3.3"
-    <<: *build-steps
+        xcode: "9.0"
+    resource_class: xlarge
+    steps:
+      - checkout
+      - run:
+          name: Reclaim disk space
+          command: |
+            df -h
+            sudo rm -rf /Library/Developer/CoreSimulator
+            df -h
+            sysctl -n hw.ncpu
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Test
+          environment:
+            MOCHA_FILE: junit/test-results.xml
+            MOCHA_REPORTER: mocha-junit-reporter
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Testing Electron debug build'
+                mkdir junit
+                script/test.py --ci --rebuild_native_modules
+             else
+                echo 'Skipping testing on release build'
+             fi
+      - run:
+          name: Verify FFmpeg
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Verifying ffmpeg on debug build'
+                script/verify-ffmpeg.py
+             else
+                echo 'Skipping verify ffmpeg on release build'
+             fi
+      - run:
+          name: Generate Typescript Definitions
+          command: npm run create-typescript-definitions
+      - store_test_results:
+          path: junit
+      - store_artifacts:
+          path: junit
+      - store_artifacts:
+          path: out/electron.d.ts
+      - store_artifacts:
+          path: out/electron-api.json
 
   electron-mas-x64:
     environment:
       TARGET_ARCH: x64
       MAS_BUILD: 1
-      RUN_TESTS: true
-      INSTALL_MACOS_NODE: true
     macos:
-      xcode: "8.3.3"
-    <<: *build-steps
-
-  electron-mas-x64-release-nightly:
-    environment:
-      TARGET_ARCH: x64
-      MAS_BUILD: 1
-      RUN_RELEASE_BUILD: true
-      INSTALL_MACOS_NODE: true
-    macos:
-      xcode: "8.3.3"
-    <<: *build-steps
-
+        xcode: "9.0"
+    resource_class: xlarge
+    steps:
+      - checkout
+      - run:
+          name: Reclaim disk space
+          command: |
+            df -h
+            sudo rm -rf /Library/Developer/CoreSimulator
+            df -h
+            sysctl -n hw.ncpu
+      - run:
+          name: Check for release
+          command: |
+            if [ -n "${RUN_RELEASE_BUILD}" ]; then
+              echo 'release build triggered from api'
+              echo 'export ELECTRON_RELEASE=1 TRIGGERED_BY_API=1' >> $BASH_ENV
+            fi
+      - run:
+         name: Bootstrap
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Bootstrapping Electron for release build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH
+           else
+              echo 'Bootstrapping Electron for debug build'
+              script/bootstrap.py --target_arch=$TARGET_ARCH --dev
+           fi
+      - run: npm run lint
+      - run:
+         name: Build
+         command: |
+           if [ "$ELECTRON_RELEASE" == "1" ]; then
+              echo 'Building Electron for release'
+              script/build.py -c R
+           else
+              echo 'Building Electron for debug'
+              script/build.py -c D
+           fi
+      - run:
+          name: Create distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ]; then
+                echo 'Creating Electron release distribution'
+                script/create-dist.py
+             else
+                echo 'Skipping create distribution because build is not for release'
+             fi
+      - run:
+          name: Upload distribution
+          command: |
+             if [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" != "1" ]; then
+                echo 'Uploading Electron release distribution to github releases'
+                script/upload.py
+             elif [ "$ELECTRON_RELEASE" == "1" ] && [ "$TRIGGERED_BY_API" == "1" ]; then
+                echo 'Uploading Electron release distribution to s3'
+                script/upload.py --upload_to_s3
+             else
+                echo 'Skipping upload distribution because build is not for release'
+             fi
+      - run:
+          name: Test
+          environment:
+            MOCHA_FILE: junit/test-results.xml
+            MOCHA_REPORTER: mocha-junit-reporter
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Testing Electron debug build'
+                mkdir junit
+                script/test.py --ci --rebuild_native_modules
+             else
+                echo 'Skipping testing on release build'
+             fi
+      - run:
+          name: Verify FFmpeg
+          command: |
+             if [ "$ELECTRON_RELEASE" != "1" ]; then
+                echo 'Verifying ffmpeg on debug build'
+                script/verify-ffmpeg.py
+             else
+                echo 'Skipping verify ffmpeg on release build'
+             fi
+      - run:
+          name: Generate Typescript Definitions
+          command: npm run create-typescript-definitions
+      - store_test_results:
+          path: junit
+      - store_artifacts:
+          path: junit
+      - store_artifacts:
+          path: out/electron.d.ts
+      - store_artifacts:
+          path: out/electron-api.json
 
 workflows:
   version: 2
@@ -312,29 +762,3 @@ workflows:
   build-mas-x64:
     jobs:
       - electron-mas-x64
-
-  nightly-release-test:
-    triggers:
-      - schedule:
-          cron: "0 0 * * *"
-          filters:
-            branches:
-              only:
-                - master
-                - 2-0-x
-                - 1-8-x
-                - 1-7-x
-    jobs:
-      - electron-linux-arm-release-nightly
-      - electron-linux-arm64-release-nightly
-      - electron-linux-ia32-release-nightly
-      - electron-linux-x64-release-nightly
-
-experimental:
-  notify:
-    branches:
-      only:
-        - master
-        - 2-0-x
-        - 1-8-x
-        - 1-7-x

.env.example

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

.github/CODEOWNERS

@@ -14,8 +14,8 @@
 *updater* @electron/updater
 
 # directories
-/.github/ @electron/electrocats
+/.github/ @electron/hubbers
 /default_app/ @electron/docs
 /docs/ @electron/docs
 /docs-translations/ @electron/i18n
-/npm/ @electron/electrocats
+/npm/ @electron/hubbers

.github/ISSUE_TEMPLATE.md

@@ -10,9 +10,6 @@ Thanks for opening an issue! A few things to keep in mind:
 * Electron version:
 * Operating system:
 
-<!-- If this used to work -->
-* Last known working Electron version: 
-
 ### Expected behavior
 
 <!-- What do you think should happen? -->

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -1,32 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve Electron
-
----
-
-* Electron Version:
-* Operating System (Platform and Version):
-* Last known working Electron version: 
-
-**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

@@ -1,17 +0,0 @@
----
-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/PULL_REQUEST_TEMPLATE.md

@@ -2,14 +2,7 @@
 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
-- [ ] commit messages or PR title follow semantic [commit guidelines](https://github.com/electron/electron/blob/master/docs/development/pull-requests.md#commit-message-guidelines)
+-->

.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).
+  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).
 
 # Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome
 
@@ -12,22 +12,14 @@ newIssueWelcomeComment: |
 newPRWelcomeComment: |
   💖 Thanks for opening this pull request! 💖
 
-  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, OR prefix at least one of your commit messages.
-
-  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:
+  ![typing cat](https://user-images.githubusercontent.com/2289/36400158-2c7c589e-1584-11e8-81c7-bd34fd3c392b.gif)
 
+  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
@@ -36,18 +28,4 @@ newPRWelcomeComment: |
 firstPRMergeComment: >
   Congrats on merging your first pull request! 🎉🎉🎉
 
-# Configuration for trop - https://github.com/codebytere/trop
-
-watchedProject:
-  name: Backports
-
-authorizedUsers:
-  - alexeykuzmin
-  - ckerr
-  - codebytere
-  - deepak1556
-  - jkleinsc
-  - MarshallOfSound
-  - nitsakh
-  - nornagon
-  - zcbenz
+# It is recommend to include as many gifs and emojis as possible

.gitignore

@@ -23,15 +23,19 @@
 /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_stretch_amd64-sysroot/
-/vendor/debian_stretch_arm-sysroot/
-/vendor/debian_stretch_arm64-sysroot/
-/vendor/debian_stretch_i386-sysroot/
+/vendor/debian_wheezy_amd64-sysroot/
+/vendor/debian_wheezy_arm-sysroot/
+/vendor/debian_wheezy_i386-sysroot/
 /vendor/gcc-4.8.3-d197-n64-loongson/
 /vendor/readme-gcc483-loongson.txt
 /vendor/download/
@@ -43,10 +47,4 @@
 /vendor/LICENSES.chromium.html
 node_modules/
 SHASUMS256.txt
-**/yarn.lock
-compile_commands.json
-.envrc
-
-# npm package
-/npm/dist
-/npm/path.txt
+**/package-lock.json

.gitmodules

@@ -7,6 +7,9 @@
 [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

.node-version

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

BUILD.gn

@@ -1,592 +0,0 @@
-import("//build/config/locales.gni")
-import("//tools/grit/repack.gni")
-import("build/asar.gni")
-import("build/npm.gni")
-
-if (is_mac) {
-  import("//build/config/mac/rules.gni")
-  import("//third_party/icu/config.gni")
-  import("//v8/gni/v8.gni")
-}
-
-if (is_linux) {
-  import("//build/config/linux/pkg_config.gni")
-
-  pkg_config("gio_unix") {
-    packages = [ "gio-unix-2.0" ]
-  }
-}
-
-declare_args() {
-  electron_project_name = "electron"
-  electron_product_name = "Electron"
-  electron_company_name = "GitHub, Inc"
-  electron_company_abbr = "github"
-  electron_version = "0.0.0-dev"
-
-  enable_desktop_capturer = true
-  enable_run_as_node = true
-  enable_osr = true
-
-  # Provide a fake location provider for mocking
-  # the geolocation responses. Disable it if you
-  # need to test with chromium's location provider.
-  # Should not be enabled for release build.
-  enable_fake_location_provider = !is_official_build
-}
-
-filenames_gypi = exec_script(
-  "//build/gypi_to_gn.py",
-  [
-    rebase_path("filenames.gypi"),
-    "--replace=<(SHARED_INTERMEDIATE_DIR)=$target_gen_dir",
-  ],
-  "scope",
-  [ "filenames.gypi" ]
-)
-
-config("branding") {
-  defines = [
-    "ATOM_PRODUCT_NAME=\"$electron_product_name\"",
-    "ATOM_PROJECT_NAME=\"$electron_project_name\"",
-  ]
-}
-
-config("features") {
-  defines = []
-  if (enable_desktop_capturer) {
-    defines += [ "ENABLE_DESKTOP_CAPTURER=1" ]
-  }
-  if (enable_run_as_node) {
-    defines += [ "ENABLE_RUN_AS_NODE=1" ]
-  }
-  if (enable_osr) {
-    defines += [ "ENABLE_OSR=1" ]
-  }
-}
-
-config("native_mate_config") {
-  include_dirs = [
-    "//third_party/native_mate",
-  ]
-  cflags_cc = [
-    "-Wno-deprecated-declarations",
-  ]
-  cflags_objcc = cflags_cc
-}
-
-source_set("native_mate") {
-  deps = [
-    "//base",
-    "//net",
-    "//v8:v8_headers",
-    "build/node",
-  ]
-  public_configs = [ ":native_mate_config" ]
-  sources = [
-    "//third_party/native_mate/native_mate/arguments.cc",
-    "//third_party/native_mate/native_mate/arguments.h",
-    "//third_party/native_mate/native_mate/compat.h",
-    "//third_party/native_mate/native_mate/constructor.h",
-    "//third_party/native_mate/native_mate/converter.cc",
-    "//third_party/native_mate/native_mate/converter.h",
-    "//third_party/native_mate/native_mate/dictionary.cc",
-    "//third_party/native_mate/native_mate/dictionary.h",
-    "//third_party/native_mate/native_mate/function_template.cc",
-    "//third_party/native_mate/native_mate/function_template.h",
-    "//third_party/native_mate/native_mate/handle.h",
-    "//third_party/native_mate/native_mate/object_template_builder.cc",
-    "//third_party/native_mate/native_mate/object_template_builder.h",
-    "//third_party/native_mate/native_mate/persistent_dictionary.cc",
-    "//third_party/native_mate/native_mate/persistent_dictionary.h",
-    "//third_party/native_mate/native_mate/scoped_persistent.h",
-    "//third_party/native_mate/native_mate/wrappable.cc",
-    "//third_party/native_mate/native_mate/wrappable.h",
-    "//third_party/native_mate/native_mate/wrappable_base.h",
-  ]
-}
-
-npm_action("atom_browserify_sandbox") {
-  deps = [ ":atom_js2c_copy" ]
-
-  sandbox_args = [
-    "lib/sandboxed_renderer/init.js",
-    "-r", "./lib/sandboxed_renderer/api/exports/electron.js:electron",
-    "-r", "./lib/sandboxed_renderer/api/exports/fs.js:fs",
-    "-r", "./lib/sandboxed_renderer/api/exports/os.js:os",
-    "-r", "./lib/sandboxed_renderer/api/exports/path.js:path",
-    "-r", "./lib/sandboxed_renderer/api/exports/child_process.js:child_process",
-  ]
-
-  inputs = [
-    "lib/sandboxed_renderer/init.js",
-    "lib/sandboxed_renderer/api/exports/electron.js",
-    "lib/sandboxed_renderer/api/exports/fs.js",
-    "lib/sandboxed_renderer/api/exports/os.js",
-    "lib/sandboxed_renderer/api/exports/path.js",
-    "lib/sandboxed_renderer/api/exports/child_process.js",
-  ]
-  outputs = [ "$target_gen_dir/js2c/preload_bundle.js" ]
-
-  script = "browserify"
-  args = sandbox_args + [
-    "-o", rebase_path(outputs[0])
-  ]
-}
-
-npm_action("atom_browserify_isolated") {
-  deps = [ ":atom_js2c_copy" ]
-
-  inputs = [ "lib/isolated_renderer/init.js" ]
-  outputs = [ "$target_gen_dir/js2c/isolated_bundle.js" ]
-
-  script = "browserify"
-  args = inputs + [
-    "-o", rebase_path(outputs[0])
-  ]
-}
-
-copy("atom_js2c_copy") {
-  sources = [
-    "lib/common/asar.js",
-    "lib/common/asar_init.js",
-  ]
-  outputs = [ "$target_gen_dir/js2c/{{source_file_part}}" ]
-}
-
-action("atom_js2c") {
-  deps = [
-    ":atom_js2c_copy",
-    ":atom_browserify_sandbox",
-    ":atom_browserify_isolated",
-  ]
-
-  js2c_sources = filenames_gypi.js2c_sources
-
-  browserify_sources = [
-    "$target_gen_dir/js2c/isolated_bundle.js",
-    "$target_gen_dir/js2c/preload_bundle.js",
-  ]
-
-  inputs = js2c_sources + browserify_sources
-
-  outputs = [ "$target_gen_dir/atom_natives.h" ]
-
-  script = "tools/js2c.py"
-  args = [
-    rebase_path("//third_party/electron_node")
-  ] + rebase_path(outputs, root_build_dir) + [
-    rebase_path("$target_gen_dir/js2c", root_build_dir)
-  ]
-}
-
-asar("js2asar") {
-  sources = filenames_gypi.js_sources
-  outputs = [ "$root_out_dir/resources/electron.asar" ]
-  root = "lib"
-}
-
-asar("app2asar") {
-  sources = filenames_gypi.default_app_sources
-  outputs = [ "$root_out_dir/resources/default_app.asar" ]
-  root = "default_app"
-}
-
-group("electron") {
-  deps = [ ":electron_lib" ]
-}
-
-static_library("electron_lib") {
-  configs += [
-    "//v8:external_startup_data",
-  ]
-  public_configs = [
-    ":branding",
-    ":features",
-  ]
-  deps = [
-    "//chrome/common:constants",
-    "//components/cdm/renderer",
-    "//components/network_session_configurator/common",
-    "//components/prefs",
-    "//components/printing/common",
-    "//components/security_state/content",
-    "//content/public/browser",
-    "//device/geolocation",
-    "//gin",
-    "//net:net_resources",
-    "//ppapi/host",
-    "//ppapi/proxy",
-    "//ppapi/shared_impl",
-    "//printing",
-    "//services/device/wake_lock/power_save_blocker", # TODO: this requires a visibility patch to chromium src
-    "//skia",
-    "//third_party/WebKit/public:blink",
-    "//third_party/boringssl",
-    "//third_party/crashpad/crashpad/client",
-    "//third_party/leveldatabase",
-    "//third_party/libyuv",
-    "//third_party/webrtc/modules/desktop_capture",
-    "//third_party/webrtc/modules/desktop_capture:primitives",
-    "//ui/events:dom_keycode_converter",
-    "//ui/views",
-    "//v8",
-    ":atom_js2c",
-    ":native_mate",
-    "brightray",
-    "build/node",
-  ]
-  if (is_mac) {
-    deps += [
-      "//ui/accelerated_widget_mac",
-      "//base/allocator:features",
-    ]
-  }
-  if (is_linux) {
-    deps += [
-      "//build/config/linux/gtk3",
-      "//chrome/browser/ui/libgtkui",
-      "//device/bluetooth",
-      "//third_party/breakpad:client",
-      "//ui/events/devices/x11",
-      "//ui/events/platform/x11",
-      "//ui/native_theme",
-      "//ui/views/controls/webview",
-      "//ui/wm",
-    ]
-    configs += [ ":gio_unix" ]
-  }
-  defines = [
-    # This is defined in skia/skia_common.gypi.
-    "SK_SUPPORT_LEGACY_GETTOPDEVICE",
-    # Disable warnings for g_settings_list_schemas.
-    "GLIB_DISABLE_DEPRECATION_WARNINGS",
-
-    # Import V8 symbols from shared library (node.dll / libnode.so)
-    "USING_V8_SHARED",
-    "USING_V8_PLATFORM_SHARED",
-    "USING_V8_BASE_SHARED",
-
-    # Enables SkBitmap size 64 operations
-    #"SK_SUPPORT_LEGACY_SAFESIZE64", # doesn't seem to be needed to build?
-  ]
-  include_dirs = [
-    "chromium_src",
-    ".",
-    "$target_gen_dir",
-    # TODO(nornagon): replace usage of SchemeRegistry by an actually exported
-    # API of blink, then delete this include dir.
-    "//third_party/WebKit/Source",
-    # NOTE(nornagon): other chromium files use the full path to include
-    # crashpad; this is just here for compatibility between GN and GYP, so that
-    # the #includes can be agnostic about where crashpad is vendored.
-    "//third_party/crashpad",
-  ]
-  if (is_linux) {
-    include_dirs += [
-      "//third_party/breakpad",
-    ]
-  }
-
-  extra_source_filters = []
-  if (!is_linux) {
-    extra_source_filters += [
-      "*\bx/*",
-      "*_x11.h",
-      "*_x11.cc",
-      "*_gtk.h",
-      "*_gtk.cc",
-    ]
-  }
-  if (!is_win) {
-    extra_source_filters += [
-      "*\bwin_*.h",
-      "*\bwin_*.cc",
-    ]
-  }
-  if (is_mac) {
-    extra_source_filters += [
-      "*_views.cc",
-      "*_views.h",
-      "*\bviews/*",
-      "*/autofill_popup.cc",
-      "*/autofill_popup.h",
-    ]
-  }
-
-  set_sources_assignment_filter(sources_assignment_filter + extra_source_filters)
-  sources = filenames_gypi.lib_sources
-  set_sources_assignment_filter(sources_assignment_filter)
-
-  if (enable_fake_location_provider) {
-    defines += [
-      "OVERRIDE_LOCATION_PROVIDER"
-    ]
-    sources += filenames_gypi.lib_sources_location_provider
-  }
-
-  if (enable_run_as_node) {
-    sources += [
-      "atom/app/node_main.cc",
-      "atom/app/node_main.h",
-    ]
-  }
-
-  if (enable_osr) {
-    sources += [
-      "atom/browser/api/atom_api_web_contents_osr.cc",
-      "atom/browser/osr/osr_output_device.cc",
-      "atom/browser/osr/osr_output_device.h",
-      "atom/browser/osr/osr_render_widget_host_view.cc",
-      "atom/browser/osr/osr_render_widget_host_view.h",
-      "atom/browser/osr/osr_render_widget_host_view_mac.mm",
-      "atom/browser/osr/osr_view_proxy.cc",
-      "atom/browser/osr/osr_view_proxy.h",
-      "atom/browser/osr/osr_web_contents_view.cc",
-      "atom/browser/osr/osr_web_contents_view.h",
-      "atom/browser/osr/osr_web_contents_view_mac.mm",
-    ]
-    deps += [
-      "//ui/compositor",
-      "//components/viz/service",
-    ]
-  }
-
-  if (enable_desktop_capturer) {
-    sources += [
-      "atom/browser/api/atom_api_desktop_capturer.cc",
-      "atom/browser/api/atom_api_desktop_capturer.h",
-    ]
-  }
-
-  if (is_mac) {
-    libs = [
-      "Squirrel.framework",
-      "ReactiveCocoa.framework",
-      "Mantle.framework",
-    ]
-    cflags_objcc = [
-      "-F", rebase_path("external_binaries", root_build_dir)
-    ]
-    if (true) { # !is_mas_build
-      # ReactiveCocoa which is used by Squirrel requires using __weak.
-      cflags_objcc += [ "-fobjc-weak" ]
-    }
-  }
-  if (is_linux) {
-    sources += filenames_gypi.lib_sources_linux
-    sources += filenames_gypi.lib_sources_nss
-  }
-}
-
-if (is_mac) {
-  electron_framework_name = electron_product_name + " Framework"
-  electron_helper_name = electron_product_name + " Helper"
-  electron_framework_version = "A"
-  electron_mac_bundle_id = "com.$electron_company_abbr.$electron_project_name"
-
-  mac_xib_bundle_data("electron_xibs") {
-    sources = [ "atom/common/resources/mac/MainMenu.xib" ]
-  }
-
-  bundle_data("electron_framework_resources") {
-    public_deps = [
-      "//content/shell:pak",
-      ":electron_locales",
-    ]
-    sources = [
-      "$root_out_dir/content_shell.pak",
-    ]
-    if (icu_use_data_file) {
-      sources += [ "$root_out_dir/icudtl.dat" ]
-      public_deps += [ "//third_party/icu:icudata" ]
-    }
-    if (v8_use_external_startup_data) {
-      sources += [
-        "$root_out_dir/natives_blob.bin",
-        "$root_out_dir/snapshot_blob.bin",
-      ]
-      public_deps += [ "//v8" ]
-    }
-    outputs = [
-      "{{bundle_resources_dir}}/{{source_file_part}}",
-    ]
-  }
-
-  bundle_data("electron_framework_libraries") {
-    public_deps = [ "build/node" ]
-    sources = [
-      "$root_out_dir/libnode.dylib"
-    ]
-    outputs = [
-      "{{bundle_contents_dir}}/Libraries/{{source_file_part}}"
-    ]
-  }
-
-  bundle_data("electron_framework_helpers") {
-    sources = [
-      "$root_out_dir/crashpad_handler",
-    ]
-
-    outputs = [
-      "{{bundle_resources_dir}}/{{source_file_part}}",
-    ]
-
-    public_deps = [
-      "//third_party/crashpad/crashpad/handler:crashpad_handler",
-    ]
-  }
-
-  mac_framework_bundle("electron_framework") {
-    output_name = electron_framework_name
-    framework_version = electron_framework_version
-    framework_contents = [ "Resources" ]
-    public_deps = [ ":electron_lib" ]
-    deps = [
-      "//base",
-      "//base:i18n",
-      ":electron_framework_helpers",
-      ":electron_framework_libraries",
-      ":electron_framework_resources",
-      ":electron_xibs",
-    ]
-    info_plist = "atom/common/resources/mac/Info.plist"
-    extra_substitutions = [
-      "ATOM_BUNDLE_ID=$electron_mac_bundle_id.framework",
-    ]
-
-    include_dirs = [
-      ".",
-    ]
-    sources = filenames_gypi.framework_sources
-
-    libs = [
-      "Carbon.framework",
-      "QuartzCore.framework",
-      "Quartz.framework",
-      "Security.framework",
-      "SecurityInterface.framework",
-      "ServiceManagement.framework",
-      "StoreKit.framework",
-    ]
-    ldflags = [
-      "-F", rebase_path("external_binaries", root_build_dir),
-      "-Wl,-install_name,@rpath/$output_name.framework/$output_name",
-      "-rpath",
-      "@loader_path/Libraries",
-    ]
-    if (is_component_build) {
-      ldflags += [
-        "-rpath",
-        "@executable_path/../../../../../.."
-      ]
-    }
-  }
-
-  mac_app_bundle("electron_helper_app") {
-    output_name = electron_helper_name
-    deps = [ ":electron_framework+link" ]
-    sources = filenames_gypi.app_sources
-    include_dirs = [ "." ]
-    info_plist = "atom/renderer/resources/mac/Info.plist"
-    extra_substitutions = [
-      "ATOM_BUNDLE_ID=$electron_mac_bundle_id.helper",
-    ]
-    ldflags = [
-      "-rpath",
-      "@executable_path/../../..",
-    ]
-  }
-
-  bundle_data("electron_app_framework_bundle_data") {
-    sources = [
-      "$root_out_dir/$electron_framework_name.framework",
-      "$root_out_dir/$electron_helper_name.app",
-      "external_binaries/Squirrel.framework",
-      "external_binaries/ReactiveCocoa.framework",
-      "external_binaries/Mantle.framework",
-    ]
-    outputs = [
-      "{{bundle_contents_dir}}/Frameworks/{{source_file_part}}",
-    ]
-    public_deps = [
-      ":electron_framework+link",
-      ":electron_helper_app",
-    ]
-  }
-
-  bundle_data("electron_app_resources") {
-    public_deps = [
-      ":js2asar",
-      ":app2asar",
-    ]
-    sources = [
-      "$root_out_dir/resources/electron.asar",
-      "$root_out_dir/resources/default_app.asar",
-    ]
-    outputs = [
-      "{{bundle_resources_dir}}/{{source_file_part}}"
-    ]
-  }
-
-  repack_locales("electron_locales") {
-    source_patterns = [
-      "${root_gen_dir}/content/app/strings/content_strings_",
-    ]
-    deps = [
-      "//content/app/strings",
-    ]
-
-    input_locales = locales
-
-    if (is_mac) {
-      output_locales = locales_as_mac_outputs
-    } else {
-      output_locales = locales
-    }
-
-    if (is_mac) {
-      output_dir = "$root_gen_dir/repack"
-      copy_data_to_bundle = true
-    } else {
-      output_dir = root_out_dir
-    }
-  }
-
-  mac_app_bundle("electron_app") {
-    output_name = electron_product_name
-    sources = filenames_gypi.app_sources
-    include_dirs = [ "." ]
-    deps = [
-      ":electron_app_framework_bundle_data",
-      ":electron_app_resources",
-    ]
-    info_plist = "atom/browser/resources/mac/Info.plist"
-    extra_substitutions = [
-      "ATOM_BUNDLE_ID=$electron_mac_bundle_id",
-    ]
-    ldflags = [
-      "-rpath",
-      "@executable_path/../Frameworks",
-    ]
-  }
-}
-
-if (is_linux) {
-  executable("electron_app") {
-    output_name = electron_project_name
-    sources = filenames_gypi.app_sources
-    include_dirs = [ "." ]
-    deps = [
-      ":app2asar",
-      ":electron_lib",
-      ":js2asar",
-      "//build/config:exe_and_shlib_deps",
-      "//chrome:packed_resources",
-      "//content/shell:copy_shell_resources",
-      "//content/shell:pak",
-      "//third_party/WebKit/public:image_resources",
-      "//ui/strings",
-    ]
-  }
-}

CONTRIBUTING.md

@@ -54,7 +54,3 @@ 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

@@ -1,73 +0,0 @@
-vars = {
-  'chromium_version':
-    '63.0.3239.150',
-  'libchromiumcontent_revision':
-    '82816abaad3930c3702cf23489f0506ba13b1529',
-  'node_version':
-    'v9.7.0-33-g538a5023af',
-  'native_mate_revision':
-    '4cd7d113915de0cc08e9a218be35bff9c7361906',
-
-  'chromium_git':
-    'https://chromium.googlesource.com',
-
-  'electron_git':
-    'https://github.com/electron',
-}
-
-deps = {
-  'src':
-    (Var("chromium_git")) + '/chromium/src.git@' + (Var("chromium_version")),
-  'src/libchromiumcontent':
-    (Var("electron_git")) + '/libchromiumcontent.git@' + (Var("libchromiumcontent_revision")),
-  'src/third_party/electron_node':
-    (Var("electron_git")) + '/node.git@' + (Var("node_version")),
-  'src/third_party/native_mate':
-    (Var("electron_git")) + '/native-mate.git@' + (Var("native_mate_revision")),
-}
-
-hooks = [
-  {
-    'action': [
-      'src/libchromiumcontent/script/apply-patches'
-    ],
-    'pattern':
-      'src/libchromiumcontent',
-    'name':
-      'patch_chromium'
-  },
-  {
-    'action': [
-      'src/electron/script/update-external-binaries.py'
-    ],
-    'pattern':
-      'src/electron/script/update-external-binaries.py',
-    'name':
-      'electron_external_binaries'
-  },
-  {
-    'action': [
-      'bash',
-      '-c',
-      # NOTE(nornagon): this ridiculous {{}} stuff is because these strings get
-      # variable-substituted twice by gclient.
-      'echo -e "#\\n{{{{\'variables\':{{{{}}}}}}}}" > src/third_party/electron_node/config.gypi',
-    ],
-    'pattern': 'src/third_party/electron_node',
-    'name': 'touch_node_config_gypi'
-  },
-  {
-    'action': [
-      'bash',
-      '-c',
-      'cd src/electron; npm install',
-    ],
-    'pattern': 'src/electron/package.json',
-    'name': 'electron_npm_deps'
-  },
-]
-
-recursedeps = [
-  'src',
-  'src/libchromiumcontent',
-]

Dockerfile

@@ -7,8 +7,8 @@ ENV HOME=/home
 RUN chmod a+rwx /home
 
 # Install node.js
-RUN curl -sL https://deb.nodesource.com/setup_10.x | bash -
-RUN apt-get install -y nodejs
+RUN curl -sL https://deb.nodesource.com/setup_8.x | bash -
+RUN apt-get update && apt-get install -y nodejs
 
 # Install wget used by crash reporter
 RUN apt-get install -y wget

Dockerfile.circleci

@@ -3,8 +3,8 @@ FROM electronbuilds/libchromiumcontent:0.0.4
 USER root
 
 # Install node.js
-RUN curl -sL https://deb.nodesource.com/setup_10.x | bash -
-RUN apt-get install -y nodejs
+RUN curl -sL https://deb.nodesource.com/setup_8.x | bash -
+RUN apt-get update && apt-get install -y nodejs
 
 # Install wget used by crash reporter
 RUN apt-get install -y wget

Jenkinsfile

@@ -0,0 +1,48 @@
+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()
+            }
+          }
+        }
+      }
+    }
+  }
+}

Jenkinsfile.arm64

@@ -0,0 +1,36 @@
+pipeline {
+  agent {
+    docker {
+      image 'electronbuilds/arm64v8:0.0.2'
+      args '--privileged'
+    }
+  }
+  environment {
+    TARGET_ARCH='arm64'
+    DISPLAY=':99.0'
+    MOCHA_TIMEOUT='60000'
+  }
+  stages {
+    stage('Bootstrap') {
+      steps {
+        sh 'script/bootstrap.py -v --dev --target_arch=$TARGET_ARCH'
+      }
+    }
+    stage('Build') {
+      steps {
+        sh 'script/build.py -c D --ninja-path /usr/local/ninja/ninja'
+      }
+    }
+    stage('Test') {
+      steps {
+        sh '/etc/init.d/xvfb start'
+        sh 'script/test.py --ci'
+      }
+    }
+  }
+  post {
+    always {
+      cleanWs()
+    }
+  }
+}

README.md

@@ -3,11 +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)
 [![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron?type=dev)
 [![Join the Electron Community on Slack](https://atom-slack.herokuapp.com/badge.svg)](https://atom-slack.herokuapp.com/)
 
 :memo: Available Translations: 🇨🇳 🇹🇼 🇧🇷 🇪🇸 🇰🇷 🇯🇵 🇷🇺 🇫🇷 🇹🇭 🇳🇱 🇹🇷 🇮🇩 🇺🇦 🇨🇿 🇮🇹.
-View these docs in other languages at [electron/i18n](https://github.com/electron/i18n/tree/master/content/).
+View these docs in other languages at [electron/electron-i18n](https://github.com/electron/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
@@ -29,11 +30,11 @@ 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 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
+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
 [Electron versioning](docs/tutorial/electron-versioning.md).
 
 For more installation options and troubleshooting tips, see
@@ -84,7 +85,7 @@ const child = proc.spawn(electron)
 
 ## Documentation Translations
 
-Find documentation translations in [electron/i18n](https://github.com/electron/i18n).
+Find documentation translations in [electron/electron-i18n](https://github.com/electron/electron-i18n).
 
 ## Community
 

appveyor.yml

@@ -1,73 +0,0 @@
-build_cloud: electron-16
-image: electron-16-vs2017-15.4.5
-build_script:
-- ps: >-
-    echo "Build worker image $env:APPVEYOR_BUILD_WORKER_IMAGE"
-
-    &"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe"
-    
-    if($env:SKIP_GYP_BUILD -eq "true") {
-      Write-warning "Skipping debug build for older branch"; Exit-AppveyorBuild
-    } elseif(($env:APPVEYOR_PULL_REQUEST_HEAD_REPO_NAME -split "/")[0] -eq ($env:APPVEYOR_REPO_NAME -split "/")[0]) {
-      Write-warning "Skipping PR build for branch"; Exit-AppveyorBuild
-    } else {
-      Add-Path "$env:ProgramFiles (x86)\Windows Kits\10\Debuggers\x64"
-      $env:path = "$env:ProgramFiles (x86)\Windows Kits\10\Debuggers\x64;$env:path"
-      if($env:APPVEYOR_SCHEDULED_BUILD -eq 'True')  {
-        $env:RUN_RELEASE_BUILD = "1"
-      }
-      $Message = (git log --format=%B -n 1 HEAD) | Out-String
-      if ((Test-Path Env:\RUN_RELEASE_BUILD)) {
-        $env:ELECTRON_RELEASE = '1'
-        Write-Output "release build triggered from api"
-      }
-      if ((Test-Path Env:\ELECTRON_RELEASE)) {
-        Write-Output "Running release build"
-        python script\bootstrap.py --target_arch=$env:TARGET_ARCH
-        python script\build.py -c R
-        python script\create-dist.py
-      } else {
-        Write-Output "Running debug build"
-        python script\bootstrap.py --target_arch=$env:TARGET_ARCH --dev
-        python script\build.py -c D
-      }
-      if ($? -ne 'True') {
-        throw "Build failed with exit code $?"
-      } else {
-        "Build succeeded."
-      }
-      Push-AppveyorArtifact out
-    }
-test_script:
-- ps: >-
-    if (Test-Path Env:\ELECTRON_RELEASE) {
-      Write-Output "Skipping tests for release build"
-    } else {
-      Write-Output "Running tests for debug build"
-      python script\test.py --ci --rebuild_native_modules
-      if ($LASTEXITCODE -ne '0') {
-        throw "Tests failed with exit code $LASTEXITCODE"
-      } else {
-        Write-Output "Tests succeeded."
-      }
-      python script\verify-ffmpeg.py
-      if ($LASTEXITCODE -ne '0') {
-        throw "Verify ffmpeg failed with exit code $LASTEXITCODE"
-      } else {
-        "Verify ffmpeg succeeded."
-      }
-    }
-artifacts:
-- path: test-results.xml
-  name: test-results.xml
-deploy_script:
-- ps: >-
-    if (Test-Path Env:\ELECTRON_RELEASE) {
-      if (Test-Path Env:\RUN_RELEASE_BUILD) {
-        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

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

atom/app/atom_content_client.cc

@@ -7,6 +7,7 @@
 #include <string>
 #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"
@@ -18,90 +19,20 @@
 #include "content/public/common/content_constants.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "content/public/common/user_agent.h"
-#include "media/media_features.h"
+#include "pdf/pdf.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
-#include "third_party/widevine/cdm/widevine_cdm_common.h"
+#include "third_party/widevine/cdm/stub/widevine_cdm_version.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/url_constants.h"
 
-#if defined(WIDEVINE_CDM_AVAILABLE)
-#include "base/native_library.h"
-#include "base/strings/stringprintf.h"
+#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
 #include "chrome/common/widevine_cdm_constants.h"
-#include "content/public/common/cdm_info.h"
-#include "media/base/video_codecs.h"
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
-
-#if defined(ENABLE_PDF_VIEWER)
-#include "atom/common/atom_constants.h"
-#include "pdf/pdf.h"
-#endif  // defined(ENABLE_PDF_VIEWER)
+#endif
 
 namespace atom {
 
 namespace {
 
-#if defined(WIDEVINE_CDM_AVAILABLE)
-bool IsWidevineAvailable(base::FilePath* adapter_path,
-                         base::FilePath* cdm_path,
-                         std::vector<media::VideoCodec>* codecs_supported) {
-  static enum {
-    NOT_CHECKED,
-    FOUND,
-    NOT_FOUND,
-  } widevine_cdm_file_check = NOT_CHECKED;
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  *adapter_path = command_line->GetSwitchValuePath(switches::kWidevineCdmPath);
-  if (!adapter_path->empty()) {
-    *cdm_path = adapter_path->DirName().AppendASCII(
-        base::GetNativeLibraryName(kWidevineCdmLibraryName));
-    if (widevine_cdm_file_check == NOT_CHECKED) {
-      widevine_cdm_file_check =
-          (base::PathExists(*adapter_path) && 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)
-      return true;
-    }
-  }
-  return false;
-}
-void AddWidevineAdapterFromCommandLine(
-    base::CommandLine* command_line,
-    std::vector<content::PepperPluginInfo>* plugins) {
-  base::FilePath adapter_path;
-  base::FilePath cdm_path;
-  std::vector<media::VideoCodec> video_codecs_supported;
-  if (IsWidevineAvailable(&adapter_path, &cdm_path, &video_codecs_supported)) {
-    auto cdm_version_string =
-        command_line->GetSwitchValueASCII(switches::kWidevineCdmVersion);
-    content::PepperPluginInfo info;
-    info.is_out_of_process = true;
-    info.path = adapter_path;
-    info.name = kWidevineCdmDisplayName;
-    info.description =
-        base::StringPrintf("%s (version: %s)", kWidevineCdmDescription,
-                           cdm_version_string.c_str());
-    info.version = cdm_version_string;
-    info.permissions = kWidevineCdmPluginPermissions;
-    content::WebPluginMimeType mime_type(kWidevineCdmPluginMimeType,
-                                         kWidevineCdmPluginExtension,
-                                         kWidevineCdmPluginMimeTypeDescription);
-    info.mime_types.push_back(mime_type);
-    plugins->push_back(info);
-  }
-}
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
-
-#if defined(ENABLE_PEPPER_FLASH)
 content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
                                                 const std::string& version) {
   content::PepperPluginInfo plugin;
@@ -126,38 +57,60 @@ 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;
 }
 
-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;
+#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);
 
-  auto flash_version =
-      command_line->GetSwitchValueASCII(switches::kPpapiFlashVersion);
+  // 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));
 
-  plugins->push_back(CreatePepperFlashInfo(flash_path, flash_version));
+  widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
+  widevine_cdm.permissions = kWidevineCdmPluginPermissions;
+
+  return widevine_cdm;
 }
-#endif  // defined(ENABLE_PEPPER_FLASH)
+#endif
 
 void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
-#if defined(ENABLE_PDF_VIEWER)
   content::PepperPluginInfo pdf_info;
   pdf_info.is_internal = true;
   pdf_info.is_out_of_process = true;
@@ -174,33 +127,71 @@ 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  // defined(ENABLE_PDF_VIEWER)
 }
 
 void ConvertStringWithSeparatorToVector(std::vector<std::string>* vec,
                                         const char* separator,
                                         const char* cmd_switch) {
-  auto* command_line = base::CommandLine::ForCurrentProcess();
+  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);
+                             base::TRIM_WHITESPACE,
+                             base::SPLIT_WANT_NONEMPTY);
 }
 
 }  // namespace
 
-AtomContentClient::AtomContentClient() {}
+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);
+  return content::BuildUserAgentFromProduct(
+      "Chrome/" CHROME_VERSION_STRING " "
+      ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING);
 }
 
 base::string16 AtomContentClient::GetLocalizedString(int message_id) const {
@@ -224,43 +215,11 @@ void AtomContentClient::AddAdditionalSchemes(Schemes* schemes) {
 
 void AtomContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-#if defined(ENABLE_PEPPER_FLASH)
-  AddPepperFlashFromCommandLine(command_line, plugins);
-#endif  // defined(ENABLE_PEPPER_FLASH)
-#if defined(WIDEVINE_CDM_AVAILABLE)
-  AddWidevineAdapterFromCommandLine(command_line, plugins);
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+  AddPepperFlashFromCommandLine(plugins);
+#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
+  AddWidevineCdmFromCommandLine(plugins);
+#endif
   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 adapter_path;
-    base::FilePath cdm_path;
-    std::vector<media::VideoCodec> video_codecs_supported;
-    bool supports_persistent_license = false;
-    if (IsWidevineAvailable(&adapter_path, &cdm_path,
-                            &video_codecs_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());
-
-      cdms->push_back(content::CdmInfo(
-          kWidevineCdmDisplayName, kWidevineCdmGuid, version, cdm_path,
-          kWidevineCdmFileSystemId, video_codecs_supported,
-          supports_persistent_license, kWidevineKeySystem, false));
-    }
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
-  }
-}
-
 }  // namespace atom

atom/app/atom_content_client.h

@@ -16,7 +16,7 @@ namespace atom {
 class AtomContentClient : public brightray::ContentClient {
  public:
   AtomContentClient();
-  ~AtomContentClient() override;
+  virtual ~AtomContentClient();
 
  protected:
   // content::ContentClient:
@@ -26,9 +26,6 @@ class AtomContentClient : public brightray::ContentClient {
   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

@@ -9,13 +9,11 @@
 
 #if defined(OS_MACOSX)
 extern "C" {
-__attribute__((visibility("default"))) int AtomMain(int argc, char* argv[]);
+__attribute__((visibility("default")))
+int AtomMain(int argc, char* argv[]);
 
-#ifdef ENABLE_RUN_AS_NODE
-__attribute__((visibility("default"))) int AtomInitializeICUandStartNode(
-    int argc,
-    char* argv[]);
-#endif
+__attribute__((visibility("default")))
+int AtomInitializeICUandStartNode(int argc, char *argv[]);
 }
 #endif  // OS_MACOSX
 

atom/app/atom_library_main.mm

@@ -14,6 +14,7 @@
 #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);
@@ -23,8 +24,7 @@ int AtomMain(int argc, char* argv[]) {
   return content::ContentMain(params);
 }
 
-#ifdef ENABLE_RUN_AS_NODE
-int AtomInitializeICUandStartNode(int argc, char* argv[]) {
+int AtomInitializeICUandStartNode(int argc, char *argv[]) {
   base::AtExitManager atexit_manager;
   base::mac::ScopedNSAutoreleasePool pool;
   base::mac::SetOverrideFrameworkBundlePath(
@@ -35,4 +35,4 @@ int AtomInitializeICUandStartNode(int argc, char* argv[]) {
   base::i18n::InitializeICU();
   return atom::NodeMain(argc, argv);
 }
-#endif
+#endif  // OS_MACOSX

atom/app/atom_login_helper.mm

@@ -3,8 +3,7 @@
 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

@@ -24,7 +24,7 @@
 #include "base/win/windows_version.h"
 #include "content/public/app/sandbox_helper_win.h"
 #include "sandbox/win/src/sandbox_types.h"
-#elif defined(OS_LINUX)                   // defined(OS_WIN)
+#elif defined(OS_LINUX)  // defined(OS_WIN)
 #include "atom/app/atom_main_delegate.h"  // NOLINT
 #include "content/public/app/content_main.h"
 #else  // defined(OS_LINUX)
@@ -39,10 +39,9 @@
 namespace {
 
 #ifdef ENABLE_RUN_AS_NODE
-const char kRunAsNode[] = "ELECTRON_RUN_AS_NODE";
+const auto kRunAsNode = "ELECTRON_RUN_AS_NODE";
 #endif
 
-#if defined(ENABLE_RUN_AS_NODE) || defined(OS_WIN)
 bool IsEnvSet(const char* name) {
 #if defined(OS_WIN)
   size_t required_size;
@@ -53,7 +52,6 @@ bool IsEnvSet(const char* name) {
   return indicator && indicator[0] != '\0';
 #endif
 }
-#endif
 
 }  // namespace
 
@@ -117,7 +115,9 @@ 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

atom/app/atom_main_delegate.cc

@@ -22,7 +22,6 @@
 #include "chrome/common/chrome_paths.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_features.h"
-#include "services/service_manager/sandbox/switches.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
@@ -46,23 +45,22 @@ bool IsBrowserProcess(base::CommandLine* cmd) {
 }
 
 #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() {}
+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)
@@ -79,12 +77,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.
-  auto env = base::Environment::Create();
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
   if (!command_line->HasSwitch(::switches::kEnableLogging) &&
       !env->HasVar("ELECTRON_ENABLE_LOGGING")) {
     settings.logging_dest = logging::LOG_NONE;
@@ -101,11 +99,6 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
   bool enable_stack_dumping = true;
 #else
   bool enable_stack_dumping = env->HasVar("ELECTRON_ENABLE_STACK_DUMPING");
-#endif
-#if defined(ARCH_CPU_ARM_FAMILY) && defined(ARCH_CPU_32_BITS)
-  // For 32bit ARM enabling stack printing would end up crashing.
-  // https://github.com/electron/electron/pull/11230#issuecomment-363232482
-  enable_stack_dumping = false;
 #endif
   if (enable_stack_dumping)
     base::debug::EnableInProcessStackDumping();
@@ -130,9 +123,14 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 void AtomMainDelegate::PreSandboxStartup() {
   brightray::MainDelegate::PreSandboxStartup();
 
-  auto* command_line = base::CommandLine::ForCurrentProcess();
-  std::string process_type =
-      command_line->GetSwitchValueASCII(::switches::kProcessType);
+  // 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);
+
+  auto command_line = base::CommandLine::ForCurrentProcess();
+  std::string process_type = command_line->GetSwitchValueASCII(
+      ::switches::kProcessType);
 
   // Only append arguments for browser process.
   if (!IsBrowserProcess(command_line))
@@ -142,8 +140,7 @@ void AtomMainDelegate::PreSandboxStartup() {
     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(
-          service_manager::switches::kDisableSetuidSandbox);
+      command_line->AppendSwitch(::switches::kDisableSetuidSandbox);
     } else {
       // Disable renderer sandbox for most of node's functions.
       command_line->AppendSwitch(::switches::kNoSandbox);
@@ -165,11 +162,11 @@ content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
 }
 
 content::ContentRendererClient*
-AtomMainDelegate::CreateContentRendererClient() {
+    AtomMainDelegate::CreateContentRendererClient() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableSandbox) ||
+        switches::kEnableSandbox) ||
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          ::switches::kNoSandbox)) {
+        ::switches::kNoSandbox)) {
     renderer_client_.reset(new AtomSandboxedRendererClient);
   } else {
     renderer_client_.reset(new AtomRendererClient);
@@ -205,7 +202,7 @@ bool AtomMainDelegate::DelaySandboxInitialization(
 
 std::unique_ptr<brightray::ContentClient>
 AtomMainDelegate::CreateContentClient() {
-  return std::make_unique<AtomContentClient>();
+  return std::unique_ptr<brightray::ContentClient>(new AtomContentClient);
 }
 
 }  // namespace atom

atom/app/atom_main_delegate.h

@@ -15,7 +15,7 @@ namespace atom {
 class AtomMainDelegate : public brightray::MainDelegate {
  public:
   AtomMainDelegate();
-  ~AtomMainDelegate() override;
+  ~AtomMainDelegate();
 
  protected:
   // content::ContentMainDelegate:

atom/app/atom_main_delegate_mac.mm

@@ -4,9 +4,9 @@
 
 #include "atom/app/atom_main_delegate.h"
 
+#include "base/mac/bundle_locations.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"
@@ -20,17 +20,16 @@ namespace atom {
 namespace {
 
 base::FilePath GetFrameworksPath() {
-  return brightray::MainApplicationBundlePath()
-      .Append("Contents")
-      .Append("Frameworks");
+  return brightray::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
@@ -42,11 +41,11 @@ 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,
+                                   brightray::GetApplicationName());
   if (!base::PathExists(helper_path))
     LOG(FATAL) << "Unable to find helper app";
   PathService::Override(content::CHILD_PROCESS_EXE, helper_path);

atom/app/command_line_args.h

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

atom/app/node_main.cc

@@ -12,7 +12,6 @@
 #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"
@@ -26,7 +25,7 @@
 
 namespace atom {
 
-int NodeMain(int argc, char* argv[]) {
+int NodeMain(int argc, char *argv[]) {
   base::CommandLine::Init(argc, argv);
 
   int exit_code = 1;
@@ -38,12 +37,11 @@ int NodeMain(int argc, char* argv[]) {
     base::ThreadTaskRunnerHandle handle(uv_task_runner);
 
     // Initialize feature list.
-    auto feature_list = std::make_unique<base::FeatureList>();
+    std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->InitializeFromCommandLine("", "");
     base::FeatureList::SetInstance(std::move(feature_list));
 
-    gin::V8Initializer::LoadV8Snapshot(
-        gin::V8Initializer::V8SnapshotFileType::kWithAdditionalContext);
+    gin::V8Initializer::LoadV8Snapshot();
     gin::V8Initializer::LoadV8Natives();
 
     // V8 requires a task scheduler apparently
@@ -52,16 +50,14 @@ int NodeMain(int argc, char* argv[]) {
     // Initialize gin::IsolateHolder.
     JavascriptEnvironment gin_env;
 
-    // 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(
-        node::CreateIsolateData(gin_env.isolate(), loop, gin_env.platform()),
-        gin_env.context(), argc, argv, exec_argc, exec_argv);
+        &isolate_data, gin_env.context(), argc, argv,
+        exec_argc, exec_argv);
 
     // Enable support for v8 inspector.
     NodeDebugger node_debugger(env);
@@ -83,7 +79,6 @@ int NodeMain(int argc, char* argv[]) {
     bool more;
     do {
       more = uv_run(env->event_loop(), UV_RUN_ONCE);
-      gin_env.platform()->DrainBackgroundTasks(env->isolate());
       if (more == false) {
         node::EmitBeforeExit(env);
 
@@ -97,8 +92,6 @@ int NodeMain(int argc, char* argv[]) {
 
     exit_code = node::EmitExit(env);
     node::RunAtExit(env);
-    gin_env.platform()->DrainBackgroundTasks(env->isolate());
-    gin_env.platform()->CancelPendingDelayedTasks(env->isolate());
 
     node::FreeEnvironment(env);
   }

atom/app/node_main.h

@@ -9,7 +9,7 @@
 
 namespace atom {
 
-int NodeMain(int argc, char* argv[]);
+int NodeMain(int argc, char *argv[]);
 
 }  // namespace atom
 

atom/app/uv_task_runner.cc

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

atom/app/uv_task_runner.h

@@ -8,9 +8,8 @@
 #include <map>
 
 #include "base/callback.h"
-#include "base/location.h"
 #include "base/single_thread_task_runner.h"
-#include "uv.h"  // NOLINT(build/include)
+#include "vendor/node/deps/uv/include/uv.h"
 
 namespace atom {
 
@@ -18,18 +17,19 @@ namespace atom {
 class UvTaskRunner : public base::SingleThreadTaskRunner {
  public:
   explicit UvTaskRunner(uv_loop_t* loop);
+  ~UvTaskRunner() override;
 
   // base::SingleThreadTaskRunner:
-  bool PostDelayedTask(const base::Location& from_here,
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override;
   bool RunsTasksInCurrentSequence() const override;
-  bool PostNonNestableDelayedTask(const base::Location& from_here,
-                                  base::OnceClosure task,
-                                  base::TimeDelta delay) override;
+  bool PostNonNestableDelayedTask(
+      const tracked_objects::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.cc

@@ -20,7 +20,6 @@
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/net_converter.h"
-#include "atom/common/native_mate_converters/network_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
@@ -48,7 +47,6 @@
 #include "native_mate/object_template_builder.h"
 #include "net/ssl/client_cert_identity.h"
 #include "net/ssl/ssl_cert_request_info.h"
-#include "services/network/public/cpp/network_switches.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image.h"
 
@@ -66,10 +64,9 @@ using atom::Browser;
 namespace mate {
 
 #if defined(OS_WIN)
-template <>
+template<>
 struct Converter<Browser::UserTask> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      Browser::UserTask* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
@@ -86,14 +83,13 @@ struct Converter<Browser::UserTask> {
   }
 };
 
-using atom::JumpListCategory;
 using atom::JumpListItem;
+using atom::JumpListCategory;
 using atom::JumpListResult;
 
-template <>
+template<>
 struct Converter<JumpListItem::Type> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      JumpListItem::Type* out) {
     std::string item_type;
     if (!ConvertFromV8(isolate, val, &item_type))
@@ -131,10 +127,9 @@ struct Converter<JumpListItem::Type> {
   }
 };
 
-template <>
+template<>
 struct Converter<JumpListItem> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      JumpListItem* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
@@ -194,10 +189,9 @@ struct Converter<JumpListItem> {
   }
 };
 
-template <>
+template<>
 struct Converter<JumpListCategory::Type> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      JumpListCategory::Type* out) {
     std::string category_type;
     if (!ConvertFromV8(isolate, val, &category_type))
@@ -241,10 +235,9 @@ struct Converter<JumpListCategory::Type> {
   }
 };
 
-template <>
+template<>
 struct Converter<JumpListCategory> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      JumpListCategory* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
@@ -271,7 +264,7 @@ struct Converter<JumpListCategory> {
 };
 
 // static
-template <>
+template<>
 struct Converter<JumpListResult> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate, JumpListResult val) {
     std::string result_code;
@@ -305,10 +298,9 @@ struct Converter<JumpListResult> {
 };
 #endif
 
-template <>
+template<>
 struct Converter<Browser::LoginItemSettings> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      Browser::LoginItemSettings* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
@@ -333,16 +325,15 @@ struct Converter<Browser::LoginItemSettings> {
   }
 };
 
-template <>
+template<>
 struct Converter<content::CertificateRequestResultType> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      content::CertificateRequestResultType* out) {
     bool b;
     if (!ConvertFromV8(isolate, val, &b))
       return false;
-    *out = b ? content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE
-             : content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL;
+    *out = b ? content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE :
+               content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL;
     return true;
   }
 };
@@ -351,16 +342,6 @@ struct Converter<content::CertificateRequestResultType> {
 
 namespace atom {
 
-ProcessMetric::ProcessMetric(int type,
-                             base::ProcessId pid,
-                             std::unique_ptr<base::ProcessMetrics> metrics) {
-  this->type = type;
-  this->pid = pid;
-  this->metrics = std::move(metrics);
-}
-
-ProcessMetric::~ProcessMetric() = default;
-
 namespace api {
 
 namespace {
@@ -424,9 +405,7 @@ int GetPathConstant(const std::string& name) {
 }
 
 bool NotificationCallbackWrapper(
-    const base::Callback<
-        void(const base::CommandLine::StringVector& command_line,
-             const base::FilePath& current_directory)>& callback,
+    const ProcessSingleton::NotificationCallback& callback,
     const base::CommandLine::StringVector& cmd,
     const base::FilePath& cwd) {
   // Make sure the callback is called after app gets ready.
@@ -436,7 +415,7 @@ bool NotificationCallbackWrapper(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner(
         base::ThreadTaskRunnerHandle::Get());
     task_runner->PostTask(
-        FROM_HERE, base::BindOnce(base::IgnoreResult(callback), cmd, cwd));
+        FROM_HERE, base::Bind(base::IgnoreResult(callback), cmd, cwd));
   }
   // ProcessSingleton needs to know whether current process is quiting.
   return !Browser::Get()->is_shutting_down();
@@ -500,11 +479,12 @@ void PassLoginInformation(scoped_refptr<LoginHandler> login_handler,
 }
 
 #if defined(USE_NSS_CERTS)
-int ImportIntoCertStore(CertificateManagerModel* model,
-                        const base::DictionaryValue& options) {
+int ImportIntoCertStore(
+    CertificateManagerModel* model,
+    const base::DictionaryValue& options) {
   std::string file_data, cert_path;
   base::string16 password;
-  net::ScopedCERTCertificateList imported_certs;
+  net::CertificateList imported_certs;
   int rv = -1;
   options.GetString("certificate", &cert_path);
   options.GetString("password", &password);
@@ -512,13 +492,17 @@ int ImportIntoCertStore(CertificateManagerModel* model,
   if (!cert_path.empty()) {
     if (base::ReadFileToString(base::FilePath(cert_path), &file_data)) {
       auto module = model->cert_db()->GetPrivateSlot();
-      rv = model->ImportFromPKCS12(module.get(), file_data, password, true,
+      rv = model->ImportFromPKCS12(module.get(),
+                                   file_data,
+                                   password,
+                                   true,
                                    &imported_certs);
       if (imported_certs.size() > 1) {
         auto it = imported_certs.begin();
         ++it;  // skip first which would  be the client certificate.
         for (; it != imported_certs.end(); ++it)
-          rv &= model->SetCertTrust(it->get(), net::CA_CERT,
+          rv &= model->SetCertTrust(it->get(),
+                                    net::CA_CERT,
                                     net::NSSCertDatabase::TRUSTED_SSL);
       }
     }
@@ -537,7 +521,7 @@ void OnIconDataAvailable(v8::Isolate* isolate,
     callback.Run(v8::Null(isolate), *icon);
   } else {
     v8::Local<v8::String> error_message =
-        v8::String::NewFromUtf8(isolate, "Failed to get file icon.");
+      v8::String::NewFromUtf8(isolate, "Failed to get file icon.");
     callback.Run(v8::Exception::Error(error_message), gfx::Image());
   }
 }
@@ -549,31 +533,29 @@ App::App(v8::Isolate* isolate) {
   Browser::Get()->AddObserver(this);
   content::GpuDataManager::GetInstance()->AddObserver(this);
   base::ProcessId pid = base::GetCurrentProcId();
-  auto process_metric = std::make_unique<atom::ProcessMetric>(
-      content::PROCESS_TYPE_BROWSER, pid,
-      base::ProcessMetrics::CreateCurrentProcessMetrics());
+  std::unique_ptr<atom::ProcessMetric> process_metric(
+      new atom::ProcessMetric(
+          content::PROCESS_TYPE_BROWSER,
+          pid,
+          base::ProcessMetrics::CreateCurrentProcessMetrics()));
   app_metrics_[pid] = std::move(process_metric);
   Init(isolate);
 }
 
 App::~App() {
-  static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())
-      ->set_delegate(nullptr);
+  static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())->set_delegate(
+      nullptr);
   Browser::Get()->RemoveObserver(this);
   content::GpuDataManager::GetInstance()->RemoveObserver(this);
   content::BrowserChildProcessObserver::Remove(this);
 }
 
 void App::OnBeforeQuit(bool* prevent_default) {
-  if (Emit("before-quit")) {
-    *prevent_default = true;
-  }
+  *prevent_default = Emit("before-quit");
 }
 
 void App::OnWillQuit(bool* prevent_default) {
-  if (Emit("will-quit")) {
-    *prevent_default = true;
-  }
+  *prevent_default = Emit("will-quit");
 }
 
 void App::OnWindowAllClosed() {
@@ -591,9 +573,7 @@ void App::OnQuit() {
 }
 
 void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
-  if (Emit("open-file", file_path)) {
-    *prevent_default = true;
-  }
+  *prevent_default = Emit("open-file", file_path);
 }
 
 void App::OnOpenURL(const std::string& url) {
@@ -629,37 +609,36 @@ void App::OnAccessibilitySupportChanged() {
 }
 
 #if defined(OS_MACOSX)
-void App::OnWillContinueUserActivity(bool* prevent_default,
-                                     const std::string& type) {
-  if (Emit("will-continue-activity", type)) {
-    *prevent_default = true;
-  }
+void App::OnWillContinueUserActivity(
+    bool* prevent_default,
+    const std::string& type) {
+  *prevent_default = Emit("will-continue-activity", type);
 }
 
-void App::OnDidFailToContinueUserActivity(const std::string& type,
-                                          const std::string& error) {
+void App::OnDidFailToContinueUserActivity(
+    const std::string& type,
+    const std::string& error) {
   Emit("continue-activity-error", type, error);
 }
 
-void App::OnContinueUserActivity(bool* prevent_default,
-                                 const std::string& type,
-                                 const base::DictionaryValue& user_info) {
-  if (Emit("continue-activity", type, user_info)) {
-    *prevent_default = true;
-  }
+void App::OnContinueUserActivity(
+    bool* prevent_default,
+    const std::string& type,
+    const base::DictionaryValue& user_info) {
+  *prevent_default = Emit("continue-activity", type, user_info);
 }
 
-void App::OnUserActivityWasContinued(const std::string& type,
-                                     const base::DictionaryValue& user_info) {
+void App::OnUserActivityWasContinued(
+    const std::string& type,
+    const base::DictionaryValue& user_info) {
   Emit("activity-was-continued", type, user_info);
 }
 
-void App::OnUpdateUserActivityState(bool* prevent_default,
-                                    const std::string& type,
-                                    const base::DictionaryValue& user_info) {
-  if (Emit("update-activity-state", type, user_info)) {
-    *prevent_default = true;
-  }
+void App::OnUpdateUserActivityState(
+    bool* prevent_default,
+    const std::string& type,
+    const base::DictionaryValue& user_info) {
+  *prevent_default = Emit("update-activity-state", type, user_info);
 }
 
 void App::OnNewWindowForTab() {
@@ -667,17 +646,20 @@ void App::OnNewWindowForTab() {
 }
 #endif
 
-void App::OnLogin(scoped_refptr<LoginHandler> login_handler,
+void App::OnLogin(LoginHandler* login_handler,
                   const base::DictionaryValue& request_details) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
   bool prevent_default = false;
   content::WebContents* web_contents = login_handler->GetWebContents();
   if (web_contents) {
-    prevent_default = Emit(
-        "login", WebContents::CreateFrom(isolate(), web_contents),
-        request_details, login_handler->auth_info(),
-        base::Bind(&PassLoginInformation, base::RetainedRef(login_handler)));
+    prevent_default =
+        Emit("login",
+             WebContents::CreateFrom(isolate(), web_contents),
+             request_details,
+             login_handler->auth_info(),
+             base::Bind(&PassLoginInformation,
+                        make_scoped_refptr(login_handler)));
   }
 
   // Default behavior is to always cancel the auth.
@@ -697,7 +679,7 @@ bool App::CanCreateWindow(
     WindowOpenDisposition disposition,
     const blink::mojom::WindowFeatures& features,
     const std::vector<std::string>& additional_features,
-    const scoped_refptr<network::ResourceRequestBody>& body,
+    const scoped_refptr<content::ResourceRequestBody>& body,
     bool user_gesture,
     bool opener_suppressed,
     bool* no_javascript_access) {
@@ -707,8 +689,8 @@ bool App::CanCreateWindow(
       content::WebContents::FromRenderFrameHost(opener);
   if (web_contents) {
     auto api_web_contents = WebContents::CreateFrom(isolate(), web_contents);
-    api_web_contents->OnCreateWindow(target_url, referrer, frame_name,
-                                     disposition, additional_features, body);
+    api_web_contents->OnCreateWindow(target_url, frame_name, disposition,
+                                     additional_features, body);
   }
 
   return false;
@@ -720,15 +702,19 @@ void App::AllowCertificateError(
     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)>&
         callback) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  bool prevent_default = Emit(
-      "certificate-error", WebContents::CreateFrom(isolate(), web_contents),
-      request_url, net::ErrorToString(cert_error), ssl_info.cert, callback);
+  bool prevent_default = Emit("certificate-error",
+                              WebContents::CreateFrom(isolate(), web_contents),
+                              request_url,
+                              net::ErrorToString(cert_error),
+                              ssl_info.cert,
+                              callback);
 
   // Deny the certificate by default.
   if (!prevent_default)
@@ -740,8 +726,8 @@ void App::SelectClientCertificate(
     net::SSLCertRequestInfo* cert_request_info,
     net::ClientCertIdentityList identities,
     std::unique_ptr<content::ClientCertificateDelegate> delegate) {
-  std::shared_ptr<content::ClientCertificateDelegate> shared_delegate(
-      delegate.release());
+  std::shared_ptr<content::ClientCertificateDelegate>
+      shared_delegate(delegate.release());
 
   // Convert the ClientCertIdentityList to a CertificateList
   // to avoid changes in the API.
@@ -771,7 +757,7 @@ void App::SelectClientCertificate(
 
 void App::OnGpuProcessCrashed(base::TerminationStatus status) {
   Emit("gpu-process-crashed",
-       status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED);
+    status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED);
 }
 
 void App::BrowserChildProcessLaunchedAndConnected(
@@ -813,8 +799,9 @@ void App::ChildProcessLaunched(int process_type, base::ProcessHandle handle) {
   std::unique_ptr<base::ProcessMetrics> metrics(
       base::ProcessMetrics::CreateProcessMetrics(handle));
 #endif
-  app_metrics_[pid] = std::make_unique<atom::ProcessMetric>(process_type, pid,
-                                                            std::move(metrics));
+  std::unique_ptr<atom::ProcessMetric> process_metric(
+      new atom::ProcessMetric(process_type, pid, std::move(metrics)));
+  app_metrics_[pid] = std::move(process_metric);
 }
 
 void App::ChildProcessDisconnected(base::ProcessId pid) {
@@ -867,43 +854,30 @@ std::string App::GetLocale() {
   return g_browser_process->GetApplicationLocale();
 }
 
-void App::OnSecondInstance(const base::CommandLine::StringVector& cmd,
-                           const base::FilePath& cwd) {
-  Emit("second-instance", cmd, cwd);
-}
-
-bool App::HasSingleInstanceLock() const {
+bool App::MakeSingleInstance(
+    const ProcessSingleton::NotificationCallback& callback) {
   if (process_singleton_)
-    return true;
-  return false;
-}
-
-bool App::RequestSingleInstanceLock() {
-  if (HasSingleInstanceLock())
-    return true;
+    return false;
 
   base::FilePath user_dir;
   PathService::Get(brightray::DIR_USER_DATA, &user_dir);
-
-  auto cb = base::Bind(&App::OnSecondInstance, base::Unretained(this));
-
   process_singleton_.reset(new ProcessSingleton(
-      user_dir, base::Bind(NotificationCallbackWrapper, cb)));
+      user_dir, base::Bind(NotificationCallbackWrapper, callback)));
 
   switch (process_singleton_->NotifyOtherProcessOrCreate()) {
     case ProcessSingleton::NotifyResult::LOCK_ERROR:
     case ProcessSingleton::NotifyResult::PROFILE_IN_USE:
     case ProcessSingleton::NotifyResult::PROCESS_NOTIFIED: {
       process_singleton_.reset();
-      return false;
+      return true;
     }
     case ProcessSingleton::NotifyResult::PROCESS_NONE:
     default:  // Shouldn't be needed, but VS warns if it is not there.
-      return true;
+      return false;
   }
 }
 
-void App::ReleaseSingleInstanceLock() {
+void App::ReleaseSingleInstance() {
   if (process_singleton_) {
     process_singleton_->Cleanup();
     process_singleton_.reset();
@@ -945,9 +919,8 @@ bool App::Relaunch(mate::Arguments* js_args) {
 
 void App::DisableHardwareAcceleration(mate::Arguments* args) {
   if (Browser::Get()->is_ready()) {
-    args->ThrowError(
-        "app.disableHardwareAcceleration() can only be called "
-        "before app is ready");
+    args->ThrowError("app.disableHardwareAcceleration() can only be called "
+                     "before app is ready");
     return;
   }
   content::GpuDataManager::GetInstance()->DisableHardwareAcceleration();
@@ -965,12 +938,12 @@ void App::DisableDomainBlockingFor3DAPIs(mate::Arguments* args) {
 }
 
 bool App::IsAccessibilitySupportEnabled() {
-  auto* ax_state = content::BrowserAccessibilityState::GetInstance();
+  auto ax_state = content::BrowserAccessibilityState::GetInstance();
   return ax_state->IsAccessibleBrowser();
 }
 
 void App::SetAccessibilitySupportEnabled(bool enabled) {
-  auto* ax_state = content::BrowserAccessibilityState::GetInstance();
+  auto ax_state = content::BrowserAccessibilityState::GetInstance();
   if (enabled) {
     ax_state->OnScreenReaderDetected();
   } else {
@@ -986,15 +959,18 @@ Browser::LoginItemSettings App::GetLoginItemSettings(mate::Arguments* args) {
 }
 
 #if defined(USE_NSS_CERTS)
-void App::ImportCertificate(const base::DictionaryValue& options,
-                            const net::CompletionCallback& callback) {
+void App::ImportCertificate(
+    const base::DictionaryValue& options,
+    const net::CompletionCallback& callback) {
   auto browser_context = AtomBrowserContext::From("", false);
   if (!certificate_manager_model_) {
     std::unique_ptr<base::DictionaryValue> copy = options.CreateDeepCopy();
     CertificateManagerModel::Create(
         browser_context.get(),
         base::Bind(&App::OnCertificateManagerModelCreated,
-                   base::Unretained(this), base::Passed(&copy), callback));
+                   base::Unretained(this),
+                   base::Passed(&copy),
+                   callback));
     return;
   }
 
@@ -1007,8 +983,8 @@ void App::OnCertificateManagerModelCreated(
     const net::CompletionCallback& callback,
     std::unique_ptr<CertificateManagerModel> model) {
   certificate_manager_model_ = std::move(model);
-  int rv =
-      ImportIntoCertStore(certificate_manager_model_.get(), *(options.get()));
+  int rv = ImportIntoCertStore(certificate_manager_model_.get(),
+                               *(options.get()));
   callback.Run(rv);
 }
 #endif
@@ -1037,7 +1013,7 @@ JumpListResult App::SetJumpList(v8::Local<v8::Value> val,
   std::vector<JumpListCategory> categories;
   bool delete_jump_list = val->IsNull();
   if (!delete_jump_list &&
-      !mate::ConvertFromV8(args->isolate(), val, &categories)) {
+    !mate::ConvertFromV8(args->isolate(), val, &categories)) {
     args->ThrowError("Argument must be null or an array of categories");
     return JumpListResult::ARGUMENT_ERROR;
   }
@@ -1045,8 +1021,9 @@ JumpListResult App::SetJumpList(v8::Local<v8::Value> val,
   JumpList jump_list(Browser::Get()->GetAppUserModelID());
 
   if (delete_jump_list) {
-    return jump_list.Delete() ? JumpListResult::SUCCESS
-                              : JumpListResult::GENERIC_ERROR;
+    return jump_list.Delete()
+      ? JumpListResult::SUCCESS
+      : JumpListResult::GENERIC_ERROR;
   }
 
   // Start a transaction that updates the JumpList of this application.
@@ -1069,7 +1046,8 @@ JumpListResult App::SetJumpList(v8::Local<v8::Value> val,
 }
 #endif  // defined(OS_WIN)
 
-void App::GetFileIcon(const base::FilePath& path, mate::Arguments* args) {
+void App::GetFileIcon(const base::FilePath& path,
+                      mate::Arguments* args) {
   mate::Dictionary options;
   IconLoader::IconSize icon_size;
   FileIconCallback callback;
@@ -1092,7 +1070,7 @@ void App::GetFileIcon(const base::FilePath& path, mate::Arguments* args) {
     return;
   }
 
-  auto* icon_manager = g_browser_process->GetIconManager();
+  auto icon_manager = g_browser_process->GetIconManager();
   gfx::Image* icon =
       icon_manager->LookupIconFromFilepath(normalized_path, icon_size);
   if (icon) {
@@ -1114,12 +1092,10 @@ std::vector<mate::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
     mate::Dictionary memory_dict = mate::Dictionary::CreateEmpty(isolate);
     mate::Dictionary cpu_dict = mate::Dictionary::CreateEmpty(isolate);
 
-    memory_dict.Set(
-        "workingSetSize",
+    memory_dict.Set("workingSetSize",
         static_cast<double>(
             process_metric.second->metrics->GetWorkingSetSize() >> 10));
-    memory_dict.Set(
-        "peakWorkingSetSize",
+    memory_dict.Set("peakWorkingSetSize",
         static_cast<double>(
             process_metric.second->metrics->GetPeakWorkingSetSize() >> 10));
 
@@ -1131,14 +1107,13 @@ std::vector<mate::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
     }
 
     pid_dict.Set("memory", memory_dict);
-    cpu_dict.Set(
-        "percentCPUUsage",
-        process_metric.second->metrics->GetPlatformIndependentCPUUsage() /
-            processor_count);
+    cpu_dict.Set("percentCPUUsage",
+        process_metric.second->metrics->GetPlatformIndependentCPUUsage()
+        / processor_count);
 
 #if !defined(OS_WIN)
     cpu_dict.Set("idleWakeupsPerSecond",
-                 process_metric.second->metrics->GetIdleWakeupsPerSecond());
+        process_metric.second->metrics->GetIdleWakeupsPerSecond());
 #else
     // Chrome's underlying process_metrics.cc will throw a non-fatal warning
     // that this method isn't implemented on Windows, so set it to 0 instead
@@ -1148,8 +1123,8 @@ std::vector<mate::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
 
     pid_dict.Set("cpu", cpu_dict);
     pid_dict.Set("pid", process_metric.second->pid);
-    pid_dict.Set("type", content::GetProcessTypeNameInEnglish(
-                             process_metric.second->type));
+    pid_dict.Set("type",
+        content::GetProcessTypeNameInEnglish(process_metric.second->type));
     result.push_back(pid_dict);
   }
 
@@ -1158,19 +1133,18 @@ std::vector<mate::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
 
 v8::Local<v8::Value> App::GetGPUFeatureStatus(v8::Isolate* isolate) {
   auto status = content::GetFeatureStatus();
-  base::DictionaryValue temp;
-  return mate::ConvertToV8(isolate, status ? *status : temp);
+  return mate::ConvertToV8(isolate,
+                           status ? *status : base::DictionaryValue());
 }
 
 void App::EnableMixedSandbox(mate::Arguments* args) {
   if (Browser::Get()->is_ready()) {
-    args->ThrowError(
-        "app.enableMixedSandbox() can only be called "
-        "before app is ready");
+    args->ThrowError("app.enableMixedSandbox() can only be called "
+                     "before app is ready");
     return;
   }
 
-  auto* command_line = base::CommandLine::ForCurrentProcess();
+  auto command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(::switches::kNoSandbox)) {
 #if defined(OS_WIN)
     const base::CommandLine::CharType* noSandboxArg = L"--no-sandbox";
@@ -1206,8 +1180,8 @@ mate::Handle<App> App::Create(v8::Isolate* isolate) {
 }
 
 // static
-void App::BuildPrototype(v8::Isolate* isolate,
-                         v8::Local<v8::FunctionTemplate> prototype) {
+void App::BuildPrototype(
+    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "App"));
   auto browser = base::Unretained(Browser::Get());
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
@@ -1268,9 +1242,8 @@ void App::BuildPrototype(v8::Isolate* isolate,
 #if defined(USE_NSS_CERTS)
       .SetMethod("importCertificate", &App::ImportCertificate)
 #endif
-      .SetMethod("hasSingleInstanceLock", &App::HasSingleInstanceLock)
-      .SetMethod("requestSingleInstanceLock", &App::RequestSingleInstanceLock)
-      .SetMethod("releaseSingleInstanceLock", &App::ReleaseSingleInstanceLock)
+      .SetMethod("makeSingleInstance", &App::MakeSingleInstance)
+      .SetMethod("releaseSingleInstance", &App::ReleaseSingleInstance)
       .SetMethod("relaunch", &App::Relaunch)
       .SetMethod("isAccessibilitySupportEnabled",
                  &App::IsAccessibilitySupportEnabled)
@@ -1283,15 +1256,15 @@ void App::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getFileIcon", &App::GetFileIcon)
       .SetMethod("getAppMetrics", &App::GetAppMetrics)
       .SetMethod("getGPUFeatureStatus", &App::GetGPUFeatureStatus)
-// TODO(juturu): Remove in 2.0, deprecate before then with warnings
-#if defined(OS_MACOSX)
+      // TODO(juturu): Remove in 2.0, deprecate before then with warnings
+      #if defined(OS_MACOSX)
       .SetMethod("moveToApplicationsFolder", &App::MoveToApplicationsFolder)
       .SetMethod("isInApplicationsFolder", &App::IsInApplicationsFolder)
-#endif
-#if defined(MAS_BUILD)
+      #endif
+      #if defined(MAS_BUILD)
       .SetMethod("startAccessingSecurityScopedResource",
                  &App::StartAccessingSecurityScopedResource)
-#endif
+      #endif
       .SetMethod("enableMixedSandbox", &App::EnableMixedSandbox);
 }
 
@@ -1299,14 +1272,15 @@ void App::BuildPrototype(v8::Isolate* isolate,
 
 }  // namespace atom
 
+
 namespace {
 
 void AppendSwitch(const std::string& switch_string, mate::Arguments* args) {
-  auto* command_line = base::CommandLine::ForCurrentProcess();
+  auto command_line = base::CommandLine::ForCurrentProcess();
 
   if (base::EndsWith(switch_string, "-path",
                      base::CompareCase::INSENSITIVE_ASCII) ||
-      switch_string == network::switches::kLogNetLog) {
+      switch_string == switches::kLogNetLog) {
     base::FilePath path;
     args->GetNext(&path);
     command_line->AppendSwitchPath(switch_string, path);
@@ -1335,19 +1309,18 @@ void DockSetMenu(atom::api::Menu* menu) {
 }
 #endif
 
-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();
-  auto* command_line = base::CommandLine::ForCurrentProcess();
+  auto command_line = base::CommandLine::ForCurrentProcess();
 
   mate::Dictionary dict(isolate, exports);
   dict.Set("App", atom::api::App::GetConstructor(isolate)->GetFunction());
   dict.Set("app", atom::api::App::Create(isolate));
   dict.SetMethod("appendSwitch", &AppendSwitch);
-  dict.SetMethod("appendArgument", base::Bind(&base::CommandLine::AppendArg,
-                                              base::Unretained(command_line)));
+  dict.SetMethod("appendArgument",
+                 base::Bind(&base::CommandLine::AppendArg,
+                            base::Unretained(command_line)));
 #if defined(OS_MACOSX)
   auto browser = base::Unretained(Browser::Get());
   dict.SetMethod("dockBounce", &DockBounce);
@@ -1369,4 +1342,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_app, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_app, Initialize)

atom/browser/api/atom_api_app.h

@@ -52,8 +52,11 @@ struct ProcessMetric {
 
   ProcessMetric(int type,
                 base::ProcessId pid,
-                std::unique_ptr<base::ProcessMetrics> metrics);
-  ~ProcessMetric();
+                std::unique_ptr<base::ProcessMetrics> metrics) {
+    this->type = type;
+    this->pid = pid;
+    this->metrics = std::move(metrics);
+  }
 };
 
 namespace api {
@@ -64,8 +67,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);
 
@@ -98,18 +101,21 @@ 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(scoped_refptr<LoginHandler> login_handler,
+  void OnLogin(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;
@@ -127,6 +133,7 @@ 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)>&
@@ -147,7 +154,7 @@ class App : public AtomBrowserClient::Delegate,
                        WindowOpenDisposition disposition,
                        const blink::mojom::WindowFeatures& features,
                        const std::vector<std::string>& additional_features,
-                       const scoped_refptr<network::ResourceRequestBody>& body,
+                       const scoped_refptr<content::ResourceRequestBody>& body,
                        bool user_gesture,
                        bool opener_suppressed,
                        bool* no_javascript_access) override;
@@ -160,10 +167,10 @@ class App : public AtomBrowserClient::Delegate,
       const content::ChildProcessData& data) override;
   void BrowserChildProcessHostDisconnected(
       const content::ChildProcessData& data) override;
-  void BrowserChildProcessCrashed(const content::ChildProcessData& data,
-                                  int exit_code) override;
-  void BrowserChildProcessKilled(const content::ChildProcessData& data,
-                                 int exit_code) override;
+  void BrowserChildProcessCrashed(
+      const content::ChildProcessData& data, int exit_code) override;
+  void BrowserChildProcessKilled(
+      const content::ChildProcessData& data, int exit_code) override;
 
  private:
   void SetAppPath(const base::FilePath& app_path);
@@ -178,11 +185,9 @@ class App : public AtomBrowserClient::Delegate,
 
   void SetDesktopName(const std::string& desktop_name);
   std::string GetLocale();
-  void OnSecondInstance(const base::CommandLine::StringVector& cmd,
-                        const base::FilePath& cwd);
-  bool HasSingleInstanceLock() const;
-  bool RequestSingleInstanceLock();
-  void ReleaseSingleInstanceLock();
+  bool MakeSingleInstance(
+      const ProcessSingleton::NotificationCallback& callback);
+  void ReleaseSingleInstance();
   bool Relaunch(mate::Arguments* args);
   void DisableHardwareAcceleration(mate::Arguments* args);
   void DisableDomainBlockingFor3DAPIs(mate::Arguments* args);
@@ -193,7 +198,8 @@ class App : public AtomBrowserClient::Delegate,
   void ImportCertificate(const base::DictionaryValue& options,
                          const net::CompletionCallback& callback);
 #endif
-  void GetFileIcon(const base::FilePath& path, mate::Arguments* args);
+  void GetFileIcon(const base::FilePath& path,
+                   mate::Arguments* args);
 
   std::vector<mate::Dictionary> GetAppMetrics(v8::Isolate* isolate);
   v8::Local<v8::Value> GetGPUFeatureStatus(v8::Isolate* isolate);
@@ -205,7 +211,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)
@@ -228,7 +234,8 @@ 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,27 +19,23 @@ 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));
   }
 
@@ -58,6 +54,6 @@ base::Callback<void()> App::StartAccessingSecurityScopedResource(
   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,20 +49,21 @@ 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"),
@@ -103,8 +104,6 @@ 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();
@@ -122,8 +121,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)
@@ -136,14 +135,13 @@ void AutoUpdater::BuildPrototype(v8::Isolate* isolate,
 
 }  // 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));
@@ -152,4 +150,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_auto_updater, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_auto_updater, Initialize)

atom/browser/api/atom_api_auto_updater.h

@@ -32,9 +32,8 @@ 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) override;
+  void OnError(const std::string& message, const int code,
+               const std::string& domain);
   void OnCheckingForUpdate() override;
   void OnUpdateAvailable() override;
   void OnUpdateNotAvailable() override;

atom/browser/api/atom_api_box_layout.cc

@@ -1,87 +0,0 @@
-// 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_box_layout.h"
-
-#include <string>
-
-#include "atom/browser/api/atom_api_view.h"
-#include "atom/common/api/constructor.h"
-#include "native_mate/dictionary.h"
-
-#include "atom/common/node_includes.h"
-
-namespace mate {
-
-template <>
-struct Converter<views::BoxLayout::Orientation> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     views::BoxLayout::Orientation* out) {
-    std::string orientation;
-    if (!ConvertFromV8(isolate, val, &orientation))
-      return false;
-    if (orientation == "horizontal")
-      *out = views::BoxLayout::kHorizontal;
-    else if (orientation == "vertical")
-      *out = views::BoxLayout::kVertical;
-    else
-      return false;
-    return true;
-  }
-};
-
-}  // namespace mate
-
-namespace atom {
-
-namespace api {
-
-BoxLayout::BoxLayout(views::BoxLayout::Orientation orientation)
-    : LayoutManager(new views::BoxLayout(orientation)) {}
-
-BoxLayout::~BoxLayout() {}
-
-void BoxLayout::SetFlexForView(mate::Handle<View> view, int flex) {
-  auto* box_layout = static_cast<views::BoxLayout*>(layout_manager());
-  box_layout->SetFlexForView(view->view(), flex);
-}
-
-// static
-mate::WrappableBase* BoxLayout::New(mate::Arguments* args,
-                                    views::BoxLayout::Orientation orientation) {
-  auto* layout = new BoxLayout(orientation);
-  layout->InitWith(args->isolate(), args->GetThis());
-  return layout;
-}
-
-// static
-void BoxLayout::BuildPrototype(v8::Isolate* isolate,
-                               v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(mate::StringToV8(isolate, "BoxLayout"));
-  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
-      .SetMethod("setFlexForView", &BoxLayout::SetFlexForView);
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-namespace {
-
-using atom::api::BoxLayout;
-
-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("BoxLayout", mate::CreateConstructor<BoxLayout>(
-                            isolate, base::Bind(&BoxLayout::New)));
-}
-
-}  // namespace
-
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_box_layout, Initialize)

atom/browser/api/atom_api_box_layout.h

@@ -1,40 +0,0 @@
-// 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_BOX_LAYOUT_H_
-#define ATOM_BROWSER_API_ATOM_API_BOX_LAYOUT_H_
-
-#include "atom/browser/api/atom_api_layout_manager.h"
-#include "native_mate/handle.h"
-#include "ui/views/layout/box_layout.h"
-
-namespace atom {
-
-namespace api {
-
-class View;
-
-class BoxLayout : public LayoutManager {
- public:
-  static mate::WrappableBase* New(mate::Arguments* args,
-                                  views::BoxLayout::Orientation orientation);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::FunctionTemplate> prototype);
-
-  void SetFlexForView(mate::Handle<View> view, int flex);
-
- protected:
-  explicit BoxLayout(views::BoxLayout::Orientation orientation);
-  ~BoxLayout() override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(BoxLayout);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_BOX_LAYOUT_H_

atom/browser/api/atom_api_browser_view.cc

@@ -51,7 +51,8 @@ namespace api {
 
 BrowserView::BrowserView(v8::Isolate* isolate,
                          v8::Local<v8::Object> wrapper,
-                         const mate::Dictionary& options) {
+                         const mate::Dictionary& options)
+    : api_web_contents_(nullptr) {
   Init(isolate, wrapper, options);
 }
 
@@ -152,13 +153,13 @@ void Initialize(v8::Local<v8::Object> exports,
   mate::Dictionary browser_view(
       isolate, BrowserView::GetConstructor(isolate)->GetFunction());
   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_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_browser_view, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_browser_view, Initialize)

atom/browser/api/atom_api_browser_view.h

@@ -59,7 +59,7 @@ class BrowserView : public mate::TrackableObject<BrowserView> {
   v8::Local<v8::Value> GetWebContents();
 
   v8::Global<v8::Value> web_contents_;
-  class WebContents* api_web_contents_ = nullptr;
+  class WebContents* api_web_contents_;
 
   std::unique_ptr<NativeBrowserView> view_;
 

atom/browser/api/atom_api_browser_window.cc

@@ -1,452 +0,0 @@
-// 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 "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/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.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->dict()->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.get();
-  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);
-
-  // Tell the content module to initialize renderer widget with transparent
-  // mode.
-  ui::GpuSwitchingManager::SetTransparent(window()->transparent());
-
-  // 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)
-  if (!window()->has_frame())
-    OverrideNSWindowContentView(web_contents->managed_web_contents());
-#endif
-
-  // Init window after everything has been setup.
-  window()->InitFromOptions(options);
-}
-
-BrowserWindow::~BrowserWindow() {
-  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->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() {
-  DCHECK(web_contents());
-
-  // 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();
-  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));
-}
-
-void BrowserWindow::SetBrowserView(v8::Local<v8::Value> value) {
-  TopLevelWindow::SetBrowserView(value);
-#if defined(OS_MACOSX)
-  UpdateDraggableRegions(nullptr, draggable_regions_);
-#endif
-}
-
-void BrowserWindow::SetVibrancy(v8::Isolate* isolate,
-                                v8::Local<v8::Value> value) {
-  std::string type = mate::V8ToString(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->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);
-
-  api_web_contents_->DestroyWebContents(true /* async */);
-  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_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_window, Initialize)

atom/browser/api/atom_api_browser_window.h

@@ -1,126 +0,0 @@
-// 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 <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 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(brightray::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_;
-  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

@@ -1,130 +0,0 @@
-// 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/common/draggable_region.h"
-#include "base/mac/scoped_nsobject.h"
-#include "brightray/browser/inspectable_web_contents_view.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(
-    brightray::InspectableWebContents* iwc) {
-  // Make NativeWindow use a NSView as content view.
-  static_cast<NativeWindowMac*>(window())->OverrideNSWindowContentView();
-  // Add webview to contentView.
-  NSView* webView = iwc->GetView()->GetNativeView();
-  NSView* contentView = [window()->GetNativeWindow() contentView];
-  [webView setFrame:[contentView bounds]];
-  [contentView addSubview:webView];
-  [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();
-  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);
-  }
-
-  if (window_->browser_view())
-    window_->browser_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

@@ -1,24 +0,0 @@
-// 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_button.cc

@@ -1,58 +0,0 @@
-// 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_button.h"
-
-#include "atom/common/api/constructor.h"
-#include "native_mate/dictionary.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace api {
-
-Button::Button(views::Button* button) : View(button) {
-  view()->set_owned_by_client();
-}
-
-Button::~Button() {}
-
-void Button::ButtonPressed(views::Button* sender, const ui::Event& event) {
-  Emit("click");
-}
-
-// static
-mate::WrappableBase* Button::New(mate::Arguments* args) {
-  args->ThrowError("Button can not be created directly");
-  return nullptr;
-}
-
-// static
-void Button::BuildPrototype(v8::Isolate* isolate,
-                            v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(mate::StringToV8(isolate, "Button"));
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-namespace {
-
-using atom::api::Button;
-
-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("Button",
-           mate::CreateConstructor<Button>(isolate, base::Bind(&Button::New)));
-}
-
-}  // namespace
-
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_button, Initialize)

atom/browser/api/atom_api_button.h

@@ -1,38 +0,0 @@
-// 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_BUTTON_H_
-#define ATOM_BROWSER_API_ATOM_API_BUTTON_H_
-
-#include "atom/browser/api/atom_api_view.h"
-#include "native_mate/handle.h"
-#include "ui/views/controls/button/button.h"
-
-namespace atom {
-
-namespace api {
-
-class Button : public View, public views::ButtonListener {
- public:
-  static mate::WrappableBase* New(mate::Arguments* args);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::FunctionTemplate> prototype);
-
- protected:
-  explicit Button(views::Button* view);
-  ~Button() override;
-
-  // views::ButtonListener:
-  void ButtonPressed(views::Button* sender, const ui::Event& event) override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Button);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_BUTTON_H_

atom/browser/api/atom_api_content_tracing.cc

@@ -18,7 +18,7 @@ using content::TracingController;
 
 namespace mate {
 
-template <>
+template<>
 struct Converter<base::trace_event::TraceConfig> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
@@ -41,39 +41,36 @@ namespace {
 
 using CompletionCallback = base::Callback<void(const base::FilePath&)>;
 
-scoped_refptr<TracingController::TraceDataEndpoint> GetTraceDataEndpoint(
-    const base::FilePath& path,
-    const CompletionCallback& callback) {
+scoped_refptr<TracingController::TraceDataSink> GetTraceDataSink(
+    const base::FilePath& path, const CompletionCallback& callback) {
   base::FilePath result_file_path = path;
   if (result_file_path.empty() && !base::CreateTemporaryFile(&result_file_path))
     LOG(ERROR) << "Creating temporary file failed";
 
-  return TracingController::CreateFileEndpoint(
-      result_file_path, base::Bind(callback, result_file_path));
+  return TracingController::CreateFileSink(result_file_path,
+                                           base::Bind(callback,
+                                                      result_file_path));
 }
 
 void StopRecording(const base::FilePath& path,
                    const CompletionCallback& callback) {
   TracingController::GetInstance()->StopTracing(
-      GetTraceDataEndpoint(path, callback));
+      GetTraceDataSink(path, callback));
 }
 
-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) {
   auto controller = base::Unretained(TracingController::GetInstance());
   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", base::Bind(
+      &TracingController::GetCategories, controller));
+  dict.SetMethod("startRecording", base::Bind(
+      &TracingController::StartTracing, controller));
   dict.SetMethod("stopRecording", &StopRecording);
-  dict.SetMethod(
-      "getTraceBufferUsage",
-      base::Bind(&TracingController::GetTraceBufferUsage, controller));
+  dict.SetMethod("getTraceBufferUsage", base::Bind(
+      &TracingController::GetTraceBufferUsage, controller));
 }
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_content_tracing, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_content_tracing, Initialize)

atom/browser/api/atom_api_cookies.cc

@@ -5,7 +5,6 @@
 #include "atom/browser/api/atom_api_cookies.h"
 
 #include "atom/browser/atom_browser_context.h"
-#include "atom/browser/request_context_delegate.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"
@@ -15,17 +14,18 @@
 #include "content/public/browser/browser_thread.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
-#include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_monster.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 +36,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,21 +55,25 @@ struct Converter<net::CanonicalCookie> {
   }
 };
 
-template <>
-struct Converter<net::CookieChangeCause> {
+template<>
+struct Converter<net::CookieStore::ChangeCause> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const net::CookieChangeCause& val) {
+                                   const net::CookieStore::ChangeCause& val) {
     switch (val) {
-      case net::CookieChangeCause::INSERTED:
-      case net::CookieChangeCause::EXPLICIT:
+      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:
         return mate::StringToV8(isolate, "explicit");
-      case net::CookieChangeCause::OVERWRITE:
+      case net::CookieStore::ChangeCause::OVERWRITE:
         return mate::StringToV8(isolate, "overwrite");
-      case net::CookieChangeCause::EXPIRED:
+      case net::CookieStore::ChangeCause::EXPIRED:
         return mate::StringToV8(isolate, "expired");
-      case net::CookieChangeCause::EVICTED:
+      case net::CookieStore::ChangeCause::EVICTED:
         return mate::StringToV8(isolate, "evicted");
-      case net::CookieChangeCause::EXPIRED_OVERWRITE:
+      case net::CookieStore::ChangeCause::EXPIRED_OVERWRITE:
         return mate::StringToV8(isolate, "expired-overwrite");
       default:
         return mate::StringToV8(isolate, "unknown");
@@ -162,16 +166,15 @@ void GetCookiesOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
     GetCookieStore(getter)->GetAllCookiesAsync(filtered_callback);
   else
     GetCookieStore(getter)->GetAllCookiesForURLAsync(GURL(url),
-                                                     filtered_callback);
+        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 GURL& url, const std::string& name,
                             const base::Closure& callback) {
   GetCookieStore(getter)->DeleteCookieAsync(
-      url, name, base::BindOnce(RunCallbackInUI, callback));
+      url, name, base::Bind(RunCallbackInUI, callback));
 }
 
 // Callback of SetCookie.
@@ -184,7 +187,7 @@ void OnSetCookie(const Cookies::SetCallback& callback, bool success) {
 void FlushCookieStoreOnIOThread(
     scoped_refptr<net::URLRequestContextGetter> getter,
     const base::Closure& callback) {
-  GetCookieStore(getter)->FlushStore(base::BindOnce(RunCallbackInUI, callback));
+  GetCookieStore(getter)->FlushStore(base::Bind(RunCallbackInUI, callback));
 }
 
 // Sets cookie with |details| in IO thread.
@@ -207,106 +210,90 @@ 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);
   }
 
-  std::unique_ptr<net::CanonicalCookie> canonical_cookie(
-      net::CanonicalCookie::CreateSanitizedCookie(
-          GURL(url), name, value, domain, path, creation_time, expiration_time,
-          last_access_time, secure, http_only,
-          net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT));
-  auto completion_callback = base::BindOnce(OnSetCookie, callback);
-  if (!canonical_cookie || !canonical_cookie->IsCanonical()) {
-    std::move(completion_callback).Run(false);
-    return;
-  }
-  if (url.empty()) {
-    std::move(completion_callback).Run(false);
-    return;
-  }
-  if (name.empty()) {
-    std::move(completion_callback).Run(false);
-    return;
-  }
-  GetCookieStore(getter)->SetCanonicalCookieAsync(
-      std::move(canonical_cookie), secure, http_only,
-      std::move(completion_callback));
+  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));
 }
 
 }  // namespace
 
-Cookies::Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context)
-    : browser_context_(browser_context) {
+Cookies::Cookies(v8::Isolate* isolate,
+                 AtomBrowserContext* browser_context)
+      : request_context_getter_(browser_context->url_request_context_getter()),
+        cookie_delegate_(browser_context->cookie_delegate()) {
   Init(isolate);
-  cookie_change_subscription_ =
-      browser_context->GetRequestContextDelegate()
-          ->RegisterCookieChangeCallback(
-              base::Bind(&Cookies::OnCookieChanged, base::Unretained(this)));
+  cookie_delegate_->AddObserver(this);
 }
 
-Cookies::~Cookies() {}
+Cookies::~Cookies() {
+  cookie_delegate_->RemoveObserver(this);
+}
 
 void Cookies::Get(const base::DictionaryValue& filter,
                   const GetCallback& callback) {
   std::unique_ptr<base::DictionaryValue> copied(filter.CreateDeepCopy());
-  auto* getter = browser_context_->GetRequestContext();
+  auto getter = make_scoped_refptr(request_context_getter_);
   content::BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(GetCookiesOnIO, base::RetainedRef(getter),
-                     std::move(copied), callback));
+      base::Bind(GetCookiesOnIO, getter, Passed(&copied), callback));
 }
 
-void Cookies::Remove(const GURL& url,
-                     const std::string& name,
+void Cookies::Remove(const GURL& url, const std::string& name,
                      const base::Closure& callback) {
-  auto* getter = browser_context_->GetRequestContext();
+  auto getter = make_scoped_refptr(request_context_getter_);
   content::BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(RemoveCookieOnIOThread, base::RetainedRef(getter), url,
-                     name, callback));
+      base::Bind(RemoveCookieOnIOThread, getter, url, name, callback));
 }
 
 void Cookies::Set(const base::DictionaryValue& details,
                   const SetCallback& callback) {
   std::unique_ptr<base::DictionaryValue> copied(details.CreateDeepCopy());
-  auto* getter = browser_context_->GetRequestContext();
+  auto getter = make_scoped_refptr(request_context_getter_);
   content::BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(SetCookieOnIO, base::RetainedRef(getter),
-                     std::move(copied), callback));
+      base::Bind(SetCookieOnIO, getter, Passed(&copied), callback));
 }
 
 void Cookies::FlushStore(const base::Closure& callback) {
-  auto* getter = browser_context_->GetRequestContext();
+  auto getter = make_scoped_refptr(request_context_getter_);
   content::BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(FlushCookieStoreOnIOThread, base::RetainedRef(getter),
-                     callback));
+      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

@@ -8,8 +8,8 @@
 #include <string>
 
 #include "atom/browser/api/trackable_object.h"
-#include "atom/browser/net/cookie_details.h"
-#include "base/callback_list.h"
+#include "atom/browser/net/atom_cookie_delegate.h"
+#include "base/callback.h"
 #include "native_mate/handle.h"
 #include "net/cookies/canonical_cookie.h"
 
@@ -27,7 +27,8 @@ class AtomBrowserContext;
 
 namespace api {
 
-class Cookies : public mate::TrackableObject<Cookies> {
+class Cookies : public mate::TrackableObject<Cookies>,
+                public AtomCookieDelegate::Observer {
  public:
   enum Error {
     SUCCESS,
@@ -49,19 +50,19 @@ class Cookies : public mate::TrackableObject<Cookies> {
   ~Cookies() override;
 
   void Get(const base::DictionaryValue& filter, const GetCallback& callback);
-  void Remove(const GURL& url,
-              const std::string& name,
+  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);
 
-  // AtomBrowserContext::RegisterCookieChangeCallback subscription:
-  void OnCookieChanged(const CookieDetails*);
+  // AtomCookieDelegate::Observer:
+  void OnCookieChanged(const net::CanonicalCookie& cookie,
+                       bool removed,
+                       net::CookieStore::ChangeCause cause) override;
 
  private:
-  std::unique_ptr<base::CallbackList<void(const CookieDetails*)>::Subscription>
-      cookie_change_subscription_;
-  scoped_refptr<AtomBrowserContext> browser_context_;
+  net::URLRequestContextGetter* request_context_getter_;
+  scoped_refptr<AtomCookieDelegate> cookie_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(Cookies);
 };

atom/browser/api/atom_api_debugger.cc

@@ -6,13 +6,16 @@
 
 #include <string>
 
+#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"
 
@@ -23,22 +26,25 @@ namespace atom {
 namespace api {
 
 Debugger::Debugger(v8::Isolate* isolate, content::WebContents* web_contents)
-    : content::WebContentsObserver(web_contents), web_contents_(web_contents) {
+    : web_contents_(web_contents),
+      previous_request_id_(0) {
   Init(isolate);
 }
 
-Debugger::~Debugger() {}
+Debugger::~Debugger() {
+}
 
-void Debugger::AgentHostClosed(DevToolsAgentHost* agent_host) {
-  DCHECK(agent_host == agent_host_);
-  agent_host_ = nullptr;
-  ClearPendingRequests();
-  Emit("detach", "target closed");
+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::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                        const std::string& message) {
-  DCHECK(agent_host == agent_host_);
+  DCHECK(agent_host == agent_host_.get());
 
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
@@ -76,52 +82,42 @@ void Debugger::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
   }
 }
 
-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);
-  }
-}
-
 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_) {
+  if (!agent_host_.get()) {
     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_ && agent_host_->IsAttached();
+  return agent_host_.get() ? agent_host_->IsAttached() : false;
 }
 
 void Debugger::Detach() {
-  if (!agent_host_)
+  if (!agent_host_.get())
     return;
   agent_host_->DetachClient(this);
-  AgentHostClosed(agent_host_.get());
+  AgentHostClosed(agent_host_.get(), false);
+  agent_host_ = nullptr;
 }
 
 void Debugger::SendCommand(mate::Arguments* args) {
-  if (!agent_host_)
+  if (!agent_host_.get())
     return;
 
   std::string method;
@@ -147,19 +143,10 @@ void Debugger::SendCommand(mate::Arguments* args) {
   agent_host_->DispatchProtocolMessage(this, json_args);
 }
 
-void Debugger::ClearPendingRequests() {
-  if (pending_requests_.empty())
-    return;
-  base::Value error(base::Value::Type::DICTIONARY);
-  base::Value error_msg("target closed while handling command");
-  error.SetKey("message", std::move(error_msg));
-  for (const auto& it : pending_requests_)
-    it.second.Run(error, base::Value());
-}
-
 // 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));
 }
 
@@ -182,10 +169,8 @@ 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());
@@ -193,4 +178,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_debugger, Initialize);
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_debugger, Initialize);

atom/browser/api/atom_api_debugger.h

@@ -12,13 +12,12 @@
 #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;
@@ -28,15 +27,15 @@ namespace atom {
 
 namespace api {
 
-class Debugger : public mate::TrackableObject<Debugger>,
-                 public content::DevToolsAgentHostClient,
-                 public content::WebContentsObserver {
+class Debugger: public mate::TrackableObject<Debugger>,
+                public content::DevToolsAgentHostClient {
  public:
   using SendCommandCallback =
-      base::Callback<void(const base::Value&, const base::Value&)>;
+      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,
@@ -47,14 +46,11 @@ class Debugger : public mate::TrackableObject<Debugger>,
   ~Debugger() override;
 
   // content::DevToolsAgentHostClient:
-  void AgentHostClosed(content::DevToolsAgentHost* agent_host) override;
+  void AgentHostClosed(content::DevToolsAgentHost* agent_host,
+                       bool replaced_with_another_client) 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>;
 
@@ -62,13 +58,12 @@ class Debugger : public mate::TrackableObject<Debugger>,
   bool IsAttached();
   void Detach();
   void 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_ = 0;
+  int previous_request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };

atom/browser/api/atom_api_desktop_capturer.cc

@@ -4,172 +4,85 @@
 
 #include "atom/browser/api/atom_api_desktop_capturer.h"
 
-#include <vector>
-
 using base::PlatformThreadRef;
 
 #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 "base/task_scheduler/post_task.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/media/desktop_media_list.h"
-#include "content/public/browser/browser_thread.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<atom::api::DesktopCapturer::Source> {
-  static v8::Local<v8::Value> ToV8(
-      v8::Isolate* isolate,
-      const atom::api::DesktopCapturer::Source& source) {
+template<>
+struct Converter<DesktopMediaList::Source> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const DesktopMediaList::Source& source) {
     mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    content::DesktopMediaID id = source.media_list_source.id;
-    dict.Set("name", base::UTF16ToUTF8(source.media_list_source.name));
+    content::DesktopMediaID id = source.id;
+    dict.Set("name", base::UTF16ToUTF8(source.name));
     dict.Set("id", id.ToString());
-    dict.Set("thumbnail",
-             atom::api::NativeImage::Create(
-                 isolate, gfx::Image(source.media_list_source.thumbnail)));
-    dict.Set("display_id", source.display_id);
+    dict.Set(
+        "thumbnail",
+        atom::api::NativeImage::Create(isolate, gfx::Image(source.thumbnail)));
     return ConvertToV8(isolate, dict);
   }
 };
 
 }  // namespace mate
 
-namespace {
-
-void EmitFinished(
-    const std::vector<atom::api::DesktopCapturer::Source>& sources,
-    atom::api::DesktopCapturer* cap) {
-  cap->Emit("finished", sources);
-}
-
-void StartHandlingTask(bool capture_window,
-                       bool capture_screen,
-                       const gfx::Size& thumbnail_size,
-                       atom::api::DesktopCapturer* cap) {
-#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();
-    cap->using_directx_capturer_ =
-        webrtc::ScreenCapturerWinDirectx::IsSupported();
-  }
-#endif  // defined(OS_WIN)
-  std::unique_ptr<webrtc::DesktopCapturer> screen_capturer(
-      capture_screen ? content::desktop_capture::CreateScreenCapturer()
-                     : nullptr);
-  std::unique_ptr<webrtc::DesktopCapturer> window_capturer(
-      capture_window ? content::desktop_capture::CreateWindowCapturer()
-                     : nullptr);
-  cap->media_list_.reset(new NativeDesktopMediaList(
-      std::move(screen_capturer), std::move(window_capturer)));
-
-  cap->media_list_->SetThumbnailSize(thumbnail_size);
-  cap->media_list_->StartUpdating(cap);
-}
-
-void OnRefreshFinishedTask(atom::api::DesktopCapturer* cap) {
-  const auto media_list_sources = cap->media_list_->GetSources();
-  std::vector<atom::api::DesktopCapturer::Source> sources;
-  for (const auto& media_list_source : media_list_sources) {
-    sources.emplace_back(
-        atom::api::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 (cap->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 : sources) {
-      if (source.media_list_source.id.type ==
-          content::DesktopMediaID::TYPE_SCREEN) {
-        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 : sources) {
-    if (source.media_list_source.id.type ==
-        content::DesktopMediaID::TYPE_SCREEN) {
-      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.
-
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                   base::Bind(EmitFinished, sources, cap));
-}
-
-}  // namespace
-
 namespace atom {
 
 namespace api {
 
 DesktopCapturer::DesktopCapturer(v8::Isolate* isolate) {
   Init(isolate);
-  capture_thread_ = base::CreateSequencedTaskRunnerWithTraits(
-      {base::WithBaseSyncPrimitives(), base::MayBlock(),
-       base::TaskPriority::USER_VISIBLE});
 }
 
-DesktopCapturer::~DesktopCapturer() {}
+DesktopCapturer::~DesktopCapturer() {
+}
 
 void DesktopCapturer::StartHandling(bool capture_window,
                                     bool capture_screen,
                                     const gfx::Size& thumbnail_size) {
-  capture_thread_->PostTask(
-      FROM_HERE, base::BindOnce(StartHandlingTask, capture_window,
-                                capture_screen, thumbnail_size, this));
+  webrtc::DesktopCaptureOptions options =
+    content::CreateDesktopCaptureOptions();
+
+  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)));
+
+  media_list_->SetThumbnailSize(thumbnail_size);
+  media_list_->StartUpdating(this);
 }
 
-void DesktopCapturer::OnSourceAdded(int index) {}
+void DesktopCapturer::OnSourceAdded(int index) {
+}
 
-void DesktopCapturer::OnSourceRemoved(int index) {}
+void DesktopCapturer::OnSourceRemoved(int index) {
+}
 
-void DesktopCapturer::OnSourceMoved(int old_index, int new_index) {}
+void DesktopCapturer::OnSourceMoved(int old_index, int new_index) {
+}
 
-void DesktopCapturer::OnSourceNameChanged(int index) {}
+void DesktopCapturer::OnSourceNameChanged(int index) {
+}
 
-void DesktopCapturer::OnSourceThumbnailChanged(int index) {}
+void DesktopCapturer::OnSourceThumbnailChanged(int index) {
+}
 
 bool DesktopCapturer::OnRefreshFinished() {
-  capture_thread_->PostTask(FROM_HERE,
-                            base::BindOnce(OnRefreshFinishedTask, this));
+  Emit("finished", media_list_->GetSources());
   return false;
 }
 
@@ -180,8 +93,7 @@ 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);
@@ -193,10 +105,8 @@ 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));
@@ -204,4 +114,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_desktop_capturer, Initialize);
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_desktop_capturer, Initialize);

atom/browser/api/atom_api_desktop_capturer.h

@@ -5,8 +5,6 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_DESKTOP_CAPTURER_H_
 #define ATOM_BROWSER_API_ATOM_API_DESKTOP_CAPTURER_H_
 
-#include <string>
-
 #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"
@@ -16,15 +14,9 @@ namespace atom {
 
 namespace api {
 
-class DesktopCapturer : public mate::EventEmitter<DesktopCapturer>,
-                        public DesktopMediaListObserver {
+class DesktopCapturer: public mate::EventEmitter<DesktopCapturer>,
+                       public DesktopMediaListObserver {
  public:
-  struct Source {
-    DesktopMediaList::Source media_list_source;
-    // Will be an empty string if not available.
-    std::string display_id;
-  };
-
   static mate::Handle<DesktopCapturer> Create(v8::Isolate* isolate);
 
   static void BuildPrototype(v8::Isolate* isolate,
@@ -34,11 +26,6 @@ class DesktopCapturer : public mate::EventEmitter<DesktopCapturer>,
                      bool capture_screen,
                      const gfx::Size& thumbnail_size);
 
-  std::unique_ptr<DesktopMediaList> media_list_;
-#if defined(OS_WIN)
-  bool using_directx_capturer_ = false;
-#endif  // defined(OS_WIN)
-
  protected:
   explicit DesktopCapturer(v8::Isolate* isolate);
   ~DesktopCapturer() override;
@@ -52,7 +39,7 @@ class DesktopCapturer : public mate::EventEmitter<DesktopCapturer>,
   bool OnRefreshFinished() override;
 
  private:
-  scoped_refptr<base::SequencedTaskRunner> capture_thread_;
+  std::unique_ptr<DesktopMediaList> media_list_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopCapturer);
 };

atom/browser/api/atom_api_dialog.cc

@@ -6,7 +6,7 @@
 #include <utility>
 #include <vector>
 
-#include "atom/browser/api/atom_api_browser_window.h"
+#include "atom/browser/api/atom_api_window.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/ui/certificate_trust.h"
 #include "atom/browser/ui/file_dialog.h"
@@ -21,7 +21,7 @@
 
 namespace mate {
 
-template <>
+template<>
 struct Converter<file_dialog::Filter> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
@@ -37,7 +37,7 @@ struct Converter<file_dialog::Filter> {
   }
 };
 
-template <>
+template<>
 struct Converter<file_dialog::DialogSettings> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
@@ -54,9 +54,9 @@ struct Converter<file_dialog::DialogSettings> {
     dict.Get("filters", &(out->filters));
     dict.Get("properties", &(out->properties));
     dict.Get("showsTagField", &(out->shows_tag_field));
-#if defined(MAS_BUILD)
+    #if defined(MAS_BUILD)
     dict.Get("securityScopedBookmarks", &(out->security_scoped_bookmarks));
-#endif
+    #endif
     return true;
   }
 };
@@ -80,7 +80,8 @@ 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,
@@ -98,8 +99,9 @@ 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;
@@ -112,8 +114,9 @@ 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;
@@ -122,10 +125,8 @@ 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);
@@ -139,4 +140,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_dialog, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_dialog, Initialize)

atom/browser/api/atom_api_download_item.cc

@@ -19,23 +19,22 @@
 
 namespace mate {
 
-template <>
-struct Converter<download::DownloadItem::DownloadState> {
-  static v8::Local<v8::Value> ToV8(
-      v8::Isolate* isolate,
-      download::DownloadItem::DownloadState state) {
+template<>
+struct Converter<content::DownloadItem::DownloadState> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   content::DownloadItem::DownloadState state) {
     std::string download_state;
     switch (state) {
-      case download::DownloadItem::IN_PROGRESS:
+      case content::DownloadItem::IN_PROGRESS:
         download_state = "progressing";
         break;
-      case download::DownloadItem::COMPLETE:
+      case content::DownloadItem::COMPLETE:
         download_state = "completed";
         break;
-      case download::DownloadItem::CANCELLED:
+      case content::DownloadItem::CANCELLED:
         download_state = "cancelled";
         break;
-      case download::DownloadItem::INTERRUPTED:
+      case content::DownloadItem::INTERRUPTED:
         download_state = "interrupted";
         break;
       default:
@@ -58,7 +57,7 @@ std::map<uint32_t, v8::Global<v8::Object>> g_download_item_objects;
 }  // namespace
 
 DownloadItem::DownloadItem(v8::Isolate* isolate,
-                           download::DownloadItem* download_item)
+                           content::DownloadItem* download_item)
     : download_item_(download_item) {
   download_item_->AddObserver(this);
   Init(isolate);
@@ -76,18 +75,18 @@ DownloadItem::~DownloadItem() {
   g_download_item_objects.erase(weak_map_id());
 }
 
-void DownloadItem::OnDownloadUpdated(download::DownloadItem* item) {
+void DownloadItem::OnDownloadUpdated(content::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(download::DownloadItem* download_item) {
+void DownloadItem::OnDownloadDestroyed(content::DownloadItem* download_item) {
   download_item_ = nullptr;
   // Destroy the native class immediately when downloadItem is destroyed.
   delete this;
@@ -130,11 +129,12 @@ 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 +149,7 @@ const std::vector<GURL>& DownloadItem::GetURLChain() const {
   return download_item_->GetUrlChain();
 }
 
-download::DownloadItem::DownloadState DownloadItem::GetState() const {
+content::DownloadItem::DownloadState DownloadItem::GetState() const {
   return download_item_->GetState();
 }
 
@@ -206,9 +206,9 @@ void DownloadItem::BuildPrototype(v8::Isolate* isolate,
 }
 
 // static
-mate::Handle<DownloadItem> DownloadItem::Create(v8::Isolate* isolate,
-                                                download::DownloadItem* item) {
-  auto* existing = TrackableObject::FromWrappedClass(isolate, item);
+mate::Handle<DownloadItem> DownloadItem::Create(
+    v8::Isolate* isolate, content::DownloadItem* item) {
+  auto existing = TrackableObject::FromWrappedClass(isolate, item);
   if (existing)
     return mate::CreateHandle(isolate, static_cast<DownloadItem*>(existing));
 
@@ -226,10 +226,8 @@ mate::Handle<DownloadItem> DownloadItem::Create(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) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary(isolate, exports)
       .Set("DownloadItem",
@@ -238,4 +236,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_download_item, Initialize);
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_download_item, Initialize);

atom/browser/api/atom_api_download_item.h

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

atom/browser/api/atom_api_global_shortcut.cc

@@ -40,8 +40,8 @@ void GlobalShortcut::OnKeyPressed(const ui::Accelerator& accelerator) {
 
 bool GlobalShortcut::Register(const ui::Accelerator& accelerator,
                               const base::Closure& callback) {
-  if (!GlobalShortcutListener::GetInstance()->RegisterAccelerator(accelerator,
-                                                                  this)) {
+  if (!GlobalShortcutListener::GetInstance()->RegisterAccelerator(
+      accelerator, this)) {
     return false;
   }
 
@@ -54,8 +54,8 @@ void GlobalShortcut::Unregister(const ui::Accelerator& accelerator) {
     return;
 
   accelerator_callback_map_.erase(accelerator);
-  GlobalShortcutListener::GetInstance()->UnregisterAccelerator(accelerator,
-                                                               this);
+  GlobalShortcutListener::GetInstance()->UnregisterAccelerator(
+      accelerator, this);
 }
 
 bool GlobalShortcut::IsRegistered(const ui::Accelerator& accelerator) {
@@ -73,8 +73,8 @@ 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("register", &GlobalShortcut::Register)
@@ -89,10 +89,8 @@ void GlobalShortcut::BuildPrototype(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) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("globalShortcut", atom::api::GlobalShortcut::Create(isolate));
@@ -100,4 +98,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_global_shortcut, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_global_shortcut, Initialize)

atom/browser/api/atom_api_in_app_purchase.cc

@@ -45,29 +45,6 @@ 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.downloadable);
-
-    return dict.GetHandle();
-  }
-};
-
 }  // namespace mate
 
 namespace atom {
@@ -87,19 +64,15 @@ 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("finishAllTransactions",
-                 &in_app_purchase::FinishAllTransactions)
-      .SetMethod("finishTransactionByDate",
-                 &in_app_purchase::FinishTransactionByDate)
-      .SetMethod("getProducts", &in_app_purchase::GetProducts);
+      .SetMethod("purchaseProduct", &InAppPurchase::PurchaseProduct);
 }
 
 InAppPurchase::InAppPurchase(v8::Isolate* isolate) {
   Init(isolate);
 }
 
-InAppPurchase::~InAppPurchase() {}
+InAppPurchase::~InAppPurchase() {
+}
 
 void InAppPurchase::PurchaseProduct(const std::string& product_id,
                                     mate::Arguments* args) {
@@ -139,4 +112,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_in_app_purchase, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_in_app_purchase, Initialize)

atom/browser/api/atom_api_in_app_purchase.h

@@ -11,15 +11,14 @@
 #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_label_button.cc

@@ -1,58 +0,0 @@
-// 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_label_button.h"
-
-#include "atom/common/api/constructor.h"
-#include "base/strings/utf_string_conversions.h"
-#include "native_mate/dictionary.h"
-#include "ui/views/controls/button/label_button.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace api {
-
-LabelButton::LabelButton(const std::string& text)
-    : Button(new views::LabelButton(this, base::UTF8ToUTF16(text))) {}
-
-LabelButton::~LabelButton() {}
-
-// static
-mate::WrappableBase* LabelButton::New(mate::Arguments* args,
-                                      const std::string& text) {
-  // Constructor call.
-  auto* view = new LabelButton(text);
-  view->InitWith(args->isolate(), args->GetThis());
-  return view;
-}
-
-// static
-void LabelButton::BuildPrototype(v8::Isolate* isolate,
-                                 v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(mate::StringToV8(isolate, "LabelButton"));
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-namespace {
-
-using atom::api::LabelButton;
-
-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("LabelButton", mate::CreateConstructor<LabelButton>(
-                              isolate, base::Bind(&LabelButton::New)));
-}
-
-}  // namespace
-
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_label_button, Initialize)

atom/browser/api/atom_api_label_button.h

@@ -1,36 +0,0 @@
-// 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_LABEL_BUTTON_H_
-#define ATOM_BROWSER_API_ATOM_API_LABEL_BUTTON_H_
-
-#include <string>
-
-#include "atom/browser/api/atom_api_button.h"
-
-namespace atom {
-
-namespace api {
-
-class LabelButton : public Button {
- public:
-  static mate::WrappableBase* New(mate::Arguments* args,
-                                  const std::string& text);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::FunctionTemplate> prototype);
-
- protected:
-  explicit LabelButton(const std::string& text);
-  ~LabelButton() override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LabelButton);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_LABEL_BUTTON_H_

atom/browser/api/atom_api_layout_manager.cc

@@ -1,63 +0,0 @@
-// 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_layout_manager.h"
-
-#include "atom/common/api/constructor.h"
-#include "native_mate/dictionary.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace api {
-
-LayoutManager::LayoutManager(views::LayoutManager* layout_manager)
-    : layout_manager_(layout_manager) {
-  DCHECK(layout_manager_);
-}
-
-LayoutManager::~LayoutManager() {
-  if (managed_by_us_)
-    delete layout_manager_;
-}
-
-std::unique_ptr<views::LayoutManager> LayoutManager::TakeOver() {
-  if (!managed_by_us_)  // already taken over.
-    return nullptr;
-  managed_by_us_ = false;
-  return std::unique_ptr<views::LayoutManager>(layout_manager_);
-}
-
-// static
-mate::WrappableBase* LayoutManager::New(mate::Arguments* args) {
-  args->ThrowError("LayoutManager can not be created directly");
-  return nullptr;
-}
-
-// static
-void LayoutManager::BuildPrototype(v8::Isolate* isolate,
-                                   v8::Local<v8::FunctionTemplate> prototype) {}
-
-}  // namespace api
-
-}  // namespace atom
-
-namespace {
-
-using atom::api::LayoutManager;
-
-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("LayoutManager", mate::CreateConstructor<LayoutManager>(
-                                isolate, base::Bind(&LayoutManager::New)));
-}
-
-}  // namespace
-
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_layout_manager, Initialize)

atom/browser/api/atom_api_layout_manager.h

@@ -1,44 +0,0 @@
-// 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_LAYOUT_MANAGER_H_
-#define ATOM_BROWSER_API_ATOM_API_LAYOUT_MANAGER_H_
-
-#include <memory>
-
-#include "atom/browser/api/trackable_object.h"
-#include "ui/views/layout/layout_manager.h"
-
-namespace atom {
-
-namespace api {
-
-class LayoutManager : public mate::TrackableObject<LayoutManager> {
- public:
-  static mate::WrappableBase* New(mate::Arguments* args);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::FunctionTemplate> prototype);
-
-  // Take over the ownership of the LayoutManager, and leave weak ref here.
-  std::unique_ptr<views::LayoutManager> TakeOver();
-
-  views::LayoutManager* layout_manager() const { return layout_manager_; }
-
- protected:
-  explicit LayoutManager(views::LayoutManager* layout_manager);
-  ~LayoutManager() override;
-
- private:
-  bool managed_by_us_ = true;
-  views::LayoutManager* layout_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(LayoutManager);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_LAYOUT_MANAGER_H_

atom/browser/api/atom_api_menu.cc

@@ -20,7 +20,8 @@ namespace atom {
 namespace api {
 
 Menu::Menu(v8::Isolate* isolate, v8::Local<v8::Object> wrapper)
-    : model_(new AtomMenuModel(this)) {
+    : model_(new AtomMenuModel(this)),
+      parent_(nullptr) {
   InitWith(isolate, wrapper);
   model_->AddObserver(this);
 }
@@ -69,17 +70,18 @@ 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);
 }
 
 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) {
@@ -88,9 +90,8 @@ void Menu::MenuWillShow(ui::SimpleMenuModel* source) {
   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);
 }
 
@@ -206,14 +207,13 @@ 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));
 
@@ -228,4 +228,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_menu, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_menu, Initialize)

atom/browser/api/atom_api_menu.h

@@ -8,7 +8,7 @@
 #include <memory>
 #include <string>
 
-#include "atom/browser/api/atom_api_top_level_window.h"
+#include "atom/browser/api/atom_api_window.h"
 #include "atom/browser/api/trackable_object.h"
 #include "atom/browser/ui/atom_menu_model.h"
 #include "base/callback.h"
@@ -18,8 +18,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);
 
@@ -54,15 +54,12 @@ class Menu : public mate::TrackableObject<Menu>,
   void ExecuteCommand(int command_id, int event_flags) override;
   void MenuWillShow(ui::SimpleMenuModel* source) override;
 
-  virtual void PopupAt(TopLevelWindow* window,
-                       int x,
-                       int y,
-                       int positioning_item,
+  virtual void PopupAt(Window* window, int x, int y, int positioning_item,
                        const base::Closure& callback) = 0;
   virtual void ClosePopupAt(int32_t window_id) = 0;
 
   std::unique_ptr<AtomMenuModel> model_;
-  Menu* parent_ = nullptr;
+  Menu* parent_;
 
   // Observable:
   void OnMenuWillClose() override;
@@ -112,12 +109,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,12 +21,8 @@ namespace api {
 class MenuMac : public Menu {
  protected:
   MenuMac(v8::Isolate* isolate, v8::Local<v8::Object> wrapper);
-  ~MenuMac() override;
 
-  void PopupAt(TopLevelWindow* window,
-               int x,
-               int y,
-               int positioning_item,
+  void PopupAt(Window* window, int x, int y, int positioning_item,
                const base::Closure& callback) override;
   void PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
                  int32_t window_id,

atom/browser/api/atom_api_menu_mac.mm

@@ -9,6 +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 "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 
@@ -16,33 +18,24 @@
 
 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) {
+}
 
-MenuMac::~MenuMac() = default;
-
-void MenuMac::PopupAt(TopLevelWindow* window,
-                      int x,
-                      int y,
-                      int positioning_item,
+void MenuMac::PopupAt(Window* window, int x, int y, int positioning_item,
                       const base::Closure& callback) {
   NativeWindow* native_window = window->window();
   if (!native_window)
     return;
 
   auto popup = base::Bind(&MenuMac::PopupOnUI, weak_factory_.GetWeakPtr(),
-                          native_window->GetWeakPtr(), window->weak_map_id(), x,
-                          y, positioning_item, callback);
+                          native_window->GetWeakPtr(), window->ID(), x, y,
+                          positioning_item, callback);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, popup);
 }
 
@@ -54,15 +47,18 @@ void MenuMac::PopupOnUI(const base::WeakPtr<NativeWindow>& native_window,
                         base::Closure callback) {
   if (!native_window)
     return;
-  NSWindow* nswindow = native_window->GetNativeWindow();
+  brightray::InspectableWebContents* web_contents =
+      native_window->inspectable_web_contents();
+  if (!web_contents)
+    return;
 
   auto close_callback = base::Bind(
       &MenuMac::OnClosed, weak_factory_.GetWeakPtr(), window_id, callback);
-  popup_controllers_[window_id] = base::scoped_nsobject<AtomMenuController>([
-      [AtomMenuController alloc] initWithModel:model()
-                         useDefaultAccelerator:NO]);
+  popup_controllers_[window_id] = base::scoped_nsobject<AtomMenuController>(
+      [[AtomMenuController alloc] initWithModel:model()
+                          useDefaultAccelerator:NO]);
   NSMenu* menu = [popup_controllers_[window_id] menu];
-  NSView* view = [nswindow contentView];
+  NSView* view = web_contents->GetView()->GetNativeView();
 
   // Which menu item to show.
   NSMenuItem* item = nil;
@@ -72,6 +68,7 @@ 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 {
@@ -135,21 +132,10 @@ void MenuMac::OnClosed(int32_t window_id, base::Closure callback) {
 // static
 void Menu::SetApplicationMenu(Menu* base_menu) {
   MenuMac* menu = static_cast<MenuMac*>(base_menu);
-  base::scoped_nsobject<AtomMenuController> menu_controller([
-      [AtomMenuController alloc] initWithModel:menu->model_.get()
-                         useDefaultAccelerator:YES]);
-
-  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]];
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:menu->model_.get()
+                          useDefaultAccelerator:YES]);
+  [NSApp setMainMenu:[menu_controller menu]];
 
   // 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

@@ -6,6 +6,8 @@
 
 #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;
@@ -15,14 +17,11 @@ 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) {
+}
 
-MenuViews::~MenuViews() = default;
-
-void MenuViews::PopupAt(TopLevelWindow* window,
-                        int x,
-                        int y,
-                        int positioning_item,
+void MenuViews::PopupAt(Window* window, int x, int y, int positioning_item,
                         const base::Closure& callback) {
   auto* native_window = static_cast<NativeWindowViews*>(window->window());
   if (!native_window)
@@ -43,14 +42,17 @@ void MenuViews::PopupAt(TopLevelWindow* window,
   atom::UnresponsiveSuppressor suppressor;
 
   // Show the menu.
-  int32_t window_id = window->weak_map_id();
+  int32_t window_id = window->ID();
   auto close_callback = base::Bind(
       &MenuViews::OnClosed, weak_factory_.GetWeakPtr(), window_id, callback);
-  menu_runners_[window_id] =
-      std::make_unique<MenuRunner>(model(), flags, close_callback);
+  menu_runners_[window_id] = std::unique_ptr<MenuRunner>(new MenuRunner(
+      model(), flags, close_callback));
   menu_runners_[window_id]->RunMenuAt(
-      native_window->widget(), NULL, gfx::Rect(location, gfx::Size()),
-      views::MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_MOUSE);
+      native_window->widget(),
+      NULL,
+      gfx::Rect(location, gfx::Size()),
+      views::MENU_ANCHOR_TOPLEFT,
+      ui::MENU_SOURCE_MOUSE);
 }
 
 void MenuViews::ClosePopupAt(int32_t window_id) {

atom/browser/api/atom_api_menu_views.h

@@ -19,13 +19,9 @@ namespace api {
 class MenuViews : public Menu {
  public:
   MenuViews(v8::Isolate* isolate, v8::Local<v8::Object> wrapper);
-  ~MenuViews() override;
 
  protected:
-  void PopupAt(TopLevelWindow* window,
-               int x,
-               int y,
-               int positioning_item,
+  void PopupAt(Window* window, int x, int y, int positioning_item,
                const base::Closure& callback) override;
   void ClosePopupAt(int32_t window_id) override;
 

atom/browser/api/atom_api_net.cc

@@ -58,4 +58,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_net, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_net, Initialize)

atom/browser/api/atom_api_net_log.cc

@@ -1,90 +0,0 @@
-// 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 "atom/browser/atom_browser_client.h"
-#include "atom/common/native_mate_converters/callback.h"
-#include "atom/common/native_mate_converters/file_path_converter.h"
-#include "base/callback.h"
-#include "content/public/common/content_switches.h"
-#include "native_mate/dictionary.h"
-#include "native_mate/handle.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace api {
-
-NetLog::NetLog(v8::Isolate* isolate) {
-  Init(isolate);
-
-  net_log_ = atom::AtomBrowserClient::Get()->GetNetLog();
-}
-
-NetLog::~NetLog() {}
-
-// static
-v8::Local<v8::Value> NetLog::Create(v8::Isolate* isolate) {
-  return mate::CreateHandle(isolate, new NetLog(isolate)).ToV8();
-}
-
-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;
-  }
-
-  net_log_->StartDynamicLogging(log_path);
-}
-
-bool NetLog::IsCurrentlyLogging() {
-  return net_log_->IsDynamicLogging();
-}
-
-base::FilePath::StringType NetLog::GetCurrentlyLoggingPath() {
-  return net_log_->GetDynamicLoggingPath().value();
-}
-
-void NetLog::StopLogging(mate::Arguments* args) {
-  base::OnceClosure callback;
-  args->GetNext(&callback);
-
-  net_log_->StopDynamicLogging(std::move(callback));
-}
-
-// 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
-
-namespace {
-
-using atom::api::NetLog;
-
-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("netLog", NetLog::Create(isolate));
-  dict.Set("NetLog", NetLog::GetConstructor(isolate)->GetFunction());
-}
-
-}  // namespace
-
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_net_log, Initialize)

atom/browser/api/atom_api_net_log.h

@@ -1,42 +0,0 @@
-// 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 <string>
-#include "brightray/browser/net_log.h"
-#include "native_mate/wrappable.h"
-
-namespace atom {
-
-namespace api {
-
-class NetLog : public mate::Wrappable<NetLog> {
- public:
-  static v8::Local<v8::Value> Create(v8::Isolate* isolate);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::FunctionTemplate> prototype);
-
-  void StartLogging(mate::Arguments* args);
-  bool IsCurrentlyLogging();
-  base::FilePath::StringType GetCurrentlyLoggingPath();
-  void StopLogging(mate::Arguments* args);
-
- protected:
-  explicit NetLog(v8::Isolate* isolate);
-  ~NetLog() override;
-
- private:
-  brightray::NetLog* net_log_;
-
-  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

@@ -9,7 +9,6 @@
 #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"
@@ -21,11 +20,10 @@
 #include "atom/common/node_includes.h"
 
 namespace mate {
-template <>
+template<>
 struct Converter<brightray::NotificationAction> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     brightray::NotificationAction* out) {
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
+                      brightray::NotificationAction* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
       return false;
@@ -38,7 +36,7 @@ struct Converter<brightray::NotificationAction> {
   }
 
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   brightray::NotificationAction val) {
+                                    brightray::NotificationAction val) {
     mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
     dict.Set("text", val.text);
     dict.Set("type", val.type);
@@ -157,7 +155,7 @@ void Notification::SetSound(const base::string16& new_sound) {
 }
 
 void Notification::SetActions(
-    const std::vector<brightray::NotificationAction>& actions) {
+  const std::vector<brightray::NotificationAction>& actions) {
   actions_ = actions;
 }
 
@@ -181,7 +179,8 @@ void Notification::NotificationDisplayed() {
   Emit("show");
 }
 
-void Notification::NotificationDestroyed() {}
+void Notification::NotificationDestroyed() {
+}
 
 void Notification::NotificationClosed() {
   Emit("close");
@@ -198,7 +197,7 @@ void Notification::Close() {
 void Notification::Show() {
   Close();
   if (presenter_) {
-    notification_ = presenter_->CreateNotification(this, base::GenerateGUID());
+    notification_ = presenter_->CreateNotification(this);
     if (notification_) {
       brightray::NotificationOptions options;
       options.title = title_;
@@ -233,12 +232,14 @@ 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,
@@ -269,4 +270,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_common_notification, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_notification, Initialize)

atom/browser/api/atom_api_power_monitor.cc

@@ -5,50 +5,26 @@
 #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() {
@@ -84,21 +60,6 @@ void PowerMonitor::OnResume() {
   Emit("resume");
 }
 
-void PowerMonitor::QuerySystemIdleState(v8::Isolate* isolate,
-                                        int idle_threshold,
-                                        const ui::IdleCallback& callback) {
-  if (idle_threshold > 0) {
-    ui::CalculateIdleState(idle_threshold, callback);
-  } else {
-    isolate->ThrowException(v8::Exception::TypeError(mate::StringToV8(
-        isolate, "Invalid idle threshold, must be greater than 0")));
-  }
-}
-
-void PowerMonitor::QuerySystemIdleTime(const ui::IdleTimeCallback& callback) {
-  ui::CalculateIdleTime(callback);
-}
-
 // static
 v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
@@ -112,32 +73,27 @@ 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"));
-
-  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
-      .MakeDestroyable()
 #if defined(OS_LINUX)
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .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));
@@ -147,4 +103,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_power_monitor, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_power_monitor, Initialize)

atom/browser/api/atom_api_power_monitor.h

@@ -9,7 +9,6 @@
 #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 {
 
@@ -36,43 +35,12 @@ 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:
-  void QuerySystemIdleState(v8::Isolate* isolate,
-                            int idle_threshold,
-                            const ui::IdleCallback& callback);
-  void QuerySystemIdleTime(const ui::IdleTimeCallback& callback);
-
-#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

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

@@ -1,71 +0,0 @@
-// 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 "base/win/wrapped_window_proc.h"
-#include "ui/base/win/shell.h"
-#include "ui/gfx/win/hwnd_util.h"
-#include "Wtsapi32.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,26 +6,28 @@
 
 #include <string>
 
-#include "base/task_scheduler/post_task.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "content/public/browser/browser_thread.h"
 #include "native_mate/dictionary.h"
 
 #include "atom/common/node_includes.h"
 
+using content::BrowserThread;
+
 namespace mate {
 
-template <>
-struct Converter<device::mojom::WakeLockType> {
+template<>
+struct Converter<device::PowerSaveBlocker::PowerSaveBlockerType> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     device::mojom::WakeLockType* out) {
+                     device::PowerSaveBlocker::PowerSaveBlockerType* out) {
+    using device::PowerSaveBlocker;
     std::string type;
     if (!ConvertFromV8(isolate, val, &type))
       return false;
     if (type == "prevent-app-suspension")
-      *out = device::mojom::WakeLockType::kPreventAppSuspension;
+      *out = PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension;
     else if (type == "prevent-display-sleep")
-      *out = device::mojom::WakeLockType::kPreventDisplaySleep;
+      *out = PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep;
     else
       return false;
     return true;
@@ -40,11 +42,12 @@ namespace api {
 
 PowerSaveBlocker::PowerSaveBlocker(v8::Isolate* isolate)
     : current_blocker_type_(
-          device::mojom::WakeLockType::kPreventAppSuspension) {
+          device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension) {
   Init(isolate);
 }
 
-PowerSaveBlocker::~PowerSaveBlocker() {}
+PowerSaveBlocker::~PowerSaveBlocker() {
+}
 
 void PowerSaveBlocker::UpdatePowerSaveBlocker() {
   if (power_save_blocker_types_.empty()) {
@@ -52,39 +55,38 @@ void PowerSaveBlocker::UpdatePowerSaveBlocker() {
     return;
   }
 
-  // |WakeLockType::kPreventAppSuspension| keeps system active, but allows
+  // |kPowerSaveBlockPreventAppSuspension| keeps system active, but allows
   // screen to be turned off.
-  // |WakeLockType::kPreventDisplaySleep| keeps system and screen active, has a
-  // higher precedence level than |WakeLockType::kPreventAppSuspension|.
+  // |kPowerSaveBlockPreventDisplaySleep| keeps system and screen active, has a
+  // higher precedence level than |kPowerSaveBlockPreventAppSuspension|.
   //
   // Only the highest-precedence blocker type takes effect.
-  device::mojom::WakeLockType new_blocker_type =
-      device::mojom::WakeLockType::kPreventAppSuspension;
+  device::PowerSaveBlocker::PowerSaveBlockerType new_blocker_type =
+      device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension;
   for (const auto& element : power_save_blocker_types_) {
     if (element.second ==
-        device::mojom::WakeLockType::kPreventDisplaySleep) {
+        device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep) {
       new_blocker_type =
-          device::mojom::WakeLockType::kPreventDisplaySleep;
+          device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep;
       break;
     }
   }
 
   if (!power_save_blocker_ || new_blocker_type != current_blocker_type_) {
-    auto new_blocker = std::make_unique<device::PowerSaveBlocker>(
-        new_blocker_type, device::mojom::WakeLockReason::kOther,
-        ATOM_PRODUCT_NAME, base::ThreadTaskRunnerHandle::Get(),
-        // This task runner may be used by some device service
-        // implementation bits to interface with dbus client code, which in
-        // turn imposes some subtle thread affinity on the clients. We
-        // therefore require a single-thread runner.
-        base::CreateSingleThreadTaskRunnerWithTraits(
-            {base::MayBlock(), base::TaskPriority::BACKGROUND}));
+    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;
   }
 }
 
-int PowerSaveBlocker::Start(device::mojom::WakeLockType type) {
+int PowerSaveBlocker::Start(
+    device::PowerSaveBlocker::PowerSaveBlockerType type) {
   static int count = 0;
   power_save_blocker_types_[count] = type;
   UpdatePowerSaveBlocker();
@@ -108,8 +110,7 @@ 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)
@@ -123,10 +124,8 @@ 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));
@@ -134,4 +133,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_power_save_blocker, Initialize);
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_power_save_blocker, Initialize);

atom/browser/api/atom_api_power_save_blocker.h

@@ -33,18 +33,19 @@ class PowerSaveBlocker : public mate::TrackableObject<PowerSaveBlocker> {
 
  private:
   void UpdatePowerSaveBlocker();
-  int Start(device::mojom::WakeLockType type);
+  int Start(device::PowerSaveBlocker::PowerSaveBlockerType type);
   bool Stop(int id);
   bool IsStarted(int id);
 
   std::unique_ptr<device::PowerSaveBlocker> power_save_blocker_;
 
-  // Current blocker type used by |power_save_blocker_|
-  device::mojom::WakeLockType current_blocker_type_;
+  // Currnet blocker type used by |power_save_blocker_|
+  device::PowerSaveBlocker::PowerSaveBlockerType current_blocker_type_;
 
   // Map from id to the corresponding blocker type for each request.
-  using WakeLockTypeMap = std::map<int, device::mojom::WakeLockType>;
-  WakeLockTypeMap power_save_blocker_types_;
+  using PowerSaveBlockerTypeMap =
+      std::map<int, device::PowerSaveBlocker::PowerSaveBlockerType>;
+  PowerSaveBlockerTypeMap power_save_blocker_types_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerSaveBlocker);
 };

atom/browser/api/atom_api_protocol.cc

@@ -33,6 +33,14 @@ 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();
+}
+
 }  // namespace
 
 std::vector<std::string> GetStandardSchemes() {
@@ -63,39 +71,44 @@ void RegisterStandardSchemes(const std::vector<std::string>& schemes,
       atom::switches::kStandardSchemes, base::JoinString(schemes, ","));
   if (secure) {
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-        atom::switches::kSecureSchemes, base::JoinString(schemes, ","));
+      atom::switches::kSecureSchemes, base::JoinString(schemes, ","));
   }
 }
 
 Protocol::Protocol(v8::Isolate* isolate, AtomBrowserContext* browser_context)
-    : browser_context_(browser_context), weak_factory_(this) {
+    : request_context_getter_(browser_context->GetRequestContext()),
+      weak_factory_(this) {
   Init(isolate);
 }
 
-Protocol::~Protocol() {}
+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) {
+void Protocol::UnregisterProtocol(
+    const std::string& scheme, mate::Arguments* args) {
   CompletionCallback callback;
   args->GetNext(&callback);
-  auto* getter = browser_context_->GetRequestContext();
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&Protocol::UnregisterProtocolInIO,
-                     base::RetainedRef(getter), scheme),
-      base::BindOnce(&Protocol::OnIOCompleted, GetWeakPtr(), callback));
+      base::Bind(&Protocol::UnregisterProtocolInIO,
+                 request_context_getter_, scheme),
+      base::Bind(&Protocol::OnIOCompleted,
+                 GetWeakPtr(), callback));
 }
 
 // static
 Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
     scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
-  auto* job_factory = static_cast<AtomURLRequestJobFactory*>(
+  auto job_factory = static_cast<AtomURLRequestJobFactory*>(
       request_context_getter->job_factory());
   if (!job_factory->HasProtocolHandler(scheme))
     return PROTOCOL_NOT_REGISTERED;
@@ -105,11 +118,10 @@ Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
 
 void Protocol::IsProtocolHandled(const std::string& scheme,
                                  const BooleanCallback& callback) {
-  auto* getter = browser_context_->GetRequestContext();
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::IsProtocolHandledInIO, base::RetainedRef(getter),
-                 scheme),
+      base::Bind(&Protocol::IsProtocolHandledInIO,
+                 request_context_getter_, scheme),
       callback);
 }
 
@@ -120,16 +132,16 @@ bool Protocol::IsProtocolHandledInIO(
   return request_context_getter->job_factory()->IsHandledProtocol(scheme);
 }
 
-void Protocol::UninterceptProtocol(const std::string& scheme,
-                                   mate::Arguments* args) {
+void Protocol::UninterceptProtocol(
+    const std::string& scheme, mate::Arguments* args) {
   CompletionCallback callback;
   args->GetNext(&callback);
-  auto* getter = browser_context_->GetRequestContext();
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&Protocol::UninterceptProtocolInIO,
-                     base::RetainedRef(getter), scheme),
-      base::BindOnce(&Protocol::OnIOCompleted, GetWeakPtr(), callback));
+      base::Bind(&Protocol::UninterceptProtocolInIO,
+                 request_context_getter_, scheme),
+      base::Bind(&Protocol::OnIOCompleted,
+                 GetWeakPtr(), callback));
 }
 
 // static
@@ -137,14 +149,12 @@ Protocol::ProtocolError Protocol::UninterceptProtocolInIO(
     scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
   return static_cast<AtomURLRequestJobFactory*>(
-             request_context_getter->job_factory())
-                 ->UninterceptProtocol(scheme)
-             ? PROTOCOL_OK
-             : PROTOCOL_NOT_INTERCEPTED;
+      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;
@@ -162,30 +172,31 @@ void Protocol::OnIOCompleted(const CompletionCallback& callback,
 
 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",
@@ -221,22 +232,19 @@ void Protocol::BuildPrototype(v8::Isolate* isolate,
 
 namespace {
 
-void RegisterStandardSchemes(const std::vector<std::string>& schemes,
-                             mate::Arguments* args) {
+void RegisterStandardSchemes(
+    const std::vector<std::string>& schemes, mate::Arguments* args) {
   if (atom::Browser::Get()->is_ready()) {
-    args->ThrowError(
-        "protocol.registerStandardSchemes should be called before "
-        "app is ready");
+    args->ThrowError("protocol.registerStandardSchemes should be called before "
+                     "app is ready");
     return;
   }
 
   atom::api::RegisterStandardSchemes(schemes, 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);
@@ -245,4 +253,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_protocol, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_protocol, Initialize)

atom/browser/api/atom_api_protocol.h

@@ -39,20 +39,20 @@ class Protocol : public mate::TrackableObject<Protocol> {
   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() override;
+  ~Protocol();
 
  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,13 +62,14 @@ 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) {}
@@ -78,13 +79,13 @@ 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_, handler_);
+      request_job->SetHandlerInfo(isolate_, request_context_.get(), handler_);
       return request_job;
     }
 
    private:
     v8::Isolate* isolate_;
-    net::URLRequestContextGetter* request_context_;
+    scoped_refptr<net::URLRequestContextGetter> request_context_;
     Protocol::Handler handler_;
 
     DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
@@ -94,31 +95,32 @@ class Protocol : public mate::TrackableObject<Protocol> {
   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);
-    auto* getter = browser_context_->GetRequestContext();
     content::BrowserThread::PostTaskAndReplyWithResult(
         content::BrowserThread::IO, FROM_HERE,
-        base::BindOnce(&Protocol::RegisterProtocolInIO<RequestJob>,
-                       base::RetainedRef(getter), isolate(), scheme, handler),
-        base::BindOnce(&Protocol::OnIOCompleted, GetWeakPtr(), callback));
+        base::Bind(&Protocol::RegisterProtocolInIO<RequestJob>,
+                   request_context_getter_, isolate(), scheme, handler),
+        base::Bind(&Protocol::OnIOCompleted,
+                   GetWeakPtr(), callback));
   }
-  template <typename RequestJob>
+  template<typename RequestJob>
   static ProtocolError RegisterProtocolInIO(
       scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
       v8::Isolate* isolate,
       const std::string& scheme,
       const Handler& handler) {
-    auto* job_factory = static_cast<AtomURLRequestJobFactory*>(
+    auto job_factory = static_cast<AtomURLRequestJobFactory*>(
         request_context_getter->job_factory());
     if (job_factory->IsHandledProtocol(scheme))
       return PROTOCOL_REGISTERED;
-    auto protocol_handler = std::make_unique<CustomProtocolHandler<RequestJob>>(
-        isolate, request_context_getter.get(), handler);
+    std::unique_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
+        new CustomProtocolHandler<RequestJob>(
+            isolate, request_context_getter.get(), handler));
     if (job_factory->SetProtocolHandler(scheme, std::move(protocol_handler)))
       return PROTOCOL_OK;
     else
@@ -139,34 +141,35 @@ class Protocol : public mate::TrackableObject<Protocol> {
       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);
-    auto* getter = browser_context_->GetRequestContext();
     content::BrowserThread::PostTaskAndReplyWithResult(
         content::BrowserThread::IO, FROM_HERE,
-        base::BindOnce(&Protocol::InterceptProtocolInIO<RequestJob>,
-                       base::RetainedRef(getter), isolate(), scheme, handler),
-        base::BindOnce(&Protocol::OnIOCompleted, GetWeakPtr(), callback));
+        base::Bind(&Protocol::InterceptProtocolInIO<RequestJob>,
+                   request_context_getter_, isolate(), scheme, handler),
+        base::Bind(&Protocol::OnIOCompleted,
+                   GetWeakPtr(), callback));
   }
-  template <typename RequestJob>
+  template<typename RequestJob>
   static ProtocolError InterceptProtocolInIO(
       scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
       v8::Isolate* isolate,
       const std::string& scheme,
       const Handler& handler) {
-    auto* job_factory = static_cast<AtomURLRequestJobFactory*>(
+    auto job_factory = static_cast<AtomURLRequestJobFactory*>(
         request_context_getter->job_factory());
     if (!job_factory->IsHandledProtocol(scheme))
       return PROTOCOL_NOT_REGISTERED;
     // It is possible a protocol is handled but can not be intercepted.
     if (!job_factory->HasProtocolHandler(scheme))
       return PROTOCOL_FAIL;
-    auto protocol_handler = std::make_unique<CustomProtocolHandler<RequestJob>>(
-        isolate, request_context_getter.get(), handler);
+    std::unique_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
+        new CustomProtocolHandler<RequestJob>(
+            isolate, request_context_getter.get(), handler));
     if (!job_factory->InterceptProtocol(scheme, std::move(protocol_handler)))
       return PROTOCOL_INTERCEPTED;
     return PROTOCOL_OK;
@@ -184,9 +187,13 @@ class Protocol : public mate::TrackableObject<Protocol> {
   // Convert error code to string.
   std::string ErrorCodeToString(ProtocolError error);
 
-  base::WeakPtr<Protocol> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
+  AtomURLRequestJobFactory* GetJobFactoryInIO() const;
 
-  scoped_refptr<AtomBrowserContext> browser_context_;
+  base::WeakPtr<Protocol> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
+  scoped_refptr<brightray::URLRequestContextGetter> request_context_getter_;
   base::WeakPtrFactory<Protocol> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Protocol);

atom/browser/api/atom_api_render_process_preferences.cc

@@ -21,8 +21,8 @@ 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;
 
@@ -41,7 +41,8 @@ RenderProcessPreferences::RenderProcessPreferences(
   Init(isolate);
 }
 
-RenderProcessPreferences::~RenderProcessPreferences() {}
+RenderProcessPreferences::~RenderProcessPreferences() {
+}
 
 int RenderProcessPreferences::AddEntry(const base::DictionaryValue& entry) {
   return preferences_.AddEntry(entry);
@@ -53,8 +54,7 @@ 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,9 +65,10 @@ 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
@@ -76,10 +77,8 @@ 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);
@@ -87,5 +86,5 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_render_process_preferences,
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(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);

atom/browser/api/atom_api_screen.cc

@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <string>
 
-#include "atom/browser/api/atom_api_browser_window.h"
 #include "atom/browser/browser.h"
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "base/bind.h"
@@ -17,10 +16,6 @@
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/point.h"
 
-#if defined(OS_WIN)
-#include "ui/display/win/screen_win.h"
-#endif
-
 #include "atom/common/node_includes.h"
 
 namespace atom {
@@ -30,9 +25,9 @@ namespace api {
 namespace {
 
 // Find an item in container according to its ID.
-template <class T>
+template<class T>
 typename T::iterator FindById(T* container, int id) {
-  auto predicate = [id](const typename T::value_type& item) -> bool {
+  auto predicate = [id] (const typename T::value_type& item) -> bool {
     return item.id() == id;
   };
   return std::find_if(container->begin(), container->end(), predicate);
@@ -84,22 +79,6 @@ display::Display Screen::GetDisplayMatching(const gfx::Rect& match_rect) {
   return screen_->GetDisplayMatching(match_rect);
 }
 
-#if defined(OS_WIN)
-
-static gfx::Rect ScreenToDIPRect(atom::NativeWindow* window,
-                                 const gfx::Rect& rect) {
-  HWND hwnd = window ? window->GetAcceleratedWidget() : nullptr;
-  return display::win::ScreenWin::ScreenToDIPRect(hwnd, rect);
-}
-
-static gfx::Rect DIPToScreenRect(atom::NativeWindow* window,
-                                 const gfx::Rect& rect) {
-  HWND hwnd = window ? window->GetAcceleratedWidget() : nullptr;
-  return display::win::ScreenWin::DIPToScreenRect(hwnd, rect);
-}
-
-#endif
-
 void Screen::OnDisplayAdded(const display::Display& new_display) {
   Emit("display-added", new_display);
 }
@@ -117,14 +96,15 @@ void Screen::OnDisplayMetricsChanged(const display::Display& display,
 v8::Local<v8::Value> Screen::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
     isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
-        isolate, "Cannot require \"screen\" module before app is ready")));
+        isolate,
+        "Cannot require \"screen\" module before app is ready")));
     return v8::Null(isolate);
   }
 
   display::Screen* screen = display::Screen::GetScreen();
   if (!screen) {
-    isolate->ThrowException(v8::Exception::Error(
-        mate::StringToV8(isolate, "Failed to get screen information")));
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Failed to get screen information")));
     return v8::Null(isolate);
   }
 
@@ -132,19 +112,16 @@ v8::Local<v8::Value> Screen::Create(v8::Isolate* isolate) {
 }
 
 // static
-void Screen::BuildPrototype(v8::Isolate* isolate,
-                            v8::Local<v8::FunctionTemplate> prototype) {
+void Screen::BuildPrototype(
+    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "Screen"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .SetMethod("getCursorScreenPoint", &Screen::GetCursorScreenPoint)
       .SetMethod("getPrimaryDisplay", &Screen::GetPrimaryDisplay)
       .SetMethod("getAllDisplays", &Screen::GetAllDisplays)
       .SetMethod("getDisplayNearestPoint", &Screen::GetDisplayNearestPoint)
-#if defined(OS_WIN)
-      .SetMethod("screenToDipPoint", &display::win::ScreenWin::ScreenToDIPPoint)
-      .SetMethod("dipToScreenPoint", &display::win::ScreenWin::DIPToScreenPoint)
-      .SetMethod("screenToDipRect", &ScreenToDIPRect)
-      .SetMethod("dipToScreenRect", &DIPToScreenRect)
+#if defined(OS_MACOSX)
+      .SetMethod("getMenuBarHeight", &Screen::getMenuBarHeight)
 #endif
       .SetMethod("getDisplayMatching", &Screen::GetDisplayMatching);
 }
@@ -157,10 +134,8 @@ namespace {
 
 using atom::api::Screen;
 
-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("screen", Screen::Create(isolate));
@@ -169,4 +144,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_common_screen, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_screen, Initialize)

atom/browser/api/atom_api_screen.h

@@ -16,7 +16,7 @@ namespace gfx {
 class Point;
 class Rect;
 class Screen;
-}  // namespace gfx
+}
 
 namespace atom {
 
@@ -40,6 +40,10 @@ class Screen : public mate::EventEmitter<Screen>,
   display::Display GetDisplayNearestPoint(const gfx::Point& point);
   display::Display GetDisplayMatching(const gfx::Rect& match_rect);
 
+#if defined(OS_MACOSX)
+  int getMenuBarHeight();
+#endif
+
   // display::DisplayObserver:
   void OnDisplayAdded(const display::Display& new_display) override;
   void OnDisplayRemoved(const display::Display& old_display) override;

atom/browser/api/atom_api_screen_mac.mm

@@ -0,0 +1,19 @@
+// Copyright (c) 2017 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#import "atom/browser/api/atom_api_screen.h"
+#import <Cocoa/Cocoa.h>
+
+namespace atom {
+
+namespace api {
+
+//TODO(codebytere): deprecated; remove in 3.0
+int Screen::getMenuBarHeight() {
+  return [[NSApp mainMenu] menuBarHeight];
+}
+
+}// namespace api
+
+}// namespace atom

atom/browser/api/atom_api_session.cc

@@ -31,12 +31,12 @@
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "brightray/browser/media/media_device_id_salt.h"
+#include "brightray/browser/net/devtools_network_conditions.h"
+#include "brightray/browser/net/devtools_network_controller_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
-#include "components/download/public/common/download_danger_type.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/download_item_utils.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/browser/storage_partition.h"
 #include "native_mate/dictionary.h"
@@ -46,13 +46,11 @@
 #include "net/dns/host_cache.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_auth_preferences.h"
-#include "net/proxy_resolution/proxy_config_service_fixed.h"
-#include "net/proxy_resolution/proxy_service.h"
+#include "net/proxy/proxy_config_service_fixed.h"
+#include "net/proxy/proxy_service.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
-#include "services/network/throttling/network_conditions.h"
-#include "services/network/throttling/throttling_controller.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using atom::api::Cookies;
@@ -96,8 +94,6 @@ uint32_t GetStorageMask(const std::vector<std::string>& storage_types) {
       storage_mask |= StoragePartition::REMOVE_DATA_MASK_WEBSQL;
     else if (type == "serviceworkers")
       storage_mask |= StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS;
-    else if (type == "cachestorage")
-      storage_mask |= StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE;
   }
   return storage_mask;
 }
@@ -141,7 +137,7 @@ void SetUserAgentInIO(scoped_refptr<net::URLRequestContextGetter> getter,
 
 namespace mate {
 
-template <>
+template<>
 struct Converter<ClearStorageDataOptions> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
@@ -210,7 +206,7 @@ struct Converter<net::ProxyConfig> {
   }
 };
 
-template <>
+template<>
 struct Converter<atom::VerifyRequestParams> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
                                    atom::VerifyRequestParams val) {
@@ -244,17 +240,19 @@ class ResolveProxyHelper {
       : callback_(callback),
         original_thread_(base::ThreadTaskRunnerHandle::Get()) {
     scoped_refptr<net::URLRequestContextGetter> context_getter =
-        browser_context->GetRequestContext();
+        browser_context->url_request_context_getter();
     context_getter->GetNetworkTaskRunner()->PostTask(
-        FROM_HERE, base::BindOnce(&ResolveProxyHelper::ResolveProxy,
-                                  base::Unretained(this), context_getter, url));
+        FROM_HERE,
+        base::Bind(&ResolveProxyHelper::ResolveProxy,
+                   base::Unretained(this), context_getter, url));
   }
 
   void OnResolveProxyCompleted(int result) {
     std::string proxy;
     if (result == net::OK)
       proxy = proxy_info_.ToPacString();
-    original_thread_->PostTask(FROM_HERE, base::BindOnce(callback_, proxy));
+    original_thread_->PostTask(FROM_HERE,
+                               base::Bind(callback_, proxy));
     delete this;
   }
 
@@ -263,15 +261,16 @@ class ResolveProxyHelper {
                     const GURL& url) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
-    net::ProxyResolutionService* proxy_service =
-        context_getter->GetURLRequestContext()->proxy_resolution_service();
-    net::CompletionCallback completion_callback = base::Bind(
-        &ResolveProxyHelper::OnResolveProxyCompleted, base::Unretained(this));
+    net::ProxyService* proxy_service =
+        context_getter->GetURLRequestContext()->proxy_service();
+    net::CompletionCallback completion_callback =
+        base::Bind(&ResolveProxyHelper::OnResolveProxyCompleted,
+                   base::Unretained(this));
 
     // Start the request.
-    int result = proxy_service->ResolveProxy(url, "GET", &proxy_info_,
-                                             completion_callback, &pac_req_,
-                                             nullptr, net::NetLogWithSource());
+    int result = proxy_service->ResolveProxy(
+        url, "GET", &proxy_info_, completion_callback, &pac_req_, nullptr,
+        net::NetLogWithSource());
 
     // Completed synchronously.
     if (result != net::ERR_IO_PENDING)
@@ -280,7 +279,7 @@ class ResolveProxyHelper {
 
   Session::ResolveProxyCallback callback_;
   net::ProxyInfo proxy_info_;
-  net::ProxyResolutionService::Request* pac_req_;
+  net::ProxyService::PacRequest* pac_req_;
   scoped_refptr<base::SingleThreadTaskRunner> original_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
@@ -290,10 +289,10 @@ class ResolveProxyHelper {
 void RunCallbackInUI(const base::Callback<void()>& callback) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
-template <typename... T>
+template<typename ...T>
 void RunCallbackInUI(const base::Callback<void(T...)>& callback, T... result) {
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::BindOnce(callback, result...));
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE, base::Bind(callback, result...));
 }
 
 // Callback of HttpCache::GetBackend.
@@ -305,8 +304,8 @@ void OnGetBackend(disk_cache::Backend** backend_ptr,
     RunCallbackInUI(callback, result);
   } else if (backend_ptr && *backend_ptr) {
     if (action == Session::CacheAction::CLEAR) {
-      (*backend_ptr)
-          ->DoomAllEntries(base::Bind(&RunCallbackInUI<int>, callback));
+      (*backend_ptr)->DoomAllEntries(base::Bind(&RunCallbackInUI<int>,
+                                                callback));
     } else if (action == Session::CacheAction::STATS) {
       base::StringPairs stats;
       (*backend_ptr)->GetStats(&stats);
@@ -328,14 +327,14 @@ void DoCacheActionInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     Session::CacheAction action,
     const net::CompletionCallback& callback) {
-  auto* request_context = context_getter->GetURLRequestContext();
-  auto* http_cache = request_context->http_transaction_factory()->GetCache();
+  auto request_context = context_getter->GetURLRequestContext();
+  auto http_cache = request_context->http_transaction_factory()->GetCache();
   if (!http_cache)
     RunCallbackInUI<int>(callback, net::ERR_FAILED);
 
   // Call GetBackend and make the backend's ptr accessable in OnGetBackend.
   using BackendPtr = disk_cache::Backend*;
-  auto** backend_ptr = new BackendPtr(nullptr);
+  auto* backend_ptr = new BackendPtr(nullptr);
   net::CompletionCallback on_get_backend =
       base::Bind(&OnGetBackend, base::Owned(backend_ptr), action, callback);
   int rv = http_cache->GetBackend(backend_ptr, on_get_backend);
@@ -343,13 +342,12 @@ void DoCacheActionInIO(
     on_get_backend.Run(net::OK);
 }
 
-void SetProxyInIO(scoped_refptr<net::URLRequestContextGetter> getter,
+void SetProxyInIO(net::URLRequestContextGetter* getter,
                   const net::ProxyConfig& config,
                   const base::Closure& callback) {
-  auto* proxy_service =
-      getter->GetURLRequestContext()->proxy_resolution_service();
-  proxy_service->ResetConfigService(
-      base::WrapUnique(new net::ProxyConfigServiceFixed(config)));
+  auto proxy_service = getter->GetURLRequestContext()->proxy_service();
+  proxy_service->ResetConfigService(base::WrapUnique(
+      new net::ProxyConfigServiceFixed(config)));
   // Refetches and applies the new pac script if provided.
   proxy_service->ForceReloadProxyConfig();
   RunCallbackInUI(callback);
@@ -358,16 +356,16 @@ void SetProxyInIO(scoped_refptr<net::URLRequestContextGetter> getter,
 void SetCertVerifyProcInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     const AtomCertVerifier::VerifyProc& proc) {
-  auto* request_context = context_getter->GetURLRequestContext();
-  static_cast<AtomCertVerifier*>(request_context->cert_verifier())
-      ->SetVerifyProc(proc);
+  auto request_context = context_getter->GetURLRequestContext();
+  static_cast<AtomCertVerifier*>(request_context->cert_verifier())->
+      SetVerifyProc(proc);
 }
 
 void ClearHostResolverCacheInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     const base::Closure& callback) {
-  auto* request_context = context_getter->GetURLRequestContext();
-  auto* cache = request_context->host_resolver()->GetHostCache();
+  auto request_context = context_getter->GetURLRequestContext();
+  auto cache = request_context->host_resolver()->GetHostCache();
   if (cache) {
     cache->clear();
     DCHECK_EQ(0u, cache->size());
@@ -380,12 +378,12 @@ void ClearAuthCacheInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     const ClearAuthCacheOptions& options,
     const base::Closure& callback) {
-  auto* request_context = context_getter->GetURLRequestContext();
-  auto* network_session =
+  auto request_context = context_getter->GetURLRequestContext();
+  auto network_session =
       request_context->http_transaction_factory()->GetSession();
   if (network_session) {
     if (options.type == "password") {
-      auto* auth_cache = network_session->http_auth_cache();
+      auto auth_cache = network_session->http_auth_cache();
       if (!options.origin.is_empty()) {
         auth_cache->Remove(
             options.origin, options.realm, options.auth_scheme,
@@ -394,7 +392,7 @@ void ClearAuthCacheInIO(
         auth_cache->ClearEntriesAddedWithin(base::TimeDelta::Max());
       }
     } else if (options.type == "clientCertificate") {
-      auto* client_auth_cache = network_session->ssl_client_auth_cache();
+      auto client_auth_cache = network_session->ssl_client_auth_cache();
       client_auth_cache->Remove(net::HostPortPair::FromURL(options.origin));
     }
     network_session->CloseAllConnections();
@@ -406,13 +404,13 @@ void ClearAuthCacheInIO(
 void AllowNTLMCredentialsForDomainsInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     const std::string& domains) {
-  auto* request_context = context_getter->GetURLRequestContext();
-  auto* auth_handler = request_context->http_auth_handler_factory();
+  auto request_context = context_getter->GetURLRequestContext();
+  auto auth_handler = request_context->http_auth_handler_factory();
   if (auth_handler) {
-    auto* auth_preferences = const_cast<net::HttpAuthPreferences*>(
+    auto auth_preferences = const_cast<net::HttpAuthPreferences*>(
         auth_handler->http_auth_preferences());
     if (auth_preferences)
-      auth_preferences->SetServerWhitelist(domains);
+      auth_preferences->set_server_whitelist(domains);
   }
 }
 
@@ -435,10 +433,11 @@ void DownloadIdCallback(content::DownloadManager* download_manager,
       base::GenerateGUID(), id, path, path, url_chain, GURL(), GURL(), GURL(),
       GURL(), mime_type, mime_type, start_time, base::Time(), etag,
       last_modified, offset, length, std::string(),
-      download::DownloadItem::INTERRUPTED,
-      download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-      download::DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT, false, base::Time(),
-      false, std::vector<download::DownloadItem::ReceivedSlice>());
+      content::DownloadItem::INTERRUPTED,
+      content::DownloadDangerType::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      content::DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT, false,
+      base::Time(), false,
+      std::vector<content::DownloadItem::ReceivedSlice>());
 }
 
 void SetDevToolsNetworkEmulationClientIdInIO(
@@ -453,31 +452,14 @@ void SetDevToolsNetworkEmulationClientIdInIO(
   network_delegate->SetDevToolsNetworkEmulationClientId(client_id);
 }
 
-void DestroyGlobalHandle(v8::Isolate* isolate,
-                         const v8::Global<v8::Value>& global_handle) {
-  v8::Locker locker(isolate);
-  v8::HandleScope handle_scope(isolate);
-  if (!global_handle.IsEmpty()) {
-    v8::Local<v8::Value> local_handle = global_handle.Get(isolate);
-    if (local_handle->IsObject()) {
-      v8::Local<v8::Object> object = local_handle->ToObject();
-      void* ptr = object->GetAlignedPointerFromInternalField(0);
-      if (!ptr)
-        return;
-      delete static_cast<mate::WrappableBase*>(ptr);
-      object->SetAlignedPointerInInternalField(0, nullptr);
-    }
-  }
-}
-
 }  // namespace
 
 Session::Session(v8::Isolate* isolate, AtomBrowserContext* browser_context)
     : devtools_network_emulation_client_id_(base::GenerateGUID()),
       browser_context_(browser_context) {
   // Observe DownloadManager to get download notifications.
-  content::BrowserContext::GetDownloadManager(browser_context)
-      ->AddObserver(this);
+  content::BrowserContext::GetDownloadManager(browser_context)->
+      AddObserver(this);
 
   new SessionPreferences(browser_context);
 
@@ -486,27 +468,22 @@ Session::Session(v8::Isolate* isolate, AtomBrowserContext* browser_context)
 }
 
 Session::~Session() {
-  content::BrowserContext::GetDownloadManager(browser_context())
-      ->RemoveObserver(this);
-  DestroyGlobalHandle(isolate(), cookies_);
-  DestroyGlobalHandle(isolate(), web_request_);
-  DestroyGlobalHandle(isolate(), protocol_);
+  content::BrowserContext::GetDownloadManager(browser_context())->
+      RemoveObserver(this);
   g_sessions.erase(weak_map_id());
 }
 
 void Session::OnDownloadCreated(content::DownloadManager* manager,
-                                download::DownloadItem* item) {
+                                content::DownloadItem* item) {
   if (item->IsSavePackageDownload())
     return;
 
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
   auto handle = DownloadItem::Create(isolate(), item);
-  if (item->GetState() == download::DownloadItem::INTERRUPTED)
+  if (item->GetState() == content::DownloadItem::INTERRUPTED)
     handle->SetSavePath(item->GetTargetFilePath());
-  content::WebContents* web_contents =
-      content::DownloadItemUtils::GetWebContents(item);
-  bool prevent_default = Emit("will-download", handle, web_contents);
+  bool prevent_default = Emit("will-download", handle, item->GetWebContents());
   if (prevent_default) {
     item->Cancel(true);
     item->Remove();
@@ -517,13 +494,13 @@ void Session::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
   new ResolveProxyHelper(browser_context(), url, callback);
 }
 
-template <Session::CacheAction action>
+template<Session::CacheAction action>
 void Session::DoCacheAction(const net::CompletionCallback& callback) {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&DoCacheActionInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     action, callback));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&DoCacheActionInIO,
+                 make_scoped_refptr(browser_context_->GetRequestContext()),
+                 action,
+                 callback));
 }
 
 void Session::ClearStorageData(mate::Arguments* args) {
@@ -533,7 +510,7 @@ void Session::ClearStorageData(mate::Arguments* args) {
   args->GetNext(&options);
   args->GetNext(&callback);
 
-  auto* storage_partition =
+  auto storage_partition =
       content::BrowserContext::GetStoragePartition(browser_context(), nullptr);
   if (options.storage_types & StoragePartition::REMOVE_DATA_MASK_COOKIES) {
     // Reset media device id salt when cookies are cleared.
@@ -542,62 +519,66 @@ void Session::ClearStorageData(mate::Arguments* args) {
   }
   storage_partition->ClearData(
       options.storage_types, options.quota_types, options.origin,
-      content::StoragePartition::OriginMatcherFunction(), base::Time(),
-      base::Time::Max(), base::Bind(&OnClearStorageDataDone, callback));
+      content::StoragePartition::OriginMatcherFunction(),
+      base::Time(), base::Time::Max(),
+      base::Bind(&OnClearStorageDataDone, callback));
 }
 
 void Session::FlushStorageData() {
-  auto* storage_partition =
+  auto storage_partition =
       content::BrowserContext::GetStoragePartition(browser_context(), nullptr);
   storage_partition->Flush();
 }
 
 void Session::SetProxy(const net::ProxyConfig& config,
                        const base::Closure& callback) {
-  auto* getter = browser_context_->GetRequestContext();
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&SetProxyInIO, base::RetainedRef(getter), config,
-                     callback));
+  auto getter = browser_context_->GetRequestContext();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&SetProxyInIO, base::Unretained(getter), config, callback));
 }
 
 void Session::SetDownloadPath(const base::FilePath& path) {
-  browser_context_->prefs()->SetFilePath(prefs::kDownloadDefaultDirectory,
-                                         path);
+  browser_context_->prefs()->SetFilePath(
+      prefs::kDownloadDefaultDirectory, path);
 }
 
 void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
-  std::unique_ptr<network::NetworkConditions> conditions;
+  std::unique_ptr<brightray::DevToolsNetworkConditions> conditions;
   bool offline = false;
   double latency = 0.0, download_throughput = 0.0, upload_throughput = 0.0;
   if (options.Get("offline", &offline) && offline) {
-    conditions.reset(new network::NetworkConditions(offline));
+    conditions.reset(new brightray::DevToolsNetworkConditions(offline));
   } else {
     options.Get("latency", &latency);
     options.Get("downloadThroughput", &download_throughput);
     options.Get("uploadThroughput", &upload_throughput);
-    conditions.reset(new network::NetworkConditions(
-        false, latency, download_throughput, upload_throughput));
+    conditions.reset(
+        new brightray::DevToolsNetworkConditions(false,
+                                                 latency,
+                                                 download_throughput,
+                                                 upload_throughput));
   }
 
-  network::ThrottlingController::SetConditions(
+  browser_context_->network_controller_handle()->SetNetworkState(
       devtools_network_emulation_client_id_, std::move(conditions));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&SetDevToolsNetworkEmulationClientIdInIO,
-                     base::RetainedRef(browser_context_->GetRequestContext()),
-                     devtools_network_emulation_client_id_));
+      base::Bind(
+          &SetDevToolsNetworkEmulationClientIdInIO,
+          base::RetainedRef(browser_context_->url_request_context_getter()),
+          devtools_network_emulation_client_id_));
 }
 
 void Session::DisableNetworkEmulation() {
-  auto conditions = std::make_unique<network::NetworkConditions>();
-  network::ThrottlingController::SetConditions(
+  std::unique_ptr<brightray::DevToolsNetworkConditions> conditions;
+  browser_context_->network_controller_handle()->SetNetworkState(
       devtools_network_emulation_client_id_, std::move(conditions));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&SetDevToolsNetworkEmulationClientIdInIO,
-                     base::RetainedRef(browser_context_->GetRequestContext()),
-                     std::string()));
+      base::Bind(
+          &SetDevToolsNetworkEmulationClientIdInIO,
+          base::RetainedRef(browser_context_->url_request_context_getter()),
+          std::string()));
 }
 
 void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
@@ -608,11 +589,10 @@ void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
     return;
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&SetCertVerifyProcInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     proc));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&SetCertVerifyProcInIO,
+                 make_scoped_refptr(browser_context_->GetRequestContext()),
+                 proc));
 }
 
 void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
@@ -622,7 +602,7 @@ void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
     args->ThrowError("Must pass null or function");
     return;
   }
-  auto* permission_manager = static_cast<AtomPermissionManager*>(
+  auto permission_manager = static_cast<AtomPermissionManager*>(
       browser_context()->GetPermissionManager());
   permission_manager->SetPermissionRequestHandler(handler);
 }
@@ -631,11 +611,10 @@ void Session::ClearHostResolverCache(mate::Arguments* args) {
   base::Closure callback;
   args->GetNext(&callback);
 
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&ClearHostResolverCacheInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     callback));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&ClearHostResolverCacheInIO,
+                 make_scoped_refptr(browser_context_->GetRequestContext()),
+                 callback));
 }
 
 void Session::ClearAuthCache(mate::Arguments* args) {
@@ -649,17 +628,16 @@ void Session::ClearAuthCache(mate::Arguments* args) {
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&ClearAuthCacheInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     options, callback));
+      base::Bind(&ClearAuthCacheInIO,
+                 make_scoped_refptr(browser_context_->GetRequestContext()),
+                 options, callback));
 }
 
 void Session::AllowNTLMCredentialsForDomains(const std::string& domains) {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&AllowNTLMCredentialsForDomainsInIO,
-                     WrapRefCounted(browser_context_->GetRequestContext()),
-                     domains));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&AllowNTLMCredentialsForDomainsInIO,
+                 make_scoped_refptr(browser_context_->GetRequestContext()),
+                 domains));
 }
 
 void Session::SetUserAgent(const std::string& user_agent,
@@ -673,23 +651,26 @@ void Session::SetUserAgent(const std::string& user_agent,
       browser_context_->GetRequestContext());
   getter->GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
-      base::BindOnce(&SetUserAgentInIO, getter, accept_lang, user_agent));
+      base::Bind(&SetUserAgentInIO, getter, accept_lang, user_agent));
 }
 
 std::string Session::GetUserAgent() {
   return browser_context_->GetUserAgent();
 }
 
-void Session::GetBlobData(const std::string& uuid,
-                          const AtomBlobReader::CompletionCallback& callback) {
+void Session::GetBlobData(
+    const std::string& uuid,
+    const AtomBlobReader::CompletionCallback& callback) {
   if (callback.is_null())
     return;
 
-  AtomBlobReader* blob_reader = browser_context()->GetBlobReader();
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&AtomBlobReader::StartReading,
-                     base::Unretained(blob_reader), uuid, callback));
+  AtomBlobReader* blob_reader =
+      browser_context()->GetBlobReader();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&AtomBlobReader::StartReading,
+                 base::Unretained(blob_reader),
+                 uuid,
+                 callback));
 }
 
 void Session::CreateInterruptedDownload(const mate::Dictionary& options) {
@@ -716,7 +697,7 @@ void Session::CreateInterruptedDownload(const mate::Dictionary& options) {
         isolate(), "Must pass an offset value less than length.")));
     return;
   }
-  auto* download_manager =
+  auto download_manager =
       content::BrowserContext::GetDownloadManager(browser_context());
   download_manager->GetDelegate()->GetNextId(base::Bind(
       &DownloadIdCallback, download_manager, path, url_chain, mime_type, offset,
@@ -761,14 +742,14 @@ v8::Local<v8::Value> Session::WebRequest(v8::Isolate* isolate) {
 }
 
 // static
-mate::Handle<Session> Session::CreateFrom(v8::Isolate* isolate,
-                                          AtomBrowserContext* browser_context) {
-  auto* existing = TrackableObject::FromWrappedClass(isolate, browser_context);
+mate::Handle<Session> Session::CreateFrom(
+    v8::Isolate* isolate, AtomBrowserContext* browser_context) {
+  auto existing = TrackableObject::FromWrappedClass(isolate, browser_context);
   if (existing)
     return mate::CreateHandle(isolate, static_cast<Session*>(existing));
 
-  auto handle =
-      mate::CreateHandle(isolate, new Session(isolate, browser_context));
+  auto handle = mate::CreateHandle(
+      isolate, new Session(isolate, browser_context));
 
   // The Sessions should never be garbage collected, since the common pattern is
   // to use partition strings, instead of using the Session object directly.
@@ -780,8 +761,7 @@ mate::Handle<Session> Session::CreateFrom(v8::Isolate* isolate,
 
 // static
 mate::Handle<Session> Session::FromPartition(
-    v8::Isolate* isolate,
-    const std::string& partition,
+    v8::Isolate* isolate, const std::string& partition,
     const base::DictionaryValue& options) {
   scoped_refptr<AtomBrowserContext> browser_context;
   if (partition.empty()) {
@@ -811,7 +791,7 @@ void Session::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setDownloadPath", &Session::SetDownloadPath)
       .SetMethod("enableNetworkEmulation", &Session::EnableNetworkEmulation)
       .SetMethod("disableNetworkEmulation", &Session::DisableNetworkEmulation)
-      .SetMethod("setCertificateVerifyProc", &Session::SetCertVerifyProc)
+      .SetMethod("_setCertificateVerifyProc", &Session::SetCertVerifyProc)
       .SetMethod("setPermissionRequestHandler",
                  &Session::SetPermissionRequestHandler)
       .SetMethod("clearHostResolverCache", &Session::ClearHostResolverCache)
@@ -838,8 +818,8 @@ namespace {
 
 using atom::api::Session;
 
-v8::Local<v8::Value> FromPartition(const std::string& partition,
-                                   mate::Arguments* args) {
+v8::Local<v8::Value> FromPartition(
+    const std::string& partition, mate::Arguments* args) {
   if (!atom::Browser::Get()->is_ready()) {
     args->ThrowError("Session can only be received when app is ready");
     return v8::Null(args->isolate());
@@ -849,10 +829,8 @@ v8::Local<v8::Value> FromPartition(const std::string& partition,
   return Session::FromPartition(args->isolate(), partition, options).ToV8();
 }
 
-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("Session", Session::GetConstructor(isolate)->GetFunction());
@@ -862,4 +840,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_session, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_session, Initialize)

atom/browser/api/atom_api_session.h

@@ -24,7 +24,7 @@ class FilePath;
 namespace mate {
 class Arguments;
 class Dictionary;
-}  // namespace mate
+}
 
 namespace net {
 class ProxyConfig;
@@ -36,8 +36,8 @@ class AtomBrowserContext;
 
 namespace api {
 
-class Session : public mate::TrackableObject<Session>,
-                public content::DownloadManager::Observer {
+class Session: public mate::TrackableObject<Session>,
+               public content::DownloadManager::Observer {
  public:
   using ResolveProxyCallback = base::Callback<void(std::string)>;
 
@@ -47,13 +47,12 @@ class Session : public mate::TrackableObject<Session>,
   };
 
   // Gets or creates Session from the |browser_context|.
-  static mate::Handle<Session> CreateFrom(v8::Isolate* isolate,
-                                          AtomBrowserContext* browser_context);
+  static mate::Handle<Session> CreateFrom(
+      v8::Isolate* isolate, AtomBrowserContext* browser_context);
 
   // Gets the Session of |partition|.
   static mate::Handle<Session> FromPartition(
-      v8::Isolate* isolate,
-      const std::string& partition,
+      v8::Isolate* isolate, const std::string& partition,
       const base::DictionaryValue& options = base::DictionaryValue());
 
   AtomBrowserContext* browser_context() const { return browser_context_.get(); }
@@ -64,7 +63,7 @@ class Session : public mate::TrackableObject<Session>,
 
   // Methods.
   void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
-  template <CacheAction action>
+  template<CacheAction action>
   void DoCacheAction(const net::CompletionCallback& callback);
   void ClearStorageData(mate::Arguments* args);
   void FlushStorageData();
@@ -91,11 +90,11 @@ class Session : public mate::TrackableObject<Session>,
 
  protected:
   Session(v8::Isolate* isolate, AtomBrowserContext* browser_context);
-  ~Session() override;
+  ~Session();
 
   // content::DownloadManager::Observer:
   void OnDownloadCreated(content::DownloadManager* manager,
-                         download::DownloadItem* item) override;
+                         content::DownloadItem* item) override;
 
  private:
   // Cached object.

atom/browser/api/atom_api_system_preferences.cc

@@ -45,8 +45,7 @@ mate::Handle<SystemPreferences> SystemPreferences::Create(
 
 // static
 void SystemPreferences::BuildPrototype(
-    v8::Isolate* isolate,
-    v8::Local<v8::FunctionTemplate> prototype) {
+    v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> prototype) {
   prototype->SetClassName(mate::StringToV8(isolate, "SystemPreferences"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
 #if defined(OS_WIN)
@@ -54,23 +53,18 @@ void SystemPreferences::BuildPrototype(
       .SetMethod("isAeroGlassEnabled", &SystemPreferences::IsAeroGlassEnabled)
       .SetMethod("getColor", &SystemPreferences::GetColor)
 #elif defined(OS_MACOSX)
-      .SetMethod("postNotification", &SystemPreferences::PostNotification)
+      .SetMethod("postNotification",
+                 &SystemPreferences::PostNotification)
+      .SetMethod("postLocalNotification",
+                 &SystemPreferences::PostLocalNotification)
       .SetMethod("subscribeNotification",
                  &SystemPreferences::SubscribeNotification)
       .SetMethod("unsubscribeNotification",
                  &SystemPreferences::UnsubscribeNotification)
-      .SetMethod("postLocalNotification",
-                 &SystemPreferences::PostLocalNotification)
       .SetMethod("subscribeLocalNotification",
                  &SystemPreferences::SubscribeLocalNotification)
       .SetMethod("unsubscribeLocalNotification",
                  &SystemPreferences::UnsubscribeLocalNotification)
-      .SetMethod("postWorkspaceNotification",
-                 &SystemPreferences::PostWorkspaceNotification)
-      .SetMethod("subscribeWorkspaceNotification",
-                 &SystemPreferences::SubscribeWorkspaceNotification)
-      .SetMethod("unsubscribeWorkspaceNotification",
-                 &SystemPreferences::UnsubscribeWorkspaceNotification)
       .SetMethod("registerDefaults", &SystemPreferences::RegisterDefaults)
       .SetMethod("getUserDefault", &SystemPreferences::GetUserDefault)
       .SetMethod("setUserDefault", &SystemPreferences::SetUserDefault)
@@ -91,10 +85,8 @@ namespace {
 
 using atom::api::SystemPreferences;
 
-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("systemPreferences", SystemPreferences::Create(isolate));
@@ -104,4 +96,4 @@ void Initialize(v8::Local<v8::Object> exports,
 
 }  // namespace
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_system_preferences, Initialize);
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_system_preferences, Initialize);

atom/browser/api/atom_api_system_preferences.h

@@ -26,21 +26,12 @@ namespace atom {
 
 namespace api {
 
-#if defined(OS_MACOSX)
-enum NotificationCenterKind {
-  kNSDistributedNotificationCenter = 0,
-  kNSNotificationCenter,
-  kNSWorkspaceNotificationCenter,
-};
-#endif
-
 class SystemPreferences : public mate::EventEmitter<SystemPreferences>
 #if defined(OS_WIN)
-    ,
-                          public BrowserObserver,
-                          public gfx::SysColorChangeListener
+    , public BrowserObserver
+    , public gfx::SysColorChangeListener
 #endif
-{
+  {
  public:
   static mate::Handle<SystemPreferences> Create(v8::Isolate* isolate);
 
@@ -50,10 +41,10 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
 #if defined(OS_WIN)
   bool IsAeroGlassEnabled();
 
-  typedef HRESULT(STDAPICALLTYPE* DwmGetColorizationColor)(DWORD*, BOOL*);
+  typedef HRESULT (STDAPICALLTYPE *DwmGetColorizationColor)(DWORD *, BOOL *);
   DwmGetColorizationColor dwmGetColorizationColor =
-      (DwmGetColorizationColor)GetProcAddress(LoadLibraryW(L"dwmapi.dll"),
-                                              "DwmGetColorizationColor");
+    (DwmGetColorizationColor) GetProcAddress(LoadLibraryW(L"dwmapi.dll"),
+                                            "DwmGetColorizationColor");
 
   std::string GetAccentColor();
   std::string GetColor(const std::string& color, mate::Arguments* args);
@@ -67,24 +58,19 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
   void OnFinishLaunching(const base::DictionaryValue& launch_info) override;
 
 #elif defined(OS_MACOSX)
-  using NotificationCallback =
-      base::Callback<void(const std::string&, const base::DictionaryValue&)>;
+  using NotificationCallback = base::Callback<
+    void(const std::string&, const base::DictionaryValue&)>;
 
   void PostNotification(const std::string& name,
                         const base::DictionaryValue& user_info);
+  void PostLocalNotification(const std::string& name,
+                             const base::DictionaryValue& user_info);
   int SubscribeNotification(const std::string& name,
                             const NotificationCallback& callback);
   void UnsubscribeNotification(int id);
-  void PostLocalNotification(const std::string& name,
-                             const base::DictionaryValue& user_info);
   int SubscribeLocalNotification(const std::string& name,
                                  const NotificationCallback& callback);
   void UnsubscribeLocalNotification(int request_id);
-  void PostWorkspaceNotification(const std::string& name,
-                                 const base::DictionaryValue& user_info);
-  int SubscribeWorkspaceNotification(const std::string& name,
-                                     const NotificationCallback& callback);
-  void UnsubscribeWorkspaceNotification(int request_id);
   v8::Local<v8::Value> GetUserDefault(const std::string& name,
                                       const std::string& type);
   void RegisterDefaults(mate::Arguments* args);
@@ -104,25 +90,21 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
 #if defined(OS_MACOSX)
   void DoPostNotification(const std::string& name,
                           const base::DictionaryValue& user_info,
-                          NotificationCenterKind kind);
+                          bool is_local);
   int DoSubscribeNotification(const std::string& name,
                               const NotificationCallback& callback,
-                              NotificationCenterKind kind);
-  void DoUnsubscribeNotification(int request_id, NotificationCenterKind kind);
+                              bool is_local);
+  void DoUnsubscribeNotification(int request_id, bool is_local);
 #endif
 
  private:
 #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);
+  static LRESULT CALLBACK
+      WndProcStatic(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
 
-  LRESULT CALLBACK WndProc(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_;

atom/browser/api/atom_api_system_preferences_mac.mm

@@ -9,8 +9,8 @@
 #import <Cocoa/Cocoa.h>
 
 #include "atom/browser/mac/dict_util.h"
-#include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/values.h"
 #include "net/base/mac/url_conversions.h"
@@ -28,151 +28,94 @@ std::map<int, id> g_id_map;
 
 }  // namespace
 
-void SystemPreferences::PostNotification(
-    const std::string& name,
+void SystemPreferences::PostNotification(const std::string& name,
     const base::DictionaryValue& user_info) {
-  DoPostNotification(name, user_info, kNSDistributedNotificationCenter);
+  DoPostNotification(name, user_info, false);
+}
+
+void SystemPreferences::PostLocalNotification(const std::string& name,
+    const base::DictionaryValue& user_info) {
+  DoPostNotification(name, user_info, true);
+}
+
+void SystemPreferences::DoPostNotification(const std::string& name,
+    const base::DictionaryValue& user_info, bool is_local) {
+  NSNotificationCenter* center = is_local ?
+    [NSNotificationCenter defaultCenter] :
+    [NSDistributedNotificationCenter defaultCenter];
+  [center
+     postNotificationName:base::SysUTF8ToNSString(name)
+                   object:nil
+                 userInfo:DictionaryValueToNSDictionary(user_info)
+  ];
 }
 
 int SystemPreferences::SubscribeNotification(
-    const std::string& name,
-    const NotificationCallback& callback) {
-  return DoSubscribeNotification(name, callback,
-                                 kNSDistributedNotificationCenter);
+    const std::string& name, const NotificationCallback& callback) {
+  return DoSubscribeNotification(name, callback, false);
 }
 
 void SystemPreferences::UnsubscribeNotification(int request_id) {
-  DoUnsubscribeNotification(request_id, kNSDistributedNotificationCenter);
-}
-
-void SystemPreferences::PostLocalNotification(
-    const std::string& name,
-    const base::DictionaryValue& user_info) {
-  DoPostNotification(name, user_info, kNSNotificationCenter);
+  DoUnsubscribeNotification(request_id, false);
 }
 
 int SystemPreferences::SubscribeLocalNotification(
-    const std::string& name,
-    const NotificationCallback& callback) {
-  return DoSubscribeNotification(name, callback, kNSNotificationCenter);
+    const std::string& name, const NotificationCallback& callback) {
+  return DoSubscribeNotification(name, callback, true);
 }
 
 void SystemPreferences::UnsubscribeLocalNotification(int request_id) {
-  DoUnsubscribeNotification(request_id, kNSNotificationCenter);
+  DoUnsubscribeNotification(request_id, true);
 }
 
-void SystemPreferences::PostWorkspaceNotification(
-    const std::string& name,
-    const base::DictionaryValue& user_info) {
-  DoPostNotification(name, user_info, kNSWorkspaceNotificationCenter);
-}
-
-int SystemPreferences::SubscribeWorkspaceNotification(
-    const std::string& name,
-    const NotificationCallback& callback) {
-  return DoSubscribeNotification(name, callback,
-                                 kNSWorkspaceNotificationCenter);
-}
-
-void SystemPreferences::UnsubscribeWorkspaceNotification(int request_id) {
-  DoUnsubscribeNotification(request_id, kNSWorkspaceNotificationCenter);
-}
-
-void SystemPreferences::DoPostNotification(
-    const std::string& name,
-    const base::DictionaryValue& user_info,
-    NotificationCenterKind kind) {
-  NSNotificationCenter* center;
-  switch (kind) {
-    case kNSDistributedNotificationCenter:
-      center = [NSDistributedNotificationCenter defaultCenter];
-      break;
-    case kNSNotificationCenter:
-      center = [NSNotificationCenter defaultCenter];
-      break;
-    case kNSWorkspaceNotificationCenter:
-      center = [[NSWorkspace sharedWorkspace] notificationCenter];
-      break;
-    default:
-      break;
-  }
-  [center postNotificationName:base::SysUTF8ToNSString(name)
-                        object:nil
-                      userInfo:DictionaryValueToNSDictionary(user_info)];
-}
-
-int SystemPreferences::DoSubscribeNotification(
-    const std::string& name,
-    const NotificationCallback& callback,
-    NotificationCenterKind kind) {
+int SystemPreferences::DoSubscribeNotification(const std::string& name,
+  const NotificationCallback& callback, bool is_local) {
   int request_id = g_next_id++;
   __block NotificationCallback copied_callback = callback;
-  NSNotificationCenter* center;
-  switch (kind) {
-    case kNSDistributedNotificationCenter:
-      center = [NSDistributedNotificationCenter defaultCenter];
-      break;
-    case kNSNotificationCenter:
-      center = [NSNotificationCenter defaultCenter];
-      break;
-    case kNSWorkspaceNotificationCenter:
-      center = [[NSWorkspace sharedWorkspace] notificationCenter];
-      break;
-    default:
-      break;
-  }
+  NSNotificationCenter* center = is_local ?
+    [NSNotificationCenter defaultCenter] :
+    [NSDistributedNotificationCenter defaultCenter];
 
   g_id_map[request_id] = [center
-      addObserverForName:base::SysUTF8ToNSString(name)
-                  object:nil
-                   queue:nil
-              usingBlock:^(NSNotification* notification) {
-                std::unique_ptr<base::DictionaryValue> user_info =
-                    NSDictionaryToDictionaryValue(notification.userInfo);
-                if (user_info) {
-                  copied_callback.Run(
-                      base::SysNSStringToUTF8(notification.name), *user_info);
-                } else {
-                  copied_callback.Run(
-                      base::SysNSStringToUTF8(notification.name),
-                      base::DictionaryValue());
-                }
-              }];
+    addObserverForName:base::SysUTF8ToNSString(name)
+    object:nil
+    queue:nil
+    usingBlock:^(NSNotification* notification) {
+      std::unique_ptr<base::DictionaryValue> user_info =
+        NSDictionaryToDictionaryValue(notification.userInfo);
+      if (user_info) {
+        copied_callback.Run(
+          base::SysNSStringToUTF8(notification.name),
+          *user_info);
+      } else {
+        copied_callback.Run(
+          base::SysNSStringToUTF8(notification.name),
+          base::DictionaryValue());
+      }
+    }
+  ];
   return request_id;
 }
 
-void SystemPreferences::DoUnsubscribeNotification(int request_id,
-                                                  NotificationCenterKind kind) {
+void SystemPreferences::DoUnsubscribeNotification(int request_id, bool is_local) {
   auto iter = g_id_map.find(request_id);
   if (iter != g_id_map.end()) {
     id observer = iter->second;
-    NSNotificationCenter* center;
-    switch (kind) {
-      case kNSDistributedNotificationCenter:
-        center = [NSDistributedNotificationCenter defaultCenter];
-        break;
-      case kNSNotificationCenter:
-        center = [NSNotificationCenter defaultCenter];
-        break;
-      case kNSWorkspaceNotificationCenter:
-        center = [[NSWorkspace sharedWorkspace] notificationCenter];
-        break;
-      default:
-        break;
-    }
+    NSNotificationCenter* center = is_local ?
+      [NSNotificationCenter defaultCenter] :
+      [NSDistributedNotificationCenter defaultCenter];
     [center removeObserver:observer];
     g_id_map.erase(iter);
   }
 }
 
 v8::Local<v8::Value> SystemPreferences::GetUserDefault(
-    const std::string& name,
-    const std::string& type) {
+    const std::string& name, const std::string& type) {
   NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
   NSString* key = base::SysUTF8ToNSString(name);
   if (type == "string") {
-    return mate::StringToV8(
-        isolate(), base::SysNSStringToUTF8([defaults stringForKey:key]));
+    return mate::StringToV8(isolate(),
+      base::SysNSStringToUTF8([defaults stringForKey:key]));
   } else if (type == "boolean") {
     return v8::Boolean::New(isolate(), [defaults boolForKey:key]);
   } else if (type == "float") {
@@ -183,7 +126,7 @@ v8::Local<v8::Value> SystemPreferences::GetUserDefault(
     return v8::Number::New(isolate(), [defaults doubleForKey:key]);
   } else if (type == "url") {
     return mate::ConvertToV8(isolate(),
-                             net::GURLWithNSURL([defaults URLForKey:key]));
+      net::GURLWithNSURL([defaults URLForKey:key]));
   } else if (type == "array") {
     std::unique_ptr<base::ListValue> list =
         NSArrayToListValue([defaults arrayForKey:key]);
@@ -204,7 +147,7 @@ v8::Local<v8::Value> SystemPreferences::GetUserDefault(
 void SystemPreferences::RegisterDefaults(mate::Arguments* args) {
   base::DictionaryValue value;
 
-  if (!args->GetNext(&value)) {
+  if(!args->GetNext(&value)) {
     args->ThrowError("Invalid userDefault data provided");
   } else {
     @try {

atom/browser/api/atom_api_system_preferences_win.cc

@@ -17,7 +17,7 @@ namespace atom {
 namespace {
 
 const wchar_t kSystemPreferencesWindowClass[] =
-    L"Electron_SystemPreferencesHostWindow";
+  L"Electron_SystemPreferencesHostWindow";
 
 }  // namespace
 
@@ -130,8 +130,9 @@ void SystemPreferences::InitializeWindow() {
   WNDCLASSEX window_class;
   base::win::InitializeWindowClass(
       kSystemPreferencesWindowClass,
-      &base::win::WrappedWindowProc<SystemPreferences::WndProcStatic>, 0, 0, 0,
-      NULL, NULL, NULL, NULL, NULL, &window_class);
+      &base::win::WrappedWindowProc<SystemPreferences::WndProcStatic>,
+      0, 0, 0, NULL, NULL, NULL, NULL, NULL,
+      &window_class);
   instance_ = window_class.hInstance;
   atom_ = RegisterClassEx(&window_class);
 
@@ -139,16 +140,16 @@ void SystemPreferences::InitializeWindow() {
   // colorization color.  Create a hidden WS_POPUP window instead of an
   // HWND_MESSAGE window, because only top-level windows such as popups can
   // receive broadcast messages like "WM_DWMCOLORIZATIONCOLORCHANGED".
-  window_ = CreateWindow(MAKEINTATOM(atom_), 0, WS_POPUP, 0, 0, 0, 0, 0, 0,
-                         instance_, 0);
+  window_ = CreateWindow(MAKEINTATOM(atom_),
+                         0, WS_POPUP, 0, 0, 0, 0, 0, 0, instance_, 0);
   gfx::CheckWindowCreated(window_);
   gfx::SetWindowUserData(window_, this);
 }
 
 LRESULT CALLBACK SystemPreferences::WndProcStatic(HWND hwnd,
-                                                  UINT message,
-                                                  WPARAM wparam,
-                                                  LPARAM lparam) {
+                                              UINT message,
+                                              WPARAM wparam,
+                                              LPARAM lparam) {
   SystemPreferences* msg_wnd = reinterpret_cast<SystemPreferences*>(
       GetWindowLongPtr(hwnd, GWLP_USERDATA));
   if (msg_wnd)
@@ -158,11 +159,11 @@ LRESULT CALLBACK SystemPreferences::WndProcStatic(HWND hwnd,
 }
 
 LRESULT CALLBACK SystemPreferences::WndProc(HWND hwnd,
-                                            UINT message,
-                                            WPARAM wparam,
-                                            LPARAM lparam) {
+                                        UINT message,
+                                        WPARAM wparam,
+                                        LPARAM lparam) {
   if (message == WM_DWMCOLORIZATIONCOLORCHANGED) {
-    DWORD new_color = (DWORD)wparam;
+    DWORD new_color = (DWORD) wparam;
     std::string new_color_string = hexColorDWORDToRGBA(new_color);
     if (new_color_string != current_color_) {
       Emit("accent-color-changed", hexColorDWORDToRGBA(new_color));

atom/browser/api/atom_api_text_field.cc

@@ -1,67 +0,0 @@
-// 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_text_field.h"
-
-#include "atom/common/api/constructor.h"
-#include "native_mate/dictionary.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace api {
-
-TextField::TextField() : View(new views::Textfield()) {
-  view()->set_owned_by_client();
-}
-
-TextField::~TextField() {}
-
-void TextField::SetText(const base::string16& new_text) {
-  text_field()->SetText(new_text);
-}
-
-base::string16 TextField::GetText() const {
-  return text_field()->text();
-}
-
-// static
-mate::WrappableBase* TextField::New(mate::Arguments* args) {
-  // Constructor call.
-  auto* view = new TextField();
-  view->InitWith(args->isolate(), args->GetThis());
-  return view;
-}
-
-// static
-void TextField::BuildPrototype(v8::Isolate* isolate,
-                               v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(mate::StringToV8(isolate, "TextField"));
-  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
-      .SetMethod("setText", &TextField::SetText)
-      .SetMethod("getText", &TextField::GetText);
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-namespace {
-
-using atom::api::TextField;
-
-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("TextField", mate::CreateConstructor<TextField>(
-                            isolate, base::Bind(&TextField::New)));
-}
-
-}  // namespace
-
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_text_field, Initialize)

atom/browser/api/atom_api_text_field.h

@@ -1,42 +0,0 @@
-// 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_TEXT_FIELD_H_
-#define ATOM_BROWSER_API_ATOM_API_TEXT_FIELD_H_
-
-#include "atom/browser/api/atom_api_view.h"
-#include "native_mate/handle.h"
-#include "ui/views/controls/textfield/textfield.h"
-
-namespace atom {
-
-namespace api {
-
-class TextField : public View {
- public:
-  static mate::WrappableBase* New(mate::Arguments* args);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::FunctionTemplate> prototype);
-
-  void SetText(const base::string16& new_text);
-  base::string16 GetText() const;
-
- private:
-  TextField();
-  ~TextField() override;
-
-  views::Textfield* text_field() const {
-    return static_cast<views::Textfield*>(view());
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TextField);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_TEXT_FIELD_H_