Bump v4.0.0-beta.11

This reverts commit 0c690f7212.

.circleci/config.yml

@@ -1,3 +1,12 @@
+# The config expects the following environment variables to be set:
+#  - "SLACK_WEBHOOK" Slack hook URL to send notifications.
+#
+# The publishing scripts expect access tokens to be defined as env vars,
+# but those are not covered here.
+#
+# CircleCI docs on variables:
+# https://circleci.com/docs/2.0/env-vars/
+
 # Build machines configs.
 docker-image: &docker-image
   docker:
@@ -145,6 +154,7 @@ step-install-nodejs-on-mac: &step-install-nodejs-on-mac
       if [ "`uname`" == "Darwin" ]; then
         brew update
         brew install node@10
+        echo 'export PATH="/usr/local/opt/node@10/bin:$PATH"' >> $BASH_ENV
       fi
 
 step-gn-gen-default: &step-gn-gen-default
@@ -233,6 +243,7 @@ step-persist-data-for-tests: &step-persist-data-for-tests
 
       # Build artifacts
       - src/out/Default/dist.zip
+      - src/out/Default/mksnapshot.zip
       - src/out/Default/gen/node_headers
 
 step-electron-dist-unzip: &step-electron-dist-unzip
@@ -244,6 +255,13 @@ step-electron-dist-unzip: &step-electron-dist-unzip
       # TODO(alexeykuzmin): Remove '-o' when it's no longer needed.
       unzip -o dist.zip
 
+step-mksnapshot-unzip: &step-mksnapshot-unzip
+  run:
+    name: Unzip mksnapshot.zip
+    command: |
+      cd src/out/Default
+      unzip -o mksnapshot.zip
+
 step-ffmpeg-gn-gen: &step-ffmpeg-gn-gen
   run:
     name: ffmpeg GN gen
@@ -272,6 +290,13 @@ step-ffmpeg-store: &step-ffmpeg-store
     path: src/out/ffmpeg/ffmpeg.zip
     destination: ffmpeg.zip
 
+step-verify-mksnapshot: &step-verify-mksnapshot
+  run:
+    name: Verify mksnapshot
+    command: |
+      cd src
+      python electron/script/verify-mksnapshot.py --source-root "$PWD" --build-dir out/Default
+
 step-setup-linux-for-headless-testing: &step-setup-linux-for-headless-testing
   run:
     name: Setup for headless testing
@@ -311,20 +336,30 @@ step-mksnapshot-store: &step-mksnapshot-store
     path: src/out/Default/mksnapshot.zip
     destination: mksnapshot.zip
 
-step-generate-breakpad-symbols: &step-generate-breakpad-symbols
+step-build-dump-syms: &step-build-dump-syms
   run:
-    name: Generate breakpad symbols
-    environment:
-      # TODO(alexeykuzmin): Explicitly pass an out folder path to the scripts.
-      ELECTRON_OUT_DIR: Default
+    name: Build dump_syms binary
     command: |
       cd src
-
       # Build needed dump_syms executable
       ninja -C out/Default third_party/breakpad:dump_syms
 
-      electron/script/dump-symbols.py -d "$PWD/out/Default/electron.breakpad.syms"
-      electron/script/zip-symbols.py
+step-generate-breakpad-symbols: &step-generate-breakpad-symbols
+  run:
+    name: Generate breakpad symbols
+    command: |
+      cd src
+      export BUILD_PATH="$PWD/out/Default"
+      export DEST_PATH="$BUILD_PATH/breakpad_symbols"
+      electron/script/dump-symbols.py -b $BUILD_PATH -d $DEST_PATH -v
+
+step-zip-symbols: &step-zip-symbols
+  run:
+    name: Zip symbols
+    command: |
+      cd src
+      export BUILD_PATH="$PWD/out/Default"
+      electron/script/zip-symbols.py -b $BUILD_PATH
 
 step-maybe-native-mksnapshot-gn-gen: &step-maybe-native-mksnapshot-gn-gen
   run:
@@ -332,7 +367,7 @@ step-maybe-native-mksnapshot-gn-gen: &step-maybe-native-mksnapshot-gn-gen
     command: |
       if [ "$BUILD_NATIVE_MKSNAPSHOT" == "1" ]; then
         cd src
-        gn gen out/native_mksnapshot --args='import("//electron/build/args/native_mksnapshot.gn") cc_wrapper="'"$SCCACHE_PATH"'" v8_snapshot_toolchain="'"$MKSNAPSHOT_TOOLCHAIN"'"'" $GN_EXTRA_ARGS"
+        gn gen out/native_mksnapshot --args='import("'$GN_CONFIG'") cc_wrapper="'"$SCCACHE_PATH"'" v8_snapshot_toolchain="'"$MKSNAPSHOT_TOOLCHAIN"'"'" $GN_EXTRA_ARGS"
       else
         echo 'Skipping native mksnapshot GN gen for non arm build'
       fi
@@ -453,12 +488,29 @@ steps-electron-build-for-tests: &steps-electron-build-for-tests
 
     - *step-show-sccache-stats
 
+    # mksnapshot
+    - *step-mksnapshot-build
+    - *step-mksnapshot-store
+
+    # native_mksnapshot
+    - *step-maybe-native-mksnapshot-gn-gen
+    - *step-maybe-native-mksnapshot-build
+    - *step-maybe-native-mksnapshot-strip
+    - *step-maybe-native-mksnapshot-store
+
+    # ffmpeg
+    - *step-ffmpeg-gn-gen
+    - *step-ffmpeg-build
+    - *step-ffmpeg-store
+
     # Save all data needed for a further tests run.
     - *step-persist-data-for-tests
 
     # Breakpad symbols.
     # TODO(alexeykuzmin): We should do it only in nightly builds.
+    - *step-build-dump-syms
     - *step-generate-breakpad-symbols
+    - *step-zip-symbols
 
     # Trigger tests on arm hardware if needed
     - *step-maybe-trigger-arm-test
@@ -479,7 +531,9 @@ steps-electron-build-for-publish: &steps-electron-build-for-publish
     - *step-maybe-electron-dist-strip
     - *step-electron-dist-build
     - *step-electron-dist-store
+    - *step-build-dump-syms
     - *step-generate-breakpad-symbols
+    - *step-zip-symbols
 
     # mksnapshot
     - *step-mksnapshot-build
@@ -594,12 +648,25 @@ steps-verify-ffmpeg: &steps-verify-ffmpeg
     - *step-verify-ffmpeg
     - *step-maybe-notify-slack-failure
 
+steps-verify-mksnapshot: &steps-verify-mksnapshot
+  steps:
+    - attach_workspace:
+        at: .
+    - *step-depot-tools-add-to-path
+    - *step-electron-dist-unzip
+    - *step-mksnapshot-unzip
+    - *step-setup-linux-for-headless-testing
+
+    - *step-verify-mksnapshot
+    - *step-maybe-notify-slack-failure
+
 steps-tests: &steps-tests
   steps:
     - attach_workspace:
         at: .
     - *step-depot-tools-add-to-path
     - *step-electron-dist-unzip
+    - *step-mksnapshot-unzip
     - *step-setup-linux-for-headless-testing
     - *step-install-nodejs-on-mac
 
@@ -625,6 +692,8 @@ steps-tests: &steps-tests
     - store_test_results:
         path: src/junit
 
+    - *step-verify-mksnapshot
+
     - *step-maybe-notify-slack-failure
 
 # Mac build are different in a few ways:
@@ -665,6 +734,8 @@ steps-build-mac: &steps-build-mac
     # to store all gn's dependencies and configs.
     - *step-verify-ffmpeg
 
+    - *step-verify-mksnapshot
+
     # Node.js headers for tests
     - *step-nodejs-headers-build
 
@@ -696,8 +767,10 @@ jobs:
       GCLIENT_EXTRA_ARGS: '--custom-var=checkout_arm=True --custom-var=checkout_arm64=True'
     <<: *steps-checkout
 
-  linux-x64-checkout:
+  linux-checkout-for-native-tests:
     <<: *machine-linux-2xlarge
+    environment:
+      GCLIENT_EXTRA_ARGS: '--custom-var=checkout_pyyaml=True'
     <<: *steps-checkout
 
   # Layer 2: Builds.
@@ -850,6 +923,7 @@ jobs:
     <<: *machine-linux-medium
     environment:
       <<: *env-arm
+      <<: *env-release-build
       <<: *env-enable-sccache
       <<: *env-send-slack-notifications
     <<: *steps-native-mksnapshot-build
@@ -909,6 +983,7 @@ jobs:
     <<: *machine-linux-medium
     environment:
       <<: *env-arm64
+      <<: *env-release-build
       <<: *env-enable-sccache
       <<: *env-send-slack-notifications
     <<: *steps-native-mksnapshot-build
@@ -968,6 +1043,13 @@ jobs:
       <<: *env-send-slack-notifications
     <<: *steps-verify-ffmpeg
 
+  linux-x64-verify-mksnapshot:
+    <<: *machine-linux-medium
+    environment:
+      <<: *env-headless-testing
+      <<: *env-send-slack-notifications
+    <<: *steps-verify-mksnapshot
+
   linux-ia32-testing-tests:
     <<: *machine-linux-medium
     environment:
@@ -992,6 +1074,14 @@ jobs:
       <<: *env-send-slack-notifications
     <<: *steps-verify-ffmpeg
 
+  linux-ia32-verify-mksnapshot:
+    <<: *machine-linux-medium
+    environment:
+      <<: *env-ia32
+      <<: *env-headless-testing
+      <<: *env-send-slack-notifications
+    <<: *steps-verify-mksnapshot
+
   osx-testing-tests:
     <<: *machine-mac
     environment:
@@ -1114,6 +1204,9 @@ workflows:
           requires:
             - linux-x64-release
             - linux-x64-ffmpeg
+      - linux-x64-verify-mksnapshot:
+          requires:
+            - linux-x64-release
       - linux-x64-chromedriver:
           requires:
             - linux-checkout
@@ -1138,6 +1231,9 @@ workflows:
           requires:
             - linux-ia32-release
             - linux-ia32-ffmpeg
+      - linux-ia32-verify-mksnapshot:
+          requires:
+            - linux-ia32-release
       - linux-ia32-chromedriver:
           requires:
             - linux-checkout
@@ -1199,15 +1295,15 @@ workflows:
                 - master
                 - *chromium-upgrade-branches
     jobs:
-      - linux-x64-checkout
+      - linux-checkout-for-native-tests
 
       # TODO(alexeykuzmin): Enable it back.
       # Tons of crashes right now, see
       # https://circleci.com/gh/electron/electron/67463
 #      - linux-x64-browsertests:
 #          requires:
-#            - linux-x64-checkout
+#            - linux-checkout-for-native-tests
 
       - linux-x64-unittests:
           requires:
-            - linux-x64-checkout
+            - linux-checkout-for-native-tests

BUILD.gn

@@ -67,6 +67,9 @@ npm_action("atom_browserify_sandbox") {
   ]
 
   inputs = [
+    # FIXME(zcbenz): The dependencies of these files are not listed here, so
+    # the generated file will be out-dated when dependencies are modified.
+    # Use a script to generate all dependencies and put them here.
     "lib/sandboxed_renderer/init.js",
     "lib/sandboxed_renderer/api/exports/electron.js",
     "lib/sandboxed_renderer/api/exports/fs.js",
@@ -207,11 +210,11 @@ static_library("electron_lib") {
     "native_mate",
     "//base",
     "//base:i18n",
+    "//chrome/app/resources:platform_locale_settings",
     "//components/certificate_transparency",
     "//components/net_log",
     "//components/network_session_configurator/common",
     "//components/prefs",
-    "//components/printing/common",
     "//components/viz/service",
     "//content/public/app:both",
     "//content/public/child",
@@ -222,7 +225,6 @@ static_library("electron_lib") {
     "//ppapi/host",
     "//ppapi/proxy",
     "//ppapi/shared_impl",
-    "//printing",
     "//services/proxy_resolver:lib",
     "//skia",
     "//third_party/blink/public:blink",
@@ -367,6 +369,7 @@ static_library("electron_lib") {
       # Disable warnings for g_settings_list_schemas.
       "GLIB_DISABLE_DEPRECATION_WARNINGS",
     ]
+
     sources += filenames.lib_sources_nss
   }
   if (is_win) {
@@ -437,6 +440,15 @@ static_library("electron_lib") {
     ]
   }
 
+  if (enable_basic_printing) {
+    sources += [
+      "atom/browser/printing/print_preview_message_handler.cc",
+      "atom/browser/printing/print_preview_message_handler.h",
+      "atom/renderer/printing/print_render_frame_helper_delegate.cc",
+      "atom/renderer/printing/print_render_frame_helper_delegate.h",
+    ]
+  }
+
   if (enable_pepper_flash) {
     deps += [ "components/pepper_flash" ]
   }
@@ -558,6 +570,7 @@ if (is_mac) {
     sources = filenames.framework_sources
 
     libs = [
+      "AVFoundation.framework",
       "Carbon.framework",
       "QuartzCore.framework",
       "Quartz.framework",
@@ -635,13 +648,44 @@ if (is_mac) {
       "$root_out_dir/$electron_login_helper_name.app",
     ]
     outputs = [
-      "{{bundle_contents_dir}}/Library/LoginItems",
+      "{{bundle_contents_dir}}/Library/LoginItems/{{source_file_part}}",
     ]
   }
 
+  action("electron_app_lproj_dirs") {
+    outputs = []
+
+    foreach(locale, locales_as_mac_outputs) {
+      outputs += [ "$target_gen_dir/app_infoplist_strings/$locale.lproj" ]
+    }
+    script = "build/mac/make_locale_dirs.py"
+    args = rebase_path(outputs)
+  }
+
+  foreach(locale, locales_as_mac_outputs) {
+    bundle_data("electron_app_strings_${locale}_bundle_data") {
+      sources = [
+        "$target_gen_dir/app_infoplist_strings/$locale.lproj",
+      ]
+      outputs = [
+        "{{bundle_resources_dir}}/$locale.lproj",
+      ]
+      public_deps = [
+        ":electron_app_lproj_dirs",
+      ]
+    }
+  }
+  group("electron_app_strings_bundle_data") {
+    public_deps = []
+    foreach(locale, locales_as_mac_outputs) {
+      public_deps += [ ":electron_app_strings_${locale}_bundle_data" ]
+    }
+  }
+
   bundle_data("electron_app_resources") {
     public_deps = [
       ":app2asar",
+      ":electron_app_strings_bundle_data",
       ":js2asar",
     ]
     sources = [
@@ -750,6 +794,16 @@ if (is_mac) {
         "/DELAYLOAD:api-ms-win-core-winrt-l1-1-0.dll",
         "/DELAYLOAD:api-ms-win-core-winrt-string-l1-1-0.dll",
       ]
+
+      # This is to support renaming of electron.exe. node-gyp has hard-coded
+      # executable names which it will recognise as node. This module definition
+      # file claims that the electron executable is in fact named "node.exe",
+      # which is one of the executable names that node-gyp recognizes.
+      # See https://github.com/nodejs/node-gyp/commit/52ceec3a6d15de3a8f385f43dbe5ecf5456ad07a
+      ldflags += [ "/DEF:" + rebase_path("build/electron.def", root_build_dir) ]
+      inputs = [
+        "build/electron.def",
+      ]
     }
     if (is_linux) {
       ldflags = [ "-pie" ]
@@ -789,7 +843,6 @@ group("chromium_unittests") {
     "//mojo:mojo_unittests",
     "//net:net_unittests",
     "//ppapi:ppapi_unittests",
-    "//printing:printing_unittests",
     "//skia:skia_unittests",
     "//sql:sql_unittests",
     "//storage:storage_unittests",
@@ -807,6 +860,10 @@ group("chromium_unittests") {
     "//v8/test/unittests:unittests",
   ]
 
+  if (enable_basic_printing) {
+    deps += [ "//printing:printing_unittests" ]
+  }
+
   if (is_linux) {
     deps += [
       "//net:disk_cache_memory_test",
@@ -925,6 +982,7 @@ dist_zip("electron_chromedriver_zip") {
 dist_zip("electron_mksnapshot_zip") {
   data_deps = [
     "//v8:mksnapshot($v8_snapshot_toolchain)",
+    "//tools/v8_context_snapshot:v8_context_snapshot_generator",
     ":licenses",
   ]
   outputs = [
@@ -948,6 +1006,13 @@ group("electron_content_manifest_overlays") {
 service_manifest("electron_content_packaged_services_manifest_overlay") {
   source = "//electron/manifests/electron_content_packaged_services_manifest_overlay.json"
   packaged_services = [ "//services/proxy_resolver:proxy_resolver_manifest" ]
+
+  if (enable_basic_printing) {
+    packaged_services += [
+      "//chrome/services/printing:manifest",
+      "//components/services/pdf_compositor:pdf_compositor_manifest",
+    ]
+  }
 }
 
 service_manifest("electron_content_browser_manifest_overlay") {

DEPS

@@ -12,7 +12,7 @@ vars = {
   'chromium_version':
     '69.0.3497.106',
   'node_version':
-    '5654c276d0497ff9a0bb0d7550b9073b2e2e7d3f',
+    '4d44266b78256449dd6ae86e419e3ec07257b569',
 
   'boto_version': 'f7574aa6cc2c819430c1f05e9a1a1a666ef8169b',
   'pyyaml_version': '3.12',
@@ -24,9 +24,19 @@ vars = {
   'requests_git': 'https://github.com/kennethreitz',
   'yaml_git': 'https://github.com/yaml',
 
+  # To be able to build clean Chromium from sources.
+  'apply_patches': True,
+
   # Python interface to Amazon Web Services. Is used for releases only.
   'checkout_boto': False,
 
+  # To allow in-house builds to checkout those manually.
+  'checkout_chromium': True,
+  'checkout_node': True,
+
+  # It's only needed to parse the native tests configurations.
+  'checkout_pyyaml': False,
+
   # Python "requests" module is used for releases only.
   'checkout_requests': False,
 
@@ -49,12 +59,18 @@ vars = {
 }
 
 deps = {
-  'src':
-    (Var("chromium_git")) + '/chromium/src.git@' + (Var("chromium_version")),
-  'src/third_party/electron_node':
-    (Var("electron_git")) + '/node.git@' + (Var("node_version")),
-  'src/electron/vendor/pyyaml':
-    (Var("yaml_git")) + '/pyyaml.git@' + (Var("pyyaml_version")),
+  'src': {
+    'url': (Var("chromium_git")) + '/chromium/src.git@' + (Var("chromium_version")),
+    'condition': 'checkout_chromium',
+  },
+  'src/third_party/electron_node': {
+    'url': (Var("electron_git")) + '/node.git@' + (Var("node_version")),
+    'condition': 'checkout_node',
+  },
+  'src/electron/vendor/pyyaml': {
+    'url': (Var("yaml_git")) + '/pyyaml.git@' + (Var("pyyaml_version")),
+    'condition': 'checkout_pyyaml',
+  },
   'src/electron/vendor/boto': {
     'url': Var('boto_git') + '/boto.git' + '@' +  Var('boto_version'),
     'condition': 'checkout_boto',
@@ -68,12 +84,12 @@ deps = {
 hooks = [
   {
     'name': 'patch_chromium',
+    'condition': 'checkout_chromium and apply_patches',
     'pattern': 'src/electron',
     'action': [
       'python',
-      'src/electron/script/apply-patches',
-      '--project-root=.',
-      '--commit',
+      'src/electron/script/apply_all_patches.py',
+      'src/electron/patches/common/config.json',
     ],
   },
   {

VERSION

@@ -1 +1 @@
-4.0.0-nightly.20181010
+4.0.0-beta.11

appveyor.yml

@@ -1,3 +1,28 @@
+# The config expects the following environment variables to be set:
+#  - "GN_CONFIG" Build type. One of {'debug', 'testing', 'release'}.
+#  - "GN_EXTRA_ARGS" Additional gn arguments for a build config,
+#      e.g. 'target_cpu="x86"' to build for a 32bit platform.
+#      https://gn.googlesource.com/gn/+/master/docs/reference.md#target_cpu
+#      Don't forget to set up "NPM_CONFIG_ARCH" and "TARGET_ARCH" accordningly
+#      if you pass a custom value for 'target_cpu'.
+#  - "ELECTRON_RELEASE" Set it to '1' upload binaries on success.
+#  - "NPM_CONFIG_ARCH" E.g. 'x86'. Is used to build native Node.js modules.
+#      Must match 'target_cpu' passed to "GN_EXTRA_ARGS" and "TARGET_ARCH" value.
+#  - "TARGET_ARCH" Choose from {'ia32', 'x64', 'arm', 'arm64', 'mips64el'}.
+#      Is used in some publishing scripts, but does NOT affect the Electron binary.
+#      Must match 'target_cpu' passed to "GN_EXTRA_ARGS" and "NPM_CONFIG_ARCH" value.
+#  - "UPLOAD_TO_S3" Set it to '1' upload a release to the S3 bucket.
+#      Otherwise the release will be uploaded to the Github Releases.
+#      (The value is only checked if "ELECTRON_RELEASE" is defined.)
+#
+# The publishing scripts expect access tokens to be defined as env vars,
+# but those are not covered here.
+#
+# AppVeyor docs on variables:
+# https://www.appveyor.com/docs/environment-variables/
+# https://www.appveyor.com/docs/build-configuration/#secure-variables
+# https://www.appveyor.com/docs/build-configuration/#custom-environment-variables
+
 version: 1.0.{build}
 build_cloud: libcc-20
 image: libcc-20-vs2017-15.7.4
@@ -29,7 +54,8 @@ build_script:
       "https://github.com/electron/electron"
   - gclient sync --with_branch_heads --with_tags
   - cd src
-  - gn gen out/Default "--args=import(\"//electron/build/args/%GN_CONFIG%.gn\") %GN_EXTRA_ARGS%"
+  - ps: $env:BUILD_CONFIG_PATH="//electron/build/args/%GN_CONFIG%.gn"
+  - gn gen out/Default "--args=import(\"%BUILD_CONFIG_PATH%\") %GN_EXTRA_ARGS%"
   - ninja -C out/Default electron:electron_app
   - gn gen out/ffmpeg "--args=import(\"//electron/build/args/ffmpeg.gn\") %GN_EXTRA_ARGS%"
   - ninja -C out/ffmpeg electron:electron_ffmpeg_zip
@@ -44,7 +70,7 @@ build_script:
       if ($env:GN_CONFIG -eq 'release') {
         ninja -C out/Default third_party/breakpad:dump_syms
       }
-  - if "%GN_CONFIG%"=="release" ( python electron\script\dump-symbols.py -d %cd%\out\Default\electron.breakpad.syms -v)
+  - if "%GN_CONFIG%"=="release" ( python electron\script\dump-symbols.py -d %cd%\out\Default\breakpad_symbols -v)
   - ps: >-
       if ($env:GN_CONFIG -eq 'release') {
         python electron\script\zip-symbols.py
@@ -56,6 +82,7 @@ test_script:
         $env:RUN_TESTS="true"
       }
   - if "%RUN_TESTS%"=="true" ( echo Verifying non proprietary ffmpeg & python electron\script\verify-ffmpeg.py --build-dir out\Default --source-root %cd% --ffmpeg-path out\ffmpeg )
+  - if "%RUN_TESTS%"=="true" ( echo Verifying mksnapshot & python electron\script\verify-mksnapshot.py --build-dir out\Default --source-root %cd% )
   - ps: >-
       if ($env:RUN_TESTS -eq 'true') {
         New-Item .\out\Default\gen\node_headers\Release -Type directory

atom/app/atom_main.cc

@@ -24,10 +24,14 @@
 #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 <unistd.h>
+#include <cstdio>
 #include "atom/app/atom_main_delegate.h"  // NOLINT
 #include "content/public/app/content_main.h"
 #else  // defined(OS_LINUX)
+#include <unistd.h>
+#include <cstdio>
 #include "atom/app/atom_library_main.h"
 #endif  // defined(OS_MACOSX)
 
@@ -54,6 +58,25 @@ bool IsEnvSet(const char* name) {
 #endif
 }
 
+#if defined(OS_POSIX)
+void FixStdioStreams() {
+  // libuv may mark stdin/stdout/stderr as close-on-exec, which interferes
+  // with chromium's subprocess spawning. As a workaround, we detect if these
+  // streams are closed on startup, and reopen them as /dev/null if necessary.
+  // Otherwise, an unrelated file descriptor will be assigned as stdout/stderr
+  // which may cause various errors when attempting to write to them.
+  //
+  // For details see https://github.com/libuv/libuv/issues/2062
+  struct stat st;
+  if (fstat(STDIN_FILENO, &st) < 0 && errno == EBADF)
+    ignore_result(freopen("/dev/null", "r", stdin));
+  if (fstat(STDOUT_FILENO, &st) < 0 && errno == EBADF)
+    ignore_result(freopen("/dev/null", "w", stdout));
+  if (fstat(STDERR_FILENO, &st) < 0 && errno == EBADF)
+    ignore_result(freopen("/dev/null", "w", stderr));
+}
+#endif
+
 }  // namespace
 
 #if defined(OS_WIN)
@@ -155,6 +178,8 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
 #elif defined(OS_LINUX)  // defined(OS_WIN)
 
 int main(int argc, char* argv[]) {
+  FixStdioStreams();
+
 #if BUILDFLAG(ENABLE_RUN_AS_NODE)
   if (IsEnvSet(kRunAsNode)) {
     base::i18n::InitializeICU();
@@ -174,6 +199,8 @@ int main(int argc, char* argv[]) {
 #else  // defined(OS_LINUX)
 
 int main(int argc, char* argv[]) {
+  FixStdioStreams();
+
 #if BUILDFLAG(ENABLE_RUN_AS_NODE)
   if (IsEnvSet(kRunAsNode)) {
     return AtomInitializeICUandStartNode(argc, argv);

atom/browser/api/atom_api_app.cc

@@ -23,7 +23,6 @@
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/native_mate_converters/network_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
-#include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/environment.h"
@@ -54,6 +53,12 @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image.h"
 
+// clang-format off
+// This header should be declared at the end to avoid
+// redefinition errors.
+#include "atom/common/node_includes.h"  // NOLINT(build/include_alpha)
+// clang-format on
+
 #if defined(OS_WIN)
 #include "atom/browser/ui/win/jump_list.h"
 #include "base/strings/utf_string_conversions.h"
@@ -1173,7 +1178,7 @@ v8::Local<v8::Promise> App::GetGPUInfo(v8::Isolate* isolate,
 
   auto* const info_mgr = GPUInfoManager::GetInstance();
   if (info_type == "complete") {
-#if defined(OS_WIN)
+#if defined(OS_WIN) || defined(OS_MACOSX)
     info_mgr->FetchCompleteInfo(promise);
 #else
     info_mgr->FetchBasicInfo(promise);
@@ -1284,6 +1289,8 @@ void App::BuildPrototype(v8::Isolate* isolate,
                  base::Bind(&Browser::UpdateCurrentActivity, browser))
       .SetMethod("setAboutPanelOptions",
                  base::Bind(&Browser::SetAboutPanelOptions, browser))
+      .SetMethod("showAboutPanel",
+                 base::Bind(&Browser::ShowAboutPanel, browser))
 #endif
 #if defined(OS_WIN)
       .SetMethod("setUserTasks", base::Bind(&Browser::SetUserTasks, browser))

atom/browser/api/atom_api_browser_view.cc

@@ -66,6 +66,7 @@ void BrowserView::Init(v8::Isolate* isolate,
 
   web_contents_.Reset(isolate, web_contents.ToV8());
   api_web_contents_ = web_contents.get();
+  Observe(web_contents->web_contents());
 
   view_.reset(
       NativeBrowserView::Create(api_web_contents_->managed_web_contents()));
@@ -74,7 +75,16 @@ void BrowserView::Init(v8::Isolate* isolate,
 }
 
 BrowserView::~BrowserView() {
-  api_web_contents_->DestroyWebContents(true /* async */);
+  if (api_web_contents_) {  // destroy() is called
+    // Destroy WebContents asynchronously unless app is shutting down,
+    // because destroy() might be called inside WebContents's event handler.
+    api_web_contents_->DestroyWebContents(!Browser::Get()->is_shutting_down());
+  }
+}
+
+void BrowserView::WebContentsDestroyed() {
+  api_web_contents_ = nullptr;
+  web_contents_.Reset();
 }
 
 // static

atom/browser/api/atom_api_browser_view.h

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

atom/browser/api/atom_api_browser_window.cc

@@ -385,7 +385,9 @@ void BrowserWindow::Cleanup() {
   if (host)
     host->GetWidget()->RemoveInputEventObserver(this);
 
-  api_web_contents_->DestroyWebContents(true /* async */);
+  // Destroy WebContents asynchronously unless app is shutting down,
+  // because destroy() might be called inside WebContents's event handler.
+  api_web_contents_->DestroyWebContents(!Browser::Get()->is_shutting_down());
   Observe(nullptr);
 }
 

atom/browser/api/atom_api_browser_window_mac.mm

@@ -63,7 +63,12 @@ void BrowserWindow::OverrideNSWindowContentView(
   NSView* webView = iwc->GetView()->GetNativeView();
   NSView* contentView = [window()->GetNativeWindow() contentView];
   [webView setFrame:[contentView bounds]];
-  [contentView addSubview:webView];
+
+  // ensure that buttons view is floated to top of view hierarchy
+  NSArray* subviews = [contentView subviews];
+  NSView* last = subviews.lastObject;
+  [contentView addSubview:webView positioned:NSWindowBelow relativeTo:last];
+
   [contentView viewDidMoveToWindow];
 }
 

atom/browser/api/atom_api_event.cc

@@ -0,0 +1,26 @@
+// Copyright (c) 2018 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/event_emitter.h"
+#include "atom/common/node_includes.h"
+#include "native_mate/dictionary.h"
+
+namespace {
+
+v8::Local<v8::Object> CreateWithSender(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> sender) {
+  return mate::internal::CreateJSEvent(isolate, sender, nullptr, nullptr);
+}
+
+void Initialize(v8::Local<v8::Object> exports,
+                v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context,
+                void* priv) {
+  mate::Dictionary dict(context->GetIsolate(), exports);
+  dict.SetMethod("createWithSender", &CreateWithSender);
+}
+
+}  // namespace
+
+NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_event, Initialize)

atom/browser/api/atom_api_menu.cc

@@ -41,6 +41,8 @@ void Menu::AfterInit(v8::Isolate* isolate) {
   delegate.Get("isCommandIdEnabled", &is_enabled_);
   delegate.Get("isCommandIdVisible", &is_visible_);
   delegate.Get("getAcceleratorForCommandId", &get_accelerator_);
+  delegate.Get("shouldRegisterAcceleratorForCommandId",
+               &should_register_accelerator_);
   delegate.Get("executeCommand", &execute_command_);
   delegate.Get("menuWillShow", &menu_will_show_);
 }
@@ -74,6 +76,12 @@ bool Menu::GetAcceleratorForCommandIdWithParams(
   return mate::ConvertFromV8(isolate(), val, accelerator);
 }
 
+bool Menu::ShouldRegisterAcceleratorForCommandId(int command_id) const {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  return should_register_accelerator_.Run(GetWrapper(), command_id);
+}
+
 void Menu::ExecuteCommand(int command_id, int flags) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
@@ -155,6 +163,12 @@ base::string16 Menu::GetSublabelAt(int index) const {
   return model_->GetSublabelAt(index);
 }
 
+base::string16 Menu::GetAcceleratorTextAt(int index) const {
+  ui::Accelerator accelerator;
+  model_->GetAcceleratorAtWithParams(index, true, &accelerator);
+  return accelerator.GetShortcutText();
+}
+
 bool Menu::IsItemCheckedAt(int index) const {
   return model_->IsItemCheckedAt(index);
 }
@@ -195,6 +209,7 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getCommandIdAt", &Menu::GetCommandIdAt)
       .SetMethod("getLabelAt", &Menu::GetLabelAt)
       .SetMethod("getSublabelAt", &Menu::GetSublabelAt)
+      .SetMethod("getAcceleratorTextAt", &Menu::GetAcceleratorTextAt)
       .SetMethod("isItemCheckedAt", &Menu::IsItemCheckedAt)
       .SetMethod("isEnabledAt", &Menu::IsEnabledAt)
       .SetMethod("isVisibleAt", &Menu::IsVisibleAt)

atom/browser/api/atom_api_menu.h

@@ -51,6 +51,7 @@ class Menu : public mate::TrackableObject<Menu>,
       int command_id,
       bool use_default_accelerator,
       ui::Accelerator* accelerator) const override;
+  bool ShouldRegisterAcceleratorForCommandId(int command_id) const override;
   void ExecuteCommand(int command_id, int event_flags) override;
   void MenuWillShow(ui::SimpleMenuModel* source) override;
 
@@ -91,6 +92,7 @@ class Menu : public mate::TrackableObject<Menu>,
   int GetCommandIdAt(int index) const;
   base::string16 GetLabelAt(int index) const;
   base::string16 GetSublabelAt(int index) const;
+  base::string16 GetAcceleratorTextAt(int index) const;
   bool IsItemCheckedAt(int index) const;
   bool IsEnabledAt(int index) const;
   bool IsVisibleAt(int index) const;
@@ -101,6 +103,7 @@ class Menu : public mate::TrackableObject<Menu>,
   base::Callback<bool(v8::Local<v8::Value>, int)> is_visible_;
   base::Callback<v8::Local<v8::Value>(v8::Local<v8::Value>, int, bool)>
       get_accelerator_;
+  base::Callback<bool(v8::Local<v8::Value>, int)> should_register_accelerator_;
   base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>, int)>
       execute_command_;
   base::Callback<void(v8::Local<v8::Value>)> menu_will_show_;

atom/browser/api/atom_api_system_preferences.cc

@@ -83,6 +83,9 @@ void SystemPreferences::BuildPrototype(
                  &SystemPreferences::GetAppLevelAppearance)
       .SetMethod("setAppLevelAppearance",
                  &SystemPreferences::SetAppLevelAppearance)
+      .SetMethod("getMediaAccessStatus",
+                 &SystemPreferences::GetMediaAccessStatus)
+      .SetMethod("askForMediaAccess", &SystemPreferences::AskForMediaAccess)
 #endif
       .SetMethod("isInvertedColorScheme",
                  &SystemPreferences::IsInvertedColorScheme)

atom/browser/api/atom_api_system_preferences.h

@@ -9,6 +9,7 @@
 #include <string>
 
 #include "atom/browser/api/event_emitter.h"
+#include "atom/common/promise_util.h"
 #include "base/callback.h"
 #include "base/values.h"
 #include "native_mate/handle.h"
@@ -90,6 +91,13 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
   void RemoveUserDefault(const std::string& name);
   bool IsSwipeTrackingFromScrollEventsEnabled();
 
+  // TODO(codebytere): Write tests for these methods once we
+  // are running tests on a Mojave machine
+  std::string GetMediaAccessStatus(const std::string& media_type,
+                                   mate::Arguments* args);
+  v8::Local<v8::Promise> AskForMediaAccess(v8::Isolate* isolate,
+                                           const std::string& media_type);
+
   // TODO(MarshallOfSound): Write tests for these methods once we
   // are running tests on a Mojave machine
   v8::Local<v8::Value> GetEffectiveAppearance(v8::Isolate* isolate);

atom/browser/api/atom_api_system_preferences_mac.mm

@@ -6,6 +6,7 @@
 
 #include <map>
 
+#import <AVFoundation/AVFoundation.h>
 #import <Cocoa/Cocoa.h>
 
 #include "atom/browser/mac/atom_application.h"
@@ -78,6 +79,31 @@ int g_next_id = 0;
 // The map to convert |id| to |int|.
 std::map<int, id> g_id_map;
 
+AVMediaType ParseMediaType(const std::string& media_type) {
+  if (media_type == "camera") {
+    return AVMediaTypeVideo;
+  } else if (media_type == "microphone") {
+    return AVMediaTypeAudio;
+  } else {
+    return nil;
+  }
+}
+
+std::string ConvertAuthorizationStatus(AVAuthorizationStatusMac status) {
+  switch (status) {
+    case AVAuthorizationStatusNotDeterminedMac:
+      return "not-determined";
+    case AVAuthorizationStatusRestrictedMac:
+      return "restricted";
+    case AVAuthorizationStatusDeniedMac:
+      return "denied";
+    case AVAuthorizationStatusAuthorizedMac:
+      return "granted";
+    default:
+      return "unknown";
+  }
+}
+
 }  // namespace
 
 void SystemPreferences::PostNotification(
@@ -360,6 +386,47 @@ void SystemPreferences::SetUserDefault(const std::string& name,
   }
 }
 
+std::string SystemPreferences::GetMediaAccessStatus(
+    const std::string& media_type,
+    mate::Arguments* args) {
+  if (auto type = ParseMediaType(media_type)) {
+    if (@available(macOS 10.14, *)) {
+      return ConvertAuthorizationStatus(
+          [AVCaptureDevice authorizationStatusForMediaType:type]);
+    } else {
+      // access always allowed pre-10.14 Mojave
+      return ConvertAuthorizationStatus(AVAuthorizationStatusAuthorizedMac);
+    }
+  } else {
+    args->ThrowError("Invalid media type");
+    return std::string();
+  }
+}
+
+v8::Local<v8::Promise> SystemPreferences::AskForMediaAccess(
+    v8::Isolate* isolate,
+    const std::string& media_type) {
+  scoped_refptr<util::Promise> promise = new util::Promise(isolate);
+
+  if (auto type = ParseMediaType(media_type)) {
+    if (@available(macOS 10.14, *)) {
+      [AVCaptureDevice requestAccessForMediaType:type
+                               completionHandler:^(BOOL granted) {
+                                 dispatch_async(dispatch_get_main_queue(), ^{
+                                   promise->Resolve(!!granted);
+                                 });
+                               }];
+    } else {
+      // access always allowed pre-10.14 Mojave
+      promise->Resolve(true);
+    }
+  } else {
+    promise->RejectWithErrorMessage("Invalid media type");
+  }
+
+  return promise->GetHandle();
+}
+
 void SystemPreferences::RemoveUserDefault(const std::string& name) {
   NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
   [defaults removeObjectForKey:base::SysUTF8ToNSString(name)];

atom/browser/api/atom_api_top_level_window.cc

@@ -691,8 +691,11 @@ void TopLevelWindow::SetBrowserView(v8::Local<v8::Value> value) {
 }
 
 v8::Local<v8::Value> TopLevelWindow::GetNativeWindowHandle() {
-  gfx::AcceleratedWidget handle = window_->GetAcceleratedWidget();
-  return ToBuffer(isolate(), static_cast<void*>(&handle), sizeof(handle));
+  // TODO(MarshallOfSound): Replace once
+  // https://chromium-review.googlesource.com/c/chromium/src/+/1253094/ has
+  // landed
+  NativeWindowHandle handle = window_->GetNativeWindowHandle();
+  return ToBuffer(isolate(), &handle, sizeof(handle));
 }
 
 void TopLevelWindow::SetProgressBar(double progress, mate::Arguments* args) {

atom/browser/api/atom_api_web_contents.cc

@@ -17,6 +17,7 @@
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_javascript_dialog_manager.h"
 #include "atom/browser/atom_navigation_throttle.h"
+#include "atom/browser/browser.h"
 #include "atom/browser/child_web_contents_tracker.h"
 #include "atom/browser/lib/bluetooth_chooser.h"
 #include "atom/browser/native_window.h"
@@ -51,8 +52,6 @@
 #include "brightray/browser/inspectable_web_contents.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/printing/print_preview_message_handler.h"
-#include "chrome/browser/printing/print_view_manager_basic.h"
 #include "chrome/browser/ssl/security_state_tab_helper.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_manager.h"
@@ -101,34 +100,16 @@
 #include "ui/gfx/font_render_params.h"
 #endif
 
+#if BUILDFLAG(ENABLE_PRINTING)
+#include "chrome/browser/printing/print_view_manager_basic.h"
+#include "components/printing/common/print_messages.h"
+#endif
+
 #include "atom/common/node_includes.h"
 
-namespace {
-
-struct PrintSettings {
-  bool silent;
-  bool print_background;
-  base::string16 device_name;
-};
-}  // namespace
-
 namespace mate {
 
-template <>
-struct Converter<PrintSettings> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     PrintSettings* out) {
-    mate::Dictionary dict;
-    if (!ConvertFromV8(isolate, val, &dict))
-      return false;
-    dict.Get("silent", &(out->silent));
-    dict.Get("printBackground", &(out->print_background));
-    dict.Get("deviceName", &(out->device_name));
-    return true;
-  }
-};
-
+#if BUILDFLAG(ENABLE_PRINTING)
 template <>
 struct Converter<printing::PrinterBasicInfo> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
@@ -142,6 +123,7 @@ struct Converter<printing::PrinterBasicInfo> {
     return dict.GetHandle();
   }
 };
+#endif
 
 template <>
 struct Converter<WindowOpenDisposition> {
@@ -480,14 +462,25 @@ WebContents::~WebContents() {
     RenderViewDeleted(web_contents()->GetRenderViewHost());
 
     if (type_ == WEB_VIEW) {
+      // For webview simply destroy the WebContents immediately.
+      // TODO(zcbenz): Add an internal API for webview instead of using
+      // destroy(), so we don't have to add a special branch here.
+      DestroyWebContents(false /* async */);
+    } else if (type_ == BROWSER_WINDOW && owner_window()) {
+      // For BrowserWindow we should close the window and clean up everything
+      // before WebContents is destroyed.
+      for (ExtendedWebContentsObserver& observer : observers_)
+        observer.OnCloseContents();
+      // BrowserWindow destroys WebContents asynchronously, manually emit the
+      // destroyed event here.
+      WebContentsDestroyed();
+    } else if (Browser::Get()->is_shutting_down()) {
+      // Destroy WebContents directly when app is shutting down.
       DestroyWebContents(false /* async */);
     } else {
-      if (type_ == BROWSER_WINDOW && owner_window()) {
-        for (ExtendedWebContentsObserver& observer : observers_)
-          observer.OnCloseContents();
-      } else {
-        DestroyWebContents(true /* async */);
-      }
+      // Destroy WebContents asynchronously unless app is shutting down,
+      // because destroy() might be called inside WebContents's event handler.
+      DestroyWebContents(true /* async */);
       // The WebContentsDestroyed will not be called automatically because we
       // destroy the webContents in the next tick. So we have to manually
       // call it here to make sure "destroyed" event is emitted.
@@ -814,8 +807,10 @@ void WebContents::DidChangeThemeColor(SkColor theme_color) {
 
 void WebContents::DocumentLoadedInFrame(
     content::RenderFrameHost* render_frame_host) {
-  if (!render_frame_host->GetParent())
+  if (!render_frame_host->GetParent()) {
+    is_dom_ready_ = true;
     Emit("dom-ready");
+  }
 }
 
 void WebContents::DidFinishLoad(content::RenderFrameHost* render_frame_host,
@@ -842,6 +837,7 @@ void WebContents::DidFailLoad(content::RenderFrameHost* render_frame_host,
 }
 
 void WebContents::DidStartLoading() {
+  is_dom_ready_ = false;
   Emit("did-start-loading");
 }
 
@@ -1099,6 +1095,37 @@ void WebContents::NavigationEntryCommitted(
        details.is_same_document, details.did_replace_entry);
 }
 
+void WebContents::SetBackgroundThrottling(bool allowed) {
+  background_throttling_ = allowed;
+
+  const auto* contents = web_contents();
+  if (!contents) {
+    return;
+  }
+
+  const auto* render_view_host = contents->GetRenderViewHost();
+  if (!render_view_host) {
+    return;
+  }
+
+  const auto* render_process_host = render_view_host->GetProcess();
+  if (!render_process_host) {
+    return;
+  }
+
+  auto* render_widget_host_impl = content::RenderWidgetHostImpl::FromID(
+      render_process_host->GetID(), render_view_host->GetRoutingID());
+  if (!render_widget_host_impl) {
+    return;
+  }
+
+  render_widget_host_impl->disable_hidden_ = !background_throttling_;
+
+  if (render_widget_host_impl->is_hidden()) {
+    render_widget_host_impl->WasShown(false);
+  }
+}
+
 int WebContents::GetProcessID() const {
   return web_contents()->GetMainFrame()->GetProcess()->GetID();
 }
@@ -1422,40 +1449,62 @@ bool WebContents::IsCurrentlyAudible() {
   return web_contents()->IsCurrentlyAudible();
 }
 
+bool WebContents::IsDOMReady() const {
+  return is_dom_ready_;
+}
+
+#if BUILDFLAG(ENABLE_PRINTING)
 void WebContents::Print(mate::Arguments* args) {
-  PrintSettings settings = {false, false, base::string16()};
-  if (args->Length() >= 1 && !args->GetNext(&settings)) {
-    args->ThrowError();
+  bool silent, print_background = false;
+  base::string16 device_name;
+  mate::Dictionary options = mate::Dictionary::CreateEmpty(args->isolate());
+  base::DictionaryValue settings;
+  if (args->Length() >= 1 && !args->GetNext(&options)) {
+    args->ThrowError("Invalid print settings specified");
     return;
   }
-  auto* print_view_manager_basic_ptr =
-      printing::PrintViewManagerBasic::FromWebContents(web_contents());
-  if (args->Length() == 2) {
-    base::Callback<void(bool)> callback;
-    if (!args->GetNext(&callback)) {
-      args->ThrowError();
-      return;
-    }
-    print_view_manager_basic_ptr->SetCallback(callback);
+  printing::CompletionCallback callback;
+  if (args->Length() == 2 && !args->GetNext(&callback)) {
+    args->ThrowError("Invalid optional callback provided");
+    return;
   }
-  print_view_manager_basic_ptr->PrintNow(
-      web_contents()->GetMainFrame(), settings.silent,
-      settings.print_background, settings.device_name);
+  options.Get("silent", &silent);
+  options.Get("printBackground", &print_background);
+  if (options.Get("deviceName", &device_name) && !device_name.empty()) {
+    settings.SetString(printing::kSettingDeviceName, device_name);
+  }
+  auto* print_view_manager =
+      printing::PrintViewManagerBasic::FromWebContents(web_contents());
+  auto* focused_frame = web_contents()->GetFocusedFrame();
+  auto* rfh = focused_frame && focused_frame->HasSelection()
+                  ? focused_frame
+                  : web_contents()->GetMainFrame();
+  print_view_manager->PrintNow(
+      rfh,
+      std::make_unique<PrintMsg_PrintPages>(rfh->GetRoutingID(), silent,
+                                            print_background, settings),
+      std::move(callback));
 }
 
 std::vector<printing::PrinterBasicInfo> WebContents::GetPrinterList() {
   std::vector<printing::PrinterBasicInfo> printers;
-  auto print_backend = printing::PrintBackend::CreateInstance(nullptr);
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-  print_backend->EnumeratePrinters(&printers);
+  {
+    // TODO(deepak1556): Deprecate this api in favor of an
+    // async version and post a non blocing task call.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    auto print_backend = printing::PrintBackend::CreateInstance(nullptr);
+    print_backend->EnumeratePrinters(&printers);
+  }
   return printers;
 }
 
-void WebContents::PrintToPDF(const base::DictionaryValue& setting,
-                             const PrintToPDFCallback& callback) {
-  printing::PrintPreviewMessageHandler::FromWebContents(web_contents())
-      ->PrintToPDF(setting, callback);
+void WebContents::PrintToPDF(
+    const base::DictionaryValue& settings,
+    const PrintPreviewMessageHandler::PrintToPDFCallback& callback) {
+  PrintPreviewMessageHandler::FromWebContents(web_contents())
+      ->PrintToPDF(settings, callback);
 }
+#endif
 
 void WebContents::AddWorkSpace(mate::Arguments* args,
                                const base::FilePath& path) {
@@ -1889,6 +1938,13 @@ v8::Local<v8::Value> WebContents::GetLastWebPreferences(
   return mate::ConvertToV8(isolate, *web_preferences->last_preference());
 }
 
+bool WebContents::IsRemoteModuleEnabled() const {
+  if (auto* web_preferences = WebContentsPreferences::From(web_contents())) {
+    return web_preferences->IsRemoteModuleEnabled();
+  }
+  return true;
+}
+
 v8::Local<v8::Value> WebContents::GetOwnerBrowserWindow() const {
   if (owner_window())
     return BrowserWindow::From(isolate(), owner_window());
@@ -1989,6 +2045,8 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
   prototype->SetClassName(mate::StringToV8(isolate, "WebContents"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .MakeDestroyable()
+      .SetMethod("setBackgroundThrottling",
+                 &WebContents::SetBackgroundThrottling)
       .SetMethod("getProcessId", &WebContents::GetProcessID)
       .SetMethod("getOSProcessId", &WebContents::GetOSProcessID)
       .SetMethod("equal", &WebContents::Equal)
@@ -2019,6 +2077,7 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setAudioMuted", &WebContents::SetAudioMuted)
       .SetMethod("isAudioMuted", &WebContents::IsAudioMuted)
       .SetMethod("isCurrentlyAudible", &WebContents::IsCurrentlyAudible)
+      .SetMethod("isDomReady", &WebContents::IsDOMReady)
       .SetMethod("undo", &WebContents::Undo)
       .SetMethod("redo", &WebContents::Redo)
       .SetMethod("cut", &WebContents::Cut)
@@ -2030,7 +2089,7 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("unselect", &WebContents::Unselect)
       .SetMethod("replace", &WebContents::Replace)
       .SetMethod("replaceMisspelling", &WebContents::ReplaceMisspelling)
-      .SetMethod("findInPage", &WebContents::FindInPage)
+      .SetMethod("_findInPage", &WebContents::FindInPage)
       .SetMethod("stopFindInPage", &WebContents::StopFindInPage)
       .SetMethod("focus", &WebContents::Focus)
       .SetMethod("isFocused", &WebContents::IsFocused)
@@ -2059,14 +2118,17 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("_getPreloadPath", &WebContents::GetPreloadPath)
       .SetMethod("getWebPreferences", &WebContents::GetWebPreferences)
       .SetMethod("getLastWebPreferences", &WebContents::GetLastWebPreferences)
+      .SetMethod("_isRemoteModuleEnabled", &WebContents::IsRemoteModuleEnabled)
       .SetMethod("getOwnerBrowserWindow", &WebContents::GetOwnerBrowserWindow)
       .SetMethod("hasServiceWorker", &WebContents::HasServiceWorker)
       .SetMethod("unregisterServiceWorker",
                  &WebContents::UnregisterServiceWorker)
       .SetMethod("inspectServiceWorker", &WebContents::InspectServiceWorker)
-      .SetMethod("print", &WebContents::Print)
-      .SetMethod("getPrinters", &WebContents::GetPrinterList)
+#if BUILDFLAG(ENABLE_PRINTING)
+      .SetMethod("_print", &WebContents::Print)
+      .SetMethod("_getPrinters", &WebContents::GetPrinterList)
       .SetMethod("_printToPDF", &WebContents::PrintToPDF)
+#endif
       .SetMethod("addWorkSpace", &WebContents::AddWorkSpace)
       .SetMethod("removeWorkSpace", &WebContents::RemoveWorkSpace)
       .SetMethod("showDefinitionForSelection",

atom/browser/api/atom_api_web_contents.h

@@ -22,9 +22,14 @@
 #include "content/public/common/favicon_url.h"
 #include "electron/buildflags/buildflags.h"
 #include "native_mate/handle.h"
-#include "printing/backend/print_backend.h"
+#include "printing/buildflags/buildflags.h"
 #include "ui/gfx/image/image.h"
 
+#if BUILDFLAG(ENABLE_PRINTING)
+#include "atom/browser/printing/print_preview_message_handler.h"
+#include "printing/backend/print_backend.h"
+#endif
+
 namespace blink {
 struct WebDeviceEmulationParams;
 }
@@ -51,7 +56,6 @@ class WebViewGuestDelegate;
 class FrameSubscriber;
 
 #if BUILDFLAG(ENABLE_OSR)
-class OffScreenWebContentsView;
 class OffScreenRenderWidgetHostView;
 #endif
 
@@ -79,10 +83,6 @@ class WebContents : public mate::TrackableObject<WebContents>,
     OFF_SCREEN,       // Used for offscreen rendering
   };
 
-  // For node.js callback function type: function(error, buffer)
-  using PrintToPDFCallback =
-      base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>;
-
   // Create from an existing WebContents.
   static mate::Handle<WebContents> CreateFrom(
       v8::Isolate* isolate,
@@ -99,9 +99,22 @@ class WebContents : public mate::TrackableObject<WebContents>,
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
 
-  // Notifies to destroy any guest web contents before destroying self.
+  // Destroy the managed content::WebContents instance.
+  //
+  // Note: The |async| should only be |true| when users are expecting to use the
+  // webContents immediately after the call. Always pass |false| if you are not
+  // sure.
+  // See https://github.com/electron/electron/issues/8930.
+  //
+  // Note: When destroying a webContents member inside a destructor, the |async|
+  // should always be |false|, otherwise the destroy task might be delayed after
+  // normal shutdown procedure, resulting in an assertion.
+  // The normal pattern for calling this method in destructor is:
+  // api_web_contents_->DestroyWebContents(!Browser::Get()->is_shutting_down())
+  // See https://github.com/electron/electron/issues/15133.
   void DestroyWebContents(bool async);
 
+  void SetBackgroundThrottling(bool allowed);
   int GetProcessID() const;
   base::ProcessId GetOSProcessID() const;
   Type GetType() const;
@@ -142,15 +155,19 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void SetAudioMuted(bool muted);
   bool IsAudioMuted();
   bool IsCurrentlyAudible();
-  void Print(mate::Arguments* args);
-  std::vector<printing::PrinterBasicInfo> GetPrinterList();
+  bool IsDOMReady() const;
   void SetEmbedder(const WebContents* embedder);
   void SetDevToolsWebContents(const WebContents* devtools);
   v8::Local<v8::Value> GetNativeView() const;
 
+#if BUILDFLAG(ENABLE_PRINTING)
+  void Print(mate::Arguments* args);
+  std::vector<printing::PrinterBasicInfo> GetPrinterList();
   // Print current page as PDF.
-  void PrintToPDF(const base::DictionaryValue& setting,
-                  const PrintToPDFCallback& callback);
+  void PrintToPDF(
+      const base::DictionaryValue& settings,
+      const PrintPreviewMessageHandler::PrintToPDFCallback& callback);
+#endif
 
   // DevTools workspace api.
   void AddWorkSpace(mate::Arguments* args, const base::FilePath& path);
@@ -249,6 +266,8 @@ class WebContents : public mate::TrackableObject<WebContents>,
   v8::Local<v8::Value> GetWebPreferences(v8::Isolate* isolate) const;
   v8::Local<v8::Value> GetLastWebPreferences(v8::Isolate* isolate) const;
 
+  bool IsRemoteModuleEnabled() const;
+
   // Returns the owner window.
   v8::Local<v8::Value> GetOwnerBrowserWindow() const;
 
@@ -424,7 +443,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
   uint32_t GetNextRequestId() { return ++request_id_; }
 
 #if BUILDFLAG(ENABLE_OSR)
-  OffScreenWebContentsView* GetOffScreenWebContentsView() const;
+  OffScreenWebContentsView* GetOffScreenWebContentsView() const override;
   OffScreenRenderWidgetHostView* GetOffScreenRenderWidgetHostView() const;
 #endif
 
@@ -470,7 +489,6 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
   std::unique_ptr<AtomJavaScriptDialogManager> dialog_manager_;
   std::unique_ptr<WebViewGuestDelegate> guest_delegate_;
-
   std::unique_ptr<FrameSubscriber> frame_subscriber_;
 
   // The host webcontents that may contain this webcontents.
@@ -491,6 +509,9 @@ class WebContents : public mate::TrackableObject<WebContents>,
   // Whether to enable devtools.
   bool enable_devtools_ = true;
 
+  // Whether page's document is ready.
+  bool is_dom_ready_ = false;
+
   // Observers of this WebContents.
   base::ObserverList<ExtendedWebContentsObserver> observers_;
 

atom/browser/api/atom_api_web_contents_osr.cc

@@ -17,15 +17,23 @@ namespace atom {
 namespace api {
 
 OffScreenWebContentsView* WebContents::GetOffScreenWebContentsView() const {
-  const auto* impl =
-      static_cast<const content::WebContentsImpl*>(web_contents());
-  return static_cast<OffScreenWebContentsView*>(impl->GetView());
+  if (IsOffScreen()) {
+    const auto* impl =
+        static_cast<const content::WebContentsImpl*>(web_contents());
+    return static_cast<OffScreenWebContentsView*>(impl->GetView());
+  } else {
+    return nullptr;
+  }
 }
 
 OffScreenRenderWidgetHostView* WebContents::GetOffScreenRenderWidgetHostView()
     const {
-  return static_cast<OffScreenRenderWidgetHostView*>(
-      web_contents()->GetRenderWidgetHostView());
+  if (IsOffScreen()) {
+    return static_cast<OffScreenRenderWidgetHostView*>(
+        web_contents()->GetRenderWidgetHostView());
+  } else {
+    return nullptr;
+  }
 }
 
 }  // namespace api

atom/browser/api/atom_api_web_contents_view.cc

@@ -5,6 +5,7 @@
 #include "atom/browser/api/atom_api_web_contents_view.h"
 
 #include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/browser.h"
 #include "atom/common/api/constructor.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
 #include "content/public/browser/web_contents_user_data.h"
@@ -64,8 +65,11 @@ WebContentsView::WebContentsView(v8::Isolate* isolate,
 }
 
 WebContentsView::~WebContentsView() {
-  if (api_web_contents_)
-    api_web_contents_->DestroyWebContents(false /* async */);
+  if (api_web_contents_) {  // destroy() is called
+    // Destroy WebContents asynchronously unless app is shutting down,
+    // because destroy() might be called inside WebContents's event handler.
+    api_web_contents_->DestroyWebContents(!Browser::Get()->is_shutting_down());
+  }
 }
 
 void WebContentsView::WebContentsDestroyed() {

atom/browser/api/gpuinfo_manager.cc

@@ -26,11 +26,12 @@ GPUInfoManager::~GPUInfoManager() {
 
 // Based on
 // https://chromium.googlesource.com/chromium/src.git/+/69.0.3497.106/content/browser/gpu/gpu_data_manager_impl_private.cc#838
-bool GPUInfoManager::NeedsCompleteGpuInfoCollection() {
-#if defined(OS_WIN)
-  const auto& gpu_info = gpu_data_manager_->GetGPUInfo();
-  return (gpu_info.dx_diagnostics.values.empty() &&
-          gpu_info.dx_diagnostics.children.empty());
+bool GPUInfoManager::NeedsCompleteGpuInfoCollection() const {
+#if defined(OS_MACOSX)
+  return gpu_data_manager_->GetGPUInfo().gl_vendor.empty();
+#elif defined(OS_WIN)
+  return (gpu_data_manager_->GetGPUInfo().dx_diagnostics.values.empty() &&
+          gpu_data_manager_->GetGPUInfo().dx_diagnostics.children.empty());
 #else
   return false;
 #endif

atom/browser/api/gpuinfo_manager.h

@@ -24,7 +24,7 @@ class GPUInfoManager : public content::GpuDataManagerObserver {
 
   GPUInfoManager();
   ~GPUInfoManager() override;
-  bool NeedsCompleteGpuInfoCollection();
+  bool NeedsCompleteGpuInfoCollection() const;
   void FetchCompleteInfo(scoped_refptr<util::Promise> promise);
   void FetchBasicInfo(scoped_refptr<util::Promise> promise);
   void OnGpuInfoUpdate() override;

atom/browser/atom_browser_client.cc

@@ -39,8 +39,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/printing/printing_message_filter.h"
-#include "chrome/browser/speech/tts_message_filter.h"
 #include "components/net_log/chrome_net_log.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/client_certificate_delegate.h"
@@ -60,6 +58,7 @@
 #include "net/base/escape.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "ppapi/host/ppapi_host.h"
+#include "printing/buildflags/buildflags.h"
 #include "services/device/public/cpp/geolocation/location_provider.h"
 #include "services/network/public/cpp/resource_request_body.h"
 #include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
@@ -85,6 +84,12 @@
 #include "atom/browser/fake_location_provider.h"
 #endif  // BUILDFLAG(OVERRIDE_LOCATION_PROVIDER)
 
+#if BUILDFLAG(ENABLE_PRINTING)
+#include "chrome/browser/printing/printing_message_filter.h"
+#include "chrome/services/printing/public/mojom/constants.mojom.h"
+#include "components/services/pdf_compositor/public/interfaces/pdf_compositor.mojom.h"
+#endif  // BUILDFLAG(ENABLE_PRINTING)
+
 using content::BrowserThread;
 
 namespace atom {
@@ -172,28 +177,34 @@ bool AtomBrowserClient::ShouldCreateNewSiteInstance(
 void AtomBrowserClient::AddProcessPreferences(
     int process_id,
     AtomBrowserClient::ProcessPreferences prefs) {
+  base::AutoLock auto_lock(process_preferences_lock_);
   process_preferences_[process_id] = prefs;
 }
 
 void AtomBrowserClient::RemoveProcessPreferences(int process_id) {
+  base::AutoLock auto_lock(process_preferences_lock_);
   process_preferences_.erase(process_id);
 }
 
 bool AtomBrowserClient::IsProcessObserved(int process_id) {
+  base::AutoLock auto_lock(process_preferences_lock_);
   return process_preferences_.find(process_id) != process_preferences_.end();
 }
 
 bool AtomBrowserClient::IsRendererSandboxed(int process_id) {
+  base::AutoLock auto_lock(process_preferences_lock_);
   auto it = process_preferences_.find(process_id);
   return it != process_preferences_.end() && it->second.sandbox;
 }
 
 bool AtomBrowserClient::RendererUsesNativeWindowOpen(int process_id) {
+  base::AutoLock auto_lock(process_preferences_lock_);
   auto it = process_preferences_.find(process_id);
   return it != process_preferences_.end() && it->second.native_window_open;
 }
 
 bool AtomBrowserClient::RendererDisablesPopups(int process_id) {
+  base::AutoLock auto_lock(process_preferences_lock_);
   auto it = process_preferences_.find(process_id);
   return it != process_preferences_.end() && it->second.disable_popups;
 }
@@ -206,8 +217,10 @@ void AtomBrowserClient::RenderProcessWillLaunch(
   if (IsProcessObserved(process_id))
     return;
 
-  host->AddFilter(new printing::PrintingMessageFilter(process_id));
-  host->AddFilter(new TtsMessageFilter(process_id, host->GetBrowserContext()));
+#if BUILDFLAG(ENABLE_PRINTING)
+  host->AddFilter(new printing::PrintingMessageFilter(
+      process_id, host->GetBrowserContext()));
+#endif
 
   ProcessPreferences prefs;
   auto* web_preferences =
@@ -217,6 +230,8 @@ void AtomBrowserClient::RenderProcessWillLaunch(
     prefs.native_window_open =
         web_preferences->IsEnabled(options::kNativeWindowOpen);
     prefs.disable_popups = web_preferences->IsEnabled("disablePopups");
+    prefs.web_security = web_preferences->IsEnabled(options::kWebSecurity,
+                                                    true /* default value */);
   }
   AddProcessPreferences(host->GetID(), prefs);
   // ensure the ProcessPreferences is removed later
@@ -529,6 +544,16 @@ void AtomBrowserClient::RegisterOutOfProcessServices(
   (*services)[proxy_resolver::mojom::kProxyResolverServiceName] =
       base::BindRepeating(&l10n_util::GetStringUTF16,
                           IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME);
+
+#if BUILDFLAG(ENABLE_PRINTING)
+  (*services)[printing::mojom::kServiceName] =
+      base::BindRepeating(&l10n_util::GetStringUTF16,
+                          IDS_UTILITY_PROCESS_PDF_COMPOSITOR_SERVICE_NAME);
+
+  (*services)[printing::mojom::kChromePrintingServiceName] =
+      base::BindRepeating(&l10n_util::GetStringUTF16,
+                          IDS_UTILITY_PROCESS_PRINTING_SERVICE_NAME);
+#endif
 }
 
 std::unique_ptr<base::Value> AtomBrowserClient::GetServiceManifestOverlay(
@@ -656,4 +681,11 @@ AtomBrowserClient::CreateThrottlesForNavigation(
   return throttles;
 }
 
+bool AtomBrowserClient::ShouldBypassCORB(int render_process_id) {
+  // This is called on the network thread.
+  base::AutoLock auto_lock(process_preferences_lock_);
+  auto it = process_preferences_.find(render_process_id);
+  return it != process_preferences_.end() && !it->second.web_security;
+}
+
 }  // namespace atom

atom/browser/atom_browser_client.h

@@ -11,7 +11,9 @@
 #include <string>
 #include <vector>
 
+#include "base/synchronization/lock.h"
 #include "brightray/browser/browser_client.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "net/ssl/client_cert_identity.h"
 
@@ -124,6 +126,7 @@ class AtomBrowserClient : public brightray::BrowserClient,
   void WebNotificationAllowed(
       int render_process_id,
       const base::Callback<void(bool, bool)>& callback) override;
+  bool ShouldBypassCORB(int render_process_id) override;
 
   // content::RenderProcessHostObserver:
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
@@ -145,6 +148,7 @@ class AtomBrowserClient : public brightray::BrowserClient,
     bool sandbox = false;
     bool native_window_open = false;
     bool disable_popups = false;
+    bool web_security = true;
   };
 
   bool ShouldCreateNewSiteInstance(content::RenderFrameHost* render_frame_host,
@@ -161,7 +165,6 @@ class AtomBrowserClient : public brightray::BrowserClient,
   // pending_render_process => web contents.
   std::map<int, content::WebContents*> pending_processes_;
 
-  std::map<int, ProcessPreferences> process_preferences_;
   std::map<int, base::ProcessId> render_process_host_pids_;
 
   // list of site per affinity. weak_ptr to prevent instance locking
@@ -172,6 +175,9 @@ class AtomBrowserClient : public brightray::BrowserClient,
 
   Delegate* delegate_ = nullptr;
 
+  base::Lock process_preferences_lock_;
+  std::map<int, ProcessPreferences> process_preferences_;
+
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
 };
 

atom/browser/atom_browser_context.cc

@@ -32,6 +32,7 @@
 #include "brightray/common/application_info.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
@@ -119,6 +120,8 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition,
   proxy_config_monitor_ = std::make_unique<ProxyConfigMonitor>(prefs_.get());
   io_handle_ = new URLRequestContextGetter::Handle(weak_factory_.GetWeakPtr());
   cookie_change_notifier_ = std::make_unique<CookieChangeNotifier>(this);
+
+  BrowserContextDependencyManager::GetInstance()->MarkBrowserContextLive(this);
 }
 
 AtomBrowserContext::~AtomBrowserContext() {
@@ -126,6 +129,9 @@ AtomBrowserContext::~AtomBrowserContext() {
   NotifyWillBeDestroyed(this);
   ShutdownStoragePartitions();
   io_handle_->ShutdownOnUIThread();
+  // Notify any keyed services of browser context destruction.
+  BrowserContextDependencyManager::GetInstance()->DestroyBrowserContextServices(
+      this);
 }
 
 void AtomBrowserContext::InitPrefs() {

atom/browser/atom_browser_main_parts.cc

@@ -19,7 +19,7 @@
 #include "atom/common/node_bindings.h"
 #include "base/command_line.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "chrome/browser/browser_process.h"
+#include "chrome/browser/browser_process_impl.h"
 #include "chrome/browser/icon_manager.h"
 #include "chrome/browser/net/chrome_net_log_helper.h"
 #include "components/net_log/chrome_net_log.h"
@@ -68,7 +68,7 @@ AtomBrowserMainParts* AtomBrowserMainParts::self_ = nullptr;
 
 AtomBrowserMainParts::AtomBrowserMainParts(
     const content::MainFunctionParams& params)
-    : fake_browser_process_(new BrowserProcess),
+    : fake_browser_process_(new BrowserProcessImpl),
       browser_(new Browser),
       node_bindings_(NodeBindings::Create(NodeBindings::BROWSER)),
       atom_bindings_(new AtomBindings(uv_default_loop())),
@@ -253,6 +253,7 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
 }
 
 bool AtomBrowserMainParts::MainMessageLoopRun(int* result_code) {
+  js_env_->OnMessageLoopCreated();
   exit_code_ = result_code;
   return brightray::BrowserMainParts::MainMessageLoopRun(result_code);
 }

atom/browser/browser_mac.mm

@@ -217,14 +217,74 @@ Browser::LoginItemSettings Browser::GetLoginItemSettings(
   return settings;
 }
 
+// copied from GetLoginItemForApp in base/mac/mac_util.mm
+LSSharedFileListItemRef GetLoginItemForApp() {
+  base::ScopedCFTypeRef<LSSharedFileListRef> login_items(
+      LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL));
+  if (!login_items.get()) {
+    LOG(ERROR) << "Couldn't get a Login Items list.";
+    return NULL;
+  }
+  base::scoped_nsobject<NSArray> login_items_array(
+      base::mac::CFToNSCast(LSSharedFileListCopySnapshot(login_items, NULL)));
+  NSURL* url = [NSURL fileURLWithPath:[base::mac::MainBundle() bundlePath]];
+  for (NSUInteger i = 0; i < [login_items_array count]; ++i) {
+    LSSharedFileListItemRef item =
+        reinterpret_cast<LSSharedFileListItemRef>(login_items_array[i]);
+    CFURLRef item_url_ref = NULL;
+    if (LSSharedFileListItemResolve(item, 0, &item_url_ref, NULL) == noErr &&
+        item_url_ref) {
+      base::ScopedCFTypeRef<CFURLRef> item_url(item_url_ref);
+      if (CFEqual(item_url, url)) {
+        CFRetain(item);
+        return item;
+      }
+    }
+  }
+  return NULL;
+}
+
+void RemoveFromLoginItems() {
+  base::ScopedCFTypeRef<LSSharedFileListRef> list(
+      LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL));
+  if (!list) {
+    LOG(ERROR) << "Unable to access shared file list";
+    return;
+  }
+
+  if (GetLoginItemForApp() != NULL) {
+    base::scoped_nsobject<NSArray> login_items_array(
+        base::mac::CFToNSCast(LSSharedFileListCopySnapshot(list, NULL)));
+
+    if (!login_items_array) {
+      LOG(ERROR) << "No items in list of auto-loaded apps";
+      return;
+    }
+
+    for (NSUInteger i = 0; i < [login_items_array count]; ++i) {
+      LSSharedFileListItemRef item =
+          reinterpret_cast<LSSharedFileListItemRef>(login_items_array[i]);
+      CFURLRef url_ref = NULL;
+      if (LSSharedFileListItemResolve(item, 0, &url_ref, NULL) == noErr &&
+          item) {
+        base::ScopedCFTypeRef<CFURLRef> url(url_ref);
+        if ([[base::mac::CFToNSCast(url.get()) path]
+                hasPrefix:[[NSBundle mainBundle] bundlePath]])
+          LSSharedFileListItemRemove(list, item);
+      }
+    }
+  }
+}
+
 void Browser::SetLoginItemSettings(LoginItemSettings settings) {
 #if defined(MAS_BUILD)
   platform_util::SetLoginItemEnabled(settings.open_at_login);
 #else
   if (settings.open_at_login)
     base::mac::AddToLoginItems(settings.open_as_hidden);
-  else
-    base::mac::RemoveFromLoginItems();
+  else {
+    RemoveFromLoginItems();
+  }
 #endif
 }
 

atom/browser/common_web_contents_delegate.cc

@@ -21,8 +21,6 @@
 #include "base/json/json_reader.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_task_runner_handle.h"
-#include "chrome/browser/printing/print_preview_message_handler.h"
-#include "chrome/browser/printing/print_view_manager_basic.h"
 #include "chrome/browser/ssl/security_state_tab_helper.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/common/pref_names.h"
@@ -30,6 +28,7 @@
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/security_state/content/content_utils.h"
 #include "components/security_state/core/security_state.h"
+#include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
@@ -37,8 +36,19 @@
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/security_style_explanation.h"
 #include "content/public/browser/security_style_explanations.h"
+#include "printing/buildflags/buildflags.h"
 #include "storage/browser/fileapi/isolated_context.h"
 
+#if BUILDFLAG(ENABLE_OSR)
+#include "atom/browser/osr/osr_web_contents_view.h"
+#endif
+
+#if BUILDFLAG(ENABLE_PRINTING)
+#include "atom/browser/printing/print_preview_message_handler.h"
+#include "chrome/browser/printing/print_view_manager_basic.h"
+#include "components/printing/browser/print_manager_utils.h"
+#endif
+
 using content::BrowserThread;
 
 namespace atom {
@@ -168,8 +178,11 @@ void CommonWebContentsDelegate::InitWithWebContents(
   browser_context_ = browser_context;
   web_contents->SetDelegate(this);
 
+#if BUILDFLAG(ENABLE_PRINTING)
+  PrintPreviewMessageHandler::CreateForWebContents(web_contents);
   printing::PrintViewManagerBasic::CreateForWebContents(web_contents);
-  printing::PrintPreviewMessageHandler::CreateForWebContents(web_contents);
+  printing::CreateCompositeClientIfNeeded(web_contents);
+#endif
 
   // Determien whether the WebContents is offscreen.
   auto* web_preferences = WebContentsPreferences::From(web_contents);
@@ -201,6 +214,11 @@ void CommonWebContentsDelegate::SetOwnerWindow(
     web_contents->RemoveUserData(
         NativeWindowRelay::kNativeWindowRelayUserDataKey);
   }
+#if BUILDFLAG(ENABLE_OSR)
+  auto* osr_wcv = GetOffScreenWebContentsView();
+  if (osr_wcv)
+    osr_wcv->SetNativeWindow(owner_window);
+#endif
 }
 
 void CommonWebContentsDelegate::ResetManagedWebContents(bool async) {
@@ -236,6 +254,13 @@ content::WebContents* CommonWebContentsDelegate::GetDevToolsWebContents()
   return web_contents_->GetDevToolsWebContents();
 }
 
+#if BUILDFLAG(ENABLE_OSR)
+OffScreenWebContentsView*
+CommonWebContentsDelegate::GetOffScreenWebContentsView() const {
+  return nullptr;
+}
+#endif
+
 content::WebContents* CommonWebContentsDelegate::OpenURLFromTab(
     content::WebContents* source,
     const content::OpenURLParams& params) {

atom/browser/common_web_contents_delegate.h

@@ -16,6 +16,7 @@
 #include "brightray/browser/inspectable_web_contents_view_delegate.h"
 #include "chrome/browser/devtools/devtools_file_system_indexer.h"
 #include "content/public/browser/web_contents_delegate.h"
+#include "electron/buildflags/buildflags.h"
 
 #if defined(TOOLKIT_VIEWS) && !defined(OS_MACOSX)
 #include "atom/browser/ui/autofill_popup.h"
@@ -31,6 +32,10 @@ class AtomBrowserContext;
 class NativeWindow;
 class WebDialogHelper;
 
+#if BUILDFLAG(ENABLE_OSR)
+class OffScreenWebContentsView;
+#endif
+
 class CommonWebContentsDelegate
     : public content::WebContentsDelegate,
       public brightray::InspectableWebContentsDelegate,
@@ -65,6 +70,10 @@ class CommonWebContentsDelegate
   bool is_html_fullscreen() const { return html_fullscreen_; }
 
  protected:
+#if BUILDFLAG(ENABLE_OSR)
+  virtual OffScreenWebContentsView* GetOffScreenWebContentsView() const;
+#endif
+
   // content::WebContentsDelegate:
   content::WebContents* OpenURLFromTab(
       content::WebContents* source,

atom/browser/javascript_environment.cc

@@ -6,6 +6,7 @@
 
 #include <string>
 
+#include "atom/browser/microtasks_runner.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/task_scheduler/initialization_util.h"
@@ -62,7 +63,15 @@ v8::Isolate* JavascriptEnvironment::Initialize(uv_loop_t* event_loop) {
   return isolate;
 }
 
+void JavascriptEnvironment::OnMessageLoopCreated() {
+  DCHECK(!microtasks_runner_);
+  microtasks_runner_.reset(new MicrotasksRunner(isolate()));
+  base::MessageLoopCurrent::Get()->AddTaskObserver(microtasks_runner_.get());
+}
+
 void JavascriptEnvironment::OnMessageLoopDestroying() {
+  DCHECK(microtasks_runner_);
+  base::MessageLoopCurrent::Get()->RemoveTaskObserver(microtasks_runner_.get());
   platform_->UnregisterIsolate(isolate_);
 }
 

atom/browser/javascript_environment.h

@@ -5,6 +5,8 @@
 #ifndef ATOM_BROWSER_JAVASCRIPT_ENVIRONMENT_H_
 #define ATOM_BROWSER_JAVASCRIPT_ENVIRONMENT_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "gin/public/isolate_holder.h"
 #include "uv.h"  // NOLINT(build/include)
@@ -16,12 +18,14 @@ class MultiIsolatePlatform;
 
 namespace atom {
 
+class MicrotasksRunner;
 // Manage the V8 isolate and context automatically.
 class JavascriptEnvironment {
  public:
   explicit JavascriptEnvironment(uv_loop_t* event_loop);
   ~JavascriptEnvironment();
 
+  void OnMessageLoopCreated();
   void OnMessageLoopDestroying();
 
   node::MultiIsolatePlatform* platform() const { return platform_; }
@@ -43,6 +47,8 @@ class JavascriptEnvironment {
   v8::Global<v8::Context> context_;
   v8::Context::Scope context_scope_;
 
+  std::unique_ptr<MicrotasksRunner> microtasks_runner_;
+
   DISALLOW_COPY_AND_ASSIGN(JavascriptEnvironment);
 };
 

atom/browser/lib/bluetooth_chooser.cc

@@ -63,16 +63,17 @@ void BluetoothChooser::ShowDiscoveryState(DiscoveryState state) {
       event_handler_.Run(Event::CANCELLED, "");
       break;
     case DiscoveryState::IDLE:
-      if (device_list_.empty()) {
+      if (device_map_.empty()) {
         auto event =
             ++num_retries_ > kMaxScanRetries ? Event::CANCELLED : Event::RESCAN;
         event_handler_.Run(event, "");
       } else {
         bool prevent_default = api_web_contents_->Emit(
-            "select-bluetooth-device", device_list_,
+            "select-bluetooth-device", GetDeviceList(),
             base::Bind(&OnDeviceChosen, event_handler_));
         if (!prevent_default) {
-          auto device_id = device_list_[0].device_id;
+          auto it = device_map_.begin();
+          auto device_id = it->first;
           event_handler_.Run(Event::SELECTED, device_id);
         }
       }
@@ -88,29 +89,40 @@ void BluetoothChooser::AddOrUpdateDevice(const std::string& device_id,
                                          bool is_gatt_connected,
                                          bool is_paired,
                                          int signal_strength_level) {
-  DeviceInfo info = {device_id, device_name};
-  device_list_.push_back(info);
-
-  // Emit a select-bluetooth-device handler to allow for user to listen for
-  // bluetooth device found.
-  bool prevent_default =
-      api_web_contents_->Emit("select-bluetooth-device", device_list_,
-                              base::Bind(&OnDeviceChosen, event_handler_));
-
-  // If emit not implimented select first device that matches the filters
-  //  provided.
-  if (!prevent_default) {
-    event_handler_.Run(Event::SELECTED, device_id);
+  bool changed = false;
+  auto entry = device_map_.find(device_id);
+  if (entry == device_map_.end()) {
+    device_map_[device_id] = device_name;
+    changed = true;
+  } else if (should_update_name) {
+    entry->second = device_name;
+    changed = true;
   }
-}
 
-void BluetoothChooser::RemoveDevice(const std::string& device_id) {
-  for (auto it = device_list_.begin(); it != device_list_.end(); ++it) {
-    if (it->device_id == device_id) {
-      device_list_.erase(it);
-      return;
+  if (changed) {
+    // Emit a select-bluetooth-device handler to allow for user to listen for
+    // bluetooth device found.
+    bool prevent_default =
+        api_web_contents_->Emit("select-bluetooth-device", GetDeviceList(),
+                                base::Bind(&OnDeviceChosen, event_handler_));
+
+    // If emit not implimented select first device that matches the filters
+    //  provided.
+    if (!prevent_default) {
+      event_handler_.Run(Event::SELECTED, device_id);
     }
   }
 }
 
+std::vector<atom::BluetoothChooser::DeviceInfo>
+BluetoothChooser::GetDeviceList() {
+  std::vector<atom::BluetoothChooser::DeviceInfo> vec;
+  for (const auto& it : device_map_) {
+    DeviceInfo info = {it.first, it.second};
+    vec.push_back(info);
+  }
+
+  return vec;
+}
+
 }  // namespace atom

atom/browser/lib/bluetooth_chooser.h

@@ -5,6 +5,7 @@
 #ifndef ATOM_BROWSER_LIB_BLUETOOTH_CHOOSER_H_
 #define ATOM_BROWSER_LIB_BLUETOOTH_CHOOSER_H_
 
+#include <map>
 #include <string>
 #include <vector>
 
@@ -33,10 +34,10 @@ class BluetoothChooser : public content::BluetoothChooser {
                          bool is_gatt_connected,
                          bool is_paired,
                          int signal_strength_level) override;
-  void RemoveDevice(const std::string& device_id);
+  std::vector<DeviceInfo> GetDeviceList();
 
  private:
-  std::vector<DeviceInfo> device_list_;
+  std::map<std::string, base::string16> device_map_;
   api::WebContents* api_web_contents_;
   EventHandler event_handler_;
   int num_retries_ = 0;

atom/browser/mac/atom_application.h

@@ -6,7 +6,9 @@
 #include "base/mac/scoped_nsobject.h"
 #include "base/mac/scoped_sending_event.h"
 
-// Forward Declare Appareance APIs
+#import <AVFoundation/AVFoundation.h>
+
+// Forward Declare Appearance APIs
 @interface NSApplication (HighSierraSDK)
 @property(copy, readonly)
     NSAppearance* effectiveAppearance API_AVAILABLE(macosx(10.14));
@@ -14,6 +16,27 @@
 - (void)setAppearance:(NSAppearance*)appearance API_AVAILABLE(macosx(10.14));
 @end
 
+// forward declare Access APIs
+typedef NSString* AVMediaType NS_EXTENSIBLE_STRING_ENUM;
+
+AVF_EXPORT AVMediaType const AVMediaTypeVideo;
+AVF_EXPORT AVMediaType const AVMediaTypeAudio;
+
+typedef NS_ENUM(NSInteger, AVAuthorizationStatusMac) {
+  AVAuthorizationStatusNotDeterminedMac = 0,
+  AVAuthorizationStatusRestrictedMac = 1,
+  AVAuthorizationStatusDeniedMac = 2,
+  AVAuthorizationStatusAuthorizedMac = 3,
+};
+
+@interface AVCaptureDevice (MojaveSDK)
++ (void)requestAccessForMediaType:(AVMediaType)mediaType
+                completionHandler:(void (^)(BOOL granted))handler
+    API_AVAILABLE(macosx(10.14));
++ (AVAuthorizationStatusMac)authorizationStatusForMediaType:
+    (AVMediaType)mediaType API_AVAILABLE(macosx(10.14));
+@end
+
 extern "C" {
 #if !defined(MAC_OS_X_VERSION_10_14) || \
     MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_14

atom/browser/mac/in_app_purchase.mm

@@ -167,7 +167,7 @@ void FinishTransactionByDate(const std::string& date) {
 std::string GetReceiptURL() {
   NSURL* receiptURL = [[NSBundle mainBundle] appStoreReceiptURL];
   if (receiptURL != nil) {
-    return [[receiptURL absoluteString] UTF8String];
+    return std::string([[receiptURL path] UTF8String]);
   } else {
     return "";
   }

atom/browser/microtasks_runner.cc

@@ -0,0 +1,20 @@
+
+// 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/microtasks_runner.h"
+#include "v8/include/v8.h"
+
+namespace atom {
+
+MicrotasksRunner::MicrotasksRunner(v8::Isolate* isolate) : isolate_(isolate) {}
+
+void MicrotasksRunner::WillProcessTask(const base::PendingTask& pending_task) {}
+
+void MicrotasksRunner::DidProcessTask(const base::PendingTask& pending_task) {
+  v8::Isolate::Scope scope(isolate_);
+  v8::MicrotasksScope::PerformCheckpoint(isolate_);
+}
+
+}  // namespace atom

atom/browser/microtasks_runner.h

@@ -0,0 +1,36 @@
+// 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_MICROTASKS_RUNNER_H_
+#define ATOM_BROWSER_MICROTASKS_RUNNER_H_
+
+#include "base/message_loop/message_loop.h"
+
+namespace v8 {
+class Isolate;
+}
+
+namespace atom {
+
+// Microtasks like promise resolution, are run at the end of the current
+// task. This class implements a task observer that runs tells v8 to run them.
+// Microtasks runner implementation is based on the EndOfTaskRunner in blink.
+// Node follows the kExplicit MicrotasksPolicy, and we do the same in browser
+// process. Hence, we need to have this task observer to flush the queued
+// microtasks.
+class MicrotasksRunner : public base::MessageLoop::TaskObserver {
+ public:
+  explicit MicrotasksRunner(v8::Isolate* isolate);
+
+  // base::MessageLoop::TaskObserver
+  void WillProcessTask(const base::PendingTask& pending_task) override;
+  void DidProcessTask(const base::PendingTask& pending_task) override;
+
+ private:
+  v8::Isolate* isolate_;
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_MICROTASKS_RUNNER_H_

atom/browser/native_browser_view_views.cc

@@ -29,6 +29,7 @@ void NativeBrowserViewViews::SetBounds(const gfx::Rect& bounds) {
 void NativeBrowserViewViews::SetBackgroundColor(SkColor color) {
   auto* view = GetInspectableWebContentsView()->GetView();
   view->SetBackground(views::CreateSolidBackground(color));
+  view->SchedulePaint();
 }
 
 // static

atom/browser/native_window.h

@@ -8,6 +8,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <tuple>
 #include <vector>
 
 #include "atom/browser/native_window_observer.h"
@@ -44,6 +45,12 @@ class NativeBrowserView;
 
 struct DraggableRegion;
 
+#if defined(OS_MACOSX)
+typedef NSView* NativeWindowHandle;
+#else
+typedef gfx::AcceleratedWidget NativeWindowHandle;
+#endif
+
 class NativeWindow : public base::SupportsUserData,
                      public views::WidgetDelegate {
  public:
@@ -152,6 +159,7 @@ class NativeWindow : public base::SupportsUserData,
   virtual gfx::NativeView GetNativeView() const = 0;
   virtual gfx::NativeWindow GetNativeWindow() const = 0;
   virtual gfx::AcceleratedWidget GetAcceleratedWidget() const = 0;
+  virtual NativeWindowHandle GetNativeWindowHandle() const = 0;
 
   // Taskbar/Dock APIs.
   enum ProgressState {

atom/browser/native_window_mac.h

@@ -9,6 +9,7 @@
 
 #include <memory>
 #include <string>
+#include <tuple>
 #include <vector>
 
 #include "atom/browser/native_window.h"
@@ -106,6 +107,7 @@ class NativeWindowMac : public NativeWindow {
   gfx::NativeView GetNativeView() const override;
   gfx::NativeWindow GetNativeWindow() const override;
   gfx::AcceleratedWidget GetAcceleratedWidget() const override;
+  NativeWindowHandle GetNativeWindowHandle() const override;
   void SetProgressBar(double progress, const ProgressState state) override;
   void SetOverlayIcon(const gfx::Image& overlay,
                       const std::string& description) override;

atom/browser/native_window_mac.mm

@@ -76,9 +76,6 @@
   NSButton* miniaturize_button =
       [NSWindow standardWindowButton:NSWindowMiniaturizeButton
                         forStyleMask:NSWindowStyleMaskTitled];
-  NSButton* zoom_button =
-      [NSWindow standardWindowButton:NSWindowZoomButton
-                        forStyleMask:NSWindowStyleMaskTitled];
 
   CGFloat x = 0;
   const CGFloat space_between = 20;
@@ -91,11 +88,7 @@
   x += space_between;
   [self addSubview:miniaturize_button];
 
-  [zoom_button setFrameOrigin:NSMakePoint(x, 0)];
-  x += space_between;
-  [self addSubview:zoom_button];
-
-  const auto last_button_frame = zoom_button.frame;
+  const auto last_button_frame = miniaturize_button.frame;
   [self setFrameSize:NSMakeSize(last_button_frame.origin.x +
                                     last_button_frame.size.width,
                                 last_button_frame.size.height)];
@@ -341,6 +334,9 @@ NativeWindowMac::NativeWindowMac(const mate::Dictionary& options,
   if (!useStandardWindow || transparent() || !has_frame()) {
     styleMask |= NSTexturedBackgroundWindowMask;
   }
+  if (resizable_) {
+    styleMask |= NSResizableWindowMask;
+  }
 
   // Create views::Widget and assign window_ with it.
   // TODO(zcbenz): Get rid of the window_ in future.
@@ -477,7 +473,8 @@ NativeWindowMac::NativeWindowMac(const mate::Dictionary& options,
 }
 
 NativeWindowMac::~NativeWindowMac() {
-  [NSEvent removeMonitor:wheel_event_monitor_];
+  if (wheel_event_monitor_)
+    [NSEvent removeMonitor:wheel_event_monitor_];
 }
 
 void NativeWindowMac::SetContentView(views::View* view) {
@@ -514,6 +511,18 @@ void NativeWindowMac::Close() {
 }
 
 void NativeWindowMac::CloseImmediately() {
+  // Remove event monitor before destroying window, otherwise the monitor may
+  // call its callback after window has been destroyed.
+  if (wheel_event_monitor_) {
+    [NSEvent removeMonitor:wheel_event_monitor_];
+    wheel_event_monitor_ = nil;
+  }
+
+  // Retain the child window before closing it. If the last reference to the
+  // NSWindow goes away inside -[NSWindow close], then bad stuff can happen.
+  // See e.g. http://crbug.com/616701.
+  base::scoped_nsobject<NSWindow> child_window(window_,
+                                               base::scoped_policy::RETAIN);
   [window_ close];
 }
 
@@ -585,13 +594,13 @@ bool NativeWindowMac::IsEnabled() {
 
 void NativeWindowMac::SetEnabled(bool enable) {
   if (enable) {
+    [window_ endSheet:[window_ attachedSheet]];
+  } else {
     [window_ beginSheet:window_
         completionHandler:^(NSModalResponse returnCode) {
           NSLog(@"modal enabled");
           return;
         }];
-  } else {
-    [window_ endSheet:[window_ attachedSheet]];
   }
 }
 
@@ -1101,6 +1110,10 @@ gfx::AcceleratedWidget NativeWindowMac::GetAcceleratedWidget() const {
   return gfx::kNullAcceleratedWidget;
 }
 
+NativeWindowHandle NativeWindowMac::GetNativeWindowHandle() const {
+  return [window_ contentView];
+}
+
 void NativeWindowMac::SetProgressBar(double progress,
                                      const NativeWindow::ProgressState state) {
   NSDockTile* dock_tile = [NSApp dockTile];
@@ -1394,6 +1407,8 @@ void NativeWindowMac::AddContentViewLayers() {
     if (title_bar_style_ == CUSTOM_BUTTONS_ON_HOVER) {
       buttons_view_.reset(
           [[CustomWindowButtonView alloc] initWithFrame:NSZeroRect]);
+      // NSWindowStyleMaskFullSizeContentView does not work with zoom button
+      SetFullScreenable(false);
       [[window_ contentView] addSubview:buttons_view_];
     } else {
       if (title_bar_style_ != NORMAL) {

atom/browser/native_window_views.cc

@@ -10,6 +10,7 @@
 #endif
 
 #include <memory>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -344,7 +345,7 @@ bool NativeWindowViews::IsFocused() {
 void NativeWindowViews::Show() {
   if (is_modal() && NativeWindow::parent() &&
       !widget()->native_widget_private()->IsVisible())
-    NativeWindow::parent()->SetEnabled(false);
+    static_cast<NativeWindowViews*>(parent())->IncrementChildModals();
 
   widget()->native_widget_private()->ShowWithWindowState(GetRestoredState());
 
@@ -369,7 +370,7 @@ void NativeWindowViews::ShowInactive() {
 
 void NativeWindowViews::Hide() {
   if (is_modal() && NativeWindow::parent())
-    NativeWindow::parent()->SetEnabled(true);
+    static_cast<NativeWindowViews*>(parent())->DecrementChildModals();
 
   widget()->Hide();
 
@@ -393,16 +394,34 @@ bool NativeWindowViews::IsEnabled() {
 #endif
 }
 
+void NativeWindowViews::IncrementChildModals() {
+  num_modal_children_++;
+  SetEnabledInternal(ShouldBeEnabled());
+}
+
+void NativeWindowViews::DecrementChildModals() {
+  if (num_modal_children_ > 0) {
+    num_modal_children_--;
+  }
+  SetEnabledInternal(ShouldBeEnabled());
+}
+
 void NativeWindowViews::SetEnabled(bool enable) {
-  // Handle multiple calls of SetEnabled correctly.
-  if (enable) {
-    --disable_count_;
-    if (disable_count_ != 0)
-      return;
-  } else {
-    ++disable_count_;
-    if (disable_count_ != 1)
-      return;
+  if (enable != is_enabled_) {
+    is_enabled_ = enable;
+    SetEnabledInternal(ShouldBeEnabled());
+  }
+}
+
+bool NativeWindowViews::ShouldBeEnabled() {
+  return is_enabled_ && (num_modal_children_ == 0);
+}
+
+void NativeWindowViews::SetEnabledInternal(bool enable) {
+  if (enable && IsEnabled()) {
+    return;
+  } else if (!enable && !IsEnabled()) {
+    return;
   }
 
 #if defined(OS_WIN)
@@ -881,14 +900,18 @@ void NativeWindowViews::SetFocusable(bool focusable) {
 
 void NativeWindowViews::SetMenu(AtomMenuModel* menu_model) {
 #if defined(USE_X11)
-  if (menu_model == nullptr)
+  if (menu_model == nullptr) {
     global_menu_bar_.reset();
+    root_view_->UnregisterAcceleratorsWithFocusManager();
+    return;
+  }
 
   if (!global_menu_bar_ && ShouldUseGlobalMenuBar())
     global_menu_bar_.reset(new GlobalMenuBarX11(this));
 
   // Use global application menu bar when possible.
   if (global_menu_bar_ && global_menu_bar_->IsServerStarted()) {
+    root_view_->RegisterAcceleratorsWithFocusManager(menu_model);
     global_menu_bar_->SetMenu(menu_model);
     return;
   }
@@ -1034,6 +1057,10 @@ gfx::AcceleratedWidget NativeWindowViews::GetAcceleratedWidget() const {
   return GetNativeWindow()->GetHost()->GetAcceleratedWidget();
 }
 
+NativeWindowHandle NativeWindowViews::GetNativeWindowHandle() const {
+  return GetAcceleratedWidget();
+}
+
 gfx::Rect NativeWindowViews::ContentBoundsToWindowBounds(
     const gfx::Rect& bounds) const {
   if (!has_frame())
@@ -1161,10 +1188,10 @@ void NativeWindowViews::OnWidgetBoundsChanged(views::Widget* changed_widget,
 }
 
 void NativeWindowViews::DeleteDelegate() {
-  if (is_modal() && NativeWindow::parent()) {
-    auto* parent = NativeWindow::parent();
+  if (is_modal() && this->parent()) {
+    auto* parent = this->parent();
     // Enable parent window after current window gets closed.
-    parent->SetEnabled(true);
+    static_cast<NativeWindowViews*>(parent)->DecrementChildModals();
     // Focus on parent window.
     parent->Focus(true);
   }

atom/browser/native_window_views.h

@@ -10,6 +10,7 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <tuple>
 
 #include "ui/views/widget/widget_observer.h"
 
@@ -128,12 +129,16 @@ class NativeWindowViews : public NativeWindow,
   bool IsVisibleOnAllWorkspaces() override;
 
   gfx::AcceleratedWidget GetAcceleratedWidget() const override;
+  NativeWindowHandle GetNativeWindowHandle() const override;
 
   gfx::Rect ContentBoundsToWindowBounds(const gfx::Rect& bounds) const override;
   gfx::Rect WindowBoundsToContentBounds(const gfx::Rect& bounds) const override;
 
   void UpdateDraggableRegions(std::unique_ptr<SkRegion> region);
 
+  void IncrementChildModals();
+  void DecrementChildModals();
+
 #if defined(OS_WIN)
   void SetIcon(HICON small_icon, HICON app_icon);
 #elif defined(USE_X11)
@@ -190,6 +195,10 @@ class NativeWindowViews : public NativeWindow,
                                         LPARAM l_param);
 #endif
 
+  // Enable/disable:
+  bool ShouldBeEnabled();
+  void SetEnabledInternal(bool enabled);
+
   // NativeWindow:
   void HandleKeyboardEvent(
       content::WebContents*,
@@ -273,8 +282,11 @@ class NativeWindowViews : public NativeWindow,
   // has to been explicitly provided.
   std::unique_ptr<SkRegion> draggable_region_;  // used in custom drag.
 
-  // How many times the Disable has been called.
-  int disable_count_ = 0;
+  // Whether the window should be enabled based on user calls to SetEnabled()
+  bool is_enabled_ = true;
+  // How many modal children this window has;
+  // used to determine enabled state
+  unsigned int num_modal_children_ = 0;
 
   bool use_content_size_ = false;
   bool movable_ = true;

atom/browser/net/url_request_context_getter.cc

@@ -97,6 +97,9 @@ network::mojom::NetworkContextParamsPtr CreateDefaultNetworkContextParams(
         base_path.Append(chrome::kChannelIDFilename);
     network_context_params->restore_old_session_cookies = false;
     network_context_params->persist_session_cookies = false;
+    // TODO(deepak1556): Matches the existing behavior https://git.io/fxHMl,
+    // enable encryption as a followup.
+    network_context_params->enable_encrypted_cookies = false;
   }
   // TODO(deepak1556): Decide the stand on chrome ct policy and
   // enable it.
@@ -299,6 +302,11 @@ void URLRequestContextGetter::NotifyContextShuttingDown(
     std::unique_ptr<ResourceContext> resource_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  // todo(brenca): remove once C70 lands
+  if (url_request_context_ && url_request_context_->cookie_store()) {
+    url_request_context_->cookie_store()->FlushStore(base::NullCallback());
+  }
+
   context_shutting_down_ = true;
   resource_context.reset();
   net::URLRequestContextGetter::NotifyContextShuttingDown();

atom/browser/net/url_request_stream_job.cc

@@ -153,13 +153,17 @@ void URLRequestStreamJob::OnData(std::vector<char>&& buffer) {  // NOLINT
   if (pending_buf_) {
     int len = BufferCopy(&write_buffer_, pending_buf_.get(), pending_buf_size_);
     write_buffer_.erase(write_buffer_.begin(), write_buffer_.begin() + len);
+    pending_buf_ = nullptr;
+    pending_buf_size_ = 0;
     ReadRawDataComplete(len);
   }
 }
 
 void URLRequestStreamJob::OnEnd() {
   ended_ = true;
-  ReadRawDataComplete(0);
+  if (pending_buf_) {
+    ReadRawDataComplete(0);
+  }
 }
 
 void URLRequestStreamJob::OnError(int error) {

atom/browser/osr/osr_render_widget_host_view.cc

@@ -19,6 +19,7 @@
 #include "components/viz/common/frame_sinks/delay_based_time_source.h"
 #include "components/viz/common/gl_helper.h"
 #include "components/viz/common/quads/render_pass.h"
+#include "content/browser/renderer_host/cursor_manager.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/view_messages.h"
@@ -31,6 +32,7 @@
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_type.h"
+#include "ui/display/screen.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/canvas.h"
@@ -255,18 +257,17 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
     const OnPaintCallback& callback,
     content::RenderWidgetHost* host,
     OffScreenRenderWidgetHostView* parent_host_view,
-    NativeWindow* native_window)
+    gfx::Size initial_size)
     : content::RenderWidgetHostViewBase(host),
       render_widget_host_(content::RenderWidgetHostImpl::From(host)),
       parent_host_view_(parent_host_view),
-      native_window_(native_window),
       transparent_(transparent),
       callback_(callback),
       frame_rate_(frame_rate),
-      scale_factor_(kDefaultScaleFactor),
-      size_(native_window->GetSize()),
+      size_(initial_size),
       painting_(painting),
       is_showing_(!render_widget_host_->is_hidden()),
+      cursor_manager_(new content::CursorManager(this)),
       mouse_wheel_phase_handler_(this),
       weak_ptr_factory_(this) {
   DCHECK(render_widget_host_);
@@ -280,6 +281,8 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
   root_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
 #endif
 
+  current_device_scale_factor_ = kDefaultScaleFactor;
+
   local_surface_id_ = local_surface_id_allocator_.GenerateId();
 
 #if defined(OS_MACOSX)
@@ -308,17 +311,12 @@ OffScreenRenderWidgetHostView::OffScreenRenderWidgetHostView(
 #endif
   GetCompositor()->SetDelegate(this);
 
-  native_window_->AddObserver(this);
-
   ResizeRootLayer(false);
   render_widget_host_->SetView(this);
   InstallTransparency();
 }
 
 OffScreenRenderWidgetHostView::~OffScreenRenderWidgetHostView() {
-  if (native_window_)
-    native_window_->RemoveObserver(this);
-
 #if defined(OS_MACOSX)
   if (is_showing_)
     browser_compositor_->SetRenderWidgetHostIsHidden(true);
@@ -349,17 +347,6 @@ OffScreenRenderWidgetHostView::CreateBrowserAccessibilityManager(
   return nullptr;
 }
 
-void OffScreenRenderWidgetHostView::OnWindowResize() {
-  // In offscreen mode call RenderWidgetHostView's SetSize explicitly
-  auto size = native_window_->GetSize();
-  SetSize(size);
-}
-
-void OffScreenRenderWidgetHostView::OnWindowClosed() {
-  native_window_->RemoveObserver(this);
-  native_window_ = nullptr;
-}
-
 void OffScreenRenderWidgetHostView::OnBeginFrameTimerTick() {
   const base::TimeTicks frame_time = base::TimeTicks::Now();
   const base::TimeDelta vsync_period =
@@ -445,12 +432,12 @@ void OffScreenRenderWidgetHostView::Show() {
   browser_compositor_->SetRenderWidgetHostIsHidden(false);
 #else
   delegated_frame_host_->SetCompositor(compositor_.get());
-  delegated_frame_host_->WasShown(
-      GetLocalSurfaceId(), GetRootLayer()->bounds().size(), ui::LatencyInfo());
+  delegated_frame_host_->WasShown(GetLocalSurfaceId(),
+                                  GetRootLayer()->bounds().size(), false);
 #endif
 
   if (render_widget_host_)
-    render_widget_host_->WasShown(ui::LatencyInfo());
+    render_widget_host_->WasShown(false);
 }
 
 void OffScreenRenderWidgetHostView::Hide() {
@@ -628,6 +615,10 @@ void OffScreenRenderWidgetHostView::InitAsFullscreen(
 
 void OffScreenRenderWidgetHostView::UpdateCursor(const content::WebCursor&) {}
 
+content::CursorManager* OffScreenRenderWidgetHostView::GetCursorManager() {
+  return cursor_manager_.get();
+}
+
 void OffScreenRenderWidgetHostView::SetIsLoading(bool loading) {}
 
 void OffScreenRenderWidgetHostView::TextInputStateChanged(
@@ -691,7 +682,7 @@ void OffScreenRenderWidgetHostView::GetScreenInfo(
   screen_info->depth = 24;
   screen_info->depth_per_component = 8;
   screen_info->orientation_angle = 0;
-  screen_info->device_scale_factor = 1.0;
+  screen_info->device_scale_factor = current_device_scale_factor_;
   screen_info->orientation_type =
       content::SCREEN_ORIENTATION_VALUES_LANDSCAPE_PRIMARY;
   screen_info->rect = gfx::Rect(size_);
@@ -724,11 +715,8 @@ void OffScreenRenderWidgetHostView::ImeCompositionRangeChanged(
 
 gfx::Size OffScreenRenderWidgetHostView::GetCompositorViewportPixelSize()
     const {
-  return gfx::ScaleToCeiledSize(GetRequestedRendererSize(), scale_factor_);
-}
-
-gfx::Size OffScreenRenderWidgetHostView::GetRequestedRendererSize() const {
-  return GetDelegatedFrameHost()->GetRequestedRendererSize();
+  return gfx::ScaleToCeiledSize(GetRequestedRendererSize(),
+                                current_device_scale_factor_);
 }
 
 content::RenderWidgetHostViewBase*
@@ -749,7 +737,7 @@ OffScreenRenderWidgetHostView::CreateViewForWidget(
 
   return new OffScreenRenderWidgetHostView(
       transparent_, true, embedder_host_view->GetFrameRate(), callback_,
-      render_widget_host, embedder_host_view, native_window_);
+      render_widget_host, embedder_host_view, size());
 }
 
 #if !defined(OS_MACOSX)
@@ -783,13 +771,14 @@ void OffScreenRenderWidgetHostView::DidReceiveFirstFrameAfterNavigation() {
   render_widget_host_->DidReceiveFirstFrameAfterNavigation();
 }
 
-viz::LocalSurfaceId OffScreenRenderWidgetHostView::GetLocalSurfaceId() const {
+const viz::LocalSurfaceId& OffScreenRenderWidgetHostView::GetLocalSurfaceId()
+    const {
   return local_surface_id_;
 }
 
 #endif  // !defined(OS_MACOSX)
 
-viz::FrameSinkId OffScreenRenderWidgetHostView::GetFrameSinkId() {
+const viz::FrameSinkId& OffScreenRenderWidgetHostView::GetFrameSinkId() const {
   return GetDelegatedFrameHost()->frame_sink_id();
 }
 
@@ -809,14 +798,15 @@ bool OffScreenRenderWidgetHostView::TransformPointToLocalCoordSpaceLegacy(
     gfx::PointF* transformed_point) {
   // Transformations use physical pixels rather than DIP, so conversion
   // is necessary.
-  gfx::PointF point_in_pixels = gfx::ConvertPointToPixel(scale_factor_, point);
+  gfx::PointF point_in_pixels =
+      gfx::ConvertPointToPixel(current_device_scale_factor_, point);
   if (!GetDelegatedFrameHost()->TransformPointToLocalCoordSpaceLegacy(
           point_in_pixels, original_surface, transformed_point)) {
     return false;
   }
 
   *transformed_point =
-      gfx::ConvertPointToDIP(scale_factor_, *transformed_point);
+      gfx::ConvertPointToDIP(current_device_scale_factor_, *transformed_point);
   return true;
 }
 
@@ -897,8 +887,8 @@ void OffScreenRenderWidgetHostView::RegisterGuestViewFrameSwappedCallback(
 
 void OffScreenRenderWidgetHostView::OnGuestViewFrameSwapped(
     content::RenderWidgetHostViewGuest* guest_host_view) {
-  InvalidateBounds(
-      gfx::ConvertRectToPixel(scale_factor_, guest_host_view->GetViewBounds()));
+  InvalidateBounds(gfx::ConvertRectToPixel(current_device_scale_factor_,
+                                           guest_host_view->GetViewBounds()));
 
   RegisterGuestViewFrameSwappedCallback(guest_host_view);
 }
@@ -959,23 +949,32 @@ void OffScreenRenderWidgetHostView::OnPaint(const gfx::Rect& damage_rect,
   } else {
     gfx::Rect damage(damage_rect);
 
-    gfx::Size size = GetViewBounds().size();
+    gfx::Size size_in_pixels = gfx::ConvertSizeToPixel(
+        current_device_scale_factor_, GetViewBounds().size());
+
     SkBitmap backing;
-    backing.allocN32Pixels(size.width(), size.height(), false);
+    backing.allocN32Pixels(size_in_pixels.width(), size_in_pixels.height(),
+                           false);
     SkCanvas canvas(backing);
 
     canvas.writePixels(bitmap, 0, 0);
 
     if (popup_host_view_ && popup_bitmap_.get()) {
-      gfx::Rect pos = popup_host_view_->popup_position_;
-      damage.Union(pos);
-      canvas.writePixels(*popup_bitmap_.get(), pos.x(), pos.y());
+      gfx::Rect rect = popup_host_view_->popup_position_;
+      gfx::Point origin_in_pixels =
+          gfx::ConvertPointToPixel(current_device_scale_factor_, rect.origin());
+      damage.Union(rect);
+      canvas.writePixels(*popup_bitmap_.get(), origin_in_pixels.x(),
+                         origin_in_pixels.y());
     }
 
     for (auto* proxy_view : proxy_views_) {
-      gfx::Rect pos = proxy_view->GetBounds();
-      damage.Union(pos);
-      canvas.writePixels(*proxy_view->GetBitmap(), pos.x(), pos.y());
+      gfx::Rect rect = proxy_view->GetBounds();
+      gfx::Point origin_in_pixels =
+          gfx::ConvertPointToPixel(current_device_scale_factor_, rect.origin());
+      damage.Union(rect);
+      canvas.writePixels(*proxy_view->GetBitmap(), origin_in_pixels.x(),
+                         origin_in_pixels.y());
     }
 
     damage.Intersect(GetViewBounds());
@@ -1029,7 +1028,7 @@ void OffScreenRenderWidgetHostView::SynchronizeVisualProperties() {
   ResizeRootLayer(false);
   if (render_widget_host_)
     render_widget_host_->SynchronizeVisualProperties();
-  GetDelegatedFrameHost()->SynchronizeVisualProperties(
+  GetDelegatedFrameHost()->EmbedSurface(
       local_surface_id_, size_, cc::DeadlinePolicy::UseDefaultDeadline());
 }
 
@@ -1243,8 +1242,13 @@ void OffScreenRenderWidgetHostView::InvalidateBounds(const gfx::Rect& bounds) {
 void OffScreenRenderWidgetHostView::ResizeRootLayer(bool force) {
   SetupFrameRate(false);
 
-  const float compositorScaleFactor = GetCompositor()->device_scale_factor();
-  const bool scaleFactorDidChange = (compositorScaleFactor != scale_factor_);
+  display::Display display =
+      display::Screen::GetScreen()->GetDisplayNearestView(GetNativeView());
+  const float scaleFactor = display.device_scale_factor();
+  const bool scaleFactorDidChange =
+      (scaleFactor != current_device_scale_factor_);
+
+  current_device_scale_factor_ = scaleFactor;
 
   gfx::Size size;
   if (!IsPopupWidget())
@@ -1257,19 +1261,19 @@ void OffScreenRenderWidgetHostView::ResizeRootLayer(bool force) {
     return;
 
   const gfx::Size& size_in_pixels =
-      gfx::ConvertSizeToPixel(scale_factor_, size);
+      gfx::ConvertSizeToPixel(current_device_scale_factor_, size);
 
   local_surface_id_ = local_surface_id_allocator_.GenerateId();
 
   GetRootLayer()->SetBounds(gfx::Rect(size));
-  GetCompositor()->SetScaleAndSize(scale_factor_, size_in_pixels,
+  GetCompositor()->SetScaleAndSize(current_device_scale_factor_, size_in_pixels,
                                    local_surface_id_);
 
 #if defined(OS_MACOSX)
   bool resized = UpdateNSViewAndDisplay();
 #else
   bool resized = true;
-  GetDelegatedFrameHost()->SynchronizeVisualProperties(
+  GetDelegatedFrameHost()->EmbedSurface(
       local_surface_id_, size, cc::DeadlinePolicy::UseDefaultDeadline());
 #endif
 

atom/browser/osr/osr_render_widget_host_view.h

@@ -14,8 +14,6 @@
 #include <windows.h>
 #endif
 
-#include "atom/browser/native_window.h"
-#include "atom/browser/native_window_observer.h"
 #include "atom/browser/osr/osr_output_device.h"
 #include "atom/browser/osr/osr_view_proxy.h"
 #include "base/process/kill.h"
@@ -57,6 +55,10 @@ class NSWindow;
 #endif
 #endif
 
+namespace content {
+class CursorManager;
+}  // namespace content
+
 namespace atom {
 
 class AtomCopyFrameGenerator;
@@ -71,7 +73,6 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
 #if !defined(OS_MACOSX)
                                       public content::DelegatedFrameHostClient,
 #endif
-                                      public NativeWindowObserver,
                                       public OffscreenViewProxyObserver {
  public:
   OffScreenRenderWidgetHostView(bool transparent,
@@ -80,7 +81,7 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
                                 const OnPaintCallback& callback,
                                 content::RenderWidgetHost* render_widget_host,
                                 OffScreenRenderWidgetHostView* parent_host_view,
-                                NativeWindow* native_window);
+                                gfx::Size initial_size);
   ~OffScreenRenderWidgetHostView() override;
 
   content::BrowserAccessibilityManager* CreateBrowserAccessibilityManager(
@@ -141,6 +142,7 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   void RenderProcessGone(base::TerminationStatus, int) override;
   void Destroy(void) override;
   void SetTooltipText(const base::string16&) override;
+  content::CursorManager* GetCursorManager() override;
   void SelectionBoundsChanged(
       const ViewHostMsg_SelectionBounds_Params&) override;
   void CopyFromSurface(
@@ -156,7 +158,11 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   void ImeCompositionRangeChanged(const gfx::Range&,
                                   const std::vector<gfx::Rect>&) override;
   gfx::Size GetCompositorViewportPixelSize() const override;
-  gfx::Size GetRequestedRendererSize() const override;
+
+#if defined(OS_MACOSX)
+  viz::ScopedSurfaceIdAllocator DidUpdateVisualProperties(
+      const cc::RenderFrameMetadata& metadata) override;
+#endif
 
   content::RenderWidgetHostViewBase* CreateViewForWidget(
       content::RenderWidgetHost*,
@@ -175,8 +181,8 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   void DidReceiveFirstFrameAfterNavigation() override;
 #endif  // !defined(OS_MACOSX)
 
-  viz::LocalSurfaceId GetLocalSurfaceId() const override;
-  viz::FrameSinkId GetFrameSinkId() override;
+  const viz::LocalSurfaceId& GetLocalSurfaceId() const override;
+  const viz::FrameSinkId& GetFrameSinkId() const override;
 
   void DidNavigate() override;
 
@@ -196,10 +202,6 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
 
   bool InstallTransparency();
 
-  // NativeWindowObserver:
-  void OnWindowResize() override;
-  void OnWindowClosed() override;
-
   void OnBeginFrameTimerTick();
   void SendBeginFrame(base::TimeTicks frame_time, base::TimeDelta vsync_period);
 
@@ -259,9 +261,8 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   content::RenderWidgetHostImpl* render_widget_host() const {
     return render_widget_host_;
   }
-  NativeWindow* window() const { return native_window_; }
+
   gfx::Size size() const { return size_; }
-  float scale_factor() const { return scale_factor_; }
 
   void set_popup_host_view(OffScreenRenderWidgetHostView* popup_view) {
     popup_host_view_ = popup_view;
@@ -272,6 +273,12 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   }
 
  private:
+#if defined(OS_MACOSX)
+  display::Display GetDisplay();
+  void OnDidUpdateVisualPropertiesComplete(
+      const cc::RenderFrameMetadata& metadata);
+#endif
+
   void SetupFrameRate(bool force);
   void ResizeRootLayer(bool force);
 
@@ -291,7 +298,6 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   std::set<OffScreenRenderWidgetHostView*> guest_host_views_;
   std::set<OffscreenViewProxy*> proxy_views_;
 
-  NativeWindow* native_window_;
   OffScreenOutputDevice* software_output_device_ = nullptr;
 
   const bool transparent_;
@@ -303,7 +309,6 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
 
   base::Time last_time_ = base::Time::Now();
 
-  float scale_factor_;
   gfx::Vector2dF last_scroll_offset_;
   gfx::Size size_;
   bool painting_;
@@ -324,6 +329,8 @@ class OffScreenRenderWidgetHostView : public content::RenderWidgetHostViewBase,
   std::unique_ptr<ui::Compositor> compositor_;
   std::unique_ptr<content::DelegatedFrameHost> delegated_frame_host_;
 
+  std::unique_ptr<content::CursorManager> cursor_manager_;
+
   std::unique_ptr<AtomCopyFrameGenerator> copy_frame_generator_;
   std::unique_ptr<AtomBeginFrameTimer> begin_frame_timer_;
 

atom/browser/osr/osr_render_widget_host_view_mac.mm

@@ -11,21 +11,13 @@
 #include "ui/accelerated_widget_mac/accelerated_widget_mac.h"
 #include "ui/display/screen.h"
 
-namespace {
-
-display::Display GetDisplay() {
-  return display::Screen::GetScreen()->GetDisplayNearestView(nullptr);
-}
-
-}  // namespace
-
 namespace atom {
 
 class MacHelper : public content::BrowserCompositorMacClient,
                   public ui::AcceleratedWidgetMacNSView {
  public:
   explicit MacHelper(OffScreenRenderWidgetHostView* view) : view_(view) {
-    [this->AcceleratedWidgetGetNSView() setWantsLayer:YES];
+    [view_->GetNativeView() setWantsLayer:YES];
   }
 
   virtual ~MacHelper() {}
@@ -48,11 +40,6 @@ class MacHelper : public content::BrowserCompositorMacClient,
     view_->render_widget_host()->DidProcessFrame(frame_token);
   }
 
-  // ui::AcceleratedWidgetMacNSView:
-  NSView* AcceleratedWidgetGetNSView() const override {
-    return [view_->window()->GetNativeWindow() contentView];
-  }
-
   void AcceleratedWidgetCALayerParamsUpdated() override {}
 
   void DidReceiveFirstFrameAfterNavigation() override {
@@ -61,7 +48,22 @@ class MacHelper : public content::BrowserCompositorMacClient,
 
   void DestroyCompositorForShutdown() override {}
 
-  bool SynchronizeVisualProperties() override {
+  bool SynchronizeVisualProperties(
+      const base::Optional<viz::LocalSurfaceId>&
+          child_allocated_local_surface_id) override {
+    auto* browser_compositor = view_->browser_compositor();
+    if (child_allocated_local_surface_id) {
+      browser_compositor->UpdateRendererLocalSurfaceIdFromChild(
+          *child_allocated_local_surface_id);
+    } else {
+      browser_compositor->AllocateNewRendererLocalSurfaceId();
+    }
+
+    if (auto* host = browser_compositor->GetDelegatedFrameHost()) {
+      host->EmbedSurface(browser_compositor->GetRendererLocalSurfaceId(),
+                         browser_compositor->GetRendererSize(),
+                         cc::DeadlinePolicy::UseDefaultDeadline());
+    }
     return view_->render_widget_host()->SynchronizeVisualProperties();
   }
 
@@ -90,8 +92,8 @@ void OffScreenRenderWidgetHostView::CreatePlatformWidget(
     bool is_guest_view_hack) {
   mac_helper_ = new MacHelper(this);
   browser_compositor_.reset(new content::BrowserCompositorMac(
-      mac_helper_, mac_helper_, render_widget_host_->is_hidden(), true,
-      GetDisplay(), AllocateFrameSinkId(is_guest_view_hack)));
+      mac_helper_, mac_helper_, render_widget_host_->is_hidden(), GetDisplay(),
+      AllocateFrameSinkId(is_guest_view_hack)));
 }
 
 void OffScreenRenderWidgetHostView::DestroyPlatformWidget() {
@@ -99,7 +101,48 @@ void OffScreenRenderWidgetHostView::DestroyPlatformWidget() {
   delete mac_helper_;
 }
 
-viz::LocalSurfaceId OffScreenRenderWidgetHostView::GetLocalSurfaceId() const {
+viz::ScopedSurfaceIdAllocator
+OffScreenRenderWidgetHostView::DidUpdateVisualProperties(
+    const cc::RenderFrameMetadata& metadata) {
+  base::OnceCallback<void()> allocation_task = base::BindOnce(
+      base::IgnoreResult(
+          &OffScreenRenderWidgetHostView::OnDidUpdateVisualPropertiesComplete),
+      weak_ptr_factory_.GetWeakPtr(), metadata);
+  return browser_compositor_->GetScopedRendererSurfaceIdAllocator(
+      std::move(allocation_task));
+}
+
+display::Display OffScreenRenderWidgetHostView::GetDisplay() {
+  content::ScreenInfo screen_info;
+  GetScreenInfo(&screen_info);
+
+  // Start with a reasonable display representation.
+  display::Display display =
+      display::Screen::GetScreen()->GetDisplayNearestView(nullptr);
+
+  // Populate attributes based on |screen_info|.
+  display.set_bounds(screen_info.rect);
+  display.set_work_area(screen_info.available_rect);
+  display.set_device_scale_factor(screen_info.device_scale_factor);
+  display.set_color_space(screen_info.color_space);
+  display.set_color_depth(screen_info.depth);
+  display.set_depth_per_component(screen_info.depth_per_component);
+  display.set_is_monochrome(screen_info.is_monochrome);
+  display.SetRotationAsDegree(screen_info.orientation_angle);
+
+  return display;
+}
+
+void OffScreenRenderWidgetHostView::OnDidUpdateVisualPropertiesComplete(
+    const cc::RenderFrameMetadata& metadata) {
+  DCHECK_EQ(current_device_scale_factor_, metadata.device_scale_factor);
+  browser_compositor_->SynchronizeVisualProperties(
+      metadata.device_scale_factor, metadata.viewport_size_in_pixels,
+      metadata.local_surface_id.value_or(viz::LocalSurfaceId()));
+}
+
+const viz::LocalSurfaceId& OffScreenRenderWidgetHostView::GetLocalSurfaceId()
+    const {
   return browser_compositor_->GetRendererLocalSurfaceId();
 }
 

atom/browser/osr/osr_web_contents_view.cc

@@ -15,13 +15,16 @@ namespace atom {
 OffScreenWebContentsView::OffScreenWebContentsView(
     bool transparent,
     const OnPaintCallback& callback)
-    : transparent_(transparent), callback_(callback) {
+    : native_window_(nullptr), transparent_(transparent), callback_(callback) {
 #if defined(OS_MACOSX)
   PlatformCreate();
 #endif
 }
 
 OffScreenWebContentsView::~OffScreenWebContentsView() {
+  if (native_window_)
+    native_window_->RemoveObserver(this);
+
 #if defined(OS_MACOSX)
   PlatformDestroy();
 #endif
@@ -34,35 +37,52 @@ void OffScreenWebContentsView::SetWebContents(
   RenderViewCreated(web_contents_->GetRenderViewHost());
 }
 
+void OffScreenWebContentsView::SetNativeWindow(NativeWindow* window) {
+  if (native_window_)
+    native_window_->RemoveObserver(this);
+
+  native_window_ = window;
+
+  if (native_window_)
+    native_window_->AddObserver(this);
+
+  OnWindowResize();
+}
+
+void OffScreenWebContentsView::OnWindowResize() {
+  // In offscreen mode call RenderWidgetHostView's SetSize explicitly
+  if (GetView())
+    GetView()->SetSize(GetSize());
+}
+
+void OffScreenWebContentsView::OnWindowClosed() {
+  if (native_window_) {
+    native_window_->RemoveObserver(this);
+    native_window_ = nullptr;
+  }
+}
+
+gfx::Size OffScreenWebContentsView::GetSize() {
+  return native_window_ ? native_window_->GetSize() : gfx::Size();
+}
+
 #if !defined(OS_MACOSX)
 gfx::NativeView OffScreenWebContentsView::GetNativeView() const {
-  if (!web_contents_)
+  if (!native_window_)
     return gfx::NativeView();
-
-  auto* relay = NativeWindowRelay::FromWebContents(web_contents_);
-  if (!relay)
-    return gfx::NativeView();
-  return relay->window->GetNativeView();
+  return native_window_->GetNativeView();
 }
 
 gfx::NativeView OffScreenWebContentsView::GetContentNativeView() const {
-  if (!web_contents_)
+  if (!native_window_)
     return gfx::NativeView();
-
-  auto* relay = NativeWindowRelay::FromWebContents(web_contents_);
-  if (!relay)
-    return gfx::NativeView();
-  return relay->window->GetNativeView();
+  return native_window_->GetNativeView();
 }
 
 gfx::NativeWindow OffScreenWebContentsView::GetTopLevelNativeWindow() const {
-  if (!web_contents_)
+  if (!native_window_)
     return gfx::NativeWindow();
-
-  auto* relay = NativeWindowRelay::FromWebContents(web_contents_);
-  if (!relay)
-    return gfx::NativeWindow();
-  return relay->window->GetNativeWindow();
+  return native_window_->GetNativeWindow();
 }
 #endif
 
@@ -102,17 +122,14 @@ OffScreenWebContentsView::CreateViewForWidget(
         render_widget_host->GetView());
   }
 
-  auto* relay = NativeWindowRelay::FromWebContents(web_contents_);
   return new OffScreenRenderWidgetHostView(
       transparent_, painting_, GetFrameRate(), callback_, render_widget_host,
-      nullptr, relay->window.get());
+      nullptr, GetSize());
 }
 
 content::RenderWidgetHostViewBase*
 OffScreenWebContentsView::CreateViewForPopupWidget(
     content::RenderWidgetHost* render_widget_host) {
-  auto* relay = NativeWindowRelay::FromWebContents(web_contents_);
-
   content::WebContentsImpl* web_contents_impl =
       static_cast<content::WebContentsImpl*>(web_contents_);
 
@@ -123,9 +140,9 @@ OffScreenWebContentsView::CreateViewForPopupWidget(
                     ->GetRenderWidgetHostView()
               : web_contents_impl->GetRenderWidgetHostView());
 
-  return new OffScreenRenderWidgetHostView(
-      transparent_, true, view->GetFrameRate(), callback_, render_widget_host,
-      view, relay->window.get());
+  return new OffScreenRenderWidgetHostView(transparent_, true,
+                                           view->GetFrameRate(), callback_,
+                                           render_widget_host, view, GetSize());
 }
 
 void OffScreenWebContentsView::SetPageTitle(const base::string16& title) {}
@@ -140,8 +157,11 @@ void OffScreenWebContentsView::RenderViewCreated(
 #endif
 }
 
-void OffScreenWebContentsView::RenderViewSwappedIn(
-    content::RenderViewHost* host) {}
+void OffScreenWebContentsView::RenderViewReady() {}
+
+void OffScreenWebContentsView::RenderViewHostChanged(
+    content::RenderViewHost* old_host,
+    content::RenderViewHost* new_host) {}
 
 void OffScreenWebContentsView::SetOverscrollControllerEnabled(bool enabled) {}
 

atom/browser/osr/osr_web_contents_view.h

@@ -5,6 +5,9 @@
 #ifndef ATOM_BROWSER_OSR_OSR_WEB_CONTENTS_VIEW_H_
 #define ATOM_BROWSER_OSR_OSR_WEB_CONTENTS_VIEW_H_
 
+#include "atom/browser/native_window.h"
+#include "atom/browser/native_window_observer.h"
+
 #include "atom/browser/osr/osr_render_widget_host_view.h"
 #include "content/browser/renderer_host/render_view_host_delegate_view.h"
 #include "content/browser/web_contents/web_contents_view.h"
@@ -21,12 +24,20 @@ class OffScreenView;
 namespace atom {
 
 class OffScreenWebContentsView : public content::WebContentsView,
-                                 public content::RenderViewHostDelegateView {
+                                 public content::RenderViewHostDelegateView,
+                                 public NativeWindowObserver {
  public:
   OffScreenWebContentsView(bool transparent, const OnPaintCallback& callback);
   ~OffScreenWebContentsView() override;
 
   void SetWebContents(content::WebContents*);
+  void SetNativeWindow(NativeWindow* window);
+
+  // NativeWindowObserver:
+  void OnWindowResize() override;
+  void OnWindowClosed() override;
+
+  gfx::Size GetSize();
 
   // content::WebContentsView:
   gfx::NativeView GetNativeView() const override;
@@ -50,7 +61,9 @@ class OffScreenWebContentsView : public content::WebContentsView,
       content::RenderWidgetHost* render_widget_host) override;
   void SetPageTitle(const base::string16& title) override;
   void RenderViewCreated(content::RenderViewHost* host) override;
-  void RenderViewSwappedIn(content::RenderViewHost* host) override;
+  void RenderViewReady() override;
+  void RenderViewHostChanged(content::RenderViewHost* old_host,
+                             content::RenderViewHost* new_host) override;
   void SetOverscrollControllerEnabled(bool enabled) override;
 
 #if defined(OS_MACOSX)
@@ -82,6 +95,8 @@ class OffScreenWebContentsView : public content::WebContentsView,
 
   OffScreenRenderWidgetHostView* GetView() const;
 
+  NativeWindow* native_window_;
+
   const bool transparent_;
   bool painting_ = true;
   int frame_rate_ = 60;

atom/browser/printing/print_preview_message_handler.cc

@@ -0,0 +1,197 @@
+// 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/printing/print_preview_message_handler.h"
+
+#include <memory>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/memory/read_only_shared_memory_region.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/ref_counted_memory.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/printing/print_job_manager.h"
+#include "chrome/browser/printing/printer_query.h"
+#include "components/printing/browser/print_composite_client.h"
+#include "components/printing/browser/print_manager_utils.h"
+#include "components/printing/common/print_messages.h"
+#include "components/services/pdf_compositor/public/cpp/pdf_service_mojo_types.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+
+#include "atom/common/node_includes.h"
+
+using content::BrowserThread;
+
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(atom::PrintPreviewMessageHandler);
+
+namespace atom {
+
+namespace {
+
+void StopWorker(int document_cookie) {
+  if (document_cookie <= 0)
+    return;
+  scoped_refptr<printing::PrintQueriesQueue> queue =
+      g_browser_process->print_job_manager()->queue();
+  scoped_refptr<printing::PrinterQuery> printer_query =
+      queue->PopPrinterQuery(document_cookie);
+  if (printer_query.get()) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&printing::PrinterQuery::StopWorker, printer_query));
+  }
+}
+
+scoped_refptr<base::RefCountedMemory> GetDataFromHandle(
+    base::SharedMemoryHandle handle,
+    uint32_t data_size) {
+  auto shared_buf = std::make_unique<base::SharedMemory>(handle, true);
+  if (!shared_buf->Map(data_size)) {
+    return nullptr;
+  }
+
+  return base::MakeRefCounted<base::RefCountedSharedMemory>(
+      std::move(shared_buf), data_size);
+}
+
+}  // namespace
+
+PrintPreviewMessageHandler::PrintPreviewMessageHandler(
+    content::WebContents* web_contents)
+    : content::WebContentsObserver(web_contents), weak_ptr_factory_(this) {
+  DCHECK(web_contents);
+}
+
+PrintPreviewMessageHandler::~PrintPreviewMessageHandler() = default;
+
+bool PrintPreviewMessageHandler::OnMessageReceived(
+    const IPC::Message& message,
+    content::RenderFrameHost* render_frame_host) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(PrintPreviewMessageHandler, message,
+                                   render_frame_host)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_MetafileReadyForPrinting,
+                        OnMetafileReadyForPrinting)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  if (handled)
+    return true;
+
+  handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PrintPreviewMessageHandler, message)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_PrintPreviewFailed, OnPrintPreviewFailed)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_PrintPreviewCancelled,
+                        OnPrintPreviewCancelled)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void PrintPreviewMessageHandler::OnMetafileReadyForPrinting(
+    content::RenderFrameHost* render_frame_host,
+    const PrintHostMsg_DidPreviewDocument_Params& params,
+    const PrintHostMsg_PreviewIds& ids) {
+  // Always try to stop the worker.
+  StopWorker(params.document_cookie);
+
+  const PrintHostMsg_DidPrintContent_Params& content = params.content;
+  if (!content.metafile_data_handle.IsValid() ||
+      params.expected_pages_count <= 0) {
+    RunPrintToPDFCallback(ids.request_id, nullptr);
+    return;
+  }
+
+  if (printing::IsOopifEnabled()) {
+    auto* client =
+        printing::PrintCompositeClient::FromWebContents(web_contents());
+    DCHECK(client);
+    client->DoCompositeDocumentToPdf(
+        params.document_cookie, render_frame_host, content.metafile_data_handle,
+        content.data_size, content.subframe_content_info,
+        base::BindOnce(&PrintPreviewMessageHandler::OnCompositePdfDocumentDone,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       params.expected_pages_count, ids));
+  } else {
+    RunPrintToPDFCallback(
+        ids.request_id,
+        GetDataFromHandle(content.metafile_data_handle, content.data_size));
+  }
+}
+
+void PrintPreviewMessageHandler::OnCompositePdfDocumentDone(
+    int page_number,
+    const PrintHostMsg_PreviewIds& ids,
+    printing::mojom::PdfCompositor::Status status,
+    base::ReadOnlySharedMemoryRegion region) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (status != printing::mojom::PdfCompositor::Status::SUCCESS) {
+    DLOG(ERROR) << "Compositing pdf failed with error " << status;
+    RunPrintToPDFCallback(ids.request_id, nullptr);
+    return;
+  }
+
+  RunPrintToPDFCallback(
+      ids.request_id,
+      base::RefCountedSharedMemoryMapping::CreateFromWholeRegion(region));
+}
+
+void PrintPreviewMessageHandler::OnPrintPreviewFailed(
+    int document_cookie,
+    const PrintHostMsg_PreviewIds& ids) {
+  StopWorker(document_cookie);
+
+  RunPrintToPDFCallback(ids.request_id, nullptr);
+}
+
+void PrintPreviewMessageHandler::OnPrintPreviewCancelled(
+    int document_cookie,
+    const PrintHostMsg_PreviewIds& ids) {
+  StopWorker(document_cookie);
+
+  RunPrintToPDFCallback(ids.request_id, nullptr);
+}
+
+void PrintPreviewMessageHandler::PrintToPDF(
+    const base::DictionaryValue& options,
+    const PrintToPDFCallback& callback) {
+  int request_id;
+  options.GetInteger(printing::kPreviewRequestID, &request_id);
+  print_to_pdf_callback_map_[request_id] = callback;
+
+  auto* focused_frame = web_contents()->GetFocusedFrame();
+  auto* rfh = focused_frame && focused_frame->HasSelection()
+                  ? focused_frame
+                  : web_contents()->GetMainFrame();
+  rfh->Send(new PrintMsg_PrintPreview(rfh->GetRoutingID(), options));
+}
+
+void PrintPreviewMessageHandler::RunPrintToPDFCallback(
+    int request_id,
+    scoped_refptr<base::RefCountedMemory> data_bytes) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  if (data_bytes && data_bytes->size()) {
+    v8::Local<v8::Value> buffer =
+        node::Buffer::Copy(isolate,
+                           reinterpret_cast<const char*>(data_bytes->front()),
+                           data_bytes->size())
+            .ToLocalChecked();
+    print_to_pdf_callback_map_[request_id].Run(v8::Null(isolate), buffer);
+  } else {
+    v8::Local<v8::String> error_message =
+        v8::String::NewFromUtf8(isolate, "Failed to generate PDF");
+    print_to_pdf_callback_map_[request_id].Run(
+        v8::Exception::Error(error_message), v8::Null(isolate));
+  }
+  print_to_pdf_callback_map_.erase(request_id);
+}
+
+}  // namespace atom

atom/browser/printing/print_preview_message_handler.h

@@ -0,0 +1,74 @@
+// 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_PRINTING_PRINT_PREVIEW_MESSAGE_HANDLER_H_
+#define ATOM_BROWSER_PRINTING_PRINT_PREVIEW_MESSAGE_HANDLER_H_
+
+#include <map>
+
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/weak_ptr.h"
+#include "components/services/pdf_compositor/public/interfaces/pdf_compositor.mojom.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "content/public/browser/web_contents_user_data.h"
+#include "v8/include/v8.h"
+
+struct PrintHostMsg_DidPreviewDocument_Params;
+struct PrintHostMsg_PreviewIds;
+
+namespace content {
+class RenderFrameHost;
+}
+
+namespace atom {
+
+// Manages the print preview handling for a WebContents.
+class PrintPreviewMessageHandler
+    : public content::WebContentsObserver,
+      public content::WebContentsUserData<PrintPreviewMessageHandler> {
+ public:
+  using PrintToPDFCallback =
+      base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>;
+
+  ~PrintPreviewMessageHandler() override;
+
+  void PrintToPDF(const base::DictionaryValue& options,
+                  const PrintToPDFCallback& callback);
+
+ protected:
+  // content::WebContentsObserver implementation.
+  bool OnMessageReceived(const IPC::Message& message,
+                         content::RenderFrameHost* render_frame_host) override;
+
+ private:
+  friend class content::WebContentsUserData<PrintPreviewMessageHandler>;
+
+  explicit PrintPreviewMessageHandler(content::WebContents* web_contents);
+
+  void OnMetafileReadyForPrinting(
+      content::RenderFrameHost* render_frame_host,
+      const PrintHostMsg_DidPreviewDocument_Params& params,
+      const PrintHostMsg_PreviewIds& ids);
+  void OnCompositePdfDocumentDone(int page_number,
+                                  const PrintHostMsg_PreviewIds& ids,
+                                  printing::mojom::PdfCompositor::Status status,
+                                  base::ReadOnlySharedMemoryRegion region);
+  void OnPrintPreviewFailed(int document_cookie,
+                            const PrintHostMsg_PreviewIds& ids);
+  void OnPrintPreviewCancelled(int document_cookie,
+                               const PrintHostMsg_PreviewIds& ids);
+  void RunPrintToPDFCallback(int request_id,
+                             scoped_refptr<base::RefCountedMemory> data_bytes);
+
+  using PrintToPDFCallbackMap = std::map<int, PrintToPDFCallback>;
+  PrintToPDFCallbackMap print_to_pdf_callback_map_;
+
+  base::WeakPtrFactory<PrintPreviewMessageHandler> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintPreviewMessageHandler);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_PRINTING_PRINT_PREVIEW_MESSAGE_HANDLER_H_

atom/browser/resources/mac/Info.plist

@@ -23,7 +23,7 @@
   <key>LSApplicationCategoryType</key>
   <string>public.app-category.developer-tools</string>
   <key>LSMinimumSystemVersion</key>
-  <string>10.9.0</string>
+  <string>10.10.0</string>
   <key>NSMainNibFile</key>
   <string>MainMenu</string>
   <key>NSPrincipalClass</key>

atom/browser/resources/win/atom.rc

@@ -50,8 +50,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 4,0,0,20181010
- PRODUCTVERSION 4,0,0,20181010
+ FILEVERSION 4,0,0,11
+ PRODUCTVERSION 4,0,0,11
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L

atom/browser/ui/accelerator_util.cc

@@ -77,9 +77,11 @@ void GenerateAcceleratorTable(AcceleratorTable* table,
       GenerateAcceleratorTable(table, submodel);
     } else {
       ui::Accelerator accelerator;
-      if (model->GetAcceleratorAtWithParams(i, true, &accelerator)) {
-        MenuItem item = {i, model};
-        (*table)[accelerator] = item;
+      if (model->ShouldRegisterAcceleratorAt(i)) {
+        if (model->GetAcceleratorAtWithParams(i, true, &accelerator)) {
+          MenuItem item = {i, model};
+          (*table)[accelerator] = item;
+        }
       }
     }
   }

atom/browser/ui/atom_menu_model.cc

@@ -43,6 +43,14 @@ bool AtomMenuModel::GetAcceleratorAtWithParams(
   return false;
 }
 
+bool AtomMenuModel::ShouldRegisterAcceleratorAt(int index) const {
+  if (delegate_) {
+    return delegate_->ShouldRegisterAcceleratorForCommandId(
+        GetCommandIdAt(index));
+  }
+  return true;
+}
+
 void AtomMenuModel::MenuWillClose() {
   ui::SimpleMenuModel::MenuWillClose();
   for (Observer& observer : observers_) {

atom/browser/ui/atom_menu_model.h

@@ -23,6 +23,9 @@ class AtomMenuModel : public ui::SimpleMenuModel {
         bool use_default_accelerator,
         ui::Accelerator* accelerator) const = 0;
 
+    virtual bool ShouldRegisterAcceleratorForCommandId(
+        int command_id) const = 0;
+
    private:
     // ui::SimpleMenuModel::Delegate:
     bool GetAcceleratorForCommandId(
@@ -52,6 +55,7 @@ class AtomMenuModel : public ui::SimpleMenuModel {
   bool GetAcceleratorAtWithParams(int index,
                                   bool use_default_accelerator,
                                   ui::Accelerator* accelerator) const;
+  bool ShouldRegisterAcceleratorAt(int index) const;
 
   // ui::SimpleMenuModel:
   void MenuWillClose() override;

atom/browser/ui/cocoa/atom_menu_controller.mm

@@ -208,7 +208,17 @@ static base::scoped_nsobject<NSMenu> recentDocumentsMenuSwap_;
 
   base::string16 role = model->GetRoleAt(index);
   atom::AtomMenuModel::ItemType type = model->GetTypeAt(index);
-  if (type == atom::AtomMenuModel::TYPE_SUBMENU) {
+
+  if (role == base::ASCIIToUTF16("services")) {
+    base::string16 title = base::ASCIIToUTF16("Services");
+    NSString* label = l10n_util::FixUpWindowsStyleLabel(title);
+
+    [item setTarget:nil];
+    [item setAction:nil];
+    NSMenu* submenu = [[NSMenu alloc] initWithTitle:label];
+    [item setSubmenu:submenu];
+    [NSApp setServicesMenu:submenu];
+  } else if (type == atom::AtomMenuModel::TYPE_SUBMENU) {
     // Recursively build a submenu from the sub-model at this index.
     [item setTarget:nil];
     [item setAction:nil];
@@ -223,8 +233,6 @@ static base::scoped_nsobject<NSMenu> recentDocumentsMenuSwap_;
       [NSApp setWindowsMenu:submenu];
     else if (role == base::ASCIIToUTF16("help"))
       [NSApp setHelpMenu:submenu];
-    else if (role == base::ASCIIToUTF16("services"))
-      [NSApp setServicesMenu:submenu];
     else if (role == base::ASCIIToUTF16("recentdocuments"))
       [self replaceSubmenuShowingRecentDocuments:item];
   } else {

atom/browser/ui/cocoa/atom_ns_window_delegate.mm

@@ -9,6 +9,7 @@
 #include "atom/browser/ui/cocoa/atom_preview_item.h"
 #include "atom/browser/ui/cocoa/atom_touch_bar.h"
 #include "base/mac/mac_util.h"
+#include "ui/views/cocoa/bridged_native_widget.h"
 #include "ui/views/widget/native_widget_mac.h"
 
 @implementation AtomNSWindowDelegate
@@ -246,7 +247,10 @@
   // Clears the delegate when window is going to be closed, since EL Capitan it
   // is possible that the methods of delegate would get called after the window
   // has been closed.
-  [shell_->GetNativeWindow() setDelegate:nil];
+  views::BridgedNativeWidget* bridged_view =
+      views::NativeWidgetMac::GetBridgeForNativeWindow(
+          shell_->GetNativeWindow());
+  bridged_view->OnWindowWillClose();
 }
 
 - (BOOL)windowShouldClose:(id)window {

atom/browser/ui/file_dialog_gtk.cc

@@ -94,10 +94,14 @@ class FileChooserDialog {
   }
 
   void SetupProperties(int properties) {
-    if (properties & FILE_DIALOG_MULTI_SELECTIONS)
-      gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog()), TRUE);
-    if (properties & FILE_DIALOG_SHOW_HIDDEN_FILES)
-      g_object_set(dialog(), "show-hidden", TRUE, NULL);
+    const auto hasProp = [properties](FileDialogProperty prop) {
+      return gboolean((properties & prop) != 0);
+    };
+    auto* file_chooser = GTK_FILE_CHOOSER(dialog());
+    gtk_file_chooser_set_select_multiple(file_chooser,
+                                         hasProp(FILE_DIALOG_MULTI_SELECTIONS));
+    gtk_file_chooser_set_show_hidden(file_chooser,
+                                     hasProp(FILE_DIALOG_SHOW_HIDDEN_FILES));
   }
 
   void RunAsynchronous() {

atom/browser/ui/message_box_gtk.cc

@@ -40,7 +40,8 @@ class GtkMessageBox : public NativeWindowObserver {
                 const std::string& message,
                 const std::string& detail,
                 const std::string& checkbox_label,
-                bool checkbox_checked)
+                bool checkbox_checked,
+                const gfx::ImageSkia& icon)
       : cancel_id_(cancel_id),
         parent_(static_cast<NativeWindow*>(parent_window)) {
     // Create dialog.
@@ -56,6 +57,21 @@ class GtkMessageBox : public NativeWindowObserver {
     if (!title.empty())
       gtk_window_set_title(GTK_WINDOW(dialog_), title.c_str());
 
+    if (!icon.isNull()) {
+      // No easy way to obtain this programmatically, but GTK+'s docs
+      // define GTK_ICON_SIZE_DIALOG to be 48 pixels
+      static constexpr int pixel_width = 48;
+      static constexpr int pixel_height = 48;
+      GdkPixbuf* pixbuf = libgtkui::GdkPixbufFromSkBitmap(*icon.bitmap());
+      GdkPixbuf* scaled_pixbuf = gdk_pixbuf_scale_simple(
+          pixbuf, pixel_width, pixel_height, GDK_INTERP_BILINEAR);
+      GtkWidget* w = gtk_image_new_from_pixbuf(scaled_pixbuf);
+      gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(dialog_), w);
+      gtk_widget_show(w);
+      g_clear_pointer(&scaled_pixbuf, gdk_pixbuf_unref);
+      g_clear_pointer(&pixbuf, gdk_pixbuf_unref);
+    }
+
     if (!checkbox_label.empty()) {
       GtkWidget* message_area =
           gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(dialog_));
@@ -66,15 +82,15 @@ class GtkMessageBox : public NativeWindowObserver {
       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_button),
                                    checkbox_checked);
       gtk_container_add(GTK_CONTAINER(message_area), check_button);
+      gtk_widget_show(check_button);
     }
 
     // Add buttons.
+    GtkDialog* dialog = GTK_DIALOG(dialog_);
     for (size_t i = 0; i < buttons.size(); ++i) {
-      GtkWidget* button = gtk_dialog_add_button(
-          GTK_DIALOG(dialog_), TranslateToStock(i, buttons[i]), i);
-      if (static_cast<int>(i) == default_id)
-        gtk_widget_grab_focus(button);
+      gtk_dialog_add_button(dialog, TranslateToStock(i, buttons[i]), i);
     }
+    gtk_dialog_set_default_response(dialog, default_id);
 
     // Parent window.
     if (parent_) {
@@ -122,7 +138,7 @@ class GtkMessageBox : public NativeWindowObserver {
   }
 
   void Show() {
-    gtk_widget_show_all(dialog_);
+    gtk_widget_show(dialog_);
     // We need to call gtk_window_present after making the widgets visible to
     // make sure window gets correctly raised and gets focus.
     int time = ui::X11EventSource::GetInstance()->GetTimestamp();
@@ -195,9 +211,9 @@ int ShowMessageBox(NativeWindow* parent,
                    const std::string& title,
                    const std::string& message,
                    const std::string& detail,
-                   const gfx::ImageSkia& /*icon*/) {
+                   const gfx::ImageSkia& icon) {
   return GtkMessageBox(parent, type, buttons, default_id, cancel_id, title,
-                       message, detail, "", false)
+                       message, detail, "", false, icon)
       .RunSynchronous();
 }
 
@@ -212,10 +228,10 @@ void ShowMessageBox(NativeWindow* parent,
                     const std::string& detail,
                     const std::string& checkbox_label,
                     bool checkbox_checked,
-                    const gfx::ImageSkia& /*icon*/,
+                    const gfx::ImageSkia& icon,
                     const MessageBoxCallback& callback) {
   (new GtkMessageBox(parent, type, buttons, default_id, cancel_id, title,
-                     message, detail, checkbox_label, checkbox_checked))
+                     message, detail, checkbox_label, checkbox_checked, icon))
       ->RunAsynchronous(callback);
 }
 
@@ -223,7 +239,8 @@ void ShowErrorBox(const base::string16& title, const base::string16& content) {
   if (Browser::Get()->is_ready()) {
     GtkMessageBox(nullptr, MESSAGE_BOX_TYPE_ERROR, {"OK"}, -1, 0, "Error",
                   base::UTF16ToUTF8(title).c_str(),
-                  base::UTF16ToUTF8(content).c_str(), "", false)
+                  base::UTF16ToUTF8(content).c_str(), "", false,
+                  gfx::ImageSkia())
         .RunSynchronous();
   } else {
     fprintf(stderr,

atom/browser/ui/views/root_view.cc

@@ -44,15 +44,14 @@ RootView::~RootView() {}
 void RootView::SetMenu(AtomMenuModel* menu_model) {
   if (menu_model == nullptr) {
     // Remove accelerators
-    accelerator_table_.clear();
-    GetFocusManager()->UnregisterAccelerators(this);
+    UnregisterAcceleratorsWithFocusManager();
     // and menu bar.
     SetMenuBarVisibility(false);
     menu_bar_.reset();
     return;
   }
 
-  RegisterAccelerators(menu_model);
+  RegisterAcceleratorsWithFocusManager(menu_model);
 
   // Do not show menu bar in frameless window.
   if (!window_->has_frame())
@@ -178,12 +177,13 @@ bool RootView::AcceleratorPressed(const ui::Accelerator& accelerator) {
                                                           accelerator);
 }
 
-void RootView::RegisterAccelerators(AtomMenuModel* menu_model) {
+void RootView::RegisterAcceleratorsWithFocusManager(AtomMenuModel* menu_model) {
+  if (!menu_model)
+    return;
   // Clear previous accelerators.
-  views::FocusManager* focus_manager = GetFocusManager();
-  accelerator_table_.clear();
-  focus_manager->UnregisterAccelerators(this);
+  UnregisterAcceleratorsWithFocusManager();
 
+  views::FocusManager* focus_manager = GetFocusManager();
   // Register accelerators with focus manager.
   accelerator_util::GenerateAcceleratorTable(&accelerator_table_, menu_model);
   for (const auto& iter : accelerator_table_) {
@@ -192,4 +192,10 @@ void RootView::RegisterAccelerators(AtomMenuModel* menu_model) {
   }
 }
 
+void RootView::UnregisterAcceleratorsWithFocusManager() {
+  views::FocusManager* focus_manager = GetFocusManager();
+  accelerator_table_.clear();
+  focus_manager->UnregisterAccelerators(this);
+}
+
 }  // namespace atom

atom/browser/ui/views/root_view.h

@@ -34,6 +34,10 @@ class RootView : public views::View {
   bool IsMenuBarVisible() const;
   void HandleKeyEvent(const content::NativeWebKeyboardEvent& event);
   void ResetAltState();
+  void RestoreFocus();
+  // Register/Unregister accelerators supported by the menu model.
+  void RegisterAcceleratorsWithFocusManager(AtomMenuModel* menu_model);
+  void UnregisterAcceleratorsWithFocusManager();
 
   // views::View:
   void Layout() override;
@@ -42,9 +46,6 @@ class RootView : public views::View {
   bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
 
  private:
-  // Register accelerators supported by the menu model.
-  void RegisterAccelerators(AtomMenuModel* menu_model);
-
   // Parent window, weak ref.
   NativeWindow* window_;
 

atom/browser/web_contents_preferences.cc

@@ -98,6 +98,15 @@ WebContentsPreferences::WebContentsPreferences(
 
   instances_.push_back(this);
 
+  preference_.SetKey(options::kNodeIntegrationWasExplicitlyEnabled,
+                     base::Value(IsEnabled(options::kNodeIntegration)));
+  preference_.SetKey(options::kContextIsolationWasExplicitlyDisabled,
+                     base::Value(!IsEnabled(options::kContextIsolation, true)));
+  preference_.SetKey(
+      options::kWebviewTagWasExplicitlyEnabled,
+      base::Value(IsEnabled(options::kWebviewTag,
+                            IsEnabled(options::kNodeIntegration))));
+
   // Set WebPreferences defaults onto the JS object
   SetDefaultBoolIfUndefined(options::kPlugins, false);
   SetDefaultBoolIfUndefined(options::kExperimentalFeatures, false);
@@ -171,6 +180,10 @@ bool WebContentsPreferences::GetPreference(const base::StringPiece& name,
   return GetAsString(&preference_, name, value);
 }
 
+bool WebContentsPreferences::IsRemoteModuleEnabled() const {
+  return IsEnabled(options::kEnableRemoteModule, true);
+}
+
 bool WebContentsPreferences::GetPreloadPath(
     base::FilePath::StringType* path) const {
   DCHECK(path);
@@ -267,6 +280,10 @@ void WebContentsPreferences::AppendCommandLineSwitches(
     }
   }
 
+  // Whether to enable the remote module
+  if (!IsRemoteModuleEnabled())
+    command_line->AppendSwitch(switches::kDisableRemoteModule);
+
   // Run Electron APIs and preload script in isolated world
   if (IsEnabled(options::kContextIsolation))
     command_line->AppendSwitch(switches::kContextIsolation);
@@ -397,6 +414,8 @@ void WebContentsPreferences::OverrideWebkitPrefs(
   std::string encoding;
   if (GetAsString(&preference_, "defaultEncoding", &encoding))
     prefs->default_encoding = encoding;
+
+  prefs->node_integration = IsEnabled(options::kNodeIntegration);
 }
 
 }  // namespace atom

atom/browser/web_contents_preferences.h

@@ -55,6 +55,9 @@ class WebContentsPreferences
   // Return true if the particular preference value exists.
   bool GetPreference(const base::StringPiece& name, std::string* value) const;
 
+  // Whether to enable the remote module
+  bool IsRemoteModuleEnabled() const;
+
   // Returns the preload script path.
   bool GetPreloadPath(base::FilePath::StringType* path) const;
 

atom/common/api/features.cc

@@ -4,6 +4,7 @@
 
 #include "electron/buildflags/buildflags.h"
 #include "native_mate/dictionary.h"
+#include "printing/buildflags/buildflags.h"
 // clang-format off
 #include "atom/common/node_includes.h"  // NOLINT(build/include_alpha)
 // clang-format on
@@ -30,6 +31,10 @@ bool IsViewApiEnabled() {
   return BUILDFLAG(ENABLE_VIEW_API);
 }
 
+bool IsPrintingEnabled() {
+  return BUILDFLAG(ENABLE_PRINTING);
+}
+
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
@@ -41,6 +46,7 @@ void Initialize(v8::Local<v8::Object> exports,
   dict.SetMethod("isFakeLocationProviderEnabled",
                  &IsFakeLocationProviderEnabled);
   dict.SetMethod("isViewApiEnabled", &IsViewApiEnabled);
+  dict.SetMethod("isPrintingEnabled", &IsPrintingEnabled);
 }
 
 }  // namespace

atom/common/atom_version.h

@@ -9,7 +9,7 @@
 #define ATOM_MINOR_VERSION 0
 #define ATOM_PATCH_VERSION 0
 // clang-format off
-#define ATOM_PRE_RELEASE_VERSION -nightly.20181010
+#define ATOM_PRE_RELEASE_VERSION -beta.11
 // clang-format on
 
 #ifndef ATOM_STRINGIFY

atom/common/common_message_generator.h

@@ -5,6 +5,3 @@
 // Multiply-included file, no traditional include guard.
 
 #include "atom/common/api/api_messages.h"
-#include "chrome/common/chrome_utility_printing_messages.h"
-#include "chrome/common/print_messages.h"
-#include "chrome/common/tts_messages.h"

atom/common/node_bindings.cc

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "atom/common/api/event_emitter_caller.h"
@@ -18,6 +19,7 @@
 #include "base/environment.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
+#include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
@@ -36,6 +38,7 @@
   V(atom_browser_debugger)                   \
   V(atom_browser_dialog)                     \
   V(atom_browser_download_item)              \
+  V(atom_browser_event)                      \
   V(atom_browser_global_shortcut)            \
   V(atom_browser_in_app_purchase)            \
   V(atom_browser_menu)                       \
@@ -213,19 +216,73 @@ void NodeBindings::Initialize() {
   // Explicitly register electron's builtin modules.
   RegisterBuiltinModules();
 
-  // Init node.
-  // (we assume node::Init would not modify the parameters under embedded mode).
-  // NOTE: If you change this line, please ping @codebytere or @MarshallOfSound
-  int argc = 0;
+  // pass non-null program name to argv so it doesn't crash
+  // trying to index into a nullptr
+  int argc = 1;
   int exec_argc = 0;
-  const char** argv = nullptr;
+  const char* prog_name = "electron";
+  const char** argv = &prog_name;
   const char** exec_argv = nullptr;
+
+  std::unique_ptr<base::Environment> env(base::Environment::Create());
+  if (env->HasVar("NODE_OPTIONS")) {
+    base::FilePath exe_path;
+    base::PathService::Get(base::FILE_EXE, &exe_path);
+#if defined(OS_WIN)
+    std::string path = base::UTF16ToUTF8(exe_path.value());
+#else
+    std::string path = exe_path.value();
+#endif
+    std::transform(path.begin(), path.end(), path.begin(), ::tolower);
+
+#if defined(OS_WIN)
+    const bool is_packaged_app = path == "electron.exe";
+#else
+    const bool is_packaged_app = path == "electron";
+#endif
+
+    // explicitly disallow NODE_OPTIONS in packaged apps
+    if (is_packaged_app) {
+      LOG(WARNING) << "NODE_OPTIONs are not supported in packaged apps";
+      env->SetVar("NODE_OPTIONS", "");
+    } else {
+      const std::vector<std::string> disallowed = {
+          "--openssl-config", "--use-bundled-ca", "--use-openssl-ca",
+          "--force-fips", "--enable-fips"};
+
+      std::string options;
+      env->GetVar("NODE_OPTIONS", &options);
+      std::vector<std::string> parts = base::SplitString(
+          options, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+
+      // parse passed options for unsupported options
+      // and remove them from the options list
+      std::string new_options = options;
+      for (const auto& disallow : disallowed) {
+        for (const auto& part : parts) {
+          if (part.find(disallow) != std::string::npos) {
+            LOG(WARNING) << "The NODE_OPTION" << disallow
+                         << "is not supported in Electron";
+            new_options.erase(new_options.find(part), part.length());
+            break;
+          }
+        }
+      }
+
+      // overwrite new NODE_OPTIONS without unsupported variables
+      if (new_options != options)
+        env->SetVar("NODE_OPTIONS", new_options);
+    }
+  }
+
+  // TODO(codebytere): this is going to be deprecated in the near future
+  // in favor of Init(std::vector<std::string>* argv,
+  //        std::vector<std::string>* exec_argv)
   node::Init(&argc, argv, &exec_argc, &exec_argv);
 
 #if defined(OS_WIN)
   // uv_init overrides error mode to suppress the default crash dialog, bring
   // it back if user wants to show it.
-  std::unique_ptr<base::Environment> env(base::Environment::Create());
   if (browser_env_ == BROWSER || env->HasVar("ELECTRON_DEFAULT_ERROR_MODE"))
     SetErrorMode(GetErrorMode() & ~SEM_NOGPFAULTERRORBOX);
 #endif

atom/common/node_bindings_win.cc

@@ -7,11 +7,25 @@
 #include <windows.h>
 
 #include "base/logging.h"
+#include "base/sys_info.h"
 
 namespace atom {
 
 NodeBindingsWin::NodeBindingsWin(BrowserEnvironment browser_env)
-    : NodeBindings(browser_env) {}
+    : NodeBindings(browser_env) {
+  // on single-core the io comp port NumberOfConcurrentThreads needs to be 2
+  // to avoid cpu pegging likely caused by a busy loop in PollEvents
+  if (base::SysInfo::NumberOfProcessors() == 1) {
+    // the expectation is the uv_loop_ has just been initialized
+    // which makes iocp replacement safe
+    CHECK_EQ(0u, uv_loop_->active_handles);
+    CHECK_EQ(0u, uv_loop_->active_reqs.count);
+
+    if (uv_loop_->iocp && uv_loop_->iocp != INVALID_HANDLE_VALUE)
+      CloseHandle(uv_loop_->iocp);
+    uv_loop_->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 2);
+  }
+}
 
 NodeBindingsWin::~NodeBindingsWin() {}
 

atom/common/node_includes.h

@@ -30,7 +30,7 @@
 #undef NO_RETURN
 #undef LIKELY
 #undef arraysize
-#undef debug_string  // This is defined in macOS 10.9 SDK in AssertMacros.h.
+#undef debug_string  // This is defined in macOS SDK in AssertMacros.h.
 #include "env-inl.h"
 #include "env.h"
 #include "node.h"

atom/common/options_switches.cc

@@ -110,9 +110,26 @@ const char kPreloadURL[] = "preloadURL";
 // Enable the node integration.
 const char kNodeIntegration[] = "nodeIntegration";
 
+// Whether node integration was explicitly enabled.
+// This is to support the change from default-enabled to default-disabled in
+// Electron 5 (with a warning message in 4). This option and its usages
+// can be removed in Electron 5.
+const char kNodeIntegrationWasExplicitlyEnabled[] =
+    "nodeIntegrationWasExplicitlyEnabled";
+
+// Enable the remote module
+const char kEnableRemoteModule[] = "enableRemoteModule";
+
 // Enable context isolation of Electron APIs and preload script
 const char kContextIsolation[] = "contextIsolation";
 
+// Whether context isolation was explicitly disabled.
+// This is to support the change from default-disabled to default-enabled in
+// Electron 5 (with a warning message in 4). This option and its usages
+// can be removed in Electron 5.
+const char kContextIsolationWasExplicitlyDisabled[] =
+    "contextIsolationWasExplicitlyDisabled";
+
 // Instance ID of guest WebContents.
 const char kGuestInstanceID[] = "guestInstanceId";
 
@@ -137,6 +154,12 @@ const char kNodeIntegrationInWorker[] = "nodeIntegrationInWorker";
 // Enable the web view tag.
 const char kWebviewTag[] = "webviewTag";
 
+// Whether the webview tag was explicitly enabled.
+// This is to support the change from default-disabled to default-enabled in
+// Electron 5 (with a warning message in 4). This option and its usages
+// can be removed in Electron 5.
+const char kWebviewTagWasExplicitlyEnabled[] = "webviewTagWasExplicitlyEnabled";
+
 const char kNativeWindowOpen[] = "nativeWindowOpen";
 
 const char kCustomArgs[] = "additionalArguments";
@@ -193,6 +216,7 @@ const char kBackgroundColor[] = "background-color";
 const char kPreloadScript[] = "preload";
 const char kPreloadScripts[] = "preload-scripts";
 const char kNodeIntegration[] = "node-integration";
+const char kDisableRemoteModule[] = "disable-remote-module";
 const char kContextIsolation[] = "context-isolation";
 const char kGuestInstanceID[] = "guest-instance-id";
 const char kOpenerID[] = "opener-id";

atom/common/options_switches.h

@@ -58,7 +58,10 @@ extern const char kZoomFactor[];
 extern const char kPreloadScript[];
 extern const char kPreloadURL[];
 extern const char kNodeIntegration[];
+extern const char kNodeIntegrationWasExplicitlyEnabled[];
+extern const char kEnableRemoteModule[];
 extern const char kContextIsolation[];
+extern const char kContextIsolationWasExplicitlyDisabled[];
 extern const char kGuestInstanceID[];
 extern const char kExperimentalFeatures[];
 extern const char kOpenerID[];
@@ -67,6 +70,7 @@ extern const char kEnableBlinkFeatures[];
 extern const char kDisableBlinkFeatures[];
 extern const char kNodeIntegrationInWorker[];
 extern const char kWebviewTag[];
+extern const char kWebviewTagWasExplicitlyEnabled[];
 extern const char kNativeWindowOpen[];
 extern const char kCustomArgs[];
 extern const char kPlugins[];
@@ -97,6 +101,7 @@ extern const char kBackgroundColor[];
 extern const char kPreloadScript[];
 extern const char kPreloadScripts[];
 extern const char kNodeIntegration[];
+extern const char kDisableRemoteModule[];
 extern const char kContextIsolation[];
 extern const char kGuestInstanceID[];
 extern const char kOpenerID[];

atom/common/platform_util_linux.cc

@@ -15,7 +15,7 @@
 #include "url/gurl.h"
 
 #define ELECTRON_TRASH "ELECTRON_TRASH"
-#define ELECTRON_DEFAULT_TRASH "gvfs-trash"
+#define ELECTRON_DEFAULT_TRASH "gio"
 
 namespace {
 
@@ -125,12 +125,13 @@ bool MoveItemToTrash(const base::FilePath& full_path) {
   } else if (trash.compare("trash-cli") == 0) {
     argv.push_back("trash-put");
     argv.push_back(full_path.value());
-  } else if (trash.compare("gio") == 0) {
-    argv.push_back("gio");
-    argv.push_back("trash");
+  } else if (trash.compare("gvfs-trash") == 0) {
+    // retain support for deprecated gvfs-trash
+    argv.push_back("gvfs-trash");
     argv.push_back(full_path.value());
   } else {
     argv.push_back(ELECTRON_DEFAULT_TRASH);
+    argv.push_back("trash");
     argv.push_back(full_path.value());
   }
   return XDGUtilV(argv, true);

atom/common/promise_util.cc

@@ -21,8 +21,7 @@ v8::Maybe<bool> Promise::RejectWithErrorMessage(const std::string& string) {
   v8::Local<v8::String> error_message =
       v8::String::NewFromUtf8(isolate(), string.c_str());
   v8::Local<v8::Value> error = v8::Exception::Error(error_message);
-  return GetInner()->Reject(isolate()->GetCurrentContext(),
-                            mate::ConvertToV8(isolate(), error));
+  return Reject(error);
 }
 
 v8::Local<v8::Promise> Promise::GetHandle() const {

atom/common/promise_util.h

@@ -32,6 +32,8 @@ class Promise : public base::RefCounted<Promise> {
                               v8::Undefined(isolate()));
   }
 
+  // Promise resolution is a microtask
+  // We use the MicrotasksRunner to trigger the running of pending microtasks
   template <typename T>
   v8::Maybe<bool> Resolve(const T& value) {
     return GetInner()->Resolve(isolate()->GetCurrentContext(),

atom/renderer/api/atom_api_web_frame.cc

@@ -188,8 +188,10 @@ void WebFrame::SetLayoutZoomLevelLimits(double min_level, double max_level) {
 }
 
 v8::Local<v8::Value> WebFrame::RegisterEmbedderCustomElement(
+    v8::Local<v8::Object> context,
     const base::string16& name,
     v8::Local<v8::Object> options) {
+  v8::Context::Scope context_scope(context->CreationContext());
   return web_frame_->GetDocument().RegisterEmbedderCustomElement(
       blink::WebString::FromUTF16(name), options);
 }

atom/renderer/api/atom_api_web_frame.h

@@ -51,6 +51,7 @@ class WebFrame : public mate::Wrappable<WebFrame> {
   void SetLayoutZoomLevelLimits(double min_level, double max_level);
 
   v8::Local<v8::Value> RegisterEmbedderCustomElement(
+      v8::Local<v8::Object> context,
       const base::string16& name,
       v8::Local<v8::Object> options);
   int GetWebFrameId(v8::Local<v8::Value> content_window);

atom/renderer/atom_render_frame_observer.cc

@@ -96,9 +96,10 @@ void AtomRenderFrameObserver::DidCreateScriptContext(
     renderer_client_->DidCreateScriptContext(context, render_frame_);
 
   if (renderer_client_->isolated_world() && IsMainWorld(world_id) &&
-      render_frame_->IsMainFrame()) {
+      // Only the top window's main frame has isolated world.
+      render_frame_->IsMainFrame() && !render_frame_->GetWebFrame()->Opener()) {
     CreateIsolatedWorldContext();
-    renderer_client_->SetupMainWorldOverrides(context);
+    renderer_client_->SetupMainWorldOverrides(context, render_frame_);
   }
 }
 

atom/renderer/atom_renderer_client.cc

@@ -12,10 +12,10 @@
 #include "atom/common/asar/asar_util.h"
 #include "atom/common/node_bindings.h"
 #include "atom/common/options_switches.h"
-#include "atom/renderer/api/atom_api_renderer_ipc.h"
 #include "atom/renderer/atom_render_frame_observer.h"
 #include "atom/renderer/web_worker_observer.h"
 #include "base/command_line.h"
+#include "content/public/common/web_preferences.h"
 #include "content/public/renderer/render_frame.h"
 #include "native_mate/dictionary.h"
 #include "third_party/blink/public/web/web_document.h"
@@ -86,6 +86,15 @@ void AtomRendererClient::DidCreateScriptContext(
   if (!render_frame->IsMainFrame() && !IsDevToolsExtension(render_frame))
     return;
 
+  // Don't allow node integration if this is a child window and it does not have
+  // node integration enabled.  Otherwise we would have memory leak in the child
+  // window since we don't clean up node environments.
+  //
+  // TODO(zcbenz): We shouldn't allow node integration even for the top frame.
+  if (!render_frame->GetWebkitPreferences().node_integration &&
+      render_frame->GetWebFrame()->Opener())
+    return;
+
   injected_frames_.insert(render_frame);
 
   // Prepare the node bindings.
@@ -179,13 +188,14 @@ void AtomRendererClient::WillDestroyWorkerContextOnWorkerThread(
 }
 
 void AtomRendererClient::SetupMainWorldOverrides(
-    v8::Handle<v8::Context> context) {
+    v8::Handle<v8::Context> context,
+    content::RenderFrame* render_frame) {
   // Setup window overrides in the main world context
   v8::Isolate* isolate = context->GetIsolate();
 
-  // Wrap the bundle into a function that receives the binding object as
+  // Wrap the bundle into a function that receives the isolatedWorld as
   // an argument.
-  std::string left = "(function (binding, require) {\n";
+  std::string left = "(function (nodeProcess, isolatedWorld) {\n";
   std::string right = "\n})";
   auto script = v8::Script::Compile(v8::String::Concat(
       mate::ConvertToV8(isolate, left)->ToString(),
@@ -194,24 +204,12 @@ void AtomRendererClient::SetupMainWorldOverrides(
   auto func =
       v8::Handle<v8::Function>::Cast(script->Run(context).ToLocalChecked());
 
-  auto binding = v8::Object::New(isolate);
-  api::Initialize(binding, v8::Null(isolate), context, nullptr);
-
-  // Pass in CLI flags needed to setup window
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  mate::Dictionary dict(isolate, binding);
-  if (command_line->HasSwitch(switches::kGuestInstanceID))
-    dict.Set(options::kGuestInstanceID,
-             command_line->GetSwitchValueASCII(switches::kGuestInstanceID));
-  if (command_line->HasSwitch(switches::kOpenerID))
-    dict.Set(options::kOpenerID,
-             command_line->GetSwitchValueASCII(switches::kOpenerID));
-  dict.Set("hiddenPage", command_line->HasSwitch(switches::kHiddenPage));
-  dict.Set(options::kNativeWindowOpen,
-           command_line->HasSwitch(switches::kNativeWindowOpen));
-
-  v8::Local<v8::Value> args[] = {binding};
-  ignore_result(func->Call(context, v8::Null(isolate), 1, args));
+  v8::Local<v8::Value> args[] = {
+      GetEnvironment(render_frame)->process_object(),
+      GetContext(render_frame->GetWebFrame(), isolate)->Global(),
+  };
+  ignore_result(
+      func->Call(context, v8::Null(isolate), node::arraysize(args), args));
 }
 
 node::Environment* AtomRendererClient::GetEnvironment(

atom/renderer/atom_renderer_client.h

@@ -31,7 +31,8 @@ class AtomRendererClient : public RendererClientBase {
                               content::RenderFrame* render_frame) override;
   void WillReleaseScriptContext(v8::Handle<v8::Context> context,
                                 content::RenderFrame* render_frame) override;
-  void SetupMainWorldOverrides(v8::Handle<v8::Context> context) override;
+  void SetupMainWorldOverrides(v8::Handle<v8::Context> context,
+                               content::RenderFrame* render_frame) override;
 
  private:
   enum NodeIntegration {

atom/renderer/atom_sandboxed_renderer_client.cc

@@ -18,7 +18,6 @@
 #include "base/path_service.h"
 #include "base/process/process_handle.h"
 #include "brightray/common/application_info.h"
-#include "chrome/renderer/printing/print_web_view_helper.h"
 #include "content/public/renderer/render_frame.h"
 #include "native_mate/dictionary.h"
 #include "third_party/blink/public/web/blink.h"
@@ -39,6 +38,11 @@ bool IsDevTools(content::RenderFrame* render_frame) {
       "chrome-devtools");
 }
 
+bool IsDevToolsExtension(content::RenderFrame* render_frame) {
+  return render_frame->GetWebFrame()->GetDocument().Url().ProtocolIs(
+      "chrome-extension");
+}
+
 v8::Local<v8::Object> GetModuleCache(v8::Isolate* isolate) {
   mate::Dictionary global(isolate, isolate->GetCurrentContext()->Global());
   v8::Local<v8::Value> cache;
@@ -198,7 +202,8 @@ void AtomSandboxedRendererClient::DidCreateScriptContext(
 
   // Only allow preload for the main frame or
   // For devtools we still want to run the preload_bundle script
-  if (!render_frame->IsMainFrame() && !IsDevTools(render_frame))
+  if (!render_frame->IsMainFrame() && !IsDevTools(render_frame) &&
+      !IsDevToolsExtension(render_frame))
     return;
 
   auto* isolate = context->GetIsolate();

atom/renderer/atom_sandboxed_renderer_client.h

@@ -28,7 +28,8 @@ class AtomSandboxedRendererClient : public RendererClientBase {
                               content::RenderFrame* render_frame) override;
   void WillReleaseScriptContext(v8::Handle<v8::Context> context,
                                 content::RenderFrame* render_frame) override;
-  void SetupMainWorldOverrides(v8::Handle<v8::Context> context) override {}
+  void SetupMainWorldOverrides(v8::Handle<v8::Context> context,
+                               content::RenderFrame* render_frame) override {}
   // content::ContentRendererClient:
   void RenderFrameCreated(content::RenderFrame*) override;
   void RenderViewCreated(content::RenderView*) override;

atom/renderer/printing/print_render_frame_helper_delegate.cc

@@ -0,0 +1,37 @@
+// 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/renderer/printing/print_render_frame_helper_delegate.h"
+
+#include "content/public/renderer/render_frame.h"
+#include "third_party/blink/public/web/web_element.h"
+#include "third_party/blink/public/web/web_local_frame.h"
+
+namespace atom {
+
+PrintRenderFrameHelperDelegate::PrintRenderFrameHelperDelegate() = default;
+
+PrintRenderFrameHelperDelegate::~PrintRenderFrameHelperDelegate() = default;
+
+bool PrintRenderFrameHelperDelegate::CancelPrerender(
+    content::RenderFrame* render_frame) {
+  return false;
+}
+
+// Return the PDF object element if |frame| is the out of process PDF extension.
+blink::WebElement PrintRenderFrameHelperDelegate::GetPdfElement(
+    blink::WebLocalFrame* frame) {
+  return blink::WebElement();
+}
+
+bool PrintRenderFrameHelperDelegate::IsPrintPreviewEnabled() {
+  return false;
+}
+
+bool PrintRenderFrameHelperDelegate::OverridePrint(
+    blink::WebLocalFrame* frame) {
+  return false;
+}
+
+}  // namespace atom

atom/renderer/printing/print_render_frame_helper_delegate.h

@@ -0,0 +1,31 @@
+// 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_RENDERER_PRINTING_PRINT_RENDER_FRAME_HELPER_DELEGATE_H_
+#define ATOM_RENDERER_PRINTING_PRINT_RENDER_FRAME_HELPER_DELEGATE_H_
+
+#include "base/macros.h"
+#include "components/printing/renderer/print_render_frame_helper.h"
+
+namespace atom {
+
+class PrintRenderFrameHelperDelegate
+    : public printing::PrintRenderFrameHelper::Delegate {
+ public:
+  PrintRenderFrameHelperDelegate();
+  ~PrintRenderFrameHelperDelegate() override;
+
+ private:
+  // printing::PrintRenderFrameHelper::Delegate:
+  bool CancelPrerender(content::RenderFrame* render_frame) override;
+  blink::WebElement GetPdfElement(blink::WebLocalFrame* frame) override;
+  bool IsPrintPreviewEnabled() override;
+  bool OverridePrint(blink::WebLocalFrame* frame) override;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintRenderFrameHelperDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_RENDERER_PRINTING_PRINT_RENDER_FRAME_HELPER_DELEGATE_H_

atom/renderer/renderer_client_base.cc

@@ -19,7 +19,6 @@
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
-#include "chrome/renderer/printing/print_web_view_helper.h"
 #include "chrome/renderer/tts_dispatcher.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
@@ -27,6 +26,7 @@
 #include "content/public/renderer/render_view.h"
 #include "electron/buildflags/buildflags.h"
 #include "native_mate/dictionary.h"
+#include "printing/buildflags/buildflags.h"
 #include "third_party/blink/public/web/blink.h"
 #include "third_party/blink/public/web/web_custom_element.h"  // NOLINT(build/include_alpha)
 #include "third_party/blink/public/web/web_frame_widget.h"
@@ -51,6 +51,11 @@
 #include "chrome/renderer/pepper/pepper_helper.h"
 #endif  // BUILDFLAG(ENABLE_PEPPER_FLASH)
 
+#if BUILDFLAG(ENABLE_PRINTING)
+#include "atom/renderer/printing/print_render_frame_helper_delegate.h"
+#include "components/printing/renderer/print_render_frame_helper.h"
+#endif  // BUILDFLAG(ENABLE_PRINTING)
+
 namespace atom {
 
 namespace {
@@ -71,6 +76,15 @@ std::vector<std::string> ParseSchemesCLISwitch(base::CommandLine* command_line,
                            base::SPLIT_WANT_NONEMPTY);
 }
 
+void SetHiddenValue(v8::Handle<v8::Context> context,
+                    const base::StringPiece& key,
+                    v8::Local<v8::Value> value) {
+  v8::Isolate* isolate = context->GetIsolate();
+  v8::Local<v8::Private> privateKey =
+      v8::Private::ForApi(isolate, mate::StringToV8(isolate, key));
+  context->Global()->SetPrivate(context, privateKey, value);
+}
+
 }  // namespace
 
 RendererClientBase::RendererClientBase() {
@@ -100,10 +114,13 @@ void RendererClientBase::DidCreateScriptContext(
   auto context_id = base::StringPrintf(
       "%s-%" PRId64, renderer_client_id_.c_str(), ++next_context_id_);
   v8::Isolate* isolate = context->GetIsolate();
-  v8::Local<v8::String> key = mate::StringToSymbol(isolate, "contextId");
-  v8::Local<v8::Private> private_key = v8::Private::ForApi(isolate, key);
-  v8::Local<v8::Value> value = mate::ConvertToV8(isolate, context_id);
-  context->Global()->SetPrivate(context, private_key, value);
+  SetHiddenValue(context, "contextId", mate::ConvertToV8(isolate, context_id));
+
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+  bool enableRemoteModule =
+      !command_line->HasSwitch(switches::kDisableRemoteModule);
+  SetHiddenValue(context, "enableRemoteModule",
+                 mate::ConvertToV8(isolate, enableRemoteModule));
 }
 
 void RendererClientBase::AddRenderBindings(
@@ -170,29 +187,36 @@ void RendererClientBase::RenderFrameCreated(
   new PepperHelper(render_frame);
 #endif
   new ContentSettingsObserver(render_frame);
-  new printing::PrintWebViewHelper(render_frame);
+#if BUILDFLAG(ENABLE_PRINTING)
+  new printing::PrintRenderFrameHelper(
+      render_frame, std::make_unique<atom::PrintRenderFrameHelperDelegate>());
+#endif
 
 #if BUILDFLAG(ENABLE_PDF_VIEWER)
   // Allow access to file scheme from pdf viewer.
   blink::WebSecurityPolicy::AddOriginAccessWhitelistEntry(
       GURL(kPdfViewerUIOrigin), "file", "", true);
 #endif  // BUILDFLAG(ENABLE_PDF_VIEWER)
+
+  content::RenderView* render_view = render_frame->GetRenderView();
+  if (render_frame->IsMainFrame() && render_view) {
+    blink::WebFrameWidget* web_frame_widget = render_view->GetWebFrameWidget();
+    if (web_frame_widget) {
+      base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
+      if (cmd->HasSwitch(switches::kGuestInstanceID)) {  // webview.
+        web_frame_widget->SetBaseBackgroundColor(SK_ColorTRANSPARENT);
+      } else {  // normal window.
+        std::string name = cmd->GetSwitchValueASCII(switches::kBackgroundColor);
+        SkColor color =
+            name.empty() ? SK_ColorTRANSPARENT : ParseHexColor(name);
+        web_frame_widget->SetBaseBackgroundColor(color);
+      }
+    }
+  }
 }
 
 void RendererClientBase::RenderViewCreated(content::RenderView* render_view) {
   new AtomRenderViewObserver(render_view);
-  blink::WebFrameWidget* web_frame_widget = render_view->GetWebFrameWidget();
-  if (!web_frame_widget)
-    return;
-
-  base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
-  if (cmd->HasSwitch(switches::kGuestInstanceID)) {  // webview.
-    web_frame_widget->SetBaseBackgroundColor(SK_ColorTRANSPARENT);
-  } else {  // normal window.
-    std::string name = cmd->GetSwitchValueASCII(switches::kBackgroundColor);
-    SkColor color = name.empty() ? SK_ColorTRANSPARENT : ParseHexColor(name);
-    web_frame_widget->SetBaseBackgroundColor(color);
-  }
 }
 
 void RendererClientBase::DidClearWindowObject(

atom/renderer/renderer_client_base.h

@@ -32,7 +32,8 @@ class RendererClientBase : public content::ContentRendererClient {
   virtual void WillReleaseScriptContext(v8::Handle<v8::Context> context,
                                         content::RenderFrame* render_frame) = 0;
   virtual void DidClearWindowObject(content::RenderFrame* render_frame);
-  virtual void SetupMainWorldOverrides(v8::Handle<v8::Context> context) = 0;
+  virtual void SetupMainWorldOverrides(v8::Handle<v8::Context> context,
+                                       content::RenderFrame* render_frame) = 0;
 
   bool isolated_world() const { return isolated_world_; }
 

atom/utility/atom_content_utility_client.cc

@@ -4,30 +4,82 @@
 
 #include "atom/utility/atom_content_utility_client.h"
 
+#include <string>
+#include <utility>
+
+#include "base/command_line.h"
 #include "content/public/child/child_thread.h"
+#include "content/public/common/service_manager_connection.h"
+#include "content/public/common/simple_connection_filter.h"
 #include "services/proxy_resolver/proxy_resolver_service.h"
 #include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
+#include "services/service_manager/sandbox/switches.h"
+
+#if BUILDFLAG(ENABLE_PRINTING)
+#include "chrome/services/printing/printing_service.h"
+#include "chrome/services/printing/public/mojom/constants.mojom.h"
+#include "components/services/pdf_compositor/public/cpp/pdf_compositor_service_factory.h"
+#include "components/services/pdf_compositor/public/interfaces/pdf_compositor.mojom.h"
 
 #if defined(OS_WIN)
-#include "chrome/utility/printing_handler_win.h"
-#endif
+#include "chrome/services/printing/pdf_to_emf_converter_factory.h"
+#include "chrome/utility/printing_handler.h"
+#endif  // defined(OS_WIN)
+
+#endif  // BUILDFLAG(ENABLE_PRINTING)
 
 namespace atom {
 
-AtomContentUtilityClient::AtomContentUtilityClient() {
-#if defined(OS_WIN)
-  handlers_.push_back(std::make_unique<printing::PrintingHandlerWin>());
+AtomContentUtilityClient::AtomContentUtilityClient() : elevated_(false) {
+#if BUILDFLAG(ENABLE_PRINTING) && defined(OS_WIN)
+  printing_handler_ = std::make_unique<printing::PrintingHandler>();
 #endif
 }
 
 AtomContentUtilityClient::~AtomContentUtilityClient() {}
 
-bool AtomContentUtilityClient::OnMessageReceived(const IPC::Message& message) {
+// The guts of this came from the chromium implementation
+// https://cs.chromium.org/chromium/src/chrome/utility/
+// chrome_content_utility_client.cc?sq=package:chromium&dr=CSs&g=0&l=142
+void AtomContentUtilityClient::UtilityThreadStarted() {
 #if defined(OS_WIN)
-  for (const auto& handler : handlers_) {
-    if (handler->OnMessageReceived(message))
-      return true;
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  elevated_ = command_line->HasSwitch(
+      service_manager::switches::kNoSandboxAndElevatedPrivileges);
+#endif
+
+  content::ServiceManagerConnection* connection =
+      content::ChildThread::Get()->GetServiceManagerConnection();
+
+  // NOTE: Some utility process instances are not connected to the Service
+  // Manager. Nothing left to do in that case.
+  if (!connection)
+    return;
+
+  auto registry = std::make_unique<service_manager::BinderRegistry>();
+  // If our process runs with elevated privileges, only add elevated Mojo
+  // interfaces to the interface registry.
+  if (!elevated_) {
+#if BUILDFLAG(ENABLE_PRINTING) && defined(OS_WIN)
+    // TODO(crbug.com/798782): remove when the Cloud print chrome/service is
+    // removed.
+    registry->AddInterface(
+        base::BindRepeating(printing::PdfToEmfConverterFactory::Create),
+        base::ThreadTaskRunnerHandle::Get());
+#endif
   }
+
+  connection->AddConnectionFilter(
+      std::make_unique<content::SimpleConnectionFilter>(std::move(registry)));
+}
+
+bool AtomContentUtilityClient::OnMessageReceived(const IPC::Message& message) {
+  if (elevated_)
+    return false;
+
+#if BUILDFLAG(ENABLE_PRINTING) && defined(OS_WIN)
+  if (printing_handler_->OnMessageReceived(message))
+    return true;
 #endif
 
   return false;
@@ -41,6 +93,18 @@ void AtomContentUtilityClient::RegisterServices(StaticServiceMap* services) {
       base::BindRepeating(&proxy_resolver::ProxyResolverService::CreateService);
   services->emplace(proxy_resolver::mojom::kProxyResolverServiceName,
                     proxy_resolver_info);
+
+#if BUILDFLAG(ENABLE_PRINTING)
+  service_manager::EmbeddedServiceInfo pdf_compositor_info;
+  pdf_compositor_info.factory =
+      base::BindRepeating(&printing::CreatePdfCompositorService, std::string());
+  services->emplace(printing::mojom::kServiceName, pdf_compositor_info);
+
+  service_manager::EmbeddedServiceInfo printing_info;
+  printing_info.factory =
+      base::BindRepeating(&printing::PrintingService::CreateService);
+  services->emplace(printing::mojom::kChromePrintingServiceName, printing_info);
+#endif
 }
 
 }  // namespace atom

atom/utility/atom_content_utility_client.h

@@ -10,8 +10,11 @@
 
 #include "base/compiler_specific.h"
 #include "content/public/utility/content_utility_client.h"
+#include "printing/buildflags/buildflags.h"
 
-class UtilityMessageHandler;
+#if BUILDFLAG(ENABLE_PRINTING) && defined(OS_WIN)
+#include "chrome/utility/printing_handler.h"
+#endif
 
 namespace atom {
 
@@ -20,15 +23,17 @@ class AtomContentUtilityClient : public content::ContentUtilityClient {
   AtomContentUtilityClient();
   ~AtomContentUtilityClient() override;
 
+  void UtilityThreadStarted() override;
   bool OnMessageReceived(const IPC::Message& message) override;
   void RegisterServices(StaticServiceMap* services) override;
 
  private:
-#if defined(OS_WIN)
-  typedef std::vector<std::unique_ptr<UtilityMessageHandler>> Handlers;
-  Handlers handlers_;
+#if BUILDFLAG(ENABLE_PRINTING) && defined(OS_WIN)
+  std::unique_ptr<printing::PrintingHandler> printing_handler_;
 #endif
 
+  bool elevated_;
+
   DISALLOW_COPY_AND_ASSIGN(AtomContentUtilityClient);
 };
 

brightray/browser/inspectable_web_contents_impl.cc

@@ -514,8 +514,9 @@ void InspectableWebContentsImpl::ShowItemInFolder(
     const std::string& file_system_path) {
   if (file_system_path.empty())
     return;
+
   base::FilePath path = base::FilePath::FromUTF8Unsafe(file_system_path);
-  platform_util::ShowItemInFolder(path);
+  platform_util::OpenItem(path);
 }
 
 void InspectableWebContentsImpl::SaveToFile(const std::string& url,

build/args/all.gn

@@ -4,10 +4,13 @@ root_extra_deps = [ "//electron" ]
 
 v8_promise_internal_field_count = 1
 v8_typed_array_max_size_in_heap = 0
+v8_embedder_string = "-electron.0"
 
 enable_cdm_host_verification = false
 enable_extensions = false
 proprietary_codecs = true
 ffmpeg_branding = "Chrome"
 
+enable_basic_printing = true
+
 is_cfi = false

build/args/native_mksnapshot.gn

@@ -1,2 +0,0 @@
-import("release.gn")
-v8_enable_i18n_support = false

build/electron.def

@@ -0,0 +1,6 @@
+; This is to support renaming of electron.exe. node-gyp has hard-coded
+; executable names which it will recognise as node. This module definition
+; file claims that the electron executable is in fact named "node.exe",
+; which is one of the executable names that node-gyp recognizes.
+; See https://github.com/nodejs/node-gyp/commit/52ceec3a6d15de3a8f385f43dbe5ecf5456ad07a
+NAME node.exe

build/mac/make_locale_dirs.py

@@ -0,0 +1,27 @@
+# usage: make_locale_dirs.py locale_dir [...]
+#
+# This script is intended to create empty locale directories (.lproj) in a
+# Cocoa .app bundle. The presence of these empty directories is sufficient to
+# convince Cocoa that the application supports the named localization, even if
+# an InfoPlist.strings file is not provided. Chrome uses these empty locale
+# directoires for its helper executable bundles, which do not otherwise
+# require any direct Cocoa locale support.
+
+import os
+import sys
+
+
+def main(args):
+  for dirname in args:
+    try:
+      os.makedirs(dirname)
+    except OSError as e:
+      if e.errno == os.errno.EEXIST:
+        # It's OK if it already exists
+        pass
+      else:
+        raise
+
+
+if __name__ == '__main__':
+  main(sys.argv[1:])

build/zip.py

@@ -10,15 +10,26 @@ EXTENSIONS_TO_SKIP = [
 
 PATHS_TO_SKIP = [
   'angledata', #Skipping because it is an output of //ui/gl that we don't need
-  'swiftshader', #Skipping because it is an output of //ui/gl that we don't need
   './libVkLayer_', #Skipping because these are outputs that we don't need
   './VkLayerLayer_', #Skipping because these are outputs that we don't need
+
+  # //chrome/browser:resources depends on this via
+  # //chrome/browser/resources/ssl/ssl_error_assistant, but we don't need to
+  # ship it.
+  'pyproto',
 ]
 
-def skip_path(dep):
+def skip_path(dep, dist_zip, target_cpu):
+  # Skip specific paths and extensions as well as the following special case:
+  # snapshot_blob.bin is a dependency of mksnapshot.zip because
+  # v8_context_generator needs it, but this file does not get generated for arm
+  # and arm 64 binaries of mksnapshot since they are built on x64 hardware.
+  # Consumers of arm and arm64 mksnapshot can generate snapshot_blob.bin
+  # themselves by running mksnapshot.
   should_skip = (
     any(dep.startswith(path) for path in PATHS_TO_SKIP) or
-    any(dep.endswith(ext) for ext in EXTENSIONS_TO_SKIP))
+    any(dep.endswith(ext) for ext in EXTENSIONS_TO_SKIP) or
+    ('arm' in target_cpu and dist_zip == 'mksnapshot.zip' and dep == 'snapshot_blob.bin'))
   if should_skip:
     print("Skipping {}".format(dep))
   return should_skip
@@ -43,7 +54,7 @@ def main(argv):
   else:
     with zipfile.ZipFile(dist_zip, 'w', zipfile.ZIP_DEFLATED) as z:
       for dep in dist_files:
-        if skip_path(dep):
+        if skip_path(dep, dist_zip, target_cpu):
           continue
         if os.path.isdir(dep):
           for root, dirs, files in os.walk(dep):

buildflags/buildflags.gni

@@ -8,7 +8,7 @@ declare_args() {
   # Allow running Electron as a node binary.
   enable_run_as_node = true
 
-  enable_osr = false
+  enable_osr = true
 
   enable_view_api = false
 

chromium_src/BUILD.gn

@@ -3,12 +3,16 @@
 # found in the LICENSE file.
 
 import("//electron/buildflags/buildflags.gni")
+import("//printing/buildflags/buildflags.gni")
+import("//third_party/widevine/cdm/widevine.gni")
 
 # Builds some of the chrome sources that Electron depends
 # on unconditionally.
 source_set("chrome") {
   visibility = [ "//electron:electron_lib" ]
   sources = [
+    "//chrome/browser/browser_process.cc",
+    "//chrome/browser/browser_process.h",
     "//chrome/browser/icon_loader.cc",
     "//chrome/browser/icon_loader.h",
     "//chrome/browser/icon_loader_mac.mm",
@@ -36,7 +40,7 @@ source_set("chrome") {
     "//content/public/browser",
   ]
   deps = [
-    "//chrome/common:constants",
+    "//chrome/common",
     "//components/proxy_config",
     "//components/security_state/content",
   ]
@@ -56,4 +60,43 @@ source_set("chrome") {
     ]
     deps += [ "//ui/snapshot" ]
   }
+
+  if (enable_basic_printing) {
+    sources += [
+      "//chrome/browser/printing/print_job.cc",
+      "//chrome/browser/printing/print_job.h",
+      "//chrome/browser/printing/print_job_manager.cc",
+      "//chrome/browser/printing/print_job_manager.h",
+      "//chrome/browser/printing/print_job_worker.cc",
+      "//chrome/browser/printing/print_job_worker.h",
+      "//chrome/browser/printing/print_view_manager_base.cc",
+      "//chrome/browser/printing/print_view_manager_base.h",
+      "//chrome/browser/printing/print_view_manager_basic.cc",
+      "//chrome/browser/printing/print_view_manager_basic.h",
+      "//chrome/browser/printing/printer_query.cc",
+      "//chrome/browser/printing/printer_query.h",
+      "//chrome/browser/printing/printing_message_filter.cc",
+      "//chrome/browser/printing/printing_message_filter.h",
+    ]
+    deps += [
+      "//chrome/services/printing:lib",
+      "//components/keyed_service/content",
+      "//components/printing/browser",
+      "//components/printing/common",
+      "//components/printing/renderer",
+      "//components/services/pdf_compositor",
+      "//components/services/pdf_compositor/public/cpp:factory",
+      "//components/services/pdf_compositor/public/interfaces",
+      "//printing",
+    ]
+
+    if (is_win) {
+      sources += [
+        "//chrome/browser/printing/pdf_to_emf_converter.cc",
+        "//chrome/browser/printing/pdf_to_emf_converter.h",
+        "//chrome/utility/printing_handler.cc",
+        "//chrome/utility/printing_handler.h",
+      ]
+    }
+  }
 }

chromium_src/chrome/browser/browser_process.cc

@@ -1,31 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chrome/browser/browser_process.h"
-
-#include "chrome/browser/printing/print_job_manager.h"
-#include "ui/base/l10n/l10n_util.h"
-
-BrowserProcess* g_browser_process = NULL;
-
-BrowserProcess::BrowserProcess()
-    : print_job_manager_(new printing::PrintJobManager) {
-  g_browser_process = this;
-}
-
-BrowserProcess::~BrowserProcess() {
-  g_browser_process = NULL;
-}
-
-void BrowserProcess::SetApplicationLocale(const std::string& locale) {
-  locale_ = locale;
-}
-
-std::string BrowserProcess::GetApplicationLocale() {
-  return locale_;
-}
-
-printing::PrintJobManager* BrowserProcess::print_job_manager() {
-  return print_job_manager_.get();
-}