Bump v4.2.1

* fix: default enable_negotiate_port to false (#18251)

* chore: command_line is not a pointer

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

@@ -10,9 +10,9 @@ gclient_gn_args = [
 
 vars = {
   'chromium_version':
-    '69.0.3497.106',
+    '69.0.3497.128',
   'node_version':
-    '5654c276d0497ff9a0bb0d7550b9073b2e2e7d3f',
+    '8bc5d171a0873c0ba49f9433798bc8b67399788c',
 
   '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',
     ],
   },
   {
@@ -83,8 +99,6 @@ hooks = [
     'action': [
       'python',
       'src/electron/script/update-external-binaries.py',
-      '--root-url=http://github.com/electron/electron-frameworks/releases/download',
-      '--version=v1.4.0',
     ],
   },
   {
@@ -93,7 +107,7 @@ hooks = [
     'action': [
       'python',
       '-c',
-      'import os; os.chdir("src"); os.chdir("electron"); os.system("npm install")',
+      'import os, subprocess; os.chdir(os.path.join("src", "electron")); subprocess.check_call(["python", "script/lib/npm.py", "install"]);',
     ],
   },
   {
@@ -103,7 +117,7 @@ hooks = [
     'action': [
       'python',
       '-c',
-      'import os; os.chdir("src"); os.chdir("electron"); os.chdir("vendor"); os.chdir("boto"); os.system("python setup.py build");',
+      'import os, subprocess; os.chdir(os.path.join("src", "electron", "vendor", "boto")); subprocess.check_call(["python", "setup.py", "build"]);',
     ],
   },
   {
@@ -113,9 +127,9 @@ hooks = [
     'action': [
       'python',
       '-c',
-      'import os; os.chdir("src"); os.chdir("electron"); os.chdir("vendor"); os.chdir("requests"); os.system("python setup.py build");',
+      'import os, subprocess; os.chdir(os.path.join("src", "electron", "vendor", "requests")); subprocess.check_call(["python", "setup.py", "build"]);',
     ],
-  }
+  },
 ]
 
 recursedeps = [

VERSION

@@ -1 +1 @@
-4.0.0-nightly.20181010
+4.2.1

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_content_client.cc

@@ -7,6 +7,7 @@
 #include <string>
 #include <vector>
 
+#include "atom/browser/browser.h"
 #include "atom/common/atom_version.h"
 #include "atom/common/chrome_version.h"
 #include "atom/common/options_switches.h"
@@ -14,8 +15,10 @@
 #include "base/files/file_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/common/content_constants.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "content/public/common/user_agent.h"
 #include "electron/buildflags/buildflags.h"
@@ -173,6 +176,27 @@ void ConvertStringWithSeparatorToVector(std::vector<std::string>* vec,
                              base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
 }
 
+std::string RemoveWhitespace(const std::string& str) {
+  std::string trimmed;
+  if (base::RemoveChars(str, " ", &trimmed))
+    return trimmed;
+  else
+    return str;
+}
+
+bool IsBrowserProcess() {
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  std::string process_type =
+      command_line->GetSwitchValueASCII(::switches::kProcessType);
+  return process_type.empty();
+}
+
+std::string BuildDefaultUserAgent() {
+  return "Chrome/" CHROME_VERSION_STRING " " ATOM_PRODUCT_NAME
+         "/" ATOM_VERSION_STRING;
+}
+
 }  // namespace
 
 AtomContentClient::AtomContentClient() {}
@@ -184,9 +208,35 @@ std::string AtomContentClient::GetProduct() const {
 }
 
 std::string AtomContentClient::GetUserAgent() const {
-  return content::BuildUserAgentFromProduct("Chrome/" CHROME_VERSION_STRING
-                                            " " ATOM_PRODUCT_NAME
-                                            "/" ATOM_VERSION_STRING);
+  if (IsBrowserProcess()) {
+    if (user_agent_override_.empty()) {
+      auto* browser = Browser::Get();
+      std::string name = RemoveWhitespace(browser->GetName());
+      std::string user_agent;
+      if (name == ATOM_PRODUCT_NAME) {
+        user_agent = BuildDefaultUserAgent();
+      } else {
+        user_agent = base::StringPrintf(
+            "%s/%s Chrome/%s " ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING,
+            name.c_str(), browser->GetVersion().c_str(), CHROME_VERSION_STRING);
+      }
+      return content::BuildUserAgentFromProduct(user_agent);
+    }
+    return user_agent_override_;
+  }
+  // In a renderer process the user agent should be provided on the CLI
+  // If it's not we just fallback to the default one, this should never happen
+  // but we want to handle it gracefully
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  std::string cli_user_agent = command_line->GetSwitchValueASCII("user-agent");
+  if (cli_user_agent.empty())
+    return BuildDefaultUserAgent();
+  return cli_user_agent;
+}
+
+void AtomContentClient::SetUserAgent(const std::string& user_agent) {
+  user_agent_override_ = user_agent;
 }
 
 base::string16 AtomContentClient::GetLocalizedString(int message_id) const {

atom/app/atom_content_client.h

@@ -18,10 +18,12 @@ class AtomContentClient : public brightray::ContentClient {
   AtomContentClient();
   ~AtomContentClient() override;
 
+  std::string GetUserAgent() const override;
+  void SetUserAgent(const std::string& user_agent);
+
  protected:
   // content::ContentClient:
   std::string GetProduct() const override;
-  std::string GetUserAgent() const override;
   base::string16 GetLocalizedString(int message_id) const override;
   void AddAdditionalSchemes(Schemes* schemes) override;
   void AddPepperPlugins(
@@ -31,6 +33,8 @@ class AtomContentClient : public brightray::ContentClient {
       std::vector<media::CdmHostFilePath>* cdm_host_file_paths) override;
 
  private:
+  std::string user_agent_override_ = "";
+
   DISALLOW_COPY_AND_ASSIGN(AtomContentClient);
 };
 

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)
 
@@ -43,7 +47,7 @@ namespace {
 const char kRunAsNode[] = "ELECTRON_RUN_AS_NODE";
 #endif
 
-bool IsEnvSet(const char* name) {
+ALLOW_UNUSED_TYPE bool IsEnvSet(const char* name) {
 #if defined(OS_WIN)
   size_t required_size;
   getenv_s(&required_size, nullptr, 0, name);
@@ -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

@@ -7,6 +7,7 @@
 #include <string>
 #include <vector>
 
+#include "atom/app/atom_content_client.h"
 #include "atom/browser/api/atom_api_menu.h"
 #include "atom/browser/api/atom_api_session.h"
 #include "atom/browser/api/atom_api_web_contents.h"
@@ -23,7 +24,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"
@@ -44,6 +44,7 @@
 #include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/render_frame_host.h"
+#include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "media/audio/audio_manager.h"
 #include "native_mate/object_template_builder.h"
@@ -54,6 +55,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"
@@ -976,7 +983,14 @@ bool App::IsAccessibilitySupportEnabled() {
   return ax_state->IsAccessibleBrowser();
 }
 
-void App::SetAccessibilitySupportEnabled(bool enabled) {
+void App::SetAccessibilitySupportEnabled(bool enabled, mate::Arguments* args) {
+  if (!Browser::Get()->is_ready()) {
+    args->ThrowError(
+        "app.setAccessibilitySupportEnabled() can only be called "
+        "after app is ready");
+    return;
+  }
+
   auto* ax_state = content::BrowserAccessibilityState::GetInstance();
   if (enabled) {
     ax_state->OnScreenReaderDetected();
@@ -1173,7 +1187,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);
@@ -1224,6 +1238,18 @@ void App::EnableMixedSandbox(mate::Arguments* args) {
   command_line->AppendSwitch(switches::kEnableMixedSandbox);
 }
 
+void App::SetUserAgentFallback(const std::string& user_agent) {
+  AtomContentClient* client =
+      static_cast<AtomContentClient*>(content::GetContentClient());
+  client->SetUserAgent(user_agent);
+}
+
+std::string App::GetUserAgentFallback() {
+  AtomContentClient* client =
+      static_cast<AtomContentClient*>(content::GetContentClient());
+  return client->GetUserAgent();
+}
+
 #if defined(OS_MACOSX)
 bool App::MoveToApplicationsFolder(mate::Arguments* args) {
   return ui::cocoa::AtomBundleMover::Move(args);
@@ -1284,6 +1310,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))
@@ -1328,6 +1356,8 @@ void App::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("startAccessingSecurityScopedResource",
                  &App::StartAccessingSecurityScopedResource)
 #endif
+      .SetProperty("userAgentFallback", &App::GetUserAgentFallback,
+                   &App::SetUserAgentFallback)
       .SetMethod("enableSandbox", &App::EnableSandbox)
       .SetMethod("enableMixedSandbox", &App::EnableMixedSandbox);
 }

atom/browser/api/atom_api_app.h

@@ -191,7 +191,7 @@ class App : public AtomBrowserClient::Delegate,
   void DisableHardwareAcceleration(mate::Arguments* args);
   void DisableDomainBlockingFor3DAPIs(mate::Arguments* args);
   bool IsAccessibilitySupportEnabled();
-  void SetAccessibilitySupportEnabled(bool enabled);
+  void SetAccessibilitySupportEnabled(bool enabled, mate::Arguments* args);
   Browser::LoginItemSettings GetLoginItemSettings(mate::Arguments* args);
 #if defined(USE_NSS_CERTS)
   void ImportCertificate(const base::DictionaryValue& options,
@@ -205,6 +205,8 @@ class App : public AtomBrowserClient::Delegate,
                                     const std::string& info_type);
   void EnableSandbox(mate::Arguments* args);
   void EnableMixedSandbox(mate::Arguments* args);
+  void SetUserAgentFallback(const std::string& user_agent);
+  std::string GetUserAgentFallback();
 
 #if defined(OS_MACOSX)
   bool MoveToApplicationsFolder(mate::Arguments* args);

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

@@ -185,7 +185,14 @@ bool BrowserWindow::OnMessageReceived(const IPC::Message& message,
 }
 
 void BrowserWindow::OnCloseContents() {
-  DCHECK(web_contents());
+  // On some machines it may happen that the window gets destroyed for twice,
+  // checking web_contents() can effectively guard against that.
+  // https://github.com/electron/electron/issues/16202.
+  //
+  // TODO(zcbenz): We should find out the root cause and improve the closing
+  // procedure of BrowserWindow.
+  if (!web_contents())
+    return;
 
   // Close all child windows before closing current window.
   v8::Locker locker(isolate());
@@ -385,7 +392,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_content_tracing.cc

@@ -7,6 +7,7 @@
 
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "content/public/browser/tracing_controller.h"
@@ -23,15 +24,27 @@ struct Converter<base::trace_event::TraceConfig> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
                      base::trace_event::TraceConfig* out) {
+    // (alexeykuzmin): A combination of "categoryFilter" and "traceOptions"
+    // has to be checked first because none of the fields
+    // in the `memory_dump_config` dict below are mandatory
+    // and we cannot check the config format.
     Dictionary options;
-    if (!ConvertFromV8(isolate, val, &options))
-      return false;
-    std::string category_filter, trace_options;
-    if (!options.Get("categoryFilter", &category_filter) ||
-        !options.Get("traceOptions", &trace_options))
-      return false;
-    *out = base::trace_event::TraceConfig(category_filter, trace_options);
-    return true;
+    if (ConvertFromV8(isolate, val, &options)) {
+      std::string category_filter, trace_options;
+      if (options.Get("categoryFilter", &category_filter) &&
+          options.Get("traceOptions", &trace_options)) {
+        *out = base::trace_event::TraceConfig(category_filter, trace_options);
+        return true;
+      }
+    }
+
+    base::DictionaryValue memory_dump_config;
+    if (ConvertFromV8(isolate, val, &memory_dump_config)) {
+      *out = base::trace_event::TraceConfig(memory_dump_config);
+      return true;
+    }
+
+    return false;
   }
 };
 

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_global_shortcut.cc

@@ -6,15 +6,44 @@
 
 #include <string>
 
+#include "atom/browser/api/atom_api_system_preferences.h"
 #include "atom/common/native_mate_converters/accelerator_converter.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "base/stl_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "native_mate/dictionary.h"
 
 #include "atom/common/node_includes.h"
 
+#if defined(OS_MACOSX)
+#include "base/mac/mac_util.h"
+#endif
+
 using extensions::GlobalShortcutListener;
 
+namespace {
+
+#if defined(OS_MACOSX)
+bool RegisteringMediaKeyForUntrustedClient(const ui::Accelerator& accelerator) {
+  if (base::mac::IsAtLeastOS10_14()) {
+    constexpr ui::KeyboardCode mediaKeys[] = {
+        ui::VKEY_MEDIA_PLAY_PAUSE, ui::VKEY_MEDIA_NEXT_TRACK,
+        ui::VKEY_MEDIA_PREV_TRACK, ui::VKEY_MEDIA_STOP};
+
+    if (std::find(std::begin(mediaKeys), std::end(mediaKeys),
+                  accelerator.key_code()) != std::end(mediaKeys)) {
+      bool trusted =
+          atom::api::SystemPreferences::IsTrustedAccessibilityClient(false);
+      if (!trusted)
+        return true;
+    }
+  }
+  return false;
+}
+#endif
+
+}  // namespace
+
 namespace atom {
 
 namespace api {
@@ -31,7 +60,7 @@ void GlobalShortcut::OnKeyPressed(const ui::Accelerator& accelerator) {
   if (accelerator_callback_map_.find(accelerator) ==
       accelerator_callback_map_.end()) {
     // This should never occur, because if it does, GlobalGlobalShortcutListener
-    // notifes us with wrong accelerator.
+    // notifies us with wrong accelerator.
     NOTREACHED();
     return;
   }
@@ -40,6 +69,11 @@ void GlobalShortcut::OnKeyPressed(const ui::Accelerator& accelerator) {
 
 bool GlobalShortcut::Register(const ui::Accelerator& accelerator,
                               const base::Closure& callback) {
+#if defined(OS_MACOSX)
+  if (RegisteringMediaKeyForUntrustedClient(accelerator))
+    return false;
+#endif
+
   if (!GlobalShortcutListener::GetInstance()->RegisterAccelerator(accelerator,
                                                                   this)) {
     return false;

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,11 @@ void SystemPreferences::BuildPrototype(
                  &SystemPreferences::GetAppLevelAppearance)
       .SetMethod("setAppLevelAppearance",
                  &SystemPreferences::SetAppLevelAppearance)
+      .SetMethod("isTrustedAccessibilityClient",
+                 &SystemPreferences::IsTrustedAccessibilityClient)
+      .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,15 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
   void RemoveUserDefault(const std::string& name);
   bool IsSwipeTrackingFromScrollEventsEnabled();
 
+  static bool IsTrustedAccessibilityClient(bool prompt);
+
+  // TODO(codebytere): Write tests for these methods once we
+  // are running tests on a Mojave machine
+  std::string GetMediaAccessStatus(const std::string& media_type,
+                                   mate::Arguments* args);
+  v8::Local<v8::Promise> AskForMediaAccess(v8::Isolate* isolate,
+                                           const std::string& media_type);
+
   // 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,53 @@ void SystemPreferences::SetUserDefault(const std::string& name,
   }
 }
 
+// static
+bool SystemPreferences::IsTrustedAccessibilityClient(bool prompt) {
+  NSDictionary* options = @{(id)kAXTrustedCheckOptionPrompt : @(prompt)};
+  return AXIsProcessTrustedWithOptions((CFDictionaryRef)options);
+}
+
+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();
 }
@@ -1157,6 +1184,9 @@ void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
   params.transition_type = ui::PAGE_TRANSITION_TYPED;
   params.should_clear_history_list = true;
   params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
+  // Discord non-committed entries to ensure that we don't re-use a pending
+  // entry
+  web_contents()->GetController().DiscardNonCommittedEntries();
   web_contents()->GetController().LoadURLWithParams(params);
 
   // Set the background color of RenderWidgetHostView.
@@ -1422,40 +1452,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 = false, 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 +1941,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 +2048,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 +2080,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 +2092,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 +2121,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/api/stream_subscriber.cc

@@ -17,12 +17,15 @@ namespace mate {
 StreamSubscriber::StreamSubscriber(
     v8::Isolate* isolate,
     v8::Local<v8::Object> emitter,
-    base::WeakPtr<atom::URLRequestStreamJob> url_job)
-    : isolate_(isolate),
+    base::WeakPtr<atom::URLRequestStreamJob> url_job,
+    scoped_refptr<base::SequencedTaskRunner> ui_task_runner)
+    : base::RefCountedDeleteOnSequence<StreamSubscriber>(ui_task_runner),
+      isolate_(isolate),
       emitter_(isolate, emitter),
       url_job_(url_job),
       weak_factory_(this) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(ui_task_runner->RunsTasksInCurrentSequence());
+
   auto weak_self = weak_factory_.GetWeakPtr();
   On("data", base::Bind(&StreamSubscriber::OnData, weak_self));
   On("end", base::Bind(&StreamSubscriber::OnEnd, weak_self));
@@ -30,13 +33,12 @@ StreamSubscriber::StreamSubscriber(
 }
 
 StreamSubscriber::~StreamSubscriber() {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   RemoveAllListeners();
 }
 
 void StreamSubscriber::On(const std::string& event,
                           EventCallback&& callback) {  // NOLINT
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(owning_task_runner()->RunsTasksInCurrentSequence());
   DCHECK(js_handlers_.find(event) == js_handlers_.end());
 
   v8::Locker locker(isolate_);
@@ -50,7 +52,7 @@ void StreamSubscriber::On(const std::string& event,
 }
 
 void StreamSubscriber::Off(const std::string& event) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(owning_task_runner()->RunsTasksInCurrentSequence());
   DCHECK(js_handlers_.find(event) != js_handlers_.end());
 
   v8::Locker locker(isolate_);
@@ -96,6 +98,7 @@ void StreamSubscriber::OnError(mate::Arguments* args) {
 }
 
 void StreamSubscriber::RemoveAllListeners() {
+  DCHECK(owning_task_runner()->RunsTasksInCurrentSequence());
   v8::Locker locker(isolate_);
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);

atom/browser/api/stream_subscriber.h

@@ -11,6 +11,8 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/ref_counted_delete_on_sequence.h"
 #include "base/memory/weak_ptr.h"
 #include "content/public/browser/browser_thread.h"
 #include "v8/include/v8.h"
@@ -23,17 +25,25 @@ namespace mate {
 
 class Arguments;
 
-class StreamSubscriber {
+class StreamSubscriber
+    : public base::RefCountedDeleteOnSequence<StreamSubscriber> {
  public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
   StreamSubscriber(v8::Isolate* isolate,
                    v8::Local<v8::Object> emitter,
-                   base::WeakPtr<atom::URLRequestStreamJob> url_job);
-  ~StreamSubscriber();
+                   base::WeakPtr<atom::URLRequestStreamJob> url_job,
+                   scoped_refptr<base::SequencedTaskRunner> ui_task_runner);
 
  private:
+  friend class base::DeleteHelper<StreamSubscriber>;
+  friend class base::RefCountedDeleteOnSequence<StreamSubscriber>;
+
   using JSHandlersMap = std::map<std::string, v8::Global<v8::Value>>;
   using EventCallback = base::Callback<void(mate::Arguments* args)>;
 
+  ~StreamSubscriber();
+
   void On(const std::string& event, EventCallback&& callback);  // NOLINT
   void Off(const std::string& event);
 

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,16 @@
 #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)
+
+#if BUILDFLAG(ENABLE_TTS)
+#include "chrome/browser/speech/tts_message_filter.h"
+#endif  // BUILDFLAG(ENABLE_TTS)
+
 using content::BrowserThread;
 
 namespace atom {
@@ -172,28 +181,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 +221,14 @@ 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
+
+#if BUILDFLAG(ENABLE_TTS)
+  host->AddFilter(new TtsMessageFilter(host->GetBrowserContext()));
+#endif
 
   ProcessPreferences prefs;
   auto* web_preferences =
@@ -217,6 +238,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 +552,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 +689,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

@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "atom/app/atom_content_client.h"
 #include "atom/browser/atom_blob_reader.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_download_manager_delegate.h"
@@ -32,6 +33,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"
@@ -41,6 +43,7 @@
 #include "components/proxy_config/proxy_config_pref_names.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/public/browser/storage_partition.h"
+#include "content/public/common/content_client.h"
 #include "content/public/common/user_agent.h"
 #include "net/base/escape.h"
 
@@ -50,14 +53,6 @@ namespace atom {
 
 namespace {
 
-std::string RemoveWhitespace(const std::string& str) {
-  std::string trimmed;
-  if (base::RemoveChars(str, " ", &trimmed))
-    return trimmed;
-  else
-    return str;
-}
-
 // Convert string to lower case and escape it.
 std::string MakePartitionName(const std::string& input) {
   return net::EscapePath(base::ToLowerASCII(input));
@@ -77,19 +72,9 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition,
       storage_policy_(new SpecialStoragePolicy),
       in_memory_(in_memory),
       weak_factory_(this) {
-  // Construct user agent string.
-  Browser* browser = Browser::Get();
-  std::string name = RemoveWhitespace(browser->GetName());
-  std::string user_agent;
-  if (name == ATOM_PRODUCT_NAME) {
-    user_agent = "Chrome/" CHROME_VERSION_STRING " " ATOM_PRODUCT_NAME
-                 "/" ATOM_VERSION_STRING;
-  } else {
-    user_agent = base::StringPrintf(
-        "%s/%s Chrome/%s " ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING,
-        name.c_str(), browser->GetVersion().c_str(), CHROME_VERSION_STRING);
-  }
-  user_agent_ = content::BuildUserAgentFromProduct(user_agent);
+  AtomContentClient* client =
+      static_cast<AtomContentClient*>(content::GetContentClient());
+  user_agent_ = client->GetUserAgent();
 
   // Read options.
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
@@ -119,6 +104,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 +113,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/atom_download_manager_delegate.cc

@@ -88,19 +88,53 @@ void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
   if (relay)
     window = relay->GetNativeWindow();
 
-  auto* web_preferences = WebContentsPreferences::From(web_contents);
-  bool offscreen =
-      !web_preferences || web_preferences->IsEnabled(options::kOffscreen);
-
+  // Show save dialog if save path was not set already on item
   base::FilePath path;
   GetItemSavePath(item, &path);
-  // Show save dialog if save path was not set already on item
-  file_dialog::DialogSettings settings;
-  settings.parent_window = window;
-  settings.force_detached = offscreen;
-  settings.title = item->GetURL().spec();
-  settings.default_path = default_path;
-  if (path.empty() && file_dialog::ShowSaveDialog(settings, &path)) {
+  if (path.empty()) {
+    file_dialog::DialogSettings settings;
+    settings.parent_window = window;
+    settings.title = item->GetURL().spec();
+    settings.default_path = default_path;
+
+    auto* web_preferences = WebContentsPreferences::From(web_contents);
+    const bool offscreen =
+        !web_preferences || web_preferences->IsEnabled(options::kOffscreen);
+    settings.force_detached = offscreen;
+
+    auto dialog_callback =
+        base::Bind(&AtomDownloadManagerDelegate::OnDownloadSaveDialogDone,
+                   base::Unretained(this), download_id, callback);
+    file_dialog::ShowSaveDialog(settings, dialog_callback);
+  } else {
+    callback.Run(path, download::DownloadItem::TARGET_DISPOSITION_PROMPT,
+                 download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, path,
+                 download::DOWNLOAD_INTERRUPT_REASON_NONE);
+  }
+}
+
+#if defined(MAS_BUILD)
+void AtomDownloadManagerDelegate::OnDownloadSaveDialogDone(
+    uint32_t download_id,
+    const content::DownloadTargetCallback& download_callback,
+    bool result,
+    const base::FilePath& path,
+    const std::string& bookmark)
+#else
+void AtomDownloadManagerDelegate::OnDownloadSaveDialogDone(
+    uint32_t download_id,
+    const content::DownloadTargetCallback& download_callback,
+    bool result,
+    const base::FilePath& path)
+#endif
+{
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  auto* item = download_manager_->GetDownload(download_id);
+  if (!item)
+    return;
+
+  if (result) {
     // Remember the last selected download directory.
     AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
         download_manager_->GetBrowserContext());
@@ -117,12 +151,16 @@ void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
   }
 
   // Running the DownloadTargetCallback with an empty FilePath signals that the
-  // download should be cancelled.
-  // If user cancels the file save dialog, run the callback with empty FilePath.
-  callback.Run(path, download::DownloadItem::TARGET_DISPOSITION_PROMPT,
-               download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, path,
-               path.empty() ? download::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED
-                            : download::DOWNLOAD_INTERRUPT_REASON_NONE);
+  // download should be cancelled. If user cancels the file save dialog, run
+  // the callback with empty FilePath.
+  const base::FilePath download_path = result ? path : base::FilePath();
+  const auto interrupt_reason =
+      download_path.empty() ? download::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED
+                            : download::DOWNLOAD_INTERRUPT_REASON_NONE;
+  download_callback.Run(download_path,
+                        download::DownloadItem::TARGET_DISPOSITION_PROMPT,
+                        download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+                        download_path, interrupt_reason);
 }
 
 void AtomDownloadManagerDelegate::Shutdown() {

atom/browser/atom_download_manager_delegate.h

@@ -24,10 +24,6 @@ class AtomDownloadManagerDelegate : public content::DownloadManagerDelegate {
   explicit AtomDownloadManagerDelegate(content::DownloadManager* manager);
   ~AtomDownloadManagerDelegate() override;
 
-  void OnDownloadPathGenerated(uint32_t download_id,
-                               const content::DownloadTargetCallback& callback,
-                               const base::FilePath& default_path);
-
   // content::DownloadManagerDelegate:
   void Shutdown() override;
   bool DetermineDownloadTarget(
@@ -42,6 +38,25 @@ class AtomDownloadManagerDelegate : public content::DownloadManagerDelegate {
   // Get the save path set on the associated api::DownloadItem object
   void GetItemSavePath(download::DownloadItem* item, base::FilePath* path);
 
+  void OnDownloadPathGenerated(uint32_t download_id,
+                               const content::DownloadTargetCallback& callback,
+                               const base::FilePath& default_path);
+
+#if defined(MAS_BUILD)
+  void OnDownloadSaveDialogDone(
+      uint32_t download_id,
+      const content::DownloadTargetCallback& download_callback,
+      bool result,
+      const base::FilePath& path,
+      const std::string& bookmark);
+#else
+  void OnDownloadSaveDialogDone(
+      uint32_t download_id,
+      const content::DownloadTargetCallback& download_callback,
+      bool result,
+      const base::FilePath& path);
+#endif
+
   content::DownloadManager* download_manager_;
   base::WeakPtrFactory<AtomDownloadManagerDelegate> weak_ptr_factory_;
 

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,13 +178,16 @@ 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);
   offscreen_ =
-      !web_preferences || web_preferences->IsEnabled(options::kOffscreen);
+      web_preferences && web_preferences->IsEnabled(options::kOffscreen);
 
   // Create InspectableWebContents.
   web_contents_.reset(brightray::InspectableWebContents::Create(
@@ -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/io_thread.cc

@@ -48,6 +48,8 @@ network::mojom::HttpAuthDynamicParamsPtr CreateHttpAuthDynamicParams(
       command_line.GetSwitchValueASCII(switches::kAuthServerWhitelist);
   auth_dynamic_params->delegate_whitelist = command_line.GetSwitchValueASCII(
       switches::kAuthNegotiateDelegateWhitelist);
+  auth_dynamic_params->enable_negotiate_port =
+      command_line.HasSwitch(atom::switches::kEnableAuthNegotiatePort);
 
   return auth_dynamic_params;
 }

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];
 }
 
@@ -576,7 +585,12 @@ void NativeWindowMac::Hide() {
 }
 
 bool NativeWindowMac::IsVisible() {
-  return [window_ isVisible];
+  bool occluded = [window_ occlusionState] == NSWindowOcclusionStateVisible;
+
+  // For a window to be visible, it must be visible to the user in the
+  // foreground of the app, which means that it should not be minimized or
+  // occluded
+  return [window_ isVisible] && !occluded && !IsMinimized();
 }
 
 bool NativeWindowMac::IsEnabled() {
@@ -585,13 +599,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,21 +1115,31 @@ 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];
 
+  // Sometimes macOS would install a default contentView for dock, we must
+  // verify whether NSProgressIndicator has been installed.
+  bool first_time = !dock_tile.contentView ||
+                    [[dock_tile.contentView subviews] count] == 0 ||
+                    ![[[dock_tile.contentView subviews] lastObject]
+                        isKindOfClass:[NSProgressIndicator class]];
+
   // For the first time API invoked, we need to create a ContentView in
   // DockTile.
-  if (dock_tile.contentView == nullptr) {
-    NSImageView* image_view = [[NSImageView alloc] init];
+  if (first_time) {
+    NSImageView* image_view = [[[NSImageView alloc] init] autorelease];
     [image_view setImage:[NSApp applicationIconImage]];
     [dock_tile setContentView:image_view];
-  }
 
-  if ([[dock_tile.contentView subviews] count] == 0) {
-    NSProgressIndicator* progress_indicator = [[AtomProgressBar alloc]
-        initWithFrame:NSMakeRect(0.0f, 0.0f, dock_tile.size.width, 15.0)];
+    NSRect frame = NSMakeRect(0.0f, 0.0f, dock_tile.size.width, 15.0);
+    NSProgressIndicator* progress_indicator =
+        [[[AtomProgressBar alloc] initWithFrame:frame] autorelease];
     [progress_indicator setStyle:NSProgressIndicatorBarStyle];
     [progress_indicator setIndeterminate:NO];
     [progress_indicator setBezeled:YES];
@@ -1126,7 +1150,7 @@ void NativeWindowMac::SetProgressBar(double progress,
   }
 
   NSProgressIndicator* progress_indicator = static_cast<NSProgressIndicator*>(
-      [[[dock_tile contentView] subviews] objectAtIndex:0]);
+      [[[dock_tile contentView] subviews] lastObject]);
   if (progress < 0) {
     [progress_indicator setHidden:YES];
   } else if (progress > 1) {
@@ -1394,6 +1418,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,10 +345,13 @@ 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());
 
+  // explicitly focus the window
+  widget()->Activate();
+
   NotifyWindowShow();
 
 #if defined(USE_X11)
@@ -369,7 +373,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 +397,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 +903,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 +1060,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 +1191,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

@@ -13,14 +13,16 @@
 #include "atom/common/api/event_emitter_caller.h"
 #include "atom/common/atom_constants.h"
 #include "atom/common/native_mate_converters/net_converter.h"
-#include "atom/common/node_includes.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "native_mate/dictionary.h"
 #include "net/base/net_errors.h"
 #include "net/filter/gzip_source_stream.h"
 
+#include "atom/common/node_includes.h"
+
 namespace atom {
 
 namespace {
@@ -82,14 +84,14 @@ void BeforeStartInUI(base::WeakPtr<URLRequestStreamJob> job,
     return;
   }
 
-  auto subscriber = std::make_unique<mate::StreamSubscriber>(
-      args->isolate(), data.GetHandle(), job);
+  auto subscriber = base::MakeRefCounted<mate::StreamSubscriber>(
+      args->isolate(), data.GetHandle(), job,
+      base::ThreadTaskRunnerHandle::Get());
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&URLRequestStreamJob::StartAsync, job,
-                     std::move(subscriber), base::RetainedRef(response_headers),
-                     ended, error));
+      base::BindOnce(&URLRequestStreamJob::StartAsync, job, subscriber,
+                     base::RetainedRef(response_headers), ended, error));
 }
 
 }  // namespace
@@ -104,10 +106,7 @@ URLRequestStreamJob::URLRequestStreamJob(net::URLRequest* request,
       weak_factory_(this) {}
 
 URLRequestStreamJob::~URLRequestStreamJob() {
-  if (subscriber_) {
-    content::BrowserThread::DeleteSoon(content::BrowserThread::UI, FROM_HERE,
-                                       std::move(subscriber_));
-  }
+  DCHECK(!subscriber_ || subscriber_->HasOneRef());
 }
 
 void URLRequestStreamJob::Start() {
@@ -121,7 +120,7 @@ void URLRequestStreamJob::Start() {
 }
 
 void URLRequestStreamJob::StartAsync(
-    std::unique_ptr<mate::StreamSubscriber> subscriber,
+    scoped_refptr<mate::StreamSubscriber> subscriber,
     scoped_refptr<net::HttpResponseHeaders> response_headers,
     bool ended,
     int error) {
@@ -133,12 +132,13 @@ void URLRequestStreamJob::StartAsync(
 
   ended_ = ended;
   response_headers_ = response_headers;
-  subscriber_ = std::move(subscriber);
+  subscriber_ = subscriber;
   request_start_time_ = base::TimeTicks::Now();
   NotifyHeadersComplete();
 }
 
 void URLRequestStreamJob::OnData(std::vector<char>&& buffer) {  // NOLINT
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (write_buffer_.empty()) {
     // Quick branch without copying.
     write_buffer_ = std::move(buffer);
@@ -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) {
@@ -169,7 +173,7 @@ void URLRequestStreamJob::OnError(int error) {
 int URLRequestStreamJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
   response_start_time_ = base::TimeTicks::Now();
 
-  if (ended_)
+  if (ended_ && write_buffer_.empty())
     return 0;
 
   // When write_buffer_ is empty, there is no data valable yet, we have to save
@@ -187,12 +191,13 @@ int URLRequestStreamJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
 }
 
 void URLRequestStreamJob::DoneReading() {
-  content::BrowserThread::DeleteSoon(content::BrowserThread::UI, FROM_HERE,
-                                     std::move(subscriber_));
   write_buffer_.clear();
 }
 
 void URLRequestStreamJob::DoneReadingRedirectResponse() {
+  if (subscriber_) {
+    subscriber_ = nullptr;
+  }
   DoneReading();
 }
 

atom/browser/net/url_request_stream_job.h

@@ -24,7 +24,7 @@ class URLRequestStreamJob : public JsAsker, public net::URLRequestJob {
                       net::NetworkDelegate* network_delegate);
   ~URLRequestStreamJob() override;
 
-  void StartAsync(std::unique_ptr<mate::StreamSubscriber> subscriber,
+  void StartAsync(scoped_refptr<mate::StreamSubscriber> subscriber,
                   scoped_refptr<net::HttpResponseHeaders> response_headers,
                   bool ended,
                   int error);
@@ -62,7 +62,7 @@ class URLRequestStreamJob : public JsAsker, public net::URLRequestJob {
   base::TimeTicks request_start_time_;
   base::TimeTicks response_start_time_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
-  std::unique_ptr<mate::StreamSubscriber> subscriber_;
+  scoped_refptr<mate::StreamSubscriber> subscriber_;
 
   base::WeakPtrFactory<URLRequestStreamJob> weak_factory_;
 

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

@@ -17,13 +17,13 @@
   <key>CFBundleIconFile</key>
   <string>electron.icns</string>
   <key>CFBundleVersion</key>
-  <string>4.0.0</string>
+  <string>4.2.1</string>
   <key>CFBundleShortVersionString</key>
-  <string>4.0.0</string>
+  <string>4.2.1</string>
   <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,2,1,0
+ PRODUCTVERSION 4,2,1,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -68,12 +68,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "GitHub, Inc."
             VALUE "FileDescription", "Electron"
-            VALUE "FileVersion", "4.0.0"
+            VALUE "FileVersion", "4.2.1"
             VALUE "InternalName", "electron.exe"
             VALUE "LegalCopyright", "Copyright (C) 2015 GitHub, Inc. All rights reserved."
             VALUE "OriginalFilename", "electron.exe"
             VALUE "ProductName", "Electron"
-            VALUE "ProductVersion", "4.0.0"
+            VALUE "ProductVersion", "4.2.1"
             VALUE "SquirrelAwareVersion", "1"
         END
     END

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

@@ -15,6 +15,7 @@
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "ui/events/cocoa/cocoa_event_utils.h"
 #include "ui/gfx/image/image.h"
+#include "ui/strings/grit/ui_strings.h"
 
 using content::BrowserThread;
 
@@ -56,6 +57,29 @@ Role kRolesMap[] = {
     {@selector(clearRecentDocuments:), "clearrecentdocuments"},
 };
 
+// Called when adding a submenu to the menu and checks if the submenu, via its
+// |model|, has visible child items.
+bool MenuHasVisibleItems(const atom::AtomMenuModel* model) {
+  int count = model->GetItemCount();
+  for (int index = 0; index < count; index++) {
+    if (model->IsVisibleAt(index))
+      return true;
+  }
+  return false;
+}
+
+// Called when an empty submenu is created. This inserts a menu item labeled
+// "(empty)" into the submenu. Matches Windows behavior.
+NSMenu* MakeEmptySubmenu() {
+  base::scoped_nsobject<NSMenu> submenu([[NSMenu alloc] initWithTitle:@""]);
+  NSString* empty_menu_title =
+      l10n_util::GetNSString(IDS_APP_MENU_EMPTY_SUBMENU);
+
+  [submenu addItemWithTitle:empty_menu_title action:NULL keyEquivalent:@""];
+  [[submenu itemAtIndex:0] setEnabled:NO];
+  return submenu.autorelease();
+}
+
 }  // namespace
 
 // Menu item is located for ease of removing it from the parent owner
@@ -208,13 +232,31 @@ 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 &&
+             model->IsVisibleAt(index)) {
+    // We need to specifically check that the submenu top-level item has been
+    // enabled as it's not validated by validateUserInterfaceItem
+    if (!model->IsEnabledAt(index))
+      [item setEnabled:NO];
+
     // Recursively build a submenu from the sub-model at this index.
     [item setTarget:nil];
     [item setAction:nil];
     atom::AtomMenuModel* submenuModel =
         static_cast<atom::AtomMenuModel*>(model->GetSubmenuModelAt(index));
-    NSMenu* submenu = [self menuFromModel:submenuModel];
+    NSMenu* submenu = MenuHasVisibleItems(submenuModel)
+                          ? [self menuFromModel:submenuModel]
+                          : MakeEmptySubmenu();
     [submenu setTitle:[item title]];
     [item setSubmenu:submenu];
 
@@ -223,8 +265,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/cocoa/atom_touch_bar.mm

@@ -623,9 +623,14 @@ static NSString* const ImageScrubberItemIdentifier = @"scrubber.image.item";
     segments[i].Get("enabled", &enabled);
     if (segments[i].Get("label", &label)) {
       [control setLabel:base::SysUTF8ToNSString(label) forSegment:i];
-    } else if (segments[i].Get("icon", &image)) {
+    } else {
+      [control setLabel:@"" forSegment:i];
+    }
+    if (segments[i].Get("icon", &image)) {
       [control setImage:image.AsNSImage() forSegment:i];
       [control setImageScaling:NSImageScaleProportionallyUpOrDown forSegment:i];
+    } else {
+      [control setImage:nil forSegment:i];
     }
     [control setEnabled:enabled forSegment:i];
   }

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/file_dialog_mac.mm

@@ -284,7 +284,7 @@ bool ShowOpenDialog(const DialogSettings& settings,
 
 void OpenDialogCompletion(int chosen,
                           NSOpenPanel* dialog,
-                          const DialogSettings& settings,
+                          bool security_scoped_bookmarks,
                           const OpenDialogCallback& callback) {
   if (chosen == NSFileHandlingPanelCancelButton) {
 #if defined(MAS_BUILD)
@@ -297,7 +297,7 @@ void OpenDialogCompletion(int chosen,
     std::vector<base::FilePath> paths;
 #if defined(MAS_BUILD)
     std::vector<std::string> bookmarks;
-    if (settings.security_scoped_bookmarks) {
+    if (security_scoped_bookmarks) {
       ReadDialogPathsWithBookmarks(dialog, &paths, &bookmarks);
     } else {
       ReadDialogPaths(dialog, &paths);
@@ -320,17 +320,21 @@ void ShowOpenDialog(const DialogSettings& settings,
   // Duplicate the callback object here since c is a reference and gcd would
   // only store the pointer, by duplication we can force gcd to store a copy.
   __block OpenDialogCallback callback = c;
+  // Capture the value of the security_scoped_bookmarks settings flag
+  // and pass it to the completion handler.
+  bool security_scoped_bookmarks = settings.security_scoped_bookmarks;
 
   if (!settings.parent_window || !settings.parent_window->GetNativeWindow() ||
       settings.force_detached) {
     [dialog beginWithCompletionHandler:^(NSInteger chosen) {
-      OpenDialogCompletion(chosen, dialog, settings, callback);
+      OpenDialogCompletion(chosen, dialog, security_scoped_bookmarks, callback);
     }];
   } else {
     NSWindow* window = settings.parent_window->GetNativeWindow();
     [dialog beginSheetModalForWindow:window
                    completionHandler:^(NSInteger chosen) {
-                     OpenDialogCompletion(chosen, dialog, settings, callback);
+                     OpenDialogCompletion(chosen, dialog,
+                                          security_scoped_bookmarks, callback);
                    }];
   }
 }
@@ -351,7 +355,7 @@ bool ShowSaveDialog(const DialogSettings& settings, base::FilePath* path) {
 
 void SaveDialogCompletion(int chosen,
                           NSSavePanel* dialog,
-                          const DialogSettings& settings,
+                          bool security_scoped_bookmarks,
                           const SaveDialogCallback& callback) {
   if (chosen == NSFileHandlingPanelCancelButton) {
 #if defined(MAS_BUILD)
@@ -363,7 +367,7 @@ void SaveDialogCompletion(int chosen,
     std::string path = base::SysNSStringToUTF8([[dialog URL] path]);
 #if defined(MAS_BUILD)
     std::string bookmark;
-    if (settings.security_scoped_bookmarks) {
+    if (security_scoped_bookmarks) {
       bookmark = GetBookmarkDataFromNSURL([dialog URL]);
     }
     callback.Run(true, base::FilePath(path), bookmark);
@@ -381,17 +385,19 @@ void ShowSaveDialog(const DialogSettings& settings,
   [dialog setCanSelectHiddenExtension:YES];
 
   __block SaveDialogCallback callback = c;
+  bool security_scoped_bookmarks = settings.security_scoped_bookmarks;
 
   if (!settings.parent_window || !settings.parent_window->GetNativeWindow() ||
       settings.force_detached) {
     [dialog beginWithCompletionHandler:^(NSInteger chosen) {
-      SaveDialogCompletion(chosen, dialog, settings, callback);
+      SaveDialogCompletion(chosen, dialog, security_scoped_bookmarks, callback);
     }];
   } else {
     NSWindow* window = settings.parent_window->GetNativeWindow();
     [dialog beginSheetModalForWindow:window
                    completionHandler:^(NSInteger chosen) {
-                     SaveDialogCompletion(chosen, dialog, settings, callback);
+                     SaveDialogCompletion(chosen, dialog,
+                                          security_scoped_bookmarks, callback);
                    }];
   }
 }

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/menu_bar.cc

@@ -5,7 +5,6 @@
 #include "atom/browser/ui/views/menu_bar.h"
 
 #include <memory>
-#include <string>
 
 #include "atom/browser/ui/views/menu_delegate.h"
 #include "atom/browser/ui/views/submenu_button.h"
@@ -129,13 +128,11 @@ void MenuBar::RefreshColorCache(const ui::NativeTheme* theme) {
     theme = ui::NativeTheme::GetInstanceForNativeUi();
   if (theme) {
 #if defined(USE_X11)
-    const std::string menubar_selector = "GtkMenuBar#menubar";
-    background_color_ = libgtkui::GetBgColor(menubar_selector);
-
-    enabled_color_ = theme->GetSystemColor(
-        ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor);
-    disabled_color_ = theme->GetSystemColor(
-        ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor);
+    background_color_ = libgtkui::GetBgColor("GtkMenuBar#menubar");
+    enabled_color_ = libgtkui::GetFgColor(
+        "GtkMenuBar#menubar GtkMenuItem#menuitem GtkLabel");
+    disabled_color_ = libgtkui::GetFgColor(
+        "GtkMenuBar#menubar GtkMenuItem#menuitem:disabled GtkLabel");
 #else
     background_color_ =
         theme->GetSystemColor(ui::NativeTheme::kColorId_MenuBackgroundColor);

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

@@ -20,6 +20,7 @@
 #include "cc/base/switches.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/web_preferences.h"
 #include "native_mate/dictionary.h"
@@ -98,6 +99,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 +181,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);
@@ -216,6 +230,9 @@ WebContentsPreferences* WebContentsPreferences::From(
 
 void WebContentsPreferences::AppendCommandLineSwitches(
     base::CommandLine* command_line) {
+  // Append UA Override
+  command_line->AppendSwitchASCII("user-agent",
+                                  content::GetContentClient()->GetUserAgent());
   // Check if plugins are enabled.
   if (IsEnabled(options::kPlugins))
     command_line->AppendSwitch(switches::kEnablePlugins);
@@ -267,6 +284,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 +418,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/atom_api_native_image.cc

@@ -81,49 +81,71 @@ float GetScaleFactorFromOptions(mate::Arguments* args) {
   return scale_factor;
 }
 
-bool AddImageSkiaRep(gfx::ImageSkia* image,
-                     const unsigned char* data,
-                     size_t size,
-                     int width,
-                     int height,
-                     double scale_factor) {
-  auto decoded = std::make_unique<SkBitmap>();
+bool AddImageSkiaRepFromPNG(gfx::ImageSkia* image,
+                            const unsigned char* data,
+                            size_t size,
+                            double scale_factor) {
+  SkBitmap bitmap;
+  if (!gfx::PNGCodec::Decode(data, size, &bitmap))
+    return false;
 
-  // Try PNG first.
-  if (!gfx::PNGCodec::Decode(data, size, decoded.get())) {
-    // Try JPEG.
-    decoded = gfx::JPEGCodec::Decode(data, size);
-    if (decoded) {
-      // `JPEGCodec::Decode()` doesn't tell `SkBitmap` instance it creates
-      // that all of its pixels are opaque, that's why the bitmap gets
-      // an alpha type `kPremul_SkAlphaType` instead of `kOpaque_SkAlphaType`.
-      // Let's fix it here.
-      // TODO(alexeykuzmin): This workaround should be removed
-      // when the `JPEGCodec::Decode()` code is fixed.
-      // See https://github.com/electron/electron/issues/11294.
-      decoded->setAlphaType(SkAlphaType::kOpaque_SkAlphaType);
-    }
-  }
-
-  if (!decoded) {
-    // Try Bitmap
-    if (width > 0 && height > 0) {
-      decoded.reset(new SkBitmap);
-      decoded->allocN32Pixels(width, height, false);
-      decoded->setPixels(
-          const_cast<void*>(reinterpret_cast<const void*>(data)));
-    } else {
-      return false;
-    }
-  }
-
-  image->AddRepresentation(gfx::ImageSkiaRep(*decoded, scale_factor));
+  image->AddRepresentation(gfx::ImageSkiaRep(bitmap, scale_factor));
   return true;
 }
 
-bool AddImageSkiaRep(gfx::ImageSkia* image,
-                     const base::FilePath& path,
-                     double scale_factor) {
+bool AddImageSkiaRepFromJPEG(gfx::ImageSkia* image,
+                             const unsigned char* data,
+                             size_t size,
+                             double scale_factor) {
+  auto bitmap = gfx::JPEGCodec::Decode(data, size);
+  if (!bitmap)
+    return false;
+
+  // `JPEGCodec::Decode()` doesn't tell `SkBitmap` instance it creates
+  // that all of its pixels are opaque, that's why the bitmap gets
+  // an alpha type `kPremul_SkAlphaType` instead of `kOpaque_SkAlphaType`.
+  // Let's fix it here.
+  // TODO(alexeykuzmin): This workaround should be removed
+  // when the `JPEGCodec::Decode()` code is fixed.
+  // See https://github.com/electron/electron/issues/11294.
+  bitmap->setAlphaType(SkAlphaType::kOpaque_SkAlphaType);
+
+  image->AddRepresentation(gfx::ImageSkiaRep(*bitmap, scale_factor));
+  return true;
+}
+
+bool AddImageSkiaRepFromBuffer(gfx::ImageSkia* image,
+                               const unsigned char* data,
+                               size_t size,
+                               int width,
+                               int height,
+                               double scale_factor) {
+  // Try PNG first.
+  if (AddImageSkiaRepFromPNG(image, data, size, scale_factor))
+    return true;
+
+  // Try JPEG second.
+  if (AddImageSkiaRepFromJPEG(image, data, size, scale_factor))
+    return true;
+
+  if (width == 0 || height == 0)
+    return false;
+
+  auto info = SkImageInfo::MakeN32(width, height, kPremul_SkAlphaType);
+  if (size < info.computeMinByteSize())
+    return false;
+
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(width, height, false);
+  bitmap.writePixels({info, data, bitmap.rowBytes()});
+
+  image->AddRepresentation(gfx::ImageSkiaRep(bitmap, scale_factor));
+  return true;
+}
+
+bool AddImageSkiaRepFromPath(gfx::ImageSkia* image,
+                             const base::FilePath& path,
+                             double scale_factor) {
   std::string file_contents;
   {
     base::ThreadRestrictions::ScopedAllowIO allow_io;
@@ -134,7 +156,8 @@ bool AddImageSkiaRep(gfx::ImageSkia* image,
   const unsigned char* data =
       reinterpret_cast<const unsigned char*>(file_contents.data());
   size_t size = file_contents.size();
-  return AddImageSkiaRep(image, data, size, 0, 0, scale_factor);
+
+  return AddImageSkiaRepFromBuffer(image, data, size, 0, 0, scale_factor);
 }
 
 bool PopulateImageSkiaRepsFromPath(gfx::ImageSkia* image,
@@ -143,12 +166,12 @@ bool PopulateImageSkiaRepsFromPath(gfx::ImageSkia* image,
   std::string filename(path.BaseName().RemoveExtension().AsUTF8Unsafe());
   if (base::MatchPattern(filename, "*@*x"))
     // Don't search for other representations if the DPI has been specified.
-    return AddImageSkiaRep(image, path, GetScaleFactorFromPath(path));
+    return AddImageSkiaRepFromPath(image, path, GetScaleFactorFromPath(path));
   else
-    succeed |= AddImageSkiaRep(image, path, 1.0f);
+    succeed |= AddImageSkiaRepFromPath(image, path, 1.0f);
 
   for (const ScaleFactorPair& pair : kScaleFactorPairs)
-    succeed |= AddImageSkiaRep(
+    succeed |= AddImageSkiaRepFromPath(
         image, path.InsertBeforeExtensionASCII(pair.name), pair.scale);
   return succeed;
 }
@@ -423,19 +446,20 @@ void NativeImage::AddRepresentation(const mate::Dictionary& options) {
   v8::Local<v8::Value> buffer;
   GURL url;
   if (options.Get("buffer", &buffer) && node::Buffer::HasInstance(buffer)) {
-    AddImageSkiaRep(
-        &image_skia,
-        reinterpret_cast<unsigned char*>(node::Buffer::Data(buffer)),
-        node::Buffer::Length(buffer), width, height, scale_factor);
-    skia_rep_added = true;
+    auto* data = reinterpret_cast<unsigned char*>(node::Buffer::Data(buffer));
+    auto size = node::Buffer::Length(buffer);
+    skia_rep_added = AddImageSkiaRepFromBuffer(&image_skia, data, size, width,
+                                               height, scale_factor);
   } else if (options.Get("dataURL", &url)) {
     std::string mime_type, charset, data;
     if (net::DataURL::Parse(url, &mime_type, &charset, &data)) {
-      if (mime_type == "image/png" || mime_type == "image/jpeg") {
-        AddImageSkiaRep(&image_skia,
-                        reinterpret_cast<const unsigned char*>(data.c_str()),
-                        data.size(), width, height, scale_factor);
-        skia_rep_added = true;
+      auto* data_ptr = reinterpret_cast<const unsigned char*>(data.c_str());
+      if (mime_type == "image/png") {
+        skia_rep_added = AddImageSkiaRepFromPNG(&image_skia, data_ptr,
+                                                data.size(), scale_factor);
+      } else if (mime_type == "image/jpeg") {
+        skia_rep_added = AddImageSkiaRepFromJPEG(&image_skia, data_ptr,
+                                                 data.size(), scale_factor);
       }
     }
   }
@@ -509,6 +533,11 @@ mate::Handle<NativeImage> NativeImage::CreateFromPath(
 mate::Handle<NativeImage> NativeImage::CreateFromBuffer(
     mate::Arguments* args,
     v8::Local<v8::Value> buffer) {
+  if (!node::Buffer::HasInstance(buffer)) {
+    args->ThrowError("buffer must be a node Buffer");
+    return mate::Handle<NativeImage>();
+  }
+
   int width = 0;
   int height = 0;
   double scale_factor = 1.;
@@ -521,9 +550,9 @@ mate::Handle<NativeImage> NativeImage::CreateFromBuffer(
   }
 
   gfx::ImageSkia image_skia;
-  AddImageSkiaRep(&image_skia,
-                  reinterpret_cast<unsigned char*>(node::Buffer::Data(buffer)),
-                  node::Buffer::Length(buffer), width, height, scale_factor);
+  AddImageSkiaRepFromBuffer(
+      &image_skia, reinterpret_cast<unsigned char*>(node::Buffer::Data(buffer)),
+      node::Buffer::Length(buffer), width, height, scale_factor);
   return Create(args->isolate(), gfx::Image(image_skia));
 }
 

atom/common/api/atom_bindings.cc

@@ -7,21 +7,31 @@
 #include <algorithm>
 #include <iostream>
 #include <string>
+#include <utility>
+#include <vector>
 
+#include "atom/browser/browser.h"
 #include "atom/common/api/locker.h"
 #include "atom/common/atom_version.h"
 #include "atom/common/chrome_version.h"
 #include "atom/common/heap_snapshot.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
-#include "atom/common/node_includes.h"
+#include "atom/common/promise_util.h"
 #include "base/logging.h"
+#include "base/process/process_handle.h"
 #include "base/process/process_info.h"
 #include "base/process/process_metrics_iocounters.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_restrictions.h"
 #include "brightray/common/application_info.h"
 #include "native_mate/dictionary.h"
+#include "services/resource_coordinator/public/cpp/memory_instrumentation/global_memory_dump.h"
+#include "services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation.h"
+
+// Must be the last in the includes list, otherwise the definition of chromium
+// macros conflicts with node macros.
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
@@ -61,6 +71,7 @@ void AtomBindings::BindTo(v8::Isolate* isolate, v8::Local<v8::Object> process) {
   dict.SetMethod("getHeapStatistics", &GetHeapStatistics);
   dict.SetMethod("getCreationTime", &GetCreationTime);
   dict.SetMethod("getSystemMemoryInfo", &GetSystemMemoryInfo);
+  dict.SetMethod("getProcessMemoryInfo", &GetProcessMemoryInfo);
   dict.SetMethod("getCPUUsage", base::Bind(&AtomBindings::GetCPUUsage,
                                            base::Unretained(metrics_.get())));
   dict.SetMethod("getIOCounters", &GetIOCounters);
@@ -209,6 +220,67 @@ v8::Local<v8::Value> AtomBindings::GetSystemMemoryInfo(v8::Isolate* isolate,
   return dict.GetHandle();
 }
 
+// static
+v8::Local<v8::Promise> AtomBindings::GetProcessMemoryInfo(
+    v8::Isolate* isolate) {
+  scoped_refptr<util::Promise> promise = new util::Promise(isolate);
+
+  if (mate::Locker::IsBrowserProcess() && !Browser::Get()->is_ready()) {
+    promise->RejectWithErrorMessage(
+        "Memory Info is available only after app ready");
+    return promise->GetHandle();
+  }
+
+  v8::Global<v8::Context> context(isolate, isolate->GetCurrentContext());
+  memory_instrumentation::MemoryInstrumentation::GetInstance()
+      ->RequestGlobalDumpForPid(base::GetCurrentProcId(),
+                                std::vector<std::string>(),
+                                base::Bind(&AtomBindings::DidReceiveMemoryDump,
+                                           std::move(context), promise));
+  return promise->GetHandle();
+}
+
+// static
+void AtomBindings::DidReceiveMemoryDump(
+    const v8::Global<v8::Context>& context,
+    scoped_refptr<util::Promise> promise,
+    bool success,
+    std::unique_ptr<memory_instrumentation::GlobalMemoryDump> global_dump) {
+  v8::Isolate* isolate = promise->isolate();
+  mate::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  v8::MicrotasksScope script_scope(isolate,
+                                   v8::MicrotasksScope::kRunMicrotasks);
+  v8::Context::Scope context_scope(
+      v8::Local<v8::Context>::New(isolate, context));
+
+  if (!success) {
+    promise->RejectWithErrorMessage("Failed to create memory dump");
+    return;
+  }
+
+  bool resolved = false;
+  for (const memory_instrumentation::GlobalMemoryDump::ProcessDump& dump :
+       global_dump->process_dumps()) {
+    if (base::GetCurrentProcId() == dump.pid()) {
+      mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+      const auto& osdump = dump.os_dump();
+#if defined(OS_LINUX) || defined(OS_WIN)
+      dict.Set("residentSet", osdump.resident_set_kb);
+#endif
+      dict.Set("private", osdump.private_footprint_kb);
+      dict.Set("shared", osdump.shared_footprint_kb);
+      promise->Resolve(dict.GetHandle());
+      resolved = true;
+      break;
+    }
+  }
+  if (!resolved) {
+    promise->RejectWithErrorMessage(
+        R"(Failed to find current process memory details in memory dump)");
+  }
+}
+
 // static
 v8::Local<v8::Value> AtomBindings::GetCPUUsage(base::ProcessMetrics* metrics,
                                                v8::Isolate* isolate) {

atom/common/api/atom_bindings.h

@@ -10,18 +10,27 @@
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string16.h"
 #include "native_mate/arguments.h"
 #include "uv.h"  // NOLINT(build/include)
 #include "v8/include/v8.h"
 
+namespace memory_instrumentation {
+class GlobalMemoryDump;
+}
+
 namespace node {
 class Environment;
 }
 
 namespace atom {
 
+namespace util {
+class Promise;
+}
+
 class AtomBindings {
  public:
   explicit AtomBindings(uv_loop_t* loop);
@@ -41,6 +50,7 @@ class AtomBindings {
   static v8::Local<v8::Value> GetCreationTime(v8::Isolate* isolate);
   static v8::Local<v8::Value> GetSystemMemoryInfo(v8::Isolate* isolate,
                                                   mate::Arguments* args);
+  static v8::Local<v8::Promise> GetProcessMemoryInfo(v8::Isolate* isolate);
   static v8::Local<v8::Value> GetCPUUsage(base::ProcessMetrics* metrics,
                                           v8::Isolate* isolate);
   static v8::Local<v8::Value> GetIOCounters(v8::Isolate* isolate);
@@ -52,6 +62,12 @@ class AtomBindings {
 
   static void OnCallNextTick(uv_async_t* handle);
 
+  static void DidReceiveMemoryDump(
+      const v8::Global<v8::Context>& context,
+      scoped_refptr<util::Promise> promise,
+      bool success,
+      std::unique_ptr<memory_instrumentation::GlobalMemoryDump> dump);
+
   uv_async_t call_next_tick_async_;
   std::list<node::Environment*> pending_next_ticks_;
   std::unique_ptr<base::ProcessMetrics> metrics_;

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
@@ -22,6 +23,10 @@ bool IsPDFViewerEnabled() {
   return BUILDFLAG(ENABLE_PDF_VIEWER);
 }
 
+bool IsRunAsNodeEnabled() {
+  return BUILDFLAG(ENABLE_RUN_AS_NODE);
+}
+
 bool IsFakeLocationProviderEnabled() {
   return BUILDFLAG(OVERRIDE_LOCATION_PROVIDER);
 }
@@ -30,6 +35,14 @@ bool IsViewApiEnabled() {
   return BUILDFLAG(ENABLE_VIEW_API);
 }
 
+bool IsPrintingEnabled() {
+  return BUILDFLAG(ENABLE_PRINTING);
+}
+
+bool IsTtsEnabled() {
+  return BUILDFLAG(ENABLE_TTS);
+}
+
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
@@ -38,9 +51,12 @@ void Initialize(v8::Local<v8::Object> exports,
   dict.SetMethod("isDesktopCapturerEnabled", &IsDesktopCapturerEnabled);
   dict.SetMethod("isOffscreenRenderingEnabled", &IsOffscreenRenderingEnabled);
   dict.SetMethod("isPDFViewerEnabled", &IsPDFViewerEnabled);
+  dict.SetMethod("isRunAsNodeEnabled", &IsRunAsNodeEnabled);
   dict.SetMethod("isFakeLocationProviderEnabled",
                  &IsFakeLocationProviderEnabled);
   dict.SetMethod("isViewApiEnabled", &IsViewApiEnabled);
+  dict.SetMethod("isPrintingEnabled", &IsPrintingEnabled);
+  dict.SetMethod("isTtsEnabled", &IsTtsEnabled);
 }
 
 }  // namespace

atom/common/atom_version.h

@@ -6,10 +6,10 @@
 #define ATOM_COMMON_ATOM_VERSION_H_
 
 #define ATOM_MAJOR_VERSION 4
-#define ATOM_MINOR_VERSION 0
-#define ATOM_PATCH_VERSION 0
+#define ATOM_MINOR_VERSION 2
+#define ATOM_PATCH_VERSION 1
 // clang-format off
-#define ATOM_PRE_RELEASE_VERSION -nightly.20181010
+// #define ATOM_PRE_RELEASE_VERSION
 // clang-format on
 
 #ifndef ATOM_STRINGIFY

atom/common/chrome_version.h

@@ -8,7 +8,7 @@
 #ifndef ATOM_COMMON_CHROME_VERSION_H_
 #define ATOM_COMMON_CHROME_VERSION_H_
 
-#define CHROME_VERSION_STRING "69.0.3497.106"
+#define CHROME_VERSION_STRING "69.0.3497.128"
 #define CHROME_VERSION "v" CHROME_VERSION_STRING
 
 #endif  // ATOM_COMMON_CHROME_VERSION_H_

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/crash_reporter/crash_reporter_win.cc

@@ -93,8 +93,13 @@ bool RegisterNonABICompliantCodeRange(void* start, size_t size_in_bytes) {
 
   // All addresses are 32bit relative offsets to start.
   record->runtime_function.BeginAddress = 0;
+#if defined(_M_ARM64)
+  record->runtime_function.FunctionLength =
+      base::checked_cast<DWORD>(size_in_bytes);
+#else
   record->runtime_function.EndAddress =
       base::checked_cast<DWORD>(size_in_bytes);
+#endif
   record->runtime_function.UnwindData =
       offsetof(ExceptionHandlerRecord, unwind_info);
 

atom/common/native_mate_converters/net_converter.cc

@@ -181,24 +181,45 @@ bool Converter<net::HttpResponseHeaders*>::FromV8(
   if (!val->IsObject()) {
     return false;
   }
+
+  auto addHeaderFromValue = [&isolate, &out](
+                                const std::string& key,
+                                const v8::Local<v8::Value>& localVal) {
+    auto context = isolate->GetCurrentContext();
+    v8::Local<v8::String> localStrVal;
+    if (!localVal->ToString(context).ToLocal(&localStrVal)) {
+      return false;
+    }
+    std::string value;
+    mate::ConvertFromV8(isolate, localStrVal, &value);
+    out->AddHeader(key + ": " + value);
+    return true;
+  };
+
   auto context = isolate->GetCurrentContext();
   auto headers = v8::Local<v8::Object>::Cast(val);
   auto keys = headers->GetOwnPropertyNames();
   for (uint32_t i = 0; i < keys->Length(); i++) {
-    v8::Local<v8::String> key, value;
-    if (!keys->Get(i)->ToString(context).ToLocal(&key)) {
+    v8::Local<v8::String> keyVal;
+    if (!keys->Get(i)->ToString(context).ToLocal(&keyVal)) {
       return false;
     }
-    if (!headers->Get(key)->ToString(context).ToLocal(&value)) {
-      return false;
+    std::string key;
+    mate::ConvertFromV8(isolate, keyVal, &key);
+
+    auto localVal = headers->Get(keyVal);
+    if (localVal->IsArray()) {
+      auto values = v8::Local<v8::Array>::Cast(localVal);
+      for (uint32_t j = 0; j < values->Length(); j++) {
+        if (!addHeaderFromValue(key, values->Get(j))) {
+          return false;
+        }
+      }
+    } else {
+      if (!addHeaderFromValue(key, localVal)) {
+        return false;
+      }
     }
-    v8::String::Utf8Value key_utf8(key);
-    v8::String::Utf8Value value_utf8(value);
-    std::string k(*key_utf8, key_utf8.length());
-    std::string v(*value_utf8, value_utf8.length());
-    std::ostringstream tmp;
-    tmp << k << ": " << v;
-    out->AddHeader(tmp.str());
   }
   return true;
 }

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";
@@ -223,6 +247,9 @@ const char kAuthServerWhitelist[] = "auth-server-whitelist";
 const char kAuthNegotiateDelegateWhitelist[] =
     "auth-negotiate-delegate-whitelist";
 
+// If set, include the port in generated Kerberos SPNs.
+const char kEnableAuthNegotiatePort[] = "enable-auth-negotiate-port";
+
 }  // namespace switches
 
 }  // namespace atom

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[];
@@ -113,6 +118,7 @@ extern const char kDiskCacheSize[];
 extern const char kIgnoreConnectionsLimit[];
 extern const char kAuthServerWhitelist[];
 extern const char kAuthNegotiateDelegateWhitelist[];
+extern const char kEnableAuthNegotiatePort[];
 
 }  // namespace switches
 

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);
@@ -138,11 +139,14 @@ bool MoveItemToTrash(const base::FilePath& full_path) {
 
 void Beep() {
   // echo '\a' > /dev/console
-  FILE* console = fopen("/dev/console", "r");
-  if (console == NULL)
-    return;
-  fprintf(console, "\a");
-  fclose(console);
+  FILE* fp = fopen("/dev/console", "a");
+  if (fp == nullptr) {
+    fp = fopen("/dev/tty", "a");
+  }
+  if (fp != nullptr) {
+    fprintf(fp, "\a");
+    fclose(fp);
+  }
 }
 
 }  // namespace platform_util

atom/common/platform_util_mac.mm

@@ -22,64 +22,21 @@
 
 namespace {
 
-std::string MessageForOSStatus(OSStatus status, const char* default_message) {
-  switch (status) {
-    case kLSAppInTrashErr:
-      return "The application cannot be run because it is inside a Trash "
-             "folder.";
-    case kLSUnknownErr:
-      return "An unknown error has occurred.";
-    case kLSNotAnApplicationErr:
-      return "The item to be registered is not an application.";
-    case kLSNotInitializedErr:
-      return "Formerly returned by LSInit on initialization failure; "
-             "no longer used.";
-    case kLSDataUnavailableErr:
-      return "Data of the desired type is not available (for example, there is "
-             "no kind string).";
-    case kLSApplicationNotFoundErr:
-      return "No application in the Launch Services database matches the input "
-             "criteria.";
-    case kLSDataErr:
-      return "Data is structured improperly (for example, an item’s "
-             "information property list is malformed). Not used in macOS 10.4.";
-    case kLSLaunchInProgressErr:
-      return "A launch of the application is already in progress.";
-    case kLSServerCommunicationErr:
-      return "There is a problem communicating with the server process that "
-             "maintains the Launch Services database.";
-    case kLSCannotSetInfoErr:
-      return "The filename extension to be hidden cannot be hidden.";
-    case kLSIncompatibleSystemVersionErr:
-      return "The application to be launched cannot run on the current Mac OS "
-             "version.";
-    case kLSNoLaunchPermissionErr:
-      return "The user does not have permission to launch the application (on a"
-             "managed network).";
-    case kLSNoExecutableErr:
-      return "The executable file is missing or has an unusable format.";
-    case kLSNoClassicEnvironmentErr:
-      return "The Classic emulation environment was required but is not "
-             "available.";
-    case kLSMultipleSessionsNotSupportedErr:
-      return "The application to be launched cannot run simultaneously in two "
-             "different user sessions.";
-    default:
-      return base::StringPrintf("%s (%d)", default_message, status);
-  }
-}
-
 // This may be called from a global dispatch queue, the methods used here are
 // thread safe, including LSGetApplicationForURL (> 10.2) and
 // NSWorkspace#openURLs.
 std::string OpenURL(NSURL* ns_url, bool activate) {
-  CFURLRef openingApp = nullptr;
-  OSStatus status = LSGetApplicationForURL(base::mac::NSToCFCast(ns_url),
-                                           kLSRolesAll, nullptr, &openingApp);
-  if (status != noErr)
-    return MessageForOSStatus(status, "Failed to open");
+  CFURLRef ref = nil;
+  if (@available(macOS 10.10, *)) {
+    ref = LSCopyDefaultApplicationURLForURL(base::mac::NSToCFCast(ns_url),
+                                            kLSRolesAll, nullptr);
+  }
 
-  CFRelease(openingApp);  // NOT A BUG; LSGetApplicationForURL retains for us
+  // If no application could be found, NULL is returned and outError
+  // (if not NULL) is populated with kLSApplicationNotFoundErr.
+  if (ref == NULL)
+    return "No application in the Launch Services database matches the input "
+           "criteria.";
 
   NSUInteger launchOptions = NSWorkspaceLaunchDefault;
   if (!activate)

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

@@ -2,7 +2,10 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "atom/renderer/api/atom_api_web_frame.h"
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "atom/common/api/api_messages.h"
 #include "atom/common/api/event_emitter_caller.h"
@@ -109,15 +112,15 @@ class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
   DISALLOW_COPY_AND_ASSIGN(ScriptExecutionCallback);
 };
 
-class FrameSpellChecker : public content::RenderFrameVisitor {
+class FrameSetSpellChecker : public content::RenderFrameVisitor {
  public:
-  explicit FrameSpellChecker(SpellCheckClient* spell_check_client,
-                             content::RenderFrame* main_frame)
-      : spell_check_client_(spell_check_client), main_frame_(main_frame) {}
-  ~FrameSpellChecker() override {
-    spell_check_client_ = nullptr;
-    main_frame_ = nullptr;
+  FrameSetSpellChecker(SpellCheckClient* spell_check_client,
+                       content::RenderFrame* main_frame)
+      : spell_check_client_(spell_check_client), main_frame_(main_frame) {
+    content::RenderFrame::ForEach(this);
+    main_frame->GetWebFrame()->SetSpellCheckPanelHostClient(spell_check_client);
   }
+
   bool Visit(content::RenderFrame* render_frame) override {
     auto* view = render_frame->GetRenderView();
     if (view->GetMainRenderFrame() == main_frame_ ||
@@ -130,71 +133,130 @@ class FrameSpellChecker : public content::RenderFrameVisitor {
  private:
   SpellCheckClient* spell_check_client_;
   content::RenderFrame* main_frame_;
-  DISALLOW_COPY_AND_ASSIGN(FrameSpellChecker);
+
+  DISALLOW_COPY_AND_ASSIGN(FrameSetSpellChecker);
+};
+
+class SpellCheckerHolder : public content::RenderFrameObserver {
+ public:
+  // Find existing holder for the |render_frame|.
+  static SpellCheckerHolder* FromRenderFrame(
+      content::RenderFrame* render_frame) {
+    for (auto* holder : instances_) {
+      if (holder->render_frame() == render_frame)
+        return holder;
+    }
+    return nullptr;
+  }
+
+  SpellCheckerHolder(content::RenderFrame* render_frame,
+                     std::unique_ptr<SpellCheckClient> spell_check_client)
+      : content::RenderFrameObserver(render_frame),
+        spell_check_client_(std::move(spell_check_client)) {
+    DCHECK(!FromRenderFrame(render_frame));
+    instances_.insert(this);
+  }
+
+  ~SpellCheckerHolder() final { instances_.erase(this); }
+
+  void UnsetAndDestroy() {
+    FrameSetSpellChecker set_spell_checker(nullptr, render_frame());
+    delete this;
+  }
+
+  // RenderFrameObserver implementation.
+  void OnDestruct() final {
+    // Since we delete this in WillReleaseScriptContext, this method is unlikely
+    // to be called, but override anyway since I'm not sure if there are some
+    // corner cases.
+    //
+    // Note that while there are two "delete this", it is totally fine as the
+    // observer unsubscribes automatically in destructor and the other one won't
+    // be called.
+    //
+    // Also note that we should not call UnsetAndDestroy here, as the render
+    // frame is going to be destroyed.
+    delete this;
+  }
+
+  void WillReleaseScriptContext(v8::Local<v8::Context> context,
+                                int world_id) final {
+    // Unset spell checker when the script context is going to be released, as
+    // the spell check implementation lives there.
+    UnsetAndDestroy();
+  }
+
+ private:
+  static std::set<SpellCheckerHolder*> instances_;
+
+  std::unique_ptr<SpellCheckClient> spell_check_client_;
 };
 
 }  // namespace
 
-WebFrame::WebFrame(v8::Isolate* isolate)
-    : web_frame_(blink::WebLocalFrame::FrameForCurrentContext()) {
-  Init(isolate);
+// static
+std::set<SpellCheckerHolder*> SpellCheckerHolder::instances_;
+
+void SetName(v8::Local<v8::Value> window, const std::string& name) {
+  GetRenderFrame(window)->GetWebFrame()->SetName(
+      blink::WebString::FromUTF8(name));
 }
 
-WebFrame::WebFrame(v8::Isolate* isolate, blink::WebLocalFrame* blink_frame)
-    : web_frame_(blink_frame) {
-  Init(isolate);
-}
-
-WebFrame::~WebFrame() {}
-
-void WebFrame::SetName(const std::string& name) {
-  web_frame_->SetName(blink::WebString::FromUTF8(name));
-}
-
-double WebFrame::SetZoomLevel(double level) {
+double SetZoomLevel(v8::Local<v8::Value> window, double level) {
   double result = 0.0;
-  content::RenderFrame* render_frame =
-      content::RenderFrame::FromWebFrame(web_frame_);
+  content::RenderFrame* render_frame = GetRenderFrame(window);
   render_frame->Send(new AtomFrameHostMsg_SetTemporaryZoomLevel(
       render_frame->GetRoutingID(), level, &result));
   return result;
 }
 
-double WebFrame::GetZoomLevel() const {
+double GetZoomLevel(v8::Local<v8::Value> window) {
   double result = 0.0;
-  content::RenderFrame* render_frame =
-      content::RenderFrame::FromWebFrame(web_frame_);
+  content::RenderFrame* render_frame = GetRenderFrame(window);
   render_frame->Send(
       new AtomFrameHostMsg_GetZoomLevel(render_frame->GetRoutingID(), &result));
   return result;
 }
 
-double WebFrame::SetZoomFactor(double factor) {
+double SetZoomFactor(v8::Local<v8::Value> window, double factor) {
   return blink::WebView::ZoomLevelToZoomFactor(
-      SetZoomLevel(blink::WebView::ZoomFactorToZoomLevel(factor)));
+      SetZoomLevel(window, blink::WebView::ZoomFactorToZoomLevel(factor)));
 }
 
-double WebFrame::GetZoomFactor() const {
-  return blink::WebView::ZoomLevelToZoomFactor(GetZoomLevel());
+double GetZoomFactor(v8::Local<v8::Value> window) {
+  return blink::WebView::ZoomLevelToZoomFactor(GetZoomLevel(window));
 }
 
-void WebFrame::SetVisualZoomLevelLimits(double min_level, double max_level) {
-  web_frame_->View()->SetDefaultPageScaleLimits(min_level, max_level);
-  web_frame_->View()->SetIgnoreViewportTagScaleLimits(true);
+void SetVisualZoomLevelLimits(v8::Local<v8::Value> window,
+                              double min_level,
+                              double max_level) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  web_frame->View()->SetDefaultPageScaleLimits(min_level, max_level);
+  web_frame->View()->SetIgnoreViewportTagScaleLimits(true);
 }
 
-void WebFrame::SetLayoutZoomLevelLimits(double min_level, double max_level) {
-  web_frame_->View()->ZoomLimitsChanged(min_level, max_level);
+void SetLayoutZoomLevelLimits(v8::Local<v8::Value> window,
+                              double min_level,
+                              double max_level) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  web_frame->View()->ZoomLimitsChanged(min_level, max_level);
 }
 
-v8::Local<v8::Value> WebFrame::RegisterEmbedderCustomElement(
+v8::Local<v8::Value> RegisterEmbedderCustomElement(
+    v8::Local<v8::Value> window,
+    v8::Local<v8::Object> context,
     const base::string16& name,
     v8::Local<v8::Object> options) {
-  return web_frame_->GetDocument().RegisterEmbedderCustomElement(
-      blink::WebString::FromUTF16(name), options);
+  v8::Context::Scope context_scope(context->CreationContext());
+  return GetRenderFrame(context)
+      ->GetWebFrame()
+      ->GetDocument()
+      .RegisterEmbedderCustomElement(blink::WebString::FromUTF16(name),
+                                     options);
 }
 
-int WebFrame::GetWebFrameId(v8::Local<v8::Value> content_window) {
+int GetWebFrameId(v8::Local<v8::Value> window,
+                  v8::Local<v8::Value> content_window) {
   // Get the WebLocalFrame before (possibly) executing any user-space JS while
   // getting the |params|. We track the status of the RenderFrame via an
   // observer in case it is deleted during user code execution.
@@ -213,34 +275,42 @@ int WebFrame::GetWebFrameId(v8::Local<v8::Value> content_window) {
   return render_frame->GetRoutingID();
 }
 
-void WebFrame::SetSpellCheckProvider(mate::Arguments* args,
-                                     const std::string& language,
-                                     bool auto_spell_correct_turned_on,
-                                     v8::Local<v8::Object> provider) {
+void SetSpellCheckProvider(mate::Arguments* args,
+                           v8::Local<v8::Value> window,
+                           const std::string& language,
+                           bool auto_spell_correct_turned_on,
+                           v8::Local<v8::Object> provider) {
   if (!provider->Has(mate::StringToV8(args->isolate(), "spellCheck"))) {
     args->ThrowError("\"spellCheck\" has to be defined");
     return;
   }
 
-  auto client = std::make_unique<SpellCheckClient>(
-      language, auto_spell_correct_turned_on, args->isolate(), provider);
+  // Remove the old client.
+  content::RenderFrame* render_frame = GetRenderFrame(window);
+  auto* existing = SpellCheckerHolder::FromRenderFrame(render_frame);
+  if (existing)
+    existing->UnsetAndDestroy();
+
   // Set spellchecker for all live frames in the same process or
   // in the sandbox mode for all live sub frames to this WebFrame.
-  FrameSpellChecker spell_checker(
-      client.get(), content::RenderFrame::FromWebFrame(web_frame_));
-  content::RenderFrame::ForEach(&spell_checker);
-  spell_check_client_.swap(client);
-  web_frame_->SetSpellCheckPanelHostClient(spell_check_client_.get());
+  auto spell_check_client = std::make_unique<SpellCheckClient>(
+      language, auto_spell_correct_turned_on, args->isolate(), provider);
+  FrameSetSpellChecker spell_checker(spell_check_client.get(), render_frame);
+
+  // Attach the spell checker to RenderFrame.
+  new SpellCheckerHolder(render_frame, std::move(spell_check_client));
 }
 
-void WebFrame::RegisterURLSchemeAsBypassingCSP(const std::string& scheme) {
+void RegisterURLSchemeAsBypassingCSP(v8::Local<v8::Value> window,
+                                     const std::string& scheme) {
   // Register scheme to bypass pages's Content Security Policy.
   blink::SchemeRegistry::RegisterURLSchemeAsBypassingContentSecurityPolicy(
       WTF::String::FromUTF8(scheme.data(), scheme.length()));
 }
 
-void WebFrame::RegisterURLSchemeAsPrivileged(const std::string& scheme,
-                                             mate::Arguments* args) {
+void RegisterURLSchemeAsPrivileged(v8::Local<v8::Value> window,
+                                   const std::string& scheme,
+                                   mate::Arguments* args) {
   // TODO(deepak1556): blink::SchemeRegistry methods should be called
   // before any renderer threads are created. Fixing this would break
   // current api. Change it with 2.0.
@@ -251,7 +321,7 @@ void WebFrame::RegisterURLSchemeAsPrivileged(const std::string& scheme,
   bool allowServiceWorkers = true;
   bool supportFetchAPI = true;
   bool corsEnabled = true;
-  if (args->Length() == 2) {
+  if (args->Length() == 3) {
     mate::Dictionary options;
     if (args->GetNext(&options)) {
       options.Get("secure", &secure);
@@ -281,30 +351,42 @@ void WebFrame::RegisterURLSchemeAsPrivileged(const std::string& scheme,
   }
 }
 
-void WebFrame::InsertText(const std::string& text) {
-  web_frame_->FrameWidget()->GetActiveWebInputMethodController()->CommitText(
-      blink::WebString::FromUTF8(text),
-      blink::WebVector<blink::WebImeTextSpan>(), blink::WebRange(), 0);
+void InsertText(v8::Local<v8::Value> window, const std::string& text) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  if (web_frame->IsWebLocalFrame()) {
+    web_frame->ToWebLocalFrame()
+        ->FrameWidget()
+        ->GetActiveWebInputMethodController()
+        ->CommitText(blink::WebString::FromUTF8(text),
+                     blink::WebVector<blink::WebImeTextSpan>(),
+                     blink::WebRange(), 0);
+  }
 }
 
-void WebFrame::InsertCSS(const std::string& css) {
-  web_frame_->GetDocument().InsertStyleSheet(blink::WebString::FromUTF8(css));
+void InsertCSS(v8::Local<v8::Value> window, const std::string& css) {
+  blink::WebFrame* web_frame = GetRenderFrame(window)->GetWebFrame();
+  if (web_frame->IsWebLocalFrame()) {
+    web_frame->ToWebLocalFrame()->GetDocument().InsertStyleSheet(
+        blink::WebString::FromUTF8(css));
+  }
 }
 
-void WebFrame::ExecuteJavaScript(const base::string16& code,
-                                 mate::Arguments* args) {
+void ExecuteJavaScript(v8::Local<v8::Value> window,
+                       const base::string16& code,
+                       mate::Arguments* args) {
   bool has_user_gesture = false;
   args->GetNext(&has_user_gesture);
   ScriptExecutionCallback::CompletionCallback completion_callback;
   args->GetNext(&completion_callback);
   std::unique_ptr<blink::WebScriptExecutionCallback> callback(
       new ScriptExecutionCallback(completion_callback));
-  web_frame_->RequestExecuteScriptAndReturnValue(
+  GetRenderFrame(window)->GetWebFrame()->RequestExecuteScriptAndReturnValue(
       blink::WebScriptSource(blink::WebString::FromUTF16(code)),
       has_user_gesture, callback.release());
 }
 
-void WebFrame::ExecuteJavaScriptInIsolatedWorld(
+void ExecuteJavaScriptInIsolatedWorld(
+    v8::Local<v8::Value> window,
     int world_id,
     const std::vector<mate::Dictionary>& scripts,
     mate::Arguments* args) {
@@ -339,186 +421,132 @@ void WebFrame::ExecuteJavaScriptInIsolatedWorld(
   std::unique_ptr<blink::WebScriptExecutionCallback> callback(
       new ScriptExecutionCallback(completion_callback));
 
-  web_frame_->RequestExecuteScriptInIsolatedWorld(
+  GetRenderFrame(window)->GetWebFrame()->RequestExecuteScriptInIsolatedWorld(
       world_id, &sources.front(), sources.size(), has_user_gesture,
       scriptExecutionType, callback.release());
 }
 
-void WebFrame::SetIsolatedWorldSecurityOrigin(int world_id,
-                                              const std::string& origin_url) {
-  web_frame_->SetIsolatedWorldSecurityOrigin(
+void SetIsolatedWorldSecurityOrigin(v8::Local<v8::Value> window,
+                                    int world_id,
+                                    const std::string& origin_url) {
+  GetRenderFrame(window)->GetWebFrame()->SetIsolatedWorldSecurityOrigin(
       world_id, blink::WebSecurityOrigin::CreateFromString(
                     blink::WebString::FromUTF8(origin_url)));
 }
 
-void WebFrame::SetIsolatedWorldContentSecurityPolicy(
-    int world_id,
-    const std::string& security_policy) {
-  web_frame_->SetIsolatedWorldContentSecurityPolicy(
+void SetIsolatedWorldContentSecurityPolicy(v8::Local<v8::Value> window,
+                                           int world_id,
+                                           const std::string& security_policy) {
+  GetRenderFrame(window)->GetWebFrame()->SetIsolatedWorldContentSecurityPolicy(
       world_id, blink::WebString::FromUTF8(security_policy));
 }
 
-void WebFrame::SetIsolatedWorldHumanReadableName(int world_id,
-                                                 const std::string& name) {
-  web_frame_->SetIsolatedWorldHumanReadableName(
+void SetIsolatedWorldHumanReadableName(v8::Local<v8::Value> window,
+                                       int world_id,
+                                       const std::string& name) {
+  GetRenderFrame(window)->GetWebFrame()->SetIsolatedWorldHumanReadableName(
       world_id, blink::WebString::FromUTF8(name));
 }
 
-// static
-mate::Handle<WebFrame> WebFrame::Create(v8::Isolate* isolate) {
-  return mate::CreateHandle(isolate, new WebFrame(isolate));
-}
-
-blink::WebCache::ResourceTypeStats WebFrame::GetResourceUsage(
-    v8::Isolate* isolate) {
+blink::WebCache::ResourceTypeStats GetResourceUsage(v8::Isolate* isolate) {
   blink::WebCache::ResourceTypeStats stats;
   blink::WebCache::GetResourceTypeStats(&stats);
   return stats;
 }
 
-void WebFrame::ClearCache(v8::Isolate* isolate) {
+void ClearCache(v8::Isolate* isolate) {
   isolate->IdleNotificationDeadline(0.5);
   blink::WebCache::Clear();
   base::MemoryPressureListener::NotifyMemoryPressure(
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
 }
 
-v8::Local<v8::Value> WebFrame::Opener() const {
-  blink::WebFrame* frame = web_frame_->Opener();
-  if (frame && frame->IsWebLocalFrame())
-    return mate::CreateHandle(isolate(),
-                              new WebFrame(isolate(), frame->ToWebLocalFrame()))
-        .ToV8();
-  else
-    return v8::Null(isolate());
-}
-
-v8::Local<v8::Value> WebFrame::Parent() const {
-  blink::WebFrame* frame = web_frame_->Parent();
-  if (frame && frame->IsWebLocalFrame())
-    return mate::CreateHandle(isolate(),
-                              new WebFrame(isolate(), frame->ToWebLocalFrame()))
-        .ToV8();
-  else
-    return v8::Null(isolate());
-}
-
-v8::Local<v8::Value> WebFrame::Top() const {
-  blink::WebFrame* frame = web_frame_->Top();
-  if (frame && frame->IsWebLocalFrame())
-    return mate::CreateHandle(isolate(),
-                              new WebFrame(isolate(), frame->ToWebLocalFrame()))
-        .ToV8();
-  else
-    return v8::Null(isolate());
-}
-
-v8::Local<v8::Value> WebFrame::FirstChild() const {
-  blink::WebFrame* frame = web_frame_->FirstChild();
-  if (frame && frame->IsWebLocalFrame())
-    return mate::CreateHandle(isolate(),
-                              new WebFrame(isolate(), frame->ToWebLocalFrame()))
-        .ToV8();
-  else
-    return v8::Null(isolate());
-}
-
-v8::Local<v8::Value> WebFrame::NextSibling() const {
-  blink::WebFrame* frame = web_frame_->NextSibling();
-  if (frame && frame->IsWebLocalFrame())
-    return mate::CreateHandle(isolate(),
-                              new WebFrame(isolate(), frame->ToWebLocalFrame()))
-        .ToV8();
-  else
-    return v8::Null(isolate());
-}
-
-v8::Local<v8::Value> WebFrame::GetFrameForSelector(
-    const std::string& selector) const {
-  blink::WebElement element = web_frame_->GetDocument().QuerySelector(
-      blink::WebString::FromUTF8(selector));
-  blink::WebLocalFrame* element_frame =
-      blink::WebLocalFrame::FromFrameOwnerElement(element);
-  if (element_frame)
-    return mate::CreateHandle(isolate(), new WebFrame(isolate(), element_frame))
-        .ToV8();
-  else
-    return v8::Null(isolate());
-}
-
-v8::Local<v8::Value> WebFrame::FindFrameByName(const std::string& name) const {
-  blink::WebLocalFrame* local_frame =
-      web_frame_->FindFrameByName(blink::WebString::FromUTF8(name))
-          ->ToWebLocalFrame();
-  if (local_frame)
-    return mate::CreateHandle(isolate(), new WebFrame(isolate(), local_frame))
-        .ToV8();
-  else
-    return v8::Null(isolate());
-}
-
-v8::Local<v8::Value> WebFrame::FindFrameByRoutingId(int routing_id) const {
+v8::Local<v8::Value> FindFrameByRoutingId(v8::Isolate* isolate,
+                                          v8::Local<v8::Value> window,
+                                          int routing_id) {
   content::RenderFrame* render_frame =
       content::RenderFrame::FromRoutingID(routing_id);
-  blink::WebLocalFrame* local_frame = nullptr;
   if (render_frame)
-    local_frame = render_frame->GetWebFrame();
-  if (local_frame)
-    return mate::CreateHandle(isolate(), new WebFrame(isolate(), local_frame))
-        .ToV8();
+    return render_frame->GetWebFrame()->MainWorldScriptContext()->Global();
   else
-    return v8::Null(isolate());
+    return v8::Null(isolate);
 }
 
-v8::Local<v8::Value> WebFrame::RoutingId() const {
-  int routing_id = content::RenderFrame::GetRoutingIdForWebFrame(web_frame_);
-  return v8::Number::New(isolate(), routing_id);
+v8::Local<v8::Value> GetOpener(v8::Isolate* isolate,
+                               v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->Opener();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
 }
 
-// static
-void WebFrame::BuildPrototype(v8::Isolate* isolate,
-                              v8::Local<v8::FunctionTemplate> prototype) {
-  prototype->SetClassName(mate::StringToV8(isolate, "WebFrame"));
-  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
-      .SetMethod("setName", &WebFrame::SetName)
-      .SetMethod("setZoomLevel", &WebFrame::SetZoomLevel)
-      .SetMethod("getZoomLevel", &WebFrame::GetZoomLevel)
-      .SetMethod("setZoomFactor", &WebFrame::SetZoomFactor)
-      .SetMethod("getZoomFactor", &WebFrame::GetZoomFactor)
-      .SetMethod("setVisualZoomLevelLimits",
-                 &WebFrame::SetVisualZoomLevelLimits)
-      .SetMethod("setLayoutZoomLevelLimits",
-                 &WebFrame::SetLayoutZoomLevelLimits)
-      .SetMethod("registerEmbedderCustomElement",
-                 &WebFrame::RegisterEmbedderCustomElement)
-      .SetMethod("getWebFrameId", &WebFrame::GetWebFrameId)
-      .SetMethod("setSpellCheckProvider", &WebFrame::SetSpellCheckProvider)
-      .SetMethod("registerURLSchemeAsBypassingCSP",
-                 &WebFrame::RegisterURLSchemeAsBypassingCSP)
-      .SetMethod("registerURLSchemeAsPrivileged",
-                 &WebFrame::RegisterURLSchemeAsPrivileged)
-      .SetMethod("insertText", &WebFrame::InsertText)
-      .SetMethod("insertCSS", &WebFrame::InsertCSS)
-      .SetMethod("executeJavaScript", &WebFrame::ExecuteJavaScript)
-      .SetMethod("executeJavaScriptInIsolatedWorld",
-                 &WebFrame::ExecuteJavaScriptInIsolatedWorld)
-      .SetMethod("setIsolatedWorldSecurityOrigin",
-                 &WebFrame::SetIsolatedWorldSecurityOrigin)
-      .SetMethod("setIsolatedWorldContentSecurityPolicy",
-                 &WebFrame::SetIsolatedWorldContentSecurityPolicy)
-      .SetMethod("setIsolatedWorldHumanReadableName",
-                 &WebFrame::SetIsolatedWorldHumanReadableName)
-      .SetMethod("getResourceUsage", &WebFrame::GetResourceUsage)
-      .SetMethod("clearCache", &WebFrame::ClearCache)
-      .SetMethod("getFrameForSelector", &WebFrame::GetFrameForSelector)
-      .SetMethod("findFrameByName", &WebFrame::FindFrameByName)
-      .SetProperty("opener", &WebFrame::Opener)
-      .SetProperty("parent", &WebFrame::Parent)
-      .SetProperty("top", &WebFrame::Top)
-      .SetProperty("firstChild", &WebFrame::FirstChild)
-      .SetProperty("nextSibling", &WebFrame::NextSibling)
-      .SetProperty("routingId", &WebFrame::RoutingId)
-      .SetMethod("findFrameByRoutingId", &WebFrame::FindFrameByRoutingId);
+// Don't name it as GetParent, Windows has API with same name.
+v8::Local<v8::Value> GetFrameParent(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->Parent();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetTop(v8::Isolate* isolate, v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->Top();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetFirstChild(v8::Isolate* isolate,
+                                   v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->FirstChild();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetNextSibling(v8::Isolate* isolate,
+                                    v8::Local<v8::Value> window) {
+  blink::WebFrame* frame = GetRenderFrame(window)->GetWebFrame()->NextSibling();
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> GetFrameForSelector(v8::Isolate* isolate,
+                                         v8::Local<v8::Value> window,
+                                         const std::string& selector) {
+  blink::WebElement element =
+      GetRenderFrame(window)->GetWebFrame()->GetDocument().QuerySelector(
+          blink::WebString::FromUTF8(selector));
+  if (element.IsNull())  // not found
+    return v8::Null(isolate);
+
+  blink::WebFrame* frame = blink::WebFrame::FromFrameOwnerElement(element);
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+v8::Local<v8::Value> FindFrameByName(v8::Isolate* isolate,
+                                     v8::Local<v8::Value> window,
+                                     const std::string& name) {
+  blink::WebFrame* frame =
+      GetRenderFrame(window)->GetWebFrame()->FindFrameByName(
+          blink::WebString::FromUTF8(name));
+  if (frame && frame->IsWebLocalFrame())
+    return frame->ToWebLocalFrame()->MainWorldScriptContext()->Global();
+  else
+    return v8::Null(isolate);
+}
+
+int GetRoutingId(v8::Local<v8::Value> window) {
+  return GetRenderFrame(window)->GetRoutingID();
 }
 
 }  // namespace api
@@ -527,16 +555,51 @@ void WebFrame::BuildPrototype(v8::Isolate* isolate,
 
 namespace {
 
-using atom::api::WebFrame;
-
 void Initialize(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> unused,
                 v8::Local<v8::Context> context,
                 void* priv) {
+  using namespace atom::api;  // NOLINT(build/namespaces)
+
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("webFrame", WebFrame::Create(isolate));
-  dict.Set("WebFrame", WebFrame::GetConstructor(isolate)->GetFunction());
+  dict.SetMethod("setName", &SetName);
+  dict.SetMethod("setZoomLevel", &SetZoomLevel);
+  dict.SetMethod("getZoomLevel", &GetZoomLevel);
+  dict.SetMethod("setZoomFactor", &SetZoomFactor);
+  dict.SetMethod("getZoomFactor", &GetZoomFactor);
+  dict.SetMethod("setVisualZoomLevelLimits", &SetVisualZoomLevelLimits);
+  dict.SetMethod("setLayoutZoomLevelLimits", &SetLayoutZoomLevelLimits);
+  dict.SetMethod("registerEmbedderCustomElement",
+                 &RegisterEmbedderCustomElement);
+  dict.SetMethod("getWebFrameId", &GetWebFrameId);
+  dict.SetMethod("setSpellCheckProvider", &SetSpellCheckProvider);
+  dict.SetMethod("registerURLSchemeAsBypassingCSP",
+                 &RegisterURLSchemeAsBypassingCSP);
+  dict.SetMethod("registerURLSchemeAsPrivileged",
+                 &RegisterURLSchemeAsPrivileged);
+  dict.SetMethod("insertText", &InsertText);
+  dict.SetMethod("insertCSS", &InsertCSS);
+  dict.SetMethod("executeJavaScript", &ExecuteJavaScript);
+  dict.SetMethod("executeJavaScriptInIsolatedWorld",
+                 &ExecuteJavaScriptInIsolatedWorld);
+  dict.SetMethod("setIsolatedWorldSecurityOrigin",
+                 &SetIsolatedWorldSecurityOrigin);
+  dict.SetMethod("setIsolatedWorldContentSecurityPolicy",
+                 &SetIsolatedWorldContentSecurityPolicy);
+  dict.SetMethod("setIsolatedWorldHumanReadableName",
+                 &SetIsolatedWorldHumanReadableName);
+  dict.SetMethod("getResourceUsage", &GetResourceUsage);
+  dict.SetMethod("clearCache", &ClearCache);
+  dict.SetMethod("_findFrameByRoutingId", &FindFrameByRoutingId);
+  dict.SetMethod("_getFrameForSelector", &GetFrameForSelector);
+  dict.SetMethod("_findFrameByName", &FindFrameByName);
+  dict.SetMethod("_getOpener", &GetOpener);
+  dict.SetMethod("_getParent", &GetFrameParent);
+  dict.SetMethod("_getTop", &GetTop);
+  dict.SetMethod("_getFirstChild", &GetFirstChild);
+  dict.SetMethod("_getNextSibling", &GetNextSibling);
+  dict.SetMethod("_getRoutingId", &GetRoutingId);
 }
 
 }  // namespace