Bump v3.1.7

* chore: bump libcc submodule to bdb1c8e9d2f184ebeb75a25824aca0be27aa879b

* chore: bump libcc in DEPS to bdb1c8e9d2f184ebeb75a25824aca0be27aa879b

.circleci/config.yml

@@ -263,6 +263,7 @@ jobs:
       TARGET_ARCH: x64
       RUN_TESTS: true
       INSTALL_MACOS_NODE: true
+    resource_class: large
     macos:
       xcode: "8.3.3"
     <<: *build-steps
@@ -272,6 +273,7 @@ jobs:
       TARGET_ARCH: x64
       RUN_RELEASE_BUILD: true
       INSTALL_MACOS_NODE: true
+    resource_class: large
     macos:
       xcode: "8.3.3"
     <<: *build-steps
@@ -282,6 +284,7 @@ jobs:
       MAS_BUILD: 1
       RUN_TESTS: true
       INSTALL_MACOS_NODE: true
+    resource_class: large
     macos:
       xcode: "8.3.3"
     <<: *build-steps
@@ -292,6 +295,7 @@ jobs:
       MAS_BUILD: 1
       RUN_RELEASE_BUILD: true
       INSTALL_MACOS_NODE: true
+    resource_class: large
     macos:
       xcode: "8.3.3"
     <<: *build-steps

DEPS

@@ -2,7 +2,7 @@ vars = {
   'chromium_version':
     '63.0.3239.150',
   'libchromiumcontent_revision':
-    'd2c3189f30cfb39f888a917671024733fe5cffcc',
+    'bdb1c8e9d2f184ebeb75a25824aca0be27aa879b',
   'node_version':
     'v9.7.0-33-g538a5023af',
   'native_mate_revision':

appveyor.yml

@@ -5,7 +5,7 @@ build_script:
     echo "Build worker image $env:APPVEYOR_BUILD_WORKER_IMAGE"
 
     &"C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe"
-    
+
     if($env:SKIP_GYP_BUILD -eq "true") {
       Write-warning "Skipping debug build for older branch"; Exit-AppveyorBuild
     } elseif(($env:APPVEYOR_PULL_REQUEST_HEAD_REPO_NAME -split "/")[0] -eq ($env:APPVEYOR_REPO_NAME -split "/")[0]) {
@@ -43,20 +43,11 @@ test_script:
     if (Test-Path Env:\ELECTRON_RELEASE) {
       Write-Output "Skipping tests for release build"
     } else {
+      $env:RUN_TESTS="true"
       Write-Output "Running tests for debug build"
-      python script\test.py --ci --rebuild_native_modules
-      if ($LASTEXITCODE -ne '0') {
-        throw "Tests failed with exit code $LASTEXITCODE"
-      } else {
-        Write-Output "Tests succeeded."
-      }
-      python script\verify-ffmpeg.py
-      if ($LASTEXITCODE -ne '0') {
-        throw "Verify ffmpeg failed with exit code $LASTEXITCODE"
-      } else {
-        "Verify ffmpeg succeeded."
-      }
     }
+- if "%RUN_TESTS%"=="true" ( echo Running test suite & python script\test.py --ci --rebuild_native_modules)
+- if "%RUN_TESTS%"=="true" ( echo Running verify ffmpeg & python script\verify-ffmpeg.py)
 artifacts:
 - path: test-results.xml
   name: test-results.xml

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)
 
@@ -55,6 +59,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)
+    freopen("/dev/null", "r", stdin);
+  if (fstat(STDOUT_FILENO, &st) < 0 && errno == EBADF)
+    freopen("/dev/null", "w", stdout);
+  if (fstat(STDERR_FILENO, &st) < 0 && errno == EBADF)
+    freopen("/dev/null", "w", stderr);
+}
+#endif
+
 }  // namespace
 
 #if defined(OS_WIN)
@@ -157,6 +180,8 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
 
 int main(int argc, char* argv[]) {
 #ifdef ENABLE_RUN_AS_NODE
+  FixStdioStreams();
+
   if (IsEnvSet(kRunAsNode)) {
     base::i18n::InitializeICU();
     base::AtExitManager atexit_manager;
@@ -176,6 +201,8 @@ int main(int argc, char* argv[]) {
 
 int main(int argc, char* argv[]) {
 #ifdef ENABLE_RUN_AS_NODE
+  FixStdioStreams();
+
   if (IsEnvSet(kRunAsNode)) {
     return AtomInitializeICUandStartNode(argc, argv);
   }

atom/browser/api/atom_api_browser_window.cc

@@ -183,7 +183,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());

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

@@ -5,7 +5,7 @@
 #include "atom/browser/api/atom_api_cookies.h"
 
 #include "atom/browser/atom_browser_context.h"
-#include "atom/browser/request_context_delegate.h"
+#include "atom/browser/cookie_change_notifier.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
@@ -56,20 +56,21 @@ struct Converter<net::CanonicalCookie> {
 };
 
 template <>
-struct Converter<net::CookieChangeCause> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const net::CookieChangeCause& val) {
+struct Converter<network::mojom::CookieChangeCause> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const network::mojom::CookieChangeCause& val) {
     switch (val) {
-      case net::CookieChangeCause::INSERTED:
-      case net::CookieChangeCause::EXPLICIT:
+      case network::mojom::CookieChangeCause::INSERTED:
+      case network::mojom::CookieChangeCause::EXPLICIT:
         return mate::StringToV8(isolate, "explicit");
-      case net::CookieChangeCause::OVERWRITE:
+      case network::mojom::CookieChangeCause::OVERWRITE:
         return mate::StringToV8(isolate, "overwrite");
-      case net::CookieChangeCause::EXPIRED:
+      case network::mojom::CookieChangeCause::EXPIRED:
         return mate::StringToV8(isolate, "expired");
-      case net::CookieChangeCause::EVICTED:
+      case network::mojom::CookieChangeCause::EVICTED:
         return mate::StringToV8(isolate, "evicted");
-      case net::CookieChangeCause::EXPIRED_OVERWRITE:
+      case network::mojom::CookieChangeCause::EXPIRED_OVERWRITE:
         return mate::StringToV8(isolate, "expired-overwrite");
       default:
         return mate::StringToV8(isolate, "unknown");
@@ -255,9 +256,8 @@ Cookies::Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context)
     : browser_context_(browser_context) {
   Init(isolate);
   cookie_change_subscription_ =
-      browser_context->GetRequestContextDelegate()
-          ->RegisterCookieChangeCallback(
-              base::Bind(&Cookies::OnCookieChanged, base::Unretained(this)));
+      browser_context_->cookie_change_notifier()->RegisterCookieChangeCallback(
+          base::Bind(&Cookies::OnCookieChanged, base::Unretained(this)));
 }
 
 Cookies::~Cookies() {}

atom/browser/api/atom_api_cookies.h

@@ -55,7 +55,7 @@ class Cookies : public mate::TrackableObject<Cookies> {
   void Set(const base::DictionaryValue& details, const SetCallback& callback);
   void FlushStore(const base::Closure& callback);
 
-  // AtomBrowserContext::RegisterCookieChangeCallback subscription:
+  // CookieChangeNotifier subscription:
   void OnCookieChanged(const CookieDetails*);
 
  private:

atom/browser/api/atom_api_global_shortcut.cc

@@ -6,15 +6,45 @@
 
 #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"
+#include "atom/common/platform_util.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 (platform_util::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 +61,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 +70,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());

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;
 
@@ -101,6 +102,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_net_log.cc

@@ -3,13 +3,19 @@
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_net_log.h"
-#include "atom/browser/atom_browser_client.h"
+
+#include <utility>
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
-#include "base/callback.h"
-#include "content/public/common/content_switches.h"
+#include "base/command_line.h"
+#include "components/net_log/chrome_net_log.h"
+#include "content/public/browser/storage_partition.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/handle.h"
+#include "net/url_request/url_request_context_getter.h"
 
 #include "atom/common/node_includes.h"
 
@@ -17,17 +23,17 @@ namespace atom {
 
 namespace api {
 
-NetLog::NetLog(v8::Isolate* isolate) {
+NetLog::NetLog(v8::Isolate* isolate, AtomBrowserContext* browser_context)
+    : browser_context_(browser_context) {
   Init(isolate);
 
-  net_log_ = atom::AtomBrowserClient::Get()->GetNetLog();
+  net_log_writer_ =
+      atom::AtomBrowserMainParts::Get()->net_log()->net_export_file_writer();
+  net_log_writer_->AddObserver(this);
 }
 
-NetLog::~NetLog() {}
-
-// static
-v8::Local<v8::Value> NetLog::Create(v8::Isolate* isolate) {
-  return mate::CreateHandle(isolate, new NetLog(isolate)).ToV8();
+NetLog::~NetLog() {
+  net_log_writer_->RemoveObserver(this);
 }
 
 void NetLog::StartLogging(mate::Arguments* args) {
@@ -37,22 +43,82 @@ void NetLog::StartLogging(mate::Arguments* args) {
     return;
   }
 
-  net_log_->StartDynamicLogging(log_path);
+  net_log::NetExportFileWriter::URLRequestContextGetterList context_getters = {
+      browser_context_->GetRequestContext()};
+
+  // TODO(deepak1556): Provide more flexibility to this module
+  // by allowing customizations on the capturing options.
+  net_log_writer_->StartNetLog(
+      log_path, net::NetLogCaptureMode::Default(),
+      net_log::NetExportFileWriter::kNoLimit /* file size limit */,
+      base::CommandLine::ForCurrentProcess()->GetCommandLineString(),
+      std::string(), context_getters);
 }
 
-bool NetLog::IsCurrentlyLogging() {
-  return net_log_->IsDynamicLogging();
+std::string NetLog::GetLoggingState() const {
+  if (!net_log_state_)
+    return std::string();
+  const base::Value* current_log_state =
+      net_log_state_->FindKeyOfType("state", base::Value::Type::STRING);
+  if (!current_log_state)
+    return std::string();
+  return current_log_state->GetString();
 }
 
-base::FilePath::StringType NetLog::GetCurrentlyLoggingPath() {
-  return net_log_->GetDynamicLoggingPath().value();
+bool NetLog::IsCurrentlyLogging() const {
+  const std::string log_state = GetLoggingState();
+  return (log_state == "STARTING_LOG") || (log_state == "LOGGING");
+}
+
+std::string NetLog::GetCurrentlyLoggingPath() const {
+  // Net log exporter has a default path which will be used
+  // when no log path is provided, but since we don't allow
+  // net log capture without user provided file path, this
+  // check is completely safe.
+  if (IsCurrentlyLogging()) {
+    const base::Value* current_log_path =
+        net_log_state_->FindKeyOfType("file", base::Value::Type::STRING);
+    if (current_log_path)
+      return current_log_path->GetString();
+  }
+
+  return std::string();
 }
 
 void NetLog::StopLogging(mate::Arguments* args) {
-  base::OnceClosure callback;
-  args->GetNext(&callback);
+  net_log::NetExportFileWriter::FilePathCallback callback;
+  if (!args->GetNext(&callback)) {
+    args->ThrowError("Invalid callback function");
+    return;
+  }
 
-  net_log_->StopDynamicLogging(std::move(callback));
+  if (IsCurrentlyLogging()) {
+    stop_callback_queue_.emplace_back(callback);
+    net_log_writer_->StopNetLog(nullptr, nullptr);
+  } else {
+    callback.Run(base::FilePath());
+  }
+}
+
+void NetLog::OnNewState(const base::DictionaryValue& state) {
+  net_log_state_ = state.CreateDeepCopy();
+
+  if (stop_callback_queue_.empty())
+    return;
+
+  if (GetLoggingState() == "NOT_LOGGING") {
+    for (auto& callback : stop_callback_queue_) {
+      if (!callback.is_null())
+        net_log_writer_->GetFilePathToCompletedLog(callback);
+    }
+    stop_callback_queue_.clear();
+  }
+}
+
+// static
+mate::Handle<NetLog> NetLog::Create(v8::Isolate* isolate,
+                                    AtomBrowserContext* browser_context) {
+  return mate::CreateHandle(isolate, new NetLog(isolate, browser_context));
 }
 
 // static
@@ -63,28 +129,9 @@ void NetLog::BuildPrototype(v8::Isolate* isolate,
       .SetProperty("currentlyLogging", &NetLog::IsCurrentlyLogging)
       .SetProperty("currentlyLoggingPath", &NetLog::GetCurrentlyLoggingPath)
       .SetMethod("startLogging", &NetLog::StartLogging)
-      .SetMethod("_stopLogging", &NetLog::StopLogging);
+      .SetMethod("stopLogging", &NetLog::StopLogging);
 }
 
 }  // namespace api
 
 }  // namespace atom
-
-namespace {
-
-using atom::api::NetLog;
-
-void Initialize(v8::Local<v8::Object> exports,
-                v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context,
-                void* priv) {
-  v8::Isolate* isolate = context->GetIsolate();
-
-  mate::Dictionary dict(isolate, exports);
-  dict.Set("netLog", NetLog::Create(isolate));
-  dict.Set("NetLog", NetLog::GetConstructor(isolate)->GetFunction());
-}
-
-}  // namespace
-
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(atom_browser_net_log, Initialize)

atom/browser/api/atom_api_net_log.h

@@ -5,32 +5,50 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_NET_LOG_H_
 #define ATOM_BROWSER_API_ATOM_API_NET_LOG_H_
 
+#include <list>
+#include <memory>
 #include <string>
-#include "brightray/browser/net_log.h"
-#include "native_mate/wrappable.h"
+
+#include "atom/browser/api/trackable_object.h"
+#include "base/callback.h"
+#include "base/values.h"
+#include "components/net_log/net_export_file_writer.h"
+#include "native_mate/handle.h"
 
 namespace atom {
 
+class AtomBrowserContext;
+
 namespace api {
 
-class NetLog : public mate::Wrappable<NetLog> {
+class NetLog : public mate::TrackableObject<NetLog>,
+               public net_log::NetExportFileWriter::StateObserver {
  public:
-  static v8::Local<v8::Value> Create(v8::Isolate* isolate);
+  static mate::Handle<NetLog> Create(v8::Isolate* isolate,
+                                     AtomBrowserContext* browser_context);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
 
   void StartLogging(mate::Arguments* args);
-  bool IsCurrentlyLogging();
-  base::FilePath::StringType GetCurrentlyLoggingPath();
+  std::string GetLoggingState() const;
+  bool IsCurrentlyLogging() const;
+  std::string GetCurrentlyLoggingPath() const;
   void StopLogging(mate::Arguments* args);
 
  protected:
-  explicit NetLog(v8::Isolate* isolate);
+  explicit NetLog(v8::Isolate* isolate, AtomBrowserContext* browser_context);
   ~NetLog() override;
 
+  // net_log::NetExportFileWriter::StateObserver implementation
+  void OnNewState(const base::DictionaryValue& state) override;
+
  private:
-  brightray::NetLog* net_log_;
+  AtomBrowserContext* browser_context_;
+  net_log::NetExportFileWriter* net_log_writer_;
+  std::list<net_log::NetExportFileWriter::FilePathCallback>
+      stop_callback_queue_;
+  std::unique_ptr<base::DictionaryValue> net_log_state_;
 
   DISALLOW_COPY_AND_ASSIGN(NetLog);
 };

atom/browser/api/atom_api_protocol.cc

@@ -83,7 +83,8 @@ void Protocol::UnregisterProtocol(const std::string& scheme,
                                   mate::Arguments* args) {
   CompletionCallback callback;
   args->GetNext(&callback);
-  auto* getter = browser_context_->GetRequestContext();
+  auto* getter = static_cast<URLRequestContextGetter*>(
+      browser_context_->GetRequestContext());
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::IO, FROM_HERE,
       base::BindOnce(&Protocol::UnregisterProtocolInIO,
@@ -93,10 +94,9 @@ void Protocol::UnregisterProtocol(const std::string& scheme,
 
 // static
 Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
-    scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+    scoped_refptr<URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
-  auto* job_factory = static_cast<AtomURLRequestJobFactory*>(
-      request_context_getter->job_factory());
+  auto* job_factory = request_context_getter->job_factory();
   if (!job_factory->HasProtocolHandler(scheme))
     return PROTOCOL_NOT_REGISTERED;
   job_factory->SetProtocolHandler(scheme, nullptr);
@@ -105,7 +105,8 @@ Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
 
 void Protocol::IsProtocolHandled(const std::string& scheme,
                                  const BooleanCallback& callback) {
-  auto* getter = browser_context_->GetRequestContext();
+  auto* getter = static_cast<URLRequestContextGetter*>(
+      browser_context_->GetRequestContext());
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&Protocol::IsProtocolHandledInIO, base::RetainedRef(getter),
@@ -115,7 +116,7 @@ void Protocol::IsProtocolHandled(const std::string& scheme,
 
 // static
 bool Protocol::IsProtocolHandledInIO(
-    scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+    scoped_refptr<URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
   return request_context_getter->job_factory()->IsHandledProtocol(scheme);
 }
@@ -124,7 +125,8 @@ void Protocol::UninterceptProtocol(const std::string& scheme,
                                    mate::Arguments* args) {
   CompletionCallback callback;
   args->GetNext(&callback);
-  auto* getter = browser_context_->GetRequestContext();
+  auto* getter = static_cast<URLRequestContextGetter*>(
+      browser_context_->GetRequestContext());
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::IO, FROM_HERE,
       base::BindOnce(&Protocol::UninterceptProtocolInIO,
@@ -134,11 +136,9 @@ void Protocol::UninterceptProtocol(const std::string& scheme,
 
 // static
 Protocol::ProtocolError Protocol::UninterceptProtocolInIO(
-    scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+    scoped_refptr<URLRequestContextGetter> request_context_getter,
     const std::string& scheme) {
-  return static_cast<AtomURLRequestJobFactory*>(
-             request_context_getter->job_factory())
-                 ->UninterceptProtocol(scheme)
+  return request_context_getter->job_factory()->UninterceptProtocol(scheme)
              ? PROTOCOL_OK
              : PROTOCOL_NOT_INTERCEPTED;
 }

atom/browser/api/atom_api_protocol.h

@@ -100,7 +100,8 @@ class Protocol : public mate::TrackableObject<Protocol> {
                         mate::Arguments* args) {
     CompletionCallback callback;
     args->GetNext(&callback);
-    auto* getter = browser_context_->GetRequestContext();
+    auto* getter = static_cast<URLRequestContextGetter*>(
+        browser_context_->GetRequestContext());
     content::BrowserThread::PostTaskAndReplyWithResult(
         content::BrowserThread::IO, FROM_HERE,
         base::BindOnce(&Protocol::RegisterProtocolInIO<RequestJob>,
@@ -109,12 +110,11 @@ class Protocol : public mate::TrackableObject<Protocol> {
   }
   template <typename RequestJob>
   static ProtocolError RegisterProtocolInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       v8::Isolate* isolate,
       const std::string& scheme,
       const Handler& handler) {
-    auto* job_factory = static_cast<AtomURLRequestJobFactory*>(
-        request_context_getter->job_factory());
+    auto* job_factory = request_context_getter->job_factory();
     if (job_factory->IsHandledProtocol(scheme))
       return PROTOCOL_REGISTERED;
     auto protocol_handler = std::make_unique<CustomProtocolHandler<RequestJob>>(
@@ -128,14 +128,14 @@ class Protocol : public mate::TrackableObject<Protocol> {
   // Unregister the protocol handler that handles |scheme|.
   void UnregisterProtocol(const std::string& scheme, mate::Arguments* args);
   static ProtocolError UnregisterProtocolInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       const std::string& scheme);
 
   // Whether the protocol has handler registered.
   void IsProtocolHandled(const std::string& scheme,
                          const BooleanCallback& callback);
   static bool IsProtocolHandledInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       const std::string& scheme);
 
   // Replace the protocol handler with a new one.
@@ -145,7 +145,8 @@ class Protocol : public mate::TrackableObject<Protocol> {
                          mate::Arguments* args) {
     CompletionCallback callback;
     args->GetNext(&callback);
-    auto* getter = browser_context_->GetRequestContext();
+    auto* getter = static_cast<URLRequestContextGetter*>(
+        browser_context_->GetRequestContext());
     content::BrowserThread::PostTaskAndReplyWithResult(
         content::BrowserThread::IO, FROM_HERE,
         base::BindOnce(&Protocol::InterceptProtocolInIO<RequestJob>,
@@ -154,12 +155,11 @@ class Protocol : public mate::TrackableObject<Protocol> {
   }
   template <typename RequestJob>
   static ProtocolError InterceptProtocolInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       v8::Isolate* isolate,
       const std::string& scheme,
       const Handler& handler) {
-    auto* job_factory = static_cast<AtomURLRequestJobFactory*>(
-        request_context_getter->job_factory());
+    auto* job_factory = request_context_getter->job_factory();
     if (!job_factory->IsHandledProtocol(scheme))
       return PROTOCOL_NOT_REGISTERED;
     // It is possible a protocol is handled but can not be intercepted.
@@ -175,7 +175,7 @@ class Protocol : public mate::TrackableObject<Protocol> {
   // Restore the |scheme| to its original protocol handler.
   void UninterceptProtocol(const std::string& scheme, mate::Arguments* args);
   static ProtocolError UninterceptProtocolInIO(
-      scoped_refptr<brightray::URLRequestContextGetter> request_context_getter,
+      scoped_refptr<URLRequestContextGetter> request_context_getter,
       const std::string& scheme);
 
   // Convert error code to JS exception and call the callback.

atom/browser/api/atom_api_session.cc

@@ -10,6 +10,7 @@
 
 #include "atom/browser/api/atom_api_cookies.h"
 #include "atom/browser/api/atom_api_download_item.h"
+#include "atom/browser/api/atom_api_net_log.h"
 #include "atom/browser/api/atom_api_protocol.h"
 #include "atom/browser/api/atom_api_web_request.h"
 #include "atom/browser/atom_browser_context.h"
@@ -29,12 +30,14 @@
 #include "base/guid.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "brightray/browser/media/media_device_id_salt.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
 #include "components/download/public/common/download_danger_type.h"
 #include "components/prefs/pref_service.h"
+#include "components/prefs/value_map_pref_store.h"
+#include "components/proxy_config/proxy_config_dictionary.h"
+#include "components/proxy_config/proxy_config_pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item_utils.h"
 #include "content/public/browser/download_manager_delegate.h"
@@ -46,8 +49,8 @@
 #include "net/dns/host_cache.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_auth_preferences.h"
-#include "net/proxy_resolution/proxy_config_service_fixed.h"
-#include "net/proxy_resolution/proxy_service.h"
+#include "net/http/http_cache.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ -179,37 +182,6 @@ struct Converter<ClearAuthCacheOptions> {
   }
 };
 
-template <>
-struct Converter<net::ProxyConfig> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     net::ProxyConfig* out) {
-    std::string proxy_rules, proxy_bypass_rules;
-    GURL pac_url;
-    mate::Dictionary options;
-    // Fallback to previous API when passed String.
-    // https://git.io/vuhjj
-    if (ConvertFromV8(isolate, val, &proxy_rules)) {
-      pac_url = GURL(proxy_rules);  // Assume it is PAC script if it is URL.
-    } else if (ConvertFromV8(isolate, val, &options)) {
-      options.Get("pacScript", &pac_url);
-      options.Get("proxyRules", &proxy_rules);
-      options.Get("proxyBypassRules", &proxy_bypass_rules);
-    } else {
-      return false;
-    }
-
-    // pacScript takes precedence over proxyRules.
-    if (!pac_url.is_empty() && pac_url.is_valid()) {
-      out->set_pac_url(pac_url);
-    } else {
-      out->proxy_rules().ParseFromString(proxy_rules);
-      out->proxy_rules().bypass_rules.ParseFromString(proxy_bypass_rules);
-    }
-    return true;
-  }
-};
-
 template <>
 struct Converter<atom::VerifyRequestParams> {
   static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
@@ -236,56 +208,6 @@ const char kPersistPrefix[] = "persist:";
 // Referenced session objects.
 std::map<uint32_t, v8::Global<v8::Object>> g_sessions;
 
-class ResolveProxyHelper {
- public:
-  ResolveProxyHelper(AtomBrowserContext* browser_context,
-                     const GURL& url,
-                     const Session::ResolveProxyCallback& callback)
-      : callback_(callback),
-        original_thread_(base::ThreadTaskRunnerHandle::Get()) {
-    scoped_refptr<net::URLRequestContextGetter> context_getter =
-        browser_context->GetRequestContext();
-    context_getter->GetNetworkTaskRunner()->PostTask(
-        FROM_HERE, base::BindOnce(&ResolveProxyHelper::ResolveProxy,
-                                  base::Unretained(this), context_getter, url));
-  }
-
-  void OnResolveProxyCompleted(int result) {
-    std::string proxy;
-    if (result == net::OK)
-      proxy = proxy_info_.ToPacString();
-    original_thread_->PostTask(FROM_HERE, base::BindOnce(callback_, proxy));
-    delete this;
-  }
-
- private:
-  void ResolveProxy(scoped_refptr<net::URLRequestContextGetter> context_getter,
-                    const GURL& url) {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-
-    net::ProxyResolutionService* proxy_service =
-        context_getter->GetURLRequestContext()->proxy_resolution_service();
-    net::CompletionCallback completion_callback = base::Bind(
-        &ResolveProxyHelper::OnResolveProxyCompleted, base::Unretained(this));
-
-    // Start the request.
-    int result = proxy_service->ResolveProxy(url, "GET", &proxy_info_,
-                                             completion_callback, &pac_req_,
-                                             nullptr, net::NetLogWithSource());
-
-    // Completed synchronously.
-    if (result != net::ERR_IO_PENDING)
-      completion_callback.Run(result);
-  }
-
-  Session::ResolveProxyCallback callback_;
-  net::ProxyInfo proxy_info_;
-  net::ProxyResolutionService::Request* pac_req_;
-  scoped_refptr<base::SingleThreadTaskRunner> original_thread_;
-
-  DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
-};
-
 // Runs the callback in UI thread.
 void RunCallbackInUI(const base::Callback<void()>& callback) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
@@ -343,18 +265,6 @@ void DoCacheActionInIO(
     on_get_backend.Run(net::OK);
 }
 
-void SetProxyInIO(scoped_refptr<net::URLRequestContextGetter> getter,
-                  const net::ProxyConfig& config,
-                  const base::Closure& callback) {
-  auto* proxy_service =
-      getter->GetURLRequestContext()->proxy_resolution_service();
-  proxy_service->ResetConfigService(
-      base::WrapUnique(new net::ProxyConfigServiceFixed(config)));
-  // Refetches and applies the new pac script if provided.
-  proxy_service->ForceReloadProxyConfig();
-  RunCallbackInUI(callback);
-}
-
 void SetCertVerifyProcInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     const AtomCertVerifier::VerifyProc& proc) {
@@ -442,7 +352,7 @@ void DownloadIdCallback(content::DownloadManager* download_manager,
 }
 
 void SetDevToolsNetworkEmulationClientIdInIO(
-    brightray::URLRequestContextGetter* url_request_context_getter,
+    net::URLRequestContextGetter* url_request_context_getter,
     const std::string& client_id) {
   if (!url_request_context_getter)
     return;
@@ -491,6 +401,7 @@ Session::~Session() {
   DestroyGlobalHandle(isolate(), cookies_);
   DestroyGlobalHandle(isolate(), web_request_);
   DestroyGlobalHandle(isolate(), protocol_);
+  DestroyGlobalHandle(isolate(), net_log_);
   g_sessions.erase(weak_map_id());
 }
 
@@ -513,8 +424,10 @@ void Session::OnDownloadCreated(content::DownloadManager* manager,
   }
 }
 
-void Session::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
-  new ResolveProxyHelper(browser_context(), url, callback);
+void Session::ResolveProxy(
+    const GURL& url,
+    const ResolveProxyHelper::ResolveProxyCallback& callback) {
+  browser_context_->GetResolveProxyHelper()->ResolveProxy(url, callback);
 }
 
 template <Session::CacheAction action>
@@ -552,13 +465,34 @@ void Session::FlushStorageData() {
   storage_partition->Flush();
 }
 
-void Session::SetProxy(const net::ProxyConfig& config,
+void Session::SetProxy(const mate::Dictionary& options,
                        const base::Closure& callback) {
-  auto* getter = browser_context_->GetRequestContext();
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&SetProxyInIO, base::RetainedRef(getter), config,
-                     callback));
+  if (!browser_context_->in_memory_pref_store()) {
+    callback.Run();
+    return;
+  }
+
+  std::string proxy_rules, bypass_list, pac_url;
+
+  options.Get("pacScript", &pac_url);
+  options.Get("proxyRules", &proxy_rules);
+  options.Get("proxyBypassRules", &bypass_list);
+
+  // pacScript takes precedence over proxyRules.
+  if (!pac_url.empty()) {
+    browser_context_->in_memory_pref_store()->SetValue(
+        proxy_config::prefs::kProxy,
+        ProxyConfigDictionary::CreatePacScript(pac_url,
+                                               true /* pac_mandatory */),
+        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  } else {
+    browser_context_->in_memory_pref_store()->SetValue(
+        proxy_config::prefs::kProxy,
+        ProxyConfigDictionary::CreateFixedServers(proxy_rules, bypass_list),
+        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  }
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
 void Session::SetDownloadPath(const base::FilePath& path) {
@@ -669,7 +603,7 @@ void Session::SetUserAgent(const std::string& user_agent,
   std::string accept_lang = g_browser_process->GetApplicationLocale();
   args->GetNext(&accept_lang);
 
-  scoped_refptr<brightray::URLRequestContextGetter> getter(
+  scoped_refptr<net::URLRequestContextGetter> getter(
       browser_context_->GetRequestContext());
   getter->GetNetworkTaskRunner()->PostTask(
       FROM_HERE,
@@ -760,6 +694,14 @@ v8::Local<v8::Value> Session::WebRequest(v8::Isolate* isolate) {
   return v8::Local<v8::Value>::New(isolate, web_request_);
 }
 
+v8::Local<v8::Value> Session::NetLog(v8::Isolate* isolate) {
+  if (net_log_.IsEmpty()) {
+    auto handle = atom::api::NetLog::Create(isolate, browser_context());
+    net_log_.Reset(isolate, handle.ToV8());
+  }
+  return v8::Local<v8::Value>::New(isolate, net_log_);
+}
+
 // static
 mate::Handle<Session> Session::CreateFrom(v8::Isolate* isolate,
                                           AtomBrowserContext* browser_context) {
@@ -826,6 +768,7 @@ void Session::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setPreloads", &Session::SetPreloads)
       .SetMethod("getPreloads", &Session::GetPreloads)
       .SetProperty("cookies", &Session::Cookies)
+      .SetProperty("netLog", &Session::NetLog)
       .SetProperty("protocol", &Session::Protocol)
       .SetProperty("webRequest", &Session::WebRequest);
 }

atom/browser/api/atom_api_session.h

@@ -10,6 +10,7 @@
 
 #include "atom/browser/api/trackable_object.h"
 #include "atom/browser/atom_blob_reader.h"
+#include "atom/browser/net/resolve_proxy_helper.h"
 #include "base/values.h"
 #include "content/public/browser/download_manager.h"
 #include "native_mate/handle.h"
@@ -39,8 +40,6 @@ namespace api {
 class Session : public mate::TrackableObject<Session>,
                 public content::DownloadManager::Observer {
  public:
-  using ResolveProxyCallback = base::Callback<void(std::string)>;
-
   enum class CacheAction {
     CLEAR,
     STATS,
@@ -63,12 +62,13 @@ class Session : public mate::TrackableObject<Session>,
                              v8::Local<v8::FunctionTemplate> prototype);
 
   // Methods.
-  void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
+  void ResolveProxy(const GURL& url,
+                    const ResolveProxyHelper::ResolveProxyCallback& callback);
   template <CacheAction action>
   void DoCacheAction(const net::CompletionCallback& callback);
   void ClearStorageData(mate::Arguments* args);
   void FlushStorageData();
-  void SetProxy(const net::ProxyConfig& config, const base::Closure& callback);
+  void SetProxy(const mate::Dictionary& options, const base::Closure& callback);
   void SetDownloadPath(const base::FilePath& path);
   void EnableNetworkEmulation(const mate::Dictionary& options);
   void DisableNetworkEmulation();
@@ -88,6 +88,7 @@ class Session : public mate::TrackableObject<Session>,
   v8::Local<v8::Value> Cookies(v8::Isolate* isolate);
   v8::Local<v8::Value> Protocol(v8::Isolate* isolate);
   v8::Local<v8::Value> WebRequest(v8::Isolate* isolate);
+  v8::Local<v8::Value> NetLog(v8::Isolate* isolate);
 
  protected:
   Session(v8::Isolate* isolate, AtomBrowserContext* browser_context);
@@ -102,6 +103,7 @@ class Session : public mate::TrackableObject<Session>,
   v8::Global<v8::Value> cookies_;
   v8::Global<v8::Value> protocol_;
   v8::Global<v8::Value> web_request_;
+  v8::Global<v8::Value> net_log_;
 
   // The X-DevTools-Emulate-Network-Conditions-Client-Id.
   std::string devtools_network_emulation_client_id_;

atom/browser/api/atom_api_system_preferences.h

@@ -93,6 +93,8 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences>
                       mate::Arguments* args);
   void RemoveUserDefault(const std::string& name);
   bool IsSwipeTrackingFromScrollEventsEnabled();
+
+  static bool IsTrustedAccessibilityClient(bool prompt);
 #endif
   bool IsDarkMode();
   bool IsInvertedColorScheme();

atom/browser/api/atom_api_system_preferences_mac.mm

@@ -308,6 +308,12 @@ void SystemPreferences::SetUserDefault(const std::string& name,
   }
 }
 
+// static
+bool SystemPreferences::IsTrustedAccessibilityClient(bool prompt) {
+  NSDictionary* options = @{(id)kAXTrustedCheckOptionPrompt : @(prompt)};
+  return AXIsProcessTrustedWithOptions((CFDictionaryRef)options);
+}
+
 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

@@ -664,8 +664,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_request.cc

@@ -42,7 +42,7 @@ namespace {
 
 template <typename Method, typename Event, typename Listener>
 void CallNetworkDelegateMethod(
-    brightray::URLRequestContextGetter* url_request_context_getter,
+    URLRequestContextGetter* url_request_context_getter,
     Method method,
     Event type,
     URLPatterns patterns,
@@ -94,8 +94,8 @@ void WebRequest::SetListener(Method method, Event type, mate::Arguments* args) {
     return;
   }
 
-  brightray::URLRequestContextGetter* url_request_context_getter =
-      browser_context_->GetRequestContext();
+  auto* url_request_context_getter = static_cast<URLRequestContextGetter*>(
+      browser_context_->GetRequestContext());
   if (!url_request_context_getter)
     return;
   BrowserThread::PostTask(

atom/browser/atom_browser_client.cc

@@ -17,6 +17,7 @@
 #include "atom/browser/atom_resource_dispatcher_host_delegate.h"
 #include "atom/browser/atom_speech_recognition_manager_delegate.h"
 #include "atom/browser/child_web_contents_tracker.h"
+#include "atom/browser/io_thread.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/session_preferences.h"
 #include "atom/browser/web_contents_permission_helper.h"
@@ -27,12 +28,16 @@
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_util.h"
+#include "base/json/json_reader.h"
+#include "base/no_destructor.h"
 #include "base/stl_util.h"
 #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/renderer_host/pepper/chrome_browser_pepper_host_factory.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"
 #include "content/public/browser/render_frame_host.h"
@@ -43,12 +48,15 @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/service_names.mojom.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/web_preferences.h"
 #include "device/geolocation/public/cpp/location_provider.h"
+#include "net/base/escape.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "ppapi/host/ppapi_host.h"
 #include "services/network/public/cpp/resource_request_body.h"
+#include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "v8/include/v8.h"
 
@@ -504,10 +512,28 @@ AtomBrowserClient::OverrideSystemLocationProvider() {
 #endif
 }
 
+network::mojom::NetworkContextPtr AtomBrowserClient::CreateNetworkContext(
+    content::BrowserContext* browser_context,
+    bool /*in_memory*/,
+    const base::FilePath& /*relative_partition_path*/) {
+  if (!browser_context)
+    return nullptr;
+  return static_cast<AtomBrowserContext*>(browser_context)->GetNetworkContext();
+}
+
+void AtomBrowserClient::RegisterOutOfProcessServices(
+    OutOfProcessServiceMap* services) {
+  (*services)[proxy_resolver::mojom::kProxyResolverServiceName] =
+      base::ASCIIToUTF16("V8 Proxy Resolver");
+}
+
+net::NetLog* AtomBrowserClient::GetNetLog() {
+  return AtomBrowserMainParts::Get()->net_log();
+}
+
 brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
-    const content::MainFunctionParams&) {
-  v8::V8::Initialize();  // Init V8 before creating main parts.
-  return new AtomBrowserMainParts;
+    const content::MainFunctionParams& params) {
+  return new AtomBrowserMainParts(params);
 }
 
 void AtomBrowserClient::WebNotificationAllowed(

atom/browser/atom_browser_client.h

@@ -108,6 +108,12 @@ class AtomBrowserClient : public brightray::BrowserClient,
       content::ResourceContext* resource_context) override;
   std::unique_ptr<device::LocationProvider> OverrideSystemLocationProvider()
       override;
+  network::mojom::NetworkContextPtr CreateNetworkContext(
+      content::BrowserContext* browser_context,
+      bool in_memory,
+      const base::FilePath& relative_partition_path) override;
+  void RegisterOutOfProcessServices(OutOfProcessServiceMap* services) override;
+  net::NetLog* GetNetLog() override;
 
   // brightray::BrowserClient:
   brightray::BrowserMainParts* OverrideCreateBrowserMainParts(

atom/browser/atom_browser_context.cc

@@ -4,12 +4,16 @@
 
 #include "atom/browser/atom_browser_context.h"
 
+#include <utility>
+
 #include "atom/browser/atom_blob_reader.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_download_manager_delegate.h"
 #include "atom/browser/atom_permission_manager.h"
 #include "atom/browser/browser.h"
-#include "atom/browser/request_context_delegate.h"
+#include "atom/browser/cookie_change_notifier.h"
+#include "atom/browser/net/resolve_proxy_helper.h"
+#include "atom/browser/pref_store_delegate.h"
 #include "atom/browser/web_view_manager.h"
 #include "atom/common/atom_version.h"
 #include "atom/common/chrome_version.h"
@@ -17,12 +21,31 @@
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/thread_restrictions.h"
+#include "brightray/browser/brightray_paths.h"
+#include "brightray/browser/inspectable_web_contents_impl.h"
+#include "brightray/browser/special_storage_policy.h"
+#include "brightray/browser/zoom_level_delegate.h"
+#include "brightray/common/application_info.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
+#include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/pref_service.h"
+#include "components/prefs/pref_service_factory.h"
+#include "components/prefs/value_map_pref_store.h"
+#include "components/proxy_config/pref_proxy_config_tracker_impl.h"
+#include "components/proxy_config/proxy_config_pref_names.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/common/user_agent.h"
+#include "net/base/escape.h"
+
+using content::BrowserThread;
 
 namespace atom {
 
@@ -36,13 +59,25 @@ std::string RemoveWhitespace(const std::string& str) {
     return str;
 }
 
+// Convert string to lower case and escape it.
+std::string MakePartitionName(const std::string& input) {
+  return net::EscapePath(base::ToLowerASCII(input));
+}
+
 }  // namespace
 
+// static
+AtomBrowserContext::BrowserContextMap AtomBrowserContext::browser_context_map_;
+
 AtomBrowserContext::AtomBrowserContext(const std::string& partition,
                                        bool in_memory,
                                        const base::DictionaryValue& options)
-    : brightray::BrowserContext(partition, in_memory),
-      url_request_context_getter_(nullptr) {
+    : base::RefCountedDeleteOnSequence<AtomBrowserContext>(
+          base::SequencedTaskRunnerHandle::Get()),
+      in_memory_pref_store_(nullptr),
+      storage_policy_(new brightray::SpecialStoragePolicy),
+      in_memory_(in_memory),
+      weak_factory_(this) {
   // Construct user agent string.
   Browser* browser = Browser::Get();
   std::string name = RemoveWhitespace(browser->GetName());
@@ -59,23 +94,131 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition,
 
   // Read options.
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  bool use_cache = !command_line->HasSwitch(switches::kDisableHttpCache);
-  options.GetBoolean("cache", &use_cache);
+  use_cache_ = !command_line->HasSwitch(switches::kDisableHttpCache);
+  options.GetBoolean("cache", &use_cache_);
 
-  request_context_delegate_.reset(new RequestContextDelegate(use_cache));
+  base::StringToInt(command_line->GetSwitchValueASCII(switches::kDiskCacheSize),
+                    &max_cache_size_);
 
-  // Initialize Pref Registry in brightray.
+  if (!base::PathService::Get(brightray::DIR_USER_DATA, &path_)) {
+    base::PathService::Get(brightray::DIR_APP_DATA, &path_);
+    path_ = path_.Append(
+        base::FilePath::FromUTF8Unsafe(brightray::GetApplicationName()));
+    base::PathService::Override(brightray::DIR_USER_DATA, path_);
+  }
+
+  if (!in_memory && !partition.empty())
+    path_ = path_.Append(FILE_PATH_LITERAL("Partitions"))
+                .Append(base::FilePath::FromUTF8Unsafe(
+                    MakePartitionName(partition)));
+
+  content::BrowserContext::Initialize(this, path_);
+
+  // Initialize Pref Registry.
   InitPrefs();
+
+  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);
 }
 
 AtomBrowserContext::~AtomBrowserContext() {
-  url_request_context_getter_->set_delegate(nullptr);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  NotifyWillBeDestroyed(this);
+  ShutdownStoragePartitions();
+  io_handle_->ShutdownOnUIThread();
+}
+
+void AtomBrowserContext::InitPrefs() {
+  auto prefs_path = GetPath().Append(FILE_PATH_LITERAL("Preferences"));
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  PrefServiceFactory prefs_factory;
+  scoped_refptr<JsonPrefStore> pref_store =
+      base::MakeRefCounted<JsonPrefStore>(prefs_path);
+  pref_store->ReadPrefs();  // Synchronous.
+  prefs_factory.set_user_prefs(pref_store);
+
+  auto registry = WrapRefCounted(new PrefRegistrySimple);
+
+  registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory,
+                                 base::FilePath());
+  base::FilePath download_dir;
+  base::PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS, &download_dir);
+  registry->RegisterFilePathPref(prefs::kDownloadDefaultDirectory,
+                                 download_dir);
+  registry->RegisterDictionaryPref(prefs::kDevToolsFileSystemPaths);
+  brightray::InspectableWebContentsImpl::RegisterPrefs(registry.get());
+  brightray::MediaDeviceIDSalt::RegisterPrefs(registry.get());
+  brightray::ZoomLevelDelegate::RegisterPrefs(registry.get());
+  PrefProxyConfigTrackerImpl::RegisterPrefs(registry.get());
+
+  prefs_ = prefs_factory.Create(
+      registry.get(),
+      std::make_unique<PrefStoreDelegate>(weak_factory_.GetWeakPtr()));
+  prefs_->UpdateCommandLinePrefStore(new ValueMapPrefStore);
 }
 
 void AtomBrowserContext::SetUserAgent(const std::string& user_agent) {
   user_agent_ = user_agent;
 }
 
+net::URLRequestContextGetter* AtomBrowserContext::CreateRequestContext(
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector protocol_interceptors) {
+  return io_handle_
+      ->CreateMainRequestContextGetter(protocol_handlers,
+                                       std::move(protocol_interceptors))
+      .get();
+}
+
+net::URLRequestContextGetter* AtomBrowserContext::CreateMediaRequestContext() {
+  return io_handle_->GetMainRequestContextGetter().get();
+}
+
+net::URLRequestContextGetter* AtomBrowserContext::GetRequestContext() {
+  return GetDefaultStoragePartition(this)->GetURLRequestContext();
+}
+
+network::mojom::NetworkContextPtr AtomBrowserContext::GetNetworkContext() {
+  return io_handle_->GetNetworkContext();
+}
+
+base::FilePath AtomBrowserContext::GetPath() const {
+  return path_;
+}
+
+bool AtomBrowserContext::IsOffTheRecord() const {
+  return in_memory_;
+}
+
+bool AtomBrowserContext::CanUseHttpCache() const {
+  return use_cache_;
+}
+
+int AtomBrowserContext::GetMaxCacheSize() const {
+  return max_cache_size_;
+}
+
+content::ResourceContext* AtomBrowserContext::GetResourceContext() {
+  return io_handle_->GetResourceContext();
+}
+
+std::string AtomBrowserContext::GetMediaDeviceIDSalt() {
+  if (!media_device_id_salt_.get())
+    media_device_id_salt_.reset(new brightray::MediaDeviceIDSalt(prefs_.get()));
+  return media_device_id_salt_->GetSalt();
+}
+
+std::unique_ptr<content::ZoomLevelDelegate>
+AtomBrowserContext::CreateZoomLevelDelegate(
+    const base::FilePath& partition_path) {
+  if (!IsOffTheRecord()) {
+    return std::make_unique<brightray::ZoomLevelDelegate>(prefs(),
+                                                          partition_path);
+  }
+  return std::unique_ptr<content::ZoomLevelDelegate>();
+}
+
 content::DownloadManagerDelegate*
 AtomBrowserContext::GetDownloadManagerDelegate() {
   if (!download_manager_delegate_.get()) {
@@ -98,26 +241,14 @@ content::PermissionManager* AtomBrowserContext::GetPermissionManager() {
   return permission_manager_.get();
 }
 
-void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
-  pref_registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory,
-                                      base::FilePath());
-  base::FilePath download_dir;
-  PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS, &download_dir);
-  pref_registry->RegisterFilePathPref(prefs::kDownloadDefaultDirectory,
-                                      download_dir);
-  pref_registry->RegisterDictionaryPref(prefs::kDevToolsFileSystemPaths);
+storage::SpecialStoragePolicy* AtomBrowserContext::GetSpecialStoragePolicy() {
+  return storage_policy_.get();
 }
 
 std::string AtomBrowserContext::GetUserAgent() const {
   return user_agent_;
 }
 
-void AtomBrowserContext::OnMainRequestContextCreated(
-    brightray::URLRequestContextGetter* getter) {
-  getter->set_delegate(request_context_delegate_.get());
-  url_request_context_getter_ = getter;
-}
-
 AtomBlobReader* AtomBrowserContext::GetBlobReader() {
   if (!blob_reader_.get()) {
     content::ChromeBlobStorageContext* blob_context =
@@ -127,16 +258,67 @@ AtomBlobReader* AtomBrowserContext::GetBlobReader() {
   return blob_reader_.get();
 }
 
+content::PushMessagingService* AtomBrowserContext::GetPushMessagingService() {
+  return nullptr;
+}
+
+content::SSLHostStateDelegate* AtomBrowserContext::GetSSLHostStateDelegate() {
+  return nullptr;
+}
+
+content::BackgroundFetchDelegate*
+AtomBrowserContext::GetBackgroundFetchDelegate() {
+  return nullptr;
+}
+
+content::BackgroundSyncController*
+AtomBrowserContext::GetBackgroundSyncController() {
+  return nullptr;
+}
+
+content::BrowsingDataRemoverDelegate*
+AtomBrowserContext::GetBrowsingDataRemoverDelegate() {
+  return nullptr;
+}
+
+net::URLRequestContextGetter*
+AtomBrowserContext::CreateRequestContextForStoragePartition(
+    const base::FilePath& partition_path,
+    bool in_memory,
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector request_interceptors) {
+  NOTREACHED();
+  return nullptr;
+}
+
+net::URLRequestContextGetter*
+AtomBrowserContext::CreateMediaRequestContextForStoragePartition(
+    const base::FilePath& partition_path,
+    bool in_memory) {
+  NOTREACHED();
+  return nullptr;
+}
+
+ResolveProxyHelper* AtomBrowserContext::GetResolveProxyHelper() {
+  if (!resolve_proxy_helper_) {
+    resolve_proxy_helper_ = base::MakeRefCounted<ResolveProxyHelper>(this);
+  }
+  return resolve_proxy_helper_.get();
+}
+
 // static
 scoped_refptr<AtomBrowserContext> AtomBrowserContext::From(
     const std::string& partition,
     bool in_memory,
     const base::DictionaryValue& options) {
-  auto browser_context = brightray::BrowserContext::Get(partition, in_memory);
+  PartitionKey key(partition, in_memory);
+  auto* browser_context = browser_context_map_[key].get();
   if (browser_context)
-    return static_cast<AtomBrowserContext*>(browser_context.get());
+    return scoped_refptr<AtomBrowserContext>(browser_context);
 
-  return new AtomBrowserContext(partition, in_memory, options);
+  auto* new_context = new AtomBrowserContext(partition, in_memory, options);
+  browser_context_map_[key] = new_context->GetWeakPtr();
+  return scoped_refptr<AtomBrowserContext>(new_context);
 }
 
 }  // namespace atom

atom/browser/atom_browser_context.h

@@ -5,20 +5,39 @@
 #ifndef ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
 #define ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
 
+#include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
-#include "brightray/browser/browser_context.h"
+#include "atom/browser/net/url_request_context_getter.h"
+#include "base/memory/ref_counted_delete_on_sequence.h"
+#include "base/memory/weak_ptr.h"
+#include "brightray/browser/media/media_device_id_salt.h"
+#include "chrome/browser/net/proxy_config_monitor.h"
+#include "content/public/browser/browser_context.h"
+
+class PrefRegistrySimple;
+class PrefService;
+class ValueMapPrefStore;
+
+namespace brightray {
+class SpecialStoragePolicy;
+}
 
 namespace atom {
 
 class AtomBlobReader;
+class AtomBrowserContext;
 class AtomDownloadManagerDelegate;
 class AtomPermissionManager;
-class RequestContextDelegate;
+class CookieChangeNotifier;
+class ResolveProxyHelper;
 class WebViewManager;
 
-class AtomBrowserContext : public brightray::BrowserContext {
+class AtomBrowserContext
+    : public base::RefCountedDeleteOnSequence<AtomBrowserContext>,
+      public content::BrowserContext {
  public:
   // Get or create the BrowserContext according to its |partition| and
   // |in_memory|. The |options| will be passed to constructor when there is no
@@ -29,21 +48,60 @@ class AtomBrowserContext : public brightray::BrowserContext {
       const base::DictionaryValue& options = base::DictionaryValue());
 
   void SetUserAgent(const std::string& user_agent);
+  std::string GetUserAgent() const;
+  bool CanUseHttpCache() const;
+  int GetMaxCacheSize() const;
   AtomBlobReader* GetBlobReader();
+  network::mojom::NetworkContextPtr GetNetworkContext();
+  // Get the request context, if there is none, create it.
+  net::URLRequestContextGetter* GetRequestContext();
+  ResolveProxyHelper* GetResolveProxyHelper();
 
   // content::BrowserContext:
+  base::FilePath GetPath() const override;
+  bool IsOffTheRecord() const override;
+  content::ResourceContext* GetResourceContext() override;
+  std::unique_ptr<content::ZoomLevelDelegate> CreateZoomLevelDelegate(
+      const base::FilePath& partition_path) override;
+  content::PushMessagingService* GetPushMessagingService() override;
+  content::SSLHostStateDelegate* GetSSLHostStateDelegate() override;
+  content::BackgroundFetchDelegate* GetBackgroundFetchDelegate() override;
+  content::BackgroundSyncController* GetBackgroundSyncController() override;
+  content::BrowsingDataRemoverDelegate* GetBrowsingDataRemoverDelegate()
+      override;
+  net::URLRequestContextGetter* CreateRequestContextForStoragePartition(
+      const base::FilePath& partition_path,
+      bool in_memory,
+      content::ProtocolHandlerMap* protocol_handlers,
+      content::URLRequestInterceptorScopedVector request_interceptors) override;
+  net::URLRequestContextGetter* CreateMediaRequestContextForStoragePartition(
+      const base::FilePath& partition_path,
+      bool in_memory) override;
+  std::string GetMediaDeviceIDSalt() override;
   content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
   content::BrowserPluginGuestManager* GetGuestManager() override;
   content::PermissionManager* GetPermissionManager() override;
+  storage::SpecialStoragePolicy* GetSpecialStoragePolicy() override;
+  net::URLRequestContextGetter* CreateRequestContext(
+      content::ProtocolHandlerMap* protocol_handlers,
+      content::URLRequestInterceptorScopedVector request_interceptors) override;
+  net::URLRequestContextGetter* CreateMediaRequestContext() override;
 
-  // brightray::BrowserContext:
-  void RegisterPrefs(PrefRegistrySimple* pref_registry) override;
-  std::string GetUserAgent() const override;
-  void OnMainRequestContextCreated(
-      brightray::URLRequestContextGetter* getter) override;
-
-  RequestContextDelegate* GetRequestContextDelegate() const {
-    return request_context_delegate_.get();
+  CookieChangeNotifier* cookie_change_notifier() const {
+    return cookie_change_notifier_.get();
+  }
+  ProxyConfigMonitor* proxy_config_monitor() {
+    return proxy_config_monitor_.get();
+  }
+  PrefService* prefs() const { return prefs_.get(); }
+  void set_in_memory_pref_store(ValueMapPrefStore* pref_store) {
+    in_memory_pref_store_ = pref_store;
+  }
+  ValueMapPrefStore* in_memory_pref_store() const {
+    return in_memory_pref_store_;
+  }
+  base::WeakPtr<AtomBrowserContext> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
   }
 
  protected:
@@ -53,14 +111,60 @@ class AtomBrowserContext : public brightray::BrowserContext {
   ~AtomBrowserContext() override;
 
  private:
-  brightray::URLRequestContextGetter* url_request_context_getter_;
+  friend class base::RefCountedDeleteOnSequence<AtomBrowserContext>;
+  friend class base::DeleteHelper<AtomBrowserContext>;
 
+  // Initialize pref registry.
+  void InitPrefs();
+
+  // partition_id => browser_context
+  struct PartitionKey {
+    std::string partition;
+    bool in_memory;
+
+    PartitionKey(const std::string& partition, bool in_memory)
+        : partition(partition), in_memory(in_memory) {}
+
+    bool operator<(const PartitionKey& other) const {
+      if (partition == other.partition)
+        return in_memory < other.in_memory;
+      return partition < other.partition;
+    }
+
+    bool operator==(const PartitionKey& other) const {
+      return (partition == other.partition) && (in_memory == other.in_memory);
+    }
+  };
+  using BrowserContextMap =
+      std::map<PartitionKey, base::WeakPtr<AtomBrowserContext>>;
+  static BrowserContextMap browser_context_map_;
+
+  // Self-destructing class responsible for creating URLRequestContextGetter
+  // on the UI thread and deletes itself on the IO thread.
+  URLRequestContextGetter::Handle* io_handle_;
+  ValueMapPrefStore* in_memory_pref_store_;
+
+  std::unique_ptr<CookieChangeNotifier> cookie_change_notifier_;
+  std::unique_ptr<PrefService> prefs_;
   std::unique_ptr<AtomDownloadManagerDelegate> download_manager_delegate_;
   std::unique_ptr<WebViewManager> guest_manager_;
   std::unique_ptr<AtomPermissionManager> permission_manager_;
   std::unique_ptr<AtomBlobReader> blob_reader_;
-  std::unique_ptr<RequestContextDelegate> request_context_delegate_;
+  std::unique_ptr<brightray::MediaDeviceIDSalt> media_device_id_salt_;
+  scoped_refptr<ResolveProxyHelper> resolve_proxy_helper_;
+  scoped_refptr<storage::SpecialStoragePolicy> storage_policy_;
+
+  // Tracks the ProxyConfig to use, and passes any updates to a NetworkContext
+  // ProxyConfigClient.
+  std::unique_ptr<ProxyConfigMonitor> proxy_config_monitor_;
+
   std::string user_agent_;
+  base::FilePath path_;
+  bool in_memory_ = false;
+  bool use_cache_ = true;
+  int max_cache_size_ = 0;
+
+  base::WeakPtrFactory<AtomBrowserContext> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
 };

atom/browser/atom_browser_main_parts.cc

@@ -10,6 +10,7 @@
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/bridge_task_runner.h"
 #include "atom/browser/browser.h"
+#include "atom/browser/io_thread.h"
 #include "atom/browser/javascript_environment.h"
 #include "atom/browser/node_debugger.h"
 #include "atom/common/api/atom_bindings.h"
@@ -18,10 +19,15 @@
 #include "base/command_line.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/net/chrome_net_log_helper.h"
+#include "components/net_log/chrome_net_log.h"
+#include "components/net_log/net_export_file_writer.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/service_manager_connection.h"
 #include "services/device/public/mojom/constants.mojom.h"
+#include "services/network/public/cpp/network_switches.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "ui/base/idle/idle.h"
 #include "ui/base/l10n/l10n_util.h"
@@ -58,12 +64,14 @@ void Erase(T* container, typename T::iterator iter) {
 // static
 AtomBrowserMainParts* AtomBrowserMainParts::self_ = nullptr;
 
-AtomBrowserMainParts::AtomBrowserMainParts()
+AtomBrowserMainParts::AtomBrowserMainParts(
+    const content::MainFunctionParams& params)
     : fake_browser_process_(new BrowserProcess),
       browser_(new Browser),
       node_bindings_(NodeBindings::Create(NodeBindings::BROWSER)),
       atom_bindings_(new AtomBindings(uv_default_loop())),
-      gc_timer_(true, true) {
+      gc_timer_(true, true),
+      main_function_params_(params) {
   DCHECK(!self_) << "Cannot have two AtomBrowserMainParts";
   self_ = this;
   // Register extension scheme as web safe scheme.
@@ -175,9 +183,34 @@ int AtomBrowserMainParts::PreCreateThreads() {
   ui::InitIdleMonitor();
 #endif
 
+  net_log_ = std::make_unique<net_log::ChromeNetLog>();
+  auto& command_line = main_function_params_.command_line;
+  // start net log trace if --log-net-log is passed in the command line.
+  if (command_line.HasSwitch(network::switches::kLogNetLog)) {
+    base::FilePath log_file =
+        command_line.GetSwitchValuePath(network::switches::kLogNetLog);
+    if (!log_file.empty()) {
+      net_log_->StartWritingToFile(
+          log_file, GetNetCaptureModeFromCommandLine(command_line),
+          command_line.GetCommandLineString(), std::string());
+    }
+  }
+  // Initialize net log file exporter.
+  net_log_->net_export_file_writer()->Initialize(
+      content::BrowserThread::GetTaskRunnerForThread(
+          content::BrowserThread::IO));
+
+  // Manage global state of net and other IO thread related.
+  io_thread_ = std::make_unique<IOThread>(net_log_.get());
+
   return result;
 }
 
+void AtomBrowserMainParts::PostDestroyThreads() {
+  brightray::BrowserMainParts::PostDestroyThreads();
+  io_thread_.reset();
+}
+
 void AtomBrowserMainParts::ToolkitInitialized() {
   brightray::BrowserMainParts::ToolkitInitialized();
 #if defined(OS_MACOSX)

atom/browser/atom_browser_main_parts.h

@@ -12,6 +12,7 @@
 #include "base/timer/timer.h"
 #include "brightray/browser/browser_main_parts.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/common/main_function_params.h"
 #include "services/device/public/mojom/geolocation_control.mojom.h"
 
 class BrowserProcess;
@@ -22,10 +23,15 @@ class ViewsDelegate;
 }
 #endif
 
+namespace net_log {
+class ChromeNetLog;
+}
+
 namespace atom {
 
 class AtomBindings;
 class Browser;
+class IOThread;
 class JavascriptEnvironment;
 class NodeBindings;
 class NodeDebugger;
@@ -38,7 +44,7 @@ class ViewsDelegateMac;
 
 class AtomBrowserMainParts : public brightray::BrowserMainParts {
  public:
-  AtomBrowserMainParts();
+  explicit AtomBrowserMainParts(const content::MainFunctionParams& params);
   ~AtomBrowserMainParts() override;
 
   static AtomBrowserMainParts* Get();
@@ -59,6 +65,8 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   device::mojom::GeolocationControl* GetGeolocationControl();
 
   Browser* browser() { return browser_.get(); }
+  IOThread* io_thread() const { return io_thread_.get(); }
+  net_log::ChromeNetLog* net_log() { return net_log_.get(); }
 
  protected:
   // content::BrowserMainParts:
@@ -73,6 +81,7 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 #if defined(OS_MACOSX)
   void PreMainMessageLoopStart() override;
 #endif
+  void PostDestroyThreads() override;
 
  private:
 #if defined(OS_POSIX)
@@ -107,6 +116,8 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   std::unique_ptr<AtomBindings> atom_bindings_;
   std::unique_ptr<NodeEnvironment> node_env_;
   std::unique_ptr<NodeDebugger> node_debugger_;
+  std::unique_ptr<IOThread> io_thread_;
+  std::unique_ptr<net_log::ChromeNetLog> net_log_;
 
   base::Timer gc_timer_;
 
@@ -115,6 +126,8 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 
   device::mojom::GeolocationControlPtr geolocation_control_;
 
+  const content::MainFunctionParams main_function_params_;
+
   static AtomBrowserMainParts* self_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserMainParts);

atom/browser/common_web_contents_delegate.cc

@@ -163,11 +163,11 @@ void CommonWebContentsDelegate::InitWithWebContents(
   // 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(web_contents, is_guest));
+  web_contents_.reset(brightray::InspectableWebContents::Create(
+      web_contents, browser_context->prefs(), is_guest));
   web_contents_->SetDelegate(this);
 }
 
@@ -194,8 +194,17 @@ void CommonWebContentsDelegate::SetOwnerWindow(
 
 void CommonWebContentsDelegate::ResetManagedWebContents(bool async) {
   if (async) {
-    base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,
-                                                    web_contents_.release());
+    // Browser context should be destroyed only after the WebContents,
+    // this is guaranteed in the sync mode by the order of declaration,
+    // in the async version we maintain a reference until the WebContents
+    // is destroyed.
+    base::ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
+        FROM_HERE,
+        base::BindOnce([](scoped_refptr<AtomBrowserContext> browser_context,
+                          std::unique_ptr<brightray::InspectableWebContents>
+                              web_contents) { web_contents.reset(); },
+                       base::RetainedRef(browser_context_),
+                       std::move(web_contents_)));
   } else {
     web_contents_.reset();
   }

atom/browser/cookie_change_notifier.cc

@@ -0,0 +1,72 @@
+// 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/cookie_change_notifier.h"
+
+#include <utility>
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/net/cookie_details.h"
+#include "base/bind.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
+#include "net/cookies/canonical_cookie.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+CookieChangeNotifier::CookieChangeNotifier(AtomBrowserContext* browser_context)
+    : browser_context_(browser_context), binding_(this) {
+  StartListening();
+}
+
+CookieChangeNotifier::~CookieChangeNotifier() = default;
+
+std::unique_ptr<base::CallbackList<void(const CookieDetails*)>::Subscription>
+CookieChangeNotifier::RegisterCookieChangeCallback(
+    const base::Callback<void(const CookieDetails*)>& cb) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  return cookie_change_sub_list_.Add(cb);
+}
+
+void CookieChangeNotifier::StartListening() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK(!binding_.is_bound());
+
+  network::mojom::CookieManager* cookie_manager =
+      content::BrowserContext::GetDefaultStoragePartition(browser_context_)
+          ->GetCookieManagerForBrowserProcess();
+  // Cookie manager should be created whenever network context is created,
+  // if this fails then there is something wrong with our context creation
+  // cycle.
+  CHECK(cookie_manager);
+
+  network::mojom::CookieChangeListenerPtr listener_ptr;
+  binding_.Bind(mojo::MakeRequest(&listener_ptr));
+  binding_.set_connection_error_handler(base::BindOnce(
+      &CookieChangeNotifier::OnConnectionError, base::Unretained(this)));
+
+  cookie_manager->AddGlobalChangeListener(std::move(listener_ptr));
+}
+
+void CookieChangeNotifier::OnConnectionError() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  binding_.Close();
+  StartListening();
+}
+
+void CookieChangeNotifier::OnCookieChange(
+    const net::CanonicalCookie& cookie,
+    network::mojom::CookieChangeCause cause) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  CookieDetails cookie_details(
+      &cookie, cause != network::mojom::CookieChangeCause::INSERTED, cause);
+  cookie_change_sub_list_.Notify(&cookie_details);
+}
+
+}  // namespace atom

atom/browser/cookie_change_notifier.h

@@ -0,0 +1,48 @@
+// 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_COOKIE_CHANGE_NOTIFIER_H_
+#define ATOM_BROWSER_COOKIE_CHANGE_NOTIFIER_H_
+
+#include <memory>
+
+#include "base/callback_list.h"
+#include "base/macros.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "services/network/public/mojom/cookie_manager.mojom.h"
+
+namespace atom {
+
+class AtomBrowserContext;
+struct CookieDetails;
+
+// Sends cookie-change notifications on the UI thread.
+class CookieChangeNotifier : public network::mojom::CookieChangeListener {
+ public:
+  explicit CookieChangeNotifier(AtomBrowserContext* browser_context);
+  ~CookieChangeNotifier() override;
+
+  // Register callbacks that needs to notified on any cookie store changes.
+  std::unique_ptr<base::CallbackList<void(const CookieDetails*)>::Subscription>
+  RegisterCookieChangeCallback(
+      const base::Callback<void(const CookieDetails*)>& cb);
+
+ private:
+  void StartListening();
+  void OnConnectionError();
+
+  // network::mojom::CookieChangeListener implementation.
+  void OnCookieChange(const net::CanonicalCookie& cookie,
+                      network::mojom::CookieChangeCause cause) override;
+
+  AtomBrowserContext* browser_context_;
+  base::CallbackList<void(const CookieDetails*)> cookie_change_sub_list_;
+  mojo::Binding<network::mojom::CookieChangeListener> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(CookieChangeNotifier);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_COOKIE_CHANGE_NOTIFIER_H_

atom/browser/io_thread.cc

@@ -0,0 +1,80 @@
+// Copyright (c) 2017 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/io_thread.h"
+
+#include "components/net_log/chrome_net_log.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/proxy_resolution/proxy_service.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_builder.h"
+#include "net/url_request/url_request_context_getter.h"
+
+#if defined(USE_NSS_CERTS)
+#include "net/cert_net/nss_ocsp.h"
+#endif
+
+#if defined(OS_LINUX) || defined(OS_MACOSX)
+#include "net/cert/cert_net_fetcher.h"
+#include "net/cert_net/cert_net_fetcher_impl.h"
+#endif
+
+using content::BrowserThread;
+
+namespace atom {
+
+IOThread::IOThread(net_log::ChromeNetLog* net_log) : net_log_(net_log) {
+  BrowserThread::SetIOThreadDelegate(this);
+}
+
+IOThread::~IOThread() {
+  BrowserThread::SetIOThreadDelegate(nullptr);
+}
+
+void IOThread::Init() {
+  net::URLRequestContextBuilder builder;
+  // TODO(deepak1556): We need to respoect user proxy configurations,
+  // the following initialization has to happen before any request
+  // contexts are utilized by the io thread, so that proper cert validation
+  // take place, solutions:
+  // 1) Use the request context from default partition, but since
+  //    an app can completely run on a custom session without ever creating
+  //    the default session, we will have to force create the default session
+  //    in those scenarios.
+  // 2) Add a new api on app module that sets the proxy configuration
+  //    for the global requests, like the cert fetchers below and
+  //    geolocation requests.
+  // 3) There is also ongoing work in upstream which will eventually allow
+  //    localizing these global fetchers to their own URLRequestContexts.
+  builder.set_proxy_resolution_service(
+      net::ProxyResolutionService::CreateDirect());
+  url_request_context_ = builder.Build();
+  url_request_context_getter_ = new net::TrivialURLRequestContextGetter(
+      url_request_context_.get(), base::ThreadTaskRunnerHandle::Get());
+
+#if defined(USE_NSS_CERTS)
+  net::SetURLRequestContextForNSSHttpIO(url_request_context_.get());
+#endif
+#if defined(OS_LINUX) || defined(OS_MACOSX)
+  net::SetGlobalCertNetFetcher(
+      net::CreateCertNetFetcher(url_request_context_.get()));
+#endif
+}
+
+void IOThread::CleanUp() {
+#if defined(USE_NSS_CERTS)
+  net::SetURLRequestContextForNSSHttpIO(nullptr);
+#endif
+#if defined(OS_LINUX) || defined(OS_MACOSX)
+  net::ShutdownGlobalCertNetFetcher();
+#endif
+  // Explicitly release before the IO thread gets destroyed.
+  url_request_context_.reset();
+  url_request_context_getter_ = nullptr;
+
+  if (net_log_)
+    net_log_->ShutDownBeforeTaskScheduler();
+}
+
+}  // namespace atom

atom/browser/io_thread.h

@@ -2,12 +2,13 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef BRIGHTRAY_BROWSER_IO_THREAD_H_
-#define BRIGHTRAY_BROWSER_IO_THREAD_H_
+#ifndef ATOM_BROWSER_IO_THREAD_H_
+#define ATOM_BROWSER_IO_THREAD_H_
 
 #include <memory>
 
 #include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
 #include "content/public/browser/browser_thread_delegate.h"
 
 namespace net {
@@ -15,15 +16,19 @@ class URLRequestContext;
 class URLRequestContextGetter;
 }  // namespace net
 
-namespace brightray {
+namespace net_log {
+class ChromeNetLog;
+}
+
+namespace atom {
 
 class IOThread : public content::BrowserThreadDelegate {
  public:
-  IOThread();
+  explicit IOThread(net_log::ChromeNetLog* net_log);
   ~IOThread() override;
 
   net::URLRequestContextGetter* GetRequestContext() {
-    return url_request_context_getter_;
+    return url_request_context_getter_.get();
   }
 
  protected:
@@ -32,12 +37,15 @@ class IOThread : public content::BrowserThreadDelegate {
   void CleanUp() override;
 
  private:
+  // The NetLog is owned by the browser process, to allow logging from other
+  // threads during shutdown, but is used most frequently on the IOThread.
+  net_log::ChromeNetLog* net_log_;
   std::unique_ptr<net::URLRequestContext> url_request_context_;
-  net::URLRequestContextGetter* url_request_context_getter_;
+  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThread);
 };
 
-}  // namespace brightray
+}  // namespace atom
 
-#endif  // BRIGHTRAY_BROWSER_IO_THREAD_H_
+#endif  // ATOM_BROWSER_IO_THREAD_H_

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:
@@ -150,6 +157,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

@@ -8,6 +8,7 @@
 #import <Cocoa/Cocoa.h>
 
 #include <string>
+#include <tuple>
 #include <vector>
 
 #include "atom/browser/native_window.h"
@@ -103,6 +104,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

@@ -74,9 +74,7 @@
                                              forStyleMask:NSTitledWindowMask];
   NSButton* miniaturize_button =
       [NSWindow standardWindowButton:NSWindowMiniaturizeButton
-                        forStyleMask:NSTitledWindowMask];
-  NSButton* zoom_button = [NSWindow standardWindowButton:NSWindowZoomButton
-                                            forStyleMask:NSTitledWindowMask];
+                        forStyleMask:NSWindowStyleMaskTitled];
 
   CGFloat x = 0;
   const CGFloat space_between = 20;
@@ -89,11 +87,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)];
@@ -478,7 +472,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) {
@@ -515,6 +510,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];
 }
 
@@ -1074,21 +1081,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];
@@ -1099,7 +1116,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) {
@@ -1351,6 +1368,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

@@ -9,6 +9,7 @@
 #include <wrl/client.h>
 #endif
 
+#include <tuple>
 #include <vector>
 
 #include "atom/browser/api/atom_api_web_contents.h"
@@ -894,7 +895,6 @@ void NativeWindowViews::SetMenu(AtomMenuModel* menu_model) {
   if (menu_model == nullptr) {
     global_menu_bar_.reset();
     root_view_->UnregisterAcceleratorsWithFocusManager();
-    return;
   }
 
   if (!global_menu_bar_ && ShouldUseGlobalMenuBar())
@@ -1047,6 +1047,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())

atom/browser/native_window_views.h

@@ -9,6 +9,7 @@
 
 #include <set>
 #include <string>
+#include <tuple>
 
 #include "ui/views/widget/widget_observer.h"
 
@@ -123,6 +124,7 @@ 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;

atom/browser/net/atom_url_request.cc

@@ -69,7 +69,7 @@ scoped_refptr<AtomURLRequest> AtomURLRequest::Create(
   if (!browser_context || url.empty() || !delegate) {
     return nullptr;
   }
-  scoped_refptr<brightray::URLRequestContextGetter> request_context_getter(
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter(
       browser_context->GetRequestContext());
   DCHECK(request_context_getter);
   scoped_refptr<AtomURLRequest> atom_url_request(new AtomURLRequest(delegate));

atom/browser/net/atom_url_request_job_factory.cc

@@ -5,6 +5,8 @@
 
 #include "atom/browser/net/atom_url_request_job_factory.h"
 
+#include <utility>
+
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "content/public/browser/browser_thread.h"
@@ -33,6 +35,11 @@ AtomURLRequestJobFactory::~AtomURLRequestJobFactory() {
   Clear();
 }
 
+void AtomURLRequestJobFactory::Chain(
+    std::unique_ptr<net::URLRequestJobFactory> job_factory) {
+  job_factory_ = std::move(job_factory);
+}
+
 bool AtomURLRequestJobFactory::SetProtocolHandler(
     const std::string& scheme,
     std::unique_ptr<ProtocolHandler> protocol_handler) {
@@ -73,16 +80,6 @@ bool AtomURLRequestJobFactory::UninterceptProtocol(const std::string& scheme) {
   return true;
 }
 
-ProtocolHandler* AtomURLRequestJobFactory::GetProtocolHandler(
-    const std::string& scheme) const {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  auto it = protocol_handler_map_.find(scheme);
-  if (it == protocol_handler_map_.end())
-    return nullptr;
-  return it->second;
-}
-
 bool AtomURLRequestJobFactory::HasProtocolHandler(
     const std::string& scheme) const {
   return base::ContainsKey(protocol_handler_map_, scheme);
@@ -101,11 +98,18 @@ net::URLRequestJob* AtomURLRequestJobFactory::MaybeCreateJobWithProtocolHandler(
     net::NetworkDelegate* network_delegate) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  auto* job = job_factory_->MaybeCreateJobWithProtocolHandler(scheme, request,
+                                                              network_delegate);
+  if (job)
+    return job;
+
   auto it = protocol_handler_map_.find(scheme);
   if (it == protocol_handler_map_.end())
     return nullptr;
+
   if (request->GetUserData(DisableProtocolInterceptFlagKey()))
     return nullptr;
+
   return it->second->MaybeCreateJob(request, network_delegate);
 }
 
@@ -113,13 +117,14 @@ net::URLRequestJob* AtomURLRequestJobFactory::MaybeInterceptRedirect(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     const GURL& location) const {
-  return nullptr;
+  return job_factory_->MaybeInterceptRedirect(request, network_delegate,
+                                              location);
 }
 
 net::URLRequestJob* AtomURLRequestJobFactory::MaybeInterceptResponse(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
-  return nullptr;
+  return job_factory_->MaybeInterceptResponse(request, network_delegate);
 }
 
 bool AtomURLRequestJobFactory::IsHandledProtocol(

atom/browser/net/atom_url_request_job_factory.h

@@ -23,6 +23,9 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
   AtomURLRequestJobFactory();
   ~AtomURLRequestJobFactory() override;
 
+  // Requests are forwarded to the chained job factory first.
+  void Chain(std::unique_ptr<net::URLRequestJobFactory> job_factory);
+
   // Sets the ProtocolHandler for a scheme. Returns true on success, false on
   // failure (a ProtocolHandler already exists for |scheme|). On success,
   // URLRequestJobFactory takes ownership of |protocol_handler|.
@@ -34,9 +37,6 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
                          std::unique_ptr<ProtocolHandler> protocol_handler);
   bool UninterceptProtocol(const std::string& scheme);
 
-  // Returns the protocol handler registered with scheme.
-  ProtocolHandler* GetProtocolHandler(const std::string& scheme) const;
-
   // Whether the protocol handler is registered by the job factory.
   bool HasProtocolHandler(const std::string& scheme) const;
 
@@ -69,6 +69,8 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
   // Can only be accessed in IO thread.
   OriginalProtocolsMap original_protocols_;
 
+  std::unique_ptr<net::URLRequestJobFactory> job_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(AtomURLRequestJobFactory);
 };
 

atom/browser/net/cookie_details.h

@@ -6,7 +6,11 @@
 #define ATOM_BROWSER_NET_COOKIE_DETAILS_H_
 
 #include "base/macros.h"
-#include "net/cookies/cookie_change_dispatcher.h"
+#include "services/network/public/mojom/cookie_manager.mojom.h"
+
+namespace net {
+class CanonicalCookie;
+}
 
 namespace atom {
 
@@ -14,12 +18,12 @@ struct CookieDetails {
  public:
   CookieDetails(const net::CanonicalCookie* cookie_copy,
                 bool is_removed,
-                net::CookieChangeCause cause)
+                network::mojom::CookieChangeCause cause)
       : cookie(cookie_copy), removed(is_removed), cause(cause) {}
 
   const net::CanonicalCookie* cookie;
   bool removed;
-  net::CookieChangeCause cause;
+  network::mojom::CookieChangeCause cause;
 };
 
 }  // namespace atom

atom/browser/net/resolve_proxy_helper.cc

@@ -0,0 +1,87 @@
+// 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/net/resolve_proxy_helper.h"
+
+#include "atom/browser/atom_browser_context.h"
+#include "base/bind.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+namespace atom {
+
+ResolveProxyHelper::ResolveProxyHelper(AtomBrowserContext* browser_context)
+    : context_getter_(browser_context->GetRequestContext()),
+      original_thread_(base::ThreadTaskRunnerHandle::Get()) {}
+
+ResolveProxyHelper::~ResolveProxyHelper() {
+  // Clear all pending requests if the ProxyService is still alive.
+  pending_requests_.clear();
+}
+
+void ResolveProxyHelper::ResolveProxy(const GURL& url,
+                                      const ResolveProxyCallback& callback) {
+  // Enqueue the pending request.
+  pending_requests_.push_back(PendingRequest(url, callback));
+
+  // If nothing is in progress, start.
+  if (pending_requests_.size() == 1)
+    StartPendingRequest();
+}
+
+void ResolveProxyHelper::StartPendingRequest() {
+  auto& pending_request = pending_requests_.front();
+  context_getter_->GetNetworkTaskRunner()->PostTask(
+      FROM_HERE, base::BindOnce(&ResolveProxyHelper::StartPendingRequestInIO,
+                                base::Unretained(this), pending_request.url));
+}
+
+void ResolveProxyHelper::StartPendingRequestInIO(const GURL& url) {
+  auto* proxy_service =
+      context_getter_->GetURLRequestContext()->proxy_resolution_service();
+  // Start the request.
+  int result = proxy_service->ResolveProxy(
+      url, std::string(), &proxy_info_,
+      base::Bind(&ResolveProxyHelper::OnProxyResolveComplete,
+                 base::RetainedRef(this)),
+      nullptr, nullptr, net::NetLogWithSource());
+  // Completed synchronously.
+  if (result != net::ERR_IO_PENDING)
+    OnProxyResolveComplete(result);
+}
+
+void ResolveProxyHelper::OnProxyResolveComplete(int result) {
+  DCHECK(!pending_requests_.empty());
+
+  std::string proxy;
+  if (result == net::OK)
+    proxy = proxy_info_.ToPacString();
+
+  original_thread_->PostTask(
+      FROM_HERE, base::BindOnce(&ResolveProxyHelper::SendProxyResult,
+                                base::RetainedRef(this), proxy));
+}
+
+void ResolveProxyHelper::SendProxyResult(const std::string& proxy) {
+  DCHECK(!pending_requests_.empty());
+
+  const auto& completed_request = pending_requests_.front();
+  if (!completed_request.callback.is_null())
+    completed_request.callback.Run(proxy);
+
+  // Clear the current (completed) request.
+  pending_requests_.pop_front();
+
+  // Start the next request.
+  if (!pending_requests_.empty())
+    StartPendingRequest();
+}
+
+ResolveProxyHelper::PendingRequest::PendingRequest(
+    const GURL& url,
+    const ResolveProxyCallback& callback)
+    : url(url), callback(callback) {}
+
+}  // namespace atom

atom/browser/net/resolve_proxy_helper.h

@@ -0,0 +1,61 @@
+// 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_NET_RESOLVE_PROXY_HELPER_H_
+#define ATOM_BROWSER_NET_RESOLVE_PROXY_HELPER_H_
+
+#include <deque>
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "net/proxy_resolution/proxy_service.h"
+#include "url/gurl.h"
+
+namespace net {
+class URLRequestContextGetter;
+}
+
+namespace atom {
+
+class AtomBrowserContext;
+
+class ResolveProxyHelper
+    : public base::RefCountedThreadSafe<ResolveProxyHelper> {
+ public:
+  using ResolveProxyCallback = base::Callback<void(std::string)>;
+
+  explicit ResolveProxyHelper(AtomBrowserContext* browser_context);
+
+  void ResolveProxy(const GURL& url, const ResolveProxyCallback& callback);
+
+ private:
+  friend class base::RefCountedThreadSafe<ResolveProxyHelper>;
+  // A PendingRequest is a resolve request that is in progress, or queued.
+  struct PendingRequest {
+   public:
+    PendingRequest(const GURL& url, const ResolveProxyCallback& callback);
+
+    GURL url;
+    ResolveProxyCallback callback;
+  };
+
+  ~ResolveProxyHelper();
+
+  // Starts the first pending request.
+  void StartPendingRequest();
+  void StartPendingRequestInIO(const GURL& url);
+  void OnProxyResolveComplete(int result);
+  void SendProxyResult(const std::string& proxy);
+
+  net::ProxyInfo proxy_info_;
+  std::deque<PendingRequest> pending_requests_;
+  scoped_refptr<net::URLRequestContextGetter> context_getter_;
+  scoped_refptr<base::SingleThreadTaskRunner> original_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NET_RESOLVE_PROXY_HELPER_H_

atom/browser/net/url_request_context_getter.cc

@@ -0,0 +1,424 @@
+// 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/net/url_request_context_getter.h"
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+
+#include "atom/browser/api/atom_api_protocol.h"
+#include "atom/browser/atom_browser_client.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/net/about_protocol_handler.h"
+#include "atom/browser/net/asar/asar_protocol_handler.h"
+#include "atom/browser/net/atom_cert_verifier.h"
+#include "atom/browser/net/atom_network_delegate.h"
+#include "atom/browser/net/atom_url_request_job_factory.h"
+#include "atom/browser/net/http_protocol_handler.h"
+#include "atom/common/options_switches.h"
+#include "base/command_line.h"
+#include "base/strings/string_util.h"
+#include "base/task_scheduler/post_task.h"
+#include "brightray/browser/net/require_ct_delegate.h"
+#include "chrome/browser/net/chrome_mojo_proxy_resolver_factory.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
+#include "components/network_session_configurator/common/network_switches.h"
+#include "components/prefs/value_map_pref_store.h"
+#include "components/proxy_config/proxy_config_dictionary.h"
+#include "components/proxy_config/proxy_config_pref_names.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_network_transaction_factory.h"
+#include "content/public/browser/network_service_instance.h"
+#include "content/public/browser/resource_context.h"
+#include "content/public/common/content_switches.h"
+#include "net/base/host_mapping_rules.h"
+#include "net/cert/multi_log_ct_verifier.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/dns/mapped_host_resolver.h"
+#include "net/http/http_auth_handler_factory.h"
+#include "net/http/http_auth_preferences.h"
+#include "net/http/http_auth_scheme.h"
+#include "net/http/http_transaction_factory.h"
+#include "net/log/net_log.h"
+#include "net/proxy_resolution/proxy_config.h"
+#include "net/proxy_resolution/proxy_config_service.h"
+#include "net/proxy_resolution/proxy_service.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
+#include "net/url_request/data_protocol_handler.h"
+#include "net/url_request/static_http_user_agent_settings.h"
+#include "net/url_request/url_request_intercepting_job_factory.h"
+#include "net/url_request/url_request_job_factory_impl.h"
+#include "services/network/ignore_errors_cert_verifier.h"
+#include "services/network/network_service.h"
+#include "services/network/public/cpp/network_switches.h"
+#include "services/network/url_request_context_builder_mojo.h"
+#include "url/url_constants.h"
+
+#if !BUILDFLAG(DISABLE_FTP_SUPPORT)
+#include "net/url_request/ftp_protocol_handler.h"
+#endif
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+network::mojom::NetworkContextParamsPtr CreateDefaultNetworkContextParams(
+    const base::FilePath& base_path,
+    const std::string& user_agent,
+    bool in_memory,
+    bool use_cache,
+    int max_cache_size) {
+  network::mojom::NetworkContextParamsPtr network_context_params =
+      network::mojom::NetworkContextParams::New();
+  network_context_params->enable_brotli = true;
+  network_context_params->user_agent = user_agent;
+  network_context_params->http_cache_enabled = use_cache;
+  network_context_params->enable_data_url_support = false;
+  network_context_params->proxy_resolver_factory =
+      ChromeMojoProxyResolverFactory::CreateWithStrongBinding().PassInterface();
+  if (!in_memory) {
+    network_context_params->http_cache_path =
+        base_path.Append(chrome::kCacheDirname);
+    network_context_params->http_cache_max_size = max_cache_size;
+    network_context_params->http_server_properties_path =
+        base_path.Append(chrome::kNetworkPersistentStateFilename);
+    network_context_params->cookie_path =
+        base_path.Append(chrome::kCookieFilename);
+    network_context_params->channel_id_path =
+        base_path.Append(chrome::kChannelIDFilename);
+    network_context_params->restore_old_session_cookies = false;
+    network_context_params->persist_session_cookies = false;
+  }
+  // TODO(deepak1556): Decide the stand on chrome ct policy and
+  // enable it.
+  // See //net/docs/certificate-transparency.md
+  // network_context_params->enforce_chrome_ct_policy = true;
+  return network_context_params;
+}
+
+void SetupAtomURLRequestJobFactory(
+    content::ProtocolHandlerMap* protocol_handlers,
+    net::URLRequestContext* url_request_context,
+    AtomURLRequestJobFactory* job_factory) {
+  for (auto& protocol_handler : *protocol_handlers) {
+    job_factory->SetProtocolHandler(
+        protocol_handler.first,
+        base::WrapUnique(protocol_handler.second.release()));
+  }
+  protocol_handlers->clear();
+
+  job_factory->SetProtocolHandler(url::kAboutScheme,
+                                  std::make_unique<AboutProtocolHandler>());
+  job_factory->SetProtocolHandler(url::kDataScheme,
+                                  std::make_unique<net::DataProtocolHandler>());
+  job_factory->SetProtocolHandler(
+      url::kFileScheme,
+      std::make_unique<asar::AsarProtocolHandler>(
+          base::CreateTaskRunnerWithTraits(
+              {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
+               base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})));
+  job_factory->SetProtocolHandler(
+      url::kHttpScheme,
+      std::make_unique<HttpProtocolHandler>(url::kHttpScheme));
+  job_factory->SetProtocolHandler(
+      url::kHttpsScheme,
+      std::make_unique<HttpProtocolHandler>(url::kHttpsScheme));
+  job_factory->SetProtocolHandler(
+      url::kWsScheme, std::make_unique<HttpProtocolHandler>(url::kWsScheme));
+  job_factory->SetProtocolHandler(
+      url::kWssScheme, std::make_unique<HttpProtocolHandler>(url::kWssScheme));
+
+#if !BUILDFLAG(DISABLE_FTP_SUPPORT)
+  auto* host_resolver = url_request_context->host_resolver();
+  job_factory->SetProtocolHandler(
+      url::kFtpScheme, net::FtpProtocolHandler::Create(host_resolver));
+#endif
+}
+
+void ApplyProxyModeFromCommandLine(ValueMapPrefStore* pref_store) {
+  if (!pref_store)
+    return;
+
+  auto* command_line = base::CommandLine::ForCurrentProcess();
+
+  if (command_line->HasSwitch(::switches::kNoProxyServer)) {
+    pref_store->SetValue(proxy_config::prefs::kProxy,
+                         ProxyConfigDictionary::CreateDirect(),
+                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  } else if (command_line->HasSwitch(::switches::kProxyPacUrl)) {
+    std::string pac_script_url =
+        command_line->GetSwitchValueASCII(::switches::kProxyPacUrl);
+    pref_store->SetValue(proxy_config::prefs::kProxy,
+                         ProxyConfigDictionary::CreatePacScript(
+                             pac_script_url, false /* pac_mandatory */),
+                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  } else if (command_line->HasSwitch(::switches::kProxyAutoDetect)) {
+    pref_store->SetValue(proxy_config::prefs::kProxy,
+                         ProxyConfigDictionary::CreateAutoDetect(),
+                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  } else if (command_line->HasSwitch(::switches::kProxyServer)) {
+    std::string proxy_server =
+        command_line->GetSwitchValueASCII(::switches::kProxyServer);
+    std::string bypass_list =
+        command_line->GetSwitchValueASCII(::switches::kProxyBypassList);
+    pref_store->SetValue(
+        proxy_config::prefs::kProxy,
+        ProxyConfigDictionary::CreateFixedServers(proxy_server, bypass_list),
+        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  }
+}
+
+}  // namespace
+
+class ResourceContext : public content::ResourceContext {
+ public:
+  ResourceContext() = default;
+  ~ResourceContext() override = default;
+
+  net::HostResolver* GetHostResolver() override {
+    if (request_context_)
+      return request_context_->host_resolver();
+    return nullptr;
+  }
+
+  net::URLRequestContext* GetRequestContext() override {
+    return request_context_;
+  }
+
+ private:
+  friend class URLRequestContextGetter;
+
+  net::URLRequestContext* request_context_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourceContext);
+};
+
+URLRequestContextGetter::Handle::Handle(
+    base::WeakPtr<AtomBrowserContext> browser_context)
+    : resource_context_(new ResourceContext),
+      browser_context_(browser_context),
+      initialized_(false) {}
+
+URLRequestContextGetter::Handle::~Handle() {}
+
+content::ResourceContext*
+URLRequestContextGetter::Handle::GetResourceContext() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  LazyInitialize();
+  return resource_context_.get();
+}
+
+scoped_refptr<URLRequestContextGetter>
+URLRequestContextGetter::Handle::CreateMainRequestContextGetter(
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector protocol_interceptors) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(!main_request_context_getter_.get());
+  LazyInitialize();
+  main_request_context_getter_ = new URLRequestContextGetter(
+      AtomBrowserClient::Get()->GetNetLog(), this, protocol_handlers,
+      std::move(protocol_interceptors));
+  return main_request_context_getter_;
+}
+
+scoped_refptr<URLRequestContextGetter>
+URLRequestContextGetter::Handle::GetMainRequestContextGetter() {
+  return main_request_context_getter_;
+}
+
+network::mojom::NetworkContextPtr
+URLRequestContextGetter::Handle::GetNetworkContext() {
+  if (!main_network_context_) {
+    main_network_context_request_ = mojo::MakeRequest(&main_network_context_);
+  }
+  return std::move(main_network_context_);
+}
+
+void URLRequestContextGetter::Handle::LazyInitialize() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (initialized_)
+    return;
+
+  initialized_ = true;
+  main_network_context_params_ = CreateDefaultNetworkContextParams(
+      browser_context_->GetPath(), browser_context_->GetUserAgent(),
+      browser_context_->IsOffTheRecord(), browser_context_->CanUseHttpCache(),
+      browser_context_->GetMaxCacheSize());
+
+  browser_context_->proxy_config_monitor()->AddToNetworkContextParams(
+      main_network_context_params_.get());
+
+  ApplyProxyModeFromCommandLine(browser_context_->in_memory_pref_store());
+
+  if (!main_network_context_request_.is_pending()) {
+    main_network_context_request_ = mojo::MakeRequest(&main_network_context_);
+  }
+  content::BrowserContext::EnsureResourceContextInitialized(
+      browser_context_.get());
+}
+
+void URLRequestContextGetter::Handle::ShutdownOnUIThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (main_request_context_getter_.get()) {
+    if (BrowserThread::IsThreadInitialized(BrowserThread::IO)) {
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::BindOnce(&URLRequestContextGetter::NotifyContextShuttingDown,
+                         base::RetainedRef(main_request_context_getter_),
+                         std::move(resource_context_)));
+    }
+  }
+
+  if (!BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this))
+    delete this;
+}
+
+URLRequestContextGetter::URLRequestContextGetter(
+    net::NetLog* net_log,
+    URLRequestContextGetter::Handle* context_handle,
+    content::ProtocolHandlerMap* protocol_handlers,
+    content::URLRequestInterceptorScopedVector protocol_interceptors)
+    : net_log_(net_log),
+      context_handle_(context_handle),
+      url_request_context_(nullptr),
+      protocol_interceptors_(std::move(protocol_interceptors)),
+      context_shutting_down_(false) {
+  // Must first be created on the UI thread.
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (protocol_handlers)
+    std::swap(protocol_handlers_, *protocol_handlers);
+}
+
+URLRequestContextGetter::~URLRequestContextGetter() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // NotifyContextShuttingDown should have been called.
+  DCHECK(context_shutting_down_);
+}
+
+void URLRequestContextGetter::NotifyContextShuttingDown(
+    std::unique_ptr<ResourceContext> resource_context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  context_shutting_down_ = true;
+  resource_context.reset();
+  http_auth_preferences_.reset();
+  net::URLRequestContextGetter::NotifyContextShuttingDown();
+}
+
+net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (context_shutting_down_)
+    return nullptr;
+
+  if (!url_request_context_) {
+    auto& command_line = *base::CommandLine::ForCurrentProcess();
+    std::unique_ptr<network::URLRequestContextBuilderMojo> builder =
+        std::make_unique<network::URLRequestContextBuilderMojo>();
+    builder->set_network_delegate(std::make_unique<AtomNetworkDelegate>());
+
+    ct_delegate_.reset(new brightray::RequireCTDelegate);
+    auto cert_verifier = std::make_unique<AtomCertVerifier>(ct_delegate_.get());
+    builder->SetCertVerifier(std::move(cert_verifier));
+
+    builder->SetCreateHttpTransactionFactoryCallback(
+        base::BindOnce(&content::CreateDevToolsNetworkTransactionFactory));
+
+    std::unique_ptr<net::HostResolver> host_resolver =
+        net::HostResolver::CreateDefaultResolver(net_log_);
+    // --host-resolver-rules
+    if (command_line.HasSwitch(network::switches::kHostResolverRules)) {
+      auto remapped_resolver =
+          std::make_unique<net::MappedHostResolver>(std::move(host_resolver));
+      remapped_resolver->SetRulesFromString(command_line.GetSwitchValueASCII(
+          network::switches::kHostResolverRules));
+      host_resolver = std::move(remapped_resolver);
+    }
+
+    std::vector<std::string> supported_schemes = {
+        net::kBasicAuthScheme, net::kDigestAuthScheme,
+        net::kNegotiateAuthScheme, net::kNtlmAuthScheme};
+    http_auth_preferences_ =
+        std::make_unique<net::HttpAuthPreferences>(supported_schemes
+#if defined(OS_POSIX)
+                                                   ,
+                                                   std::string()
+#endif
+        );  // NOLINT(whitespace/parens)
+
+    // --auth-server-whitelist
+    if (command_line.HasSwitch(switches::kAuthServerWhitelist)) {
+      http_auth_preferences_->SetServerWhitelist(
+          command_line.GetSwitchValueASCII(switches::kAuthServerWhitelist));
+    }
+
+    // --auth-negotiate-delegate-whitelist
+    if (command_line.HasSwitch(switches::kAuthNegotiateDelegateWhitelist)) {
+      http_auth_preferences_->SetDelegateWhitelist(
+          command_line.GetSwitchValueASCII(
+              switches::kAuthNegotiateDelegateWhitelist));
+    }
+    auto http_auth_handler_factory =
+        net::HttpAuthHandlerRegistryFactory::Create(
+            http_auth_preferences_.get(), host_resolver.get());
+    builder->SetHttpAuthHandlerFactory(std::move(http_auth_handler_factory));
+    builder->set_host_resolver(std::move(host_resolver));
+    builder->set_ct_verifier(std::make_unique<net::MultiLogCTVerifier>());
+
+    network_context_ =
+        content::GetNetworkServiceImpl()->CreateNetworkContextWithBuilder(
+            std::move(context_handle_->main_network_context_request_),
+            std::move(context_handle_->main_network_context_params_),
+            std::move(builder), &url_request_context_);
+
+    net::TransportSecurityState* transport_security_state =
+        url_request_context_->transport_security_state();
+    transport_security_state->SetRequireCTDelegate(ct_delegate_.get());
+
+    // Add custom standard schemes to cookie schemes.
+    auto* cookie_monster =
+        static_cast<net::CookieMonster*>(url_request_context_->cookie_store());
+    std::vector<std::string> cookie_schemes(
+        {url::kHttpScheme, url::kHttpsScheme, url::kWsScheme, url::kWssScheme});
+    const auto& custom_standard_schemes = atom::api::GetStandardSchemes();
+    cookie_schemes.insert(cookie_schemes.end(), custom_standard_schemes.begin(),
+                          custom_standard_schemes.end());
+    cookie_monster->SetCookieableSchemes(cookie_schemes);
+
+    // Setup handlers for custom job factory.
+    top_job_factory_.reset(new AtomURLRequestJobFactory);
+    SetupAtomURLRequestJobFactory(&protocol_handlers_, url_request_context_,
+                                  top_job_factory_.get());
+    std::unique_ptr<net::URLRequestJobFactory> inner_job_factory(
+        new net::URLRequestJobFactoryImpl);
+    if (!protocol_interceptors_.empty()) {
+      // Set up interceptors in the reverse order.
+      for (auto it = protocol_interceptors_.rbegin();
+           it != protocol_interceptors_.rend(); ++it) {
+        inner_job_factory.reset(new net::URLRequestInterceptingJobFactory(
+            std::move(inner_job_factory), std::move(*it)));
+      }
+      protocol_interceptors_.clear();
+    }
+    top_job_factory_->Chain(std::move(inner_job_factory));
+    url_request_context_->set_job_factory(top_job_factory_.get());
+
+    context_handle_->resource_context_->request_context_ = url_request_context_;
+  }
+
+  return url_request_context_;
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+URLRequestContextGetter::GetNetworkTaskRunner() const {
+  return BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
+}
+
+}  // namespace atom

atom/browser/net/url_request_context_getter.h

@@ -0,0 +1,119 @@
+// 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_NET_URL_REQUEST_CONTEXT_GETTER_H_
+#define ATOM_BROWSER_NET_URL_REQUEST_CONTEXT_GETTER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/files/file_path.h"
+#include "content/public/browser/browser_context.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "services/network/public/mojom/network_service.mojom.h"
+
+#if DCHECK_IS_ON()
+#include "base/debug/leak_tracker.h"
+#endif
+
+namespace brightray {
+class RequireCTDelegate;
+}  // namespace brightray
+
+namespace net {
+class HttpAuthPreferences;
+class NetLog;
+}  // namespace net
+
+namespace atom {
+
+class AtomBrowserContext;
+class AtomURLRequestJobFactory;
+class ResourceContext;
+
+class URLRequestContextGetter : public net::URLRequestContextGetter {
+ public:
+  // net::URLRequestContextGetter:
+  net::URLRequestContext* GetURLRequestContext() override;
+  scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
+      const override;
+
+  // Discard reference to URLRequestContext and inform observers to
+  // shutdown. Must be called only on IO thread.
+  void NotifyContextShuttingDown(std::unique_ptr<ResourceContext>);
+
+  AtomURLRequestJobFactory* job_factory() const {
+    return top_job_factory_.get();
+  }
+
+ private:
+  friend class AtomBrowserContext;
+
+  // Responsible for destroying URLRequestContextGetter
+  // on the IO thread.
+  class Handle {
+   public:
+    explicit Handle(base::WeakPtr<AtomBrowserContext> browser_context);
+    ~Handle();
+
+    scoped_refptr<URLRequestContextGetter> CreateMainRequestContextGetter(
+        content::ProtocolHandlerMap* protocol_handlers,
+        content::URLRequestInterceptorScopedVector protocol_interceptors);
+    content::ResourceContext* GetResourceContext();
+    scoped_refptr<URLRequestContextGetter> GetMainRequestContextGetter();
+    network::mojom::NetworkContextPtr GetNetworkContext();
+
+    void ShutdownOnUIThread();
+
+   private:
+    friend class URLRequestContextGetter;
+    void LazyInitialize();
+
+    scoped_refptr<URLRequestContextGetter> main_request_context_getter_;
+    std::unique_ptr<ResourceContext> resource_context_;
+    base::WeakPtr<AtomBrowserContext> browser_context_;
+    // This is a NetworkContext interface that uses URLRequestContextGetter
+    // NetworkContext, ownership is passed to StoragePartition when
+    // CreateMainNetworkContext is called.
+    network::mojom::NetworkContextPtr main_network_context_;
+    // Request corresponding to |main_network_context_|. Ownership
+    // is passed to network service.
+    network::mojom::NetworkContextRequest main_network_context_request_;
+    network::mojom::NetworkContextParamsPtr main_network_context_params_;
+    bool initialized_;
+
+    DISALLOW_COPY_AND_ASSIGN(Handle);
+  };
+
+  URLRequestContextGetter(
+      net::NetLog* net_log,
+      URLRequestContextGetter::Handle* context_handle,
+      content::ProtocolHandlerMap* protocol_handlers,
+      content::URLRequestInterceptorScopedVector protocol_interceptors);
+  ~URLRequestContextGetter() override;
+
+#if DCHECK_IS_ON()
+  base::debug::LeakTracker<URLRequestContextGetter> leak_tracker_;
+#endif
+
+  std::unique_ptr<brightray::RequireCTDelegate> ct_delegate_;
+  std::unique_ptr<AtomURLRequestJobFactory> top_job_factory_;
+  std::unique_ptr<net::HttpAuthPreferences> http_auth_preferences_;
+  std::unique_ptr<network::mojom::NetworkContext> network_context_;
+
+  net::NetLog* net_log_;
+  URLRequestContextGetter::Handle* context_handle_;
+  net::URLRequestContext* url_request_context_;
+  content::ProtocolHandlerMap protocol_handlers_;
+  content::URLRequestInterceptorScopedVector protocol_interceptors_;
+  bool context_shutting_down_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestContextGetter);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NET_URL_REQUEST_CONTEXT_GETTER_H_

atom/browser/net/url_request_fetch_job.cc

@@ -167,6 +167,9 @@ void URLRequestFetchJob::StartAsync(std::unique_ptr<base::Value> options) {
       request()->extra_request_headers().ToString());
 
   fetcher_->Start();
+  // URLFetcher has a refernce to the context, which
+  // will be cleared when the request is destroyed.
+  url_request_context_getter_ = nullptr;
 }
 
 void URLRequestFetchJob::HeadersCompleted() {
@@ -199,6 +202,7 @@ int URLRequestFetchJob::DataAvailable(net::IOBuffer* buffer,
 void URLRequestFetchJob::Kill() {
   JsAsker<URLRequestJob>::Kill();
   fetcher_.reset();
+  custom_browser_context_ = nullptr;
 }
 
 int URLRequestFetchJob::ReadRawData(net::IOBuffer* dest, int dest_size) {

atom/browser/pref_store_delegate.cc

@@ -0,0 +1,30 @@
+// 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/pref_store_delegate.h"
+
+#include <utility>
+
+#include "atom/browser/atom_browser_context.h"
+#include "components/prefs/value_map_pref_store.h"
+
+namespace atom {
+
+PrefStoreDelegate::PrefStoreDelegate(
+    base::WeakPtr<AtomBrowserContext> browser_context)
+    : browser_context_(std::move(browser_context)) {}
+
+PrefStoreDelegate::~PrefStoreDelegate() {
+  if (browser_context_)
+    browser_context_->set_in_memory_pref_store(nullptr);
+}
+
+void PrefStoreDelegate::UpdateCommandLinePrefStore(
+    PrefStore* command_line_prefs) {
+  if (browser_context_)
+    browser_context_->set_in_memory_pref_store(
+        static_cast<ValueMapPrefStore*>(command_line_prefs));
+}
+
+}  // namespace atom

atom/browser/pref_store_delegate.h

@@ -0,0 +1,52 @@
+// 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_PREF_STORE_DELEGATE_H_
+#define ATOM_BROWSER_PREF_STORE_DELEGATE_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "components/prefs/persistent_pref_store.h"
+#include "components/prefs/pref_value_store.h"
+
+namespace atom {
+
+class AtomBrowserContext;
+
+// Retrieves handle to the in memory pref store that gets
+// initialized with the pref service.
+class PrefStoreDelegate : public PrefValueStore::Delegate {
+ public:
+  explicit PrefStoreDelegate(base::WeakPtr<AtomBrowserContext> browser_context);
+  ~PrefStoreDelegate() override;
+
+  void Init(PrefStore* managed_prefs,
+            PrefStore* supervised_user_prefs,
+            PrefStore* extension_prefs,
+            PrefStore* command_line_prefs,
+            PrefStore* user_prefs,
+            PrefStore* recommended_prefs,
+            PrefStore* default_prefs,
+            PrefNotifier* pref_notifier) override {}
+
+  void InitIncognitoUserPrefs(
+      scoped_refptr<PersistentPrefStore> incognito_user_prefs_overlay,
+      scoped_refptr<PersistentPrefStore> incognito_user_prefs_underlay,
+      const std::vector<const char*>& overlay_pref_names) override {}
+
+  void InitPrefRegistry(PrefRegistry* pref_registry) override {}
+
+  void UpdateCommandLinePrefStore(PrefStore* command_line_prefs) override;
+
+ private:
+  base::WeakPtr<AtomBrowserContext> browser_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrefStoreDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_PREF_STORE_DELEGATE_H_

atom/browser/request_context_delegate.cc

@@ -1,163 +0,0 @@
-// Copyright (c) 2018 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/request_context_delegate.h"
-
-#include "atom/browser/api/atom_api_protocol.h"
-#include "atom/browser/net/about_protocol_handler.h"
-#include "atom/browser/net/asar/asar_protocol_handler.h"
-#include "atom/browser/net/atom_cert_verifier.h"
-#include "atom/browser/net/atom_network_delegate.h"
-#include "atom/browser/net/atom_url_request_job_factory.h"
-#include "atom/browser/net/cookie_details.h"
-#include "atom/browser/net/http_protocol_handler.h"
-#include "atom/common/options_switches.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/task_scheduler/post_task.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/common/url_constants.h"
-#include "net/ftp/ftp_network_layer.h"
-#include "net/url_request/data_protocol_handler.h"
-#include "net/url_request/ftp_protocol_handler.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_intercepting_job_factory.h"
-#include "url/url_constants.h"
-
-using content::BrowserThread;
-
-namespace atom {
-
-namespace {
-
-class NoCacheBackend : public net::HttpCache::BackendFactory {
-  int CreateBackend(net::NetLog* net_log,
-                    std::unique_ptr<disk_cache::Backend>* backend,
-                    const net::CompletionCallback& callback) override {
-    return net::ERR_FAILED;
-  }
-};
-
-}  // namespace
-
-RequestContextDelegate::RequestContextDelegate(bool use_cache)
-    : use_cache_(use_cache), weak_factory_(this) {}
-
-RequestContextDelegate::~RequestContextDelegate() {}
-
-std::unique_ptr<base::CallbackList<void(const CookieDetails*)>::Subscription>
-RequestContextDelegate::RegisterCookieChangeCallback(
-    const base::Callback<void(const CookieDetails*)>& cb) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  return cookie_change_sub_list_.Add(cb);
-}
-
-void RequestContextDelegate::NotifyCookieChange(
-    const net::CanonicalCookie& cookie,
-    net::CookieChangeCause cause) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  CookieDetails cookie_details(
-      &cookie, !(cause == net::CookieChangeCause::INSERTED), cause);
-  cookie_change_sub_list_.Notify(&cookie_details);
-}
-
-std::unique_ptr<net::NetworkDelegate>
-RequestContextDelegate::CreateNetworkDelegate() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  return std::make_unique<AtomNetworkDelegate>();
-}
-
-std::unique_ptr<net::URLRequestJobFactory>
-RequestContextDelegate::CreateURLRequestJobFactory(
-    net::URLRequestContext* url_request_context,
-    content::ProtocolHandlerMap* protocol_handlers) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  std::unique_ptr<AtomURLRequestJobFactory> job_factory(
-      new AtomURLRequestJobFactory);
-
-  for (auto& it : *protocol_handlers) {
-    job_factory->SetProtocolHandler(it.first,
-                                    base::WrapUnique(it.second.release()));
-  }
-  protocol_handlers->clear();
-
-  job_factory->SetProtocolHandler(url::kAboutScheme,
-                                  base::WrapUnique(new AboutProtocolHandler));
-  job_factory->SetProtocolHandler(
-      url::kDataScheme, base::WrapUnique(new net::DataProtocolHandler));
-  job_factory->SetProtocolHandler(
-      url::kFileScheme,
-      base::WrapUnique(
-          new asar::AsarProtocolHandler(base::CreateTaskRunnerWithTraits(
-              {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
-               base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}))));
-  job_factory->SetProtocolHandler(
-      url::kHttpScheme,
-      base::WrapUnique(new HttpProtocolHandler(url::kHttpScheme)));
-  job_factory->SetProtocolHandler(
-      url::kHttpsScheme,
-      base::WrapUnique(new HttpProtocolHandler(url::kHttpsScheme)));
-  job_factory->SetProtocolHandler(
-      url::kWsScheme,
-      base::WrapUnique(new HttpProtocolHandler(url::kWsScheme)));
-  job_factory->SetProtocolHandler(
-      url::kWssScheme,
-      base::WrapUnique(new HttpProtocolHandler(url::kWssScheme)));
-
-  auto* host_resolver = url_request_context->host_resolver();
-  job_factory->SetProtocolHandler(
-      url::kFtpScheme, net::FtpProtocolHandler::Create(host_resolver));
-
-  return std::move(job_factory);
-}
-
-net::HttpCache::BackendFactory*
-RequestContextDelegate::CreateHttpCacheBackendFactory(
-    const base::FilePath& base_path) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  if (!use_cache_) {
-    return new NoCacheBackend;
-  } else {
-    int max_size = 0;
-    base::StringToInt(
-        command_line->GetSwitchValueASCII(switches::kDiskCacheSize), &max_size);
-
-    base::FilePath cache_path = base_path.Append(FILE_PATH_LITERAL("Cache"));
-    return new net::HttpCache::DefaultBackend(
-        net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, cache_path, max_size);
-  }
-}
-
-std::unique_ptr<net::CertVerifier> RequestContextDelegate::CreateCertVerifier(
-    brightray::RequireCTDelegate* ct_delegate) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  return std::make_unique<AtomCertVerifier>(ct_delegate);
-}
-
-void RequestContextDelegate::GetCookieableSchemes(
-    std::vector<std::string>* cookie_schemes) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  const auto& standard_schemes = atom::api::GetStandardSchemes();
-  cookie_schemes->insert(cookie_schemes->end(), standard_schemes.begin(),
-                         standard_schemes.end());
-}
-
-void RequestContextDelegate::OnCookieChanged(const net::CanonicalCookie& cookie,
-                                             net::CookieChangeCause cause) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::BindRepeating(&RequestContextDelegate::NotifyCookieChange,
-                          weak_factory_.GetWeakPtr(), cookie, cause));
-}
-
-}  // namespace atom

atom/browser/request_context_delegate.h

@@ -1,58 +0,0 @@
-// Copyright (c) 2018 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_REQUEST_CONTEXT_DELEGATE_H_
-#define ATOM_BROWSER_REQUEST_CONTEXT_DELEGATE_H_
-
-#include <string>
-#include <vector>
-
-#include "base/callback_list.h"
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "brightray/browser/url_request_context_getter.h"
-
-namespace atom {
-
-struct CookieDetails;
-
-class RequestContextDelegate
-    : public brightray::URLRequestContextGetter::Delegate {
- public:
-  explicit RequestContextDelegate(bool use_cache);
-  ~RequestContextDelegate() override;
-
-  // Register callbacks that needs to notified on any cookie store changes.
-  std::unique_ptr<base::CallbackList<void(const CookieDetails*)>::Subscription>
-  RegisterCookieChangeCallback(
-      const base::Callback<void(const CookieDetails*)>& cb);
-
- protected:
-  std::unique_ptr<net::NetworkDelegate> CreateNetworkDelegate() override;
-  std::unique_ptr<net::URLRequestJobFactory> CreateURLRequestJobFactory(
-      net::URLRequestContext* url_request_context,
-      content::ProtocolHandlerMap* protocol_handlers) override;
-  net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
-      const base::FilePath& base_path) override;
-  std::unique_ptr<net::CertVerifier> CreateCertVerifier(
-      brightray::RequireCTDelegate* ct_delegate) override;
-  void GetCookieableSchemes(std::vector<std::string>* cookie_schemes) override;
-  void OnCookieChanged(const net::CanonicalCookie& cookie,
-                       net::CookieChangeCause cause) override;
-
- private:
-  void NotifyCookieChange(const net::CanonicalCookie& cookie,
-                          net::CookieChangeCause cause);
-
-  base::CallbackList<void(const CookieDetails*)> cookie_change_sub_list_;
-  bool use_cache_ = true;
-
-  base::WeakPtrFactory<RequestContextDelegate> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(RequestContextDelegate);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_REQUEST_CONTEXT_DELEGATE_H_

atom/browser/resources/mac/Info.plist

@@ -17,9 +17,9 @@
   <key>CFBundleIconFile</key>
   <string>electron.icns</string>
   <key>CFBundleVersion</key>
-  <string>3.0.8</string>
+  <string>3.1.7</string>
   <key>CFBundleShortVersionString</key>
-  <string>3.0.8</string>
+  <string>3.1.7</string>
   <key>LSApplicationCategoryType</key>
   <string>public.app-category.developer-tools</string>
   <key>LSMinimumSystemVersion</key>

atom/browser/resources/win/atom.rc

@@ -56,8 +56,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 3,0,8,0
- PRODUCTVERSION 3,0,8,0
+ FILEVERSION 3,1,7,0
+ PRODUCTVERSION 3,1,7,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -74,12 +74,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "GitHub, Inc."
             VALUE "FileDescription", "Electron"
-            VALUE "FileVersion", "3.0.8"
+            VALUE "FileVersion", "3.1.7"
             VALUE "InternalName", "electron.exe"
             VALUE "LegalCopyright", "Copyright (C) 2015 GitHub, Inc. All rights reserved."
             VALUE "OriginalFilename", "electron.exe"
             VALUE "ProductName", "Electron"
-            VALUE "ProductVersion", "3.0.8"
+            VALUE "ProductVersion", "3.1.7"
             VALUE "SquirrelAwareVersion", "1"
         END
     END

atom/browser/ui/accelerator_util.cc

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

atom/browser/ui/atom_menu_model.cc

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

atom/browser/ui/atom_menu_model.h

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

atom/browser/ui/cocoa/atom_menu_controller.mm

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

@@ -178,9 +178,10 @@ bool RootView::AcceleratorPressed(const ui::Accelerator& accelerator) {
 }
 
 void RootView::RegisterAcceleratorsWithFocusManager(AtomMenuModel* menu_model) {
+  if (!menu_model)
+    return;
   // Clear previous accelerators.
   UnregisterAcceleratorsWithFocusManager();
-
   views::FocusManager* focus_manager = GetFocusManager();
   // Register accelerators with focus manager.
   accelerator_util::GenerateAcceleratorTable(&accelerator_table_, menu_model);

atom/common/api/atom_api_native_image.cc

@@ -508,6 +508,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.;

atom/common/atom_version.h

@@ -6,8 +6,8 @@
 #define ATOM_COMMON_ATOM_VERSION_H_
 
 #define ATOM_MAJOR_VERSION 3
-#define ATOM_MINOR_VERSION 0
-#define ATOM_PATCH_VERSION 8
+#define ATOM_MINOR_VERSION 1
+#define ATOM_PATCH_VERSION 7
 // #define ATOM_PRE_RELEASE_VERSION
 
 #ifndef ATOM_STRINGIFY

atom/common/node_bindings.cc

@@ -39,7 +39,6 @@
   V(atom_browser_in_app_purchase)            \
   V(atom_browser_menu)                       \
   V(atom_browser_net)                        \
-  V(atom_browser_net_log)                    \
   V(atom_browser_power_monitor)              \
   V(atom_browser_power_save_blocker)         \
   V(atom_browser_protocol)                   \

atom/common/node_bindings_win.cc

@@ -7,6 +7,7 @@
 #include <windows.h>
 
 #include "base/logging.h"
+#include "base/sys_info.h"
 
 extern "C" {
 #include "vendor/node/deps/uv/src/win/internal.h"
@@ -15,7 +16,20 @@ extern "C" {
 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/options_switches.cc

@@ -218,6 +218,13 @@ const char kDiskCacheSize[] = "disk-cache-size";
 // Ignore the limit of 6 connections per host.
 const char kIgnoreConnectionsLimit[] = "ignore-connections-limit";
 
+// Whitelist containing servers for which Integrated Authentication is enabled.
+const char kAuthServerWhitelist[] = "auth-server-whitelist";
+
+// Whitelist containing servers for which Kerberos delegation is allowed.
+const char kAuthNegotiateDelegateWhitelist[] =
+    "auth-negotiate-delegate-whitelist";
+
 }  // namespace switches
 
 }  // namespace atom

atom/common/options_switches.h

@@ -113,6 +113,8 @@ extern const char kWidevineCdmVersion[];
 
 extern const char kDiskCacheSize[];
 extern const char kIgnoreConnectionsLimit[];
+extern const char kAuthServerWhitelist[];
+extern const char kAuthNegotiateDelegateWhitelist[];
 
 }  // namespace switches
 

atom/common/platform_util.h

@@ -60,6 +60,7 @@ void Beep();
 #if defined(OS_MACOSX)
 bool GetLoginItemEnabled();
 void SetLoginItemEnabled(bool enabled);
+bool IsAtLeastOS10_14();
 #endif
 
 }  // namespace platform_util

atom/common/platform_util_mac.mm

@@ -8,6 +8,8 @@
 #import <Cocoa/Cocoa.h>
 #import <ServiceManagement/ServiceManagement.h>
 
+#include "atom/common/platform_util.h"
+
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ -18,6 +20,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "net/base/mac/url_conversions.h"
+#include "third_party/WebKit/Source/platform/mac/VersionUtilMac.h"
 #include "url/gurl.h"
 
 namespace {
@@ -166,6 +169,10 @@ void OpenExternal(const GURL& url,
                  });
 }
 
+bool IsAtLeastOS10_14() {
+  return blink::internal::MacOSXMinorVersion() >= 14;
+}
+
 bool MoveItemToTrash(const base::FilePath& full_path) {
   NSString* path_string = base::SysUTF8ToNSString(full_path.value());
   BOOL status = [[NSFileManager defaultManager]

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,128 @@ 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,
     const base::string16& name,
     v8::Local<v8::Object> options) {
-  return web_frame_->GetDocument().RegisterEmbedderCustomElement(
-      blink::WebString::FromUTF16(name), options);
+  return GetRenderFrame(window)
+      ->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 +273,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 +319,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 +349,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 +419,131 @@ 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);
+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 +552,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

atom/renderer/api/atom_api_web_frame.h

@@ -1,113 +0,0 @@
-// Copyright (c) 2014 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_RENDERER_API_ATOM_API_WEB_FRAME_H_
-#define ATOM_RENDERER_API_ATOM_API_WEB_FRAME_H_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "native_mate/handle.h"
-#include "native_mate/wrappable.h"
-#include "third_party/WebKit/public/platform/WebCache.h"
-
-namespace blink {
-class WebLocalFrame;
-}
-
-namespace mate {
-class Dictionary;
-class Arguments;
-}  // namespace mate
-
-namespace atom {
-
-namespace api {
-
-class SpellCheckClient;
-
-class WebFrame : public mate::Wrappable<WebFrame> {
- public:
-  static mate::Handle<WebFrame> Create(v8::Isolate* isolate);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::FunctionTemplate> prototype);
-
- private:
-  explicit WebFrame(v8::Isolate* isolate);
-  explicit WebFrame(v8::Isolate* isolate, blink::WebLocalFrame* blink_frame);
-  ~WebFrame() override;
-
-  void SetName(const std::string& name);
-
-  double SetZoomLevel(double level);
-  double GetZoomLevel() const;
-  double SetZoomFactor(double factor);
-  double GetZoomFactor() const;
-
-  void SetVisualZoomLevelLimits(double min_level, double max_level);
-  void SetLayoutZoomLevelLimits(double min_level, double max_level);
-
-  v8::Local<v8::Value> RegisterEmbedderCustomElement(
-      const base::string16& name,
-      v8::Local<v8::Object> options);
-  int GetWebFrameId(v8::Local<v8::Value> content_window);
-
-  // Set the provider that will be used by SpellCheckClient for spell check.
-  void SetSpellCheckProvider(mate::Arguments* args,
-                             const std::string& language,
-                             bool auto_spell_correct_turned_on,
-                             v8::Local<v8::Object> provider);
-
-  void RegisterURLSchemeAsBypassingCSP(const std::string& scheme);
-  void RegisterURLSchemeAsPrivileged(const std::string& scheme,
-                                     mate::Arguments* args);
-
-  // Editing.
-  void InsertText(const std::string& text);
-  void InsertCSS(const std::string& css);
-
-  // Executing scripts.
-  void ExecuteJavaScript(const base::string16& code, mate::Arguments* args);
-  void ExecuteJavaScriptInIsolatedWorld(
-      int world_id,
-      const std::vector<mate::Dictionary>& scripts,
-      mate::Arguments* args);
-
-  // Isolated world related methods
-  void SetIsolatedWorldSecurityOrigin(int world_id,
-                                      const std::string& origin_url);
-  void SetIsolatedWorldContentSecurityPolicy(
-      int world_id,
-      const std::string& security_policy);
-  void SetIsolatedWorldHumanReadableName(int world_id, const std::string& name);
-
-  // Resource related methods
-  blink::WebCache::ResourceTypeStats GetResourceUsage(v8::Isolate* isolate);
-  void ClearCache(v8::Isolate* isolate);
-
-  // Frame navigation
-  v8::Local<v8::Value> Opener() const;
-  v8::Local<v8::Value> Parent() const;
-  v8::Local<v8::Value> Top() const;
-  v8::Local<v8::Value> FirstChild() const;
-  v8::Local<v8::Value> NextSibling() const;
-  v8::Local<v8::Value> GetFrameForSelector(const std::string& selector) const;
-  v8::Local<v8::Value> FindFrameByName(const std::string& name) const;
-  v8::Local<v8::Value> FindFrameByRoutingId(int routing_id) const;
-  v8::Local<v8::Value> RoutingId() const;
-
-  std::unique_ptr<SpellCheckClient> spell_check_client_;
-
-  blink::WebLocalFrame* web_frame_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebFrame);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_RENDERER_API_ATOM_API_WEB_FRAME_H_

atom/utility/atom_content_utility_client.cc

@@ -4,6 +4,10 @@
 
 #include "atom/utility/atom_content_utility_client.h"
 
+#include "content/public/child/child_thread.h"
+#include "services/proxy_resolver/proxy_resolver_service.h"
+#include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
+
 #if defined(OS_WIN)
 #include "chrome/utility/printing_handler_win.h"
 #endif
@@ -29,4 +33,14 @@ bool AtomContentUtilityClient::OnMessageReceived(const IPC::Message& message) {
   return false;
 }
 
+void AtomContentUtilityClient::RegisterServices(StaticServiceMap* services) {
+  service_manager::EmbeddedServiceInfo proxy_resolver_info;
+  proxy_resolver_info.task_runner =
+      content::ChildThread::Get()->GetIOTaskRunner();
+  proxy_resolver_info.factory =
+      base::BindRepeating(&proxy_resolver::ProxyResolverService::CreateService);
+  services->emplace(proxy_resolver::mojom::kProxyResolverServiceName,
+                    proxy_resolver_info);
+}
+
 }  // namespace atom

atom/utility/atom_content_utility_client.h

@@ -21,6 +21,7 @@ class AtomContentUtilityClient : public content::ContentUtilityClient {
   ~AtomContentUtilityClient() override;
 
   bool OnMessageReceived(const IPC::Message& message) override;
+  void RegisterServices(StaticServiceMap* services) override;
 
  private:
 #if defined(OS_WIN)

brightray/brightray.gyp

@@ -150,8 +150,8 @@
                   '<(libchromiumcontent_dir)/libfx_agg.a',
                   '<(libchromiumcontent_dir)/libfx_lcms2.a',
                   '<(libchromiumcontent_dir)/libfx_libopenjpeg.a',
-                  '<(libchromiumcontent_dir)/libfx_zlib.a',
                   '-Wl,--no-whole-archive',
+                  '<(libchromiumcontent_dir)/libchrome.a',
                 ],
               },
             }, {
@@ -221,6 +221,7 @@
                   '<(libchromiumcontent_dir)/librenderer.a',
                   '<(libchromiumcontent_dir)/libsecurity_state.a',
                   '<(libchromiumcontent_dir)/libviz_service.a',
+                  '<(libchromiumcontent_dir)/libchrome.a',
                   # services/device/wake_lock/power_save_blocker/
                   '<(libchromiumcontent_dir)/libpower_save_blocker.a',
                   # Friends of libpdf.a:
@@ -360,6 +361,7 @@
                   '<(libchromiumcontent_dir)/renderer.lib',
                   '<(libchromiumcontent_dir)/security_state.lib',
                   '<(libchromiumcontent_dir)/viz_service.lib',
+                  '<(libchromiumcontent_dir)/chrome.lib',
                   # services/device/wake_lock/power_save_blocker/
                   '<(libchromiumcontent_dir)/power_save_blocker.lib',
                   # Friends of pdf.lib:

brightray/browser/browser_client.cc

@@ -6,7 +6,6 @@
 
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
-#include "brightray/browser/browser_context.h"
 #include "brightray/browser/browser_main_parts.h"
 #include "brightray/browser/devtools_manager_delegate.h"
 #include "brightray/browser/media/media_capture_devices_dispatcher.h"
@@ -106,10 +105,6 @@ void BrowserClient::GetAdditionalWebUISchemes(
   additional_schemes->push_back(content::kChromeDevToolsScheme);
 }
 
-NetLog* BrowserClient::GetNetLog() {
-  return &net_log_;
-}
-
 base::FilePath BrowserClient::GetDefaultDownloadDirectory() {
   // ~/Downloads
   base::FilePath path;

brightray/browser/browser_client.h

@@ -8,7 +8,6 @@
 #include <string>
 #include <vector>
 
-#include "brightray/browser/net_log.h"
 #include "content/public/browser/content_browser_client.h"
 
 namespace brightray {
@@ -45,7 +44,6 @@ class BrowserClient : public content::ContentBrowserClient {
       std::vector<std::string>* additional_schemes) override;
   void GetAdditionalWebUISchemes(
       std::vector<std::string>* additional_schemes) override;
-  NetLog* GetNetLog() override;
   base::FilePath GetDefaultDownloadDirectory() override;
   content::DevToolsManagerDelegate* GetDevToolsManagerDelegate() override;
   std::string GetApplicationLocale() override;
@@ -59,7 +57,6 @@ class BrowserClient : public content::ContentBrowserClient {
 
  private:
   BrowserMainParts* browser_main_parts_;
-  NetLog net_log_;
 
   std::unique_ptr<PlatformNotificationService> notification_service_;
   std::unique_ptr<NotificationPresenter> notification_presenter_;

brightray/browser/browser_context.cc

@@ -1,211 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE-CHROMIUM file.
-
-#include "brightray/browser/browser_context.h"
-
-#include "base/files/file_path.h"
-#include "base/path_service.h"
-#include "base/strings/string_util.h"
-#include "base/threading/thread_restrictions.h"
-#include "brightray/browser/brightray_paths.h"
-#include "brightray/browser/browser_client.h"
-#include "brightray/browser/inspectable_web_contents_impl.h"
-#include "brightray/browser/special_storage_policy.h"
-#include "brightray/browser/zoom_level_delegate.h"
-#include "brightray/common/application_info.h"
-#include "components/prefs/json_pref_store.h"
-#include "components/prefs/pref_registry_simple.h"
-#include "components/prefs/pref_service.h"
-#include "components/prefs/pref_service_factory.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/storage_partition.h"
-#include "net/base/escape.h"
-
-using content::BrowserThread;
-
-namespace brightray {
-
-namespace {
-
-// Convert string to lower case and escape it.
-std::string MakePartitionName(const std::string& input) {
-  return net::EscapePath(base::ToLowerASCII(input));
-}
-
-}  // namespace
-
-// static
-void BrowserContextDeleter::Destruct(const BrowserContext* browser_context) {
-  browser_context->OnDestruct();
-}
-
-// static
-BrowserContext::BrowserContextMap BrowserContext::browser_context_map_;
-
-// static
-scoped_refptr<BrowserContext> BrowserContext::Get(const std::string& partition,
-                                                  bool in_memory) {
-  PartitionKey key(partition, in_memory);
-  if (browser_context_map_[key].get())
-    return WrapRefCounted(browser_context_map_[key].get());
-
-  return nullptr;
-}
-
-BrowserContext::BrowserContext(const std::string& partition, bool in_memory)
-    : in_memory_(in_memory),
-      storage_policy_(new SpecialStoragePolicy),
-      weak_factory_(this) {
-  if (!PathService::Get(DIR_USER_DATA, &path_)) {
-    PathService::Get(DIR_APP_DATA, &path_);
-    path_ = path_.Append(base::FilePath::FromUTF8Unsafe(GetApplicationName()));
-    PathService::Override(DIR_USER_DATA, path_);
-  }
-
-  if (!in_memory_ && !partition.empty())
-    path_ = path_.Append(FILE_PATH_LITERAL("Partitions"))
-                .Append(base::FilePath::FromUTF8Unsafe(
-                    MakePartitionName(partition)));
-
-  content::BrowserContext::Initialize(this, path_);
-
-  io_handle_ = new URLRequestContextGetter::Handle(GetWeakPtr());
-
-  browser_context_map_[PartitionKey(partition, in_memory)] = GetWeakPtr();
-}
-
-BrowserContext::~BrowserContext() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  NotifyWillBeDestroyed(this);
-  ShutdownStoragePartitions();
-  io_handle_->ShutdownOnUIThread();
-}
-
-void BrowserContext::OnDestruct() const {
-  if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    delete this;
-  } else {
-    BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
-  }
-}
-
-void BrowserContext::InitPrefs() {
-  auto prefs_path = GetPath().Append(FILE_PATH_LITERAL("Preferences"));
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-  PrefServiceFactory prefs_factory;
-  scoped_refptr<JsonPrefStore> pref_store =
-      base::MakeRefCounted<JsonPrefStore>(prefs_path);
-  pref_store->ReadPrefs();  // Synchronous.
-  prefs_factory.set_user_prefs(pref_store);
-
-  auto registry = WrapRefCounted(new PrefRegistrySimple);
-  RegisterInternalPrefs(registry.get());
-  RegisterPrefs(registry.get());
-
-  prefs_ = prefs_factory.Create(registry.get());
-}
-
-void BrowserContext::RegisterInternalPrefs(PrefRegistrySimple* registry) {
-  InspectableWebContentsImpl::RegisterPrefs(registry);
-  MediaDeviceIDSalt::RegisterPrefs(registry);
-  ZoomLevelDelegate::RegisterPrefs(registry);
-}
-
-URLRequestContextGetter* BrowserContext::GetRequestContext() {
-  return static_cast<URLRequestContextGetter*>(
-      GetDefaultStoragePartition(this)->GetURLRequestContext());
-}
-
-net::URLRequestContextGetter* BrowserContext::CreateRequestContext(
-    content::ProtocolHandlerMap* protocol_handlers,
-    content::URLRequestInterceptorScopedVector protocol_interceptors) {
-  return io_handle_
-      ->CreateMainRequestContextGetter(protocol_handlers,
-                                       std::move(protocol_interceptors))
-      .get();
-}
-
-std::string BrowserContext::GetMediaDeviceIDSalt() {
-  if (!media_device_id_salt_.get())
-    media_device_id_salt_.reset(new MediaDeviceIDSalt(prefs_.get()));
-  return media_device_id_salt_->GetSalt();
-}
-
-base::FilePath BrowserContext::GetPath() const {
-  return path_;
-}
-
-std::unique_ptr<content::ZoomLevelDelegate>
-BrowserContext::CreateZoomLevelDelegate(const base::FilePath& partition_path) {
-  if (!IsOffTheRecord()) {
-    return std::make_unique<ZoomLevelDelegate>(prefs(), partition_path);
-  }
-  return std::unique_ptr<content::ZoomLevelDelegate>();
-}
-
-bool BrowserContext::IsOffTheRecord() const {
-  return in_memory_;
-}
-
-content::ResourceContext* BrowserContext::GetResourceContext() {
-  return io_handle_->GetResourceContext();
-}
-
-content::DownloadManagerDelegate* BrowserContext::GetDownloadManagerDelegate() {
-  return nullptr;
-}
-
-content::BrowserPluginGuestManager* BrowserContext::GetGuestManager() {
-  return nullptr;
-}
-
-storage::SpecialStoragePolicy* BrowserContext::GetSpecialStoragePolicy() {
-  return storage_policy_.get();
-}
-
-content::PushMessagingService* BrowserContext::GetPushMessagingService() {
-  return nullptr;
-}
-
-content::SSLHostStateDelegate* BrowserContext::GetSSLHostStateDelegate() {
-  return nullptr;
-}
-
-content::BackgroundFetchDelegate* BrowserContext::GetBackgroundFetchDelegate() {
-  return nullptr;
-}
-
-content::BackgroundSyncController*
-BrowserContext::GetBackgroundSyncController() {
-  return nullptr;
-}
-
-content::BrowsingDataRemoverDelegate*
-BrowserContext::GetBrowsingDataRemoverDelegate() {
-  return nullptr;
-}
-
-net::URLRequestContextGetter*
-BrowserContext::CreateRequestContextForStoragePartition(
-    const base::FilePath& partition_path,
-    bool in_memory,
-    content::ProtocolHandlerMap* protocol_handlers,
-    content::URLRequestInterceptorScopedVector request_interceptors) {
-  NOTREACHED();
-  return nullptr;
-}
-
-net::URLRequestContextGetter* BrowserContext::CreateMediaRequestContext() {
-  return io_handle_->GetMainRequestContextGetter().get();
-}
-
-net::URLRequestContextGetter*
-BrowserContext::CreateMediaRequestContextForStoragePartition(
-    const base::FilePath& partition_path,
-    bool in_memory) {
-  NOTREACHED();
-  return nullptr;
-}
-
-}  // namespace brightray

brightray/browser/browser_context.h

@@ -1,138 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE-CHROMIUM file.
-
-#ifndef BRIGHTRAY_BROWSER_BROWSER_CONTEXT_H_
-#define BRIGHTRAY_BROWSER_BROWSER_CONTEXT_H_
-
-#include <map>
-#include <string>
-
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "brightray/browser/media/media_device_id_salt.h"
-#include "brightray/browser/url_request_context_getter.h"
-#include "content/public/browser/browser_context.h"
-
-class PrefRegistrySimple;
-class PrefService;
-
-namespace storage {
-class SpecialStoragePolicy;
-}
-
-namespace brightray {
-
-class BrowserContext;
-
-struct BrowserContextDeleter {
-  static void Destruct(const BrowserContext* browser_context);
-};
-
-class BrowserContext
-    : public base::RefCountedThreadSafe<BrowserContext, BrowserContextDeleter>,
-      public content::BrowserContext {
- public:
-  // Get the BrowserContext according to its |partition| and |in_memory|,
-  // empty pointer when be returned when there is no matching BrowserContext.
-  static scoped_refptr<BrowserContext> Get(const std::string& partition,
-                                           bool in_memory);
-
-  base::WeakPtr<BrowserContext> GetWeakPtr() {
-    return weak_factory_.GetWeakPtr();
-  }
-
-  // Get the request context, if there is no one, create it.
-  URLRequestContextGetter* GetRequestContext();
-
-  // content::BrowserContext:
-  std::unique_ptr<content::ZoomLevelDelegate> CreateZoomLevelDelegate(
-      const base::FilePath& partition_path) override;
-  bool IsOffTheRecord() const override;
-  content::ResourceContext* GetResourceContext() override;
-  content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
-  content::BrowserPluginGuestManager* GetGuestManager() override;
-  storage::SpecialStoragePolicy* GetSpecialStoragePolicy() override;
-  content::PushMessagingService* GetPushMessagingService() override;
-  content::SSLHostStateDelegate* GetSSLHostStateDelegate() override;
-  content::BackgroundFetchDelegate* GetBackgroundFetchDelegate() override;
-  content::BackgroundSyncController* GetBackgroundSyncController() override;
-  content::BrowsingDataRemoverDelegate* GetBrowsingDataRemoverDelegate()
-      override;
-  net::URLRequestContextGetter* CreateRequestContext(
-      content::ProtocolHandlerMap* protocol_handlers,
-      content::URLRequestInterceptorScopedVector request_interceptors) override;
-  net::URLRequestContextGetter* CreateRequestContextForStoragePartition(
-      const base::FilePath& partition_path,
-      bool in_memory,
-      content::ProtocolHandlerMap* protocol_handlers,
-      content::URLRequestInterceptorScopedVector request_interceptors) override;
-  net::URLRequestContextGetter* CreateMediaRequestContext() override;
-  net::URLRequestContextGetter* CreateMediaRequestContextForStoragePartition(
-      const base::FilePath& partition_path,
-      bool in_memory) override;
-  std::string GetMediaDeviceIDSalt() override;
-  base::FilePath GetPath() const override;
-
-  void InitPrefs();
-  PrefService* prefs() { return prefs_.get(); }
-
-  virtual std::string GetUserAgent() const = 0;
-  virtual void OnMainRequestContextCreated(URLRequestContextGetter* getter) {}
-
- protected:
-  BrowserContext(const std::string& partition, bool in_memory);
-  ~BrowserContext() override;
-
-  // Subclasses should override this to register custom preferences.
-  virtual void RegisterPrefs(PrefRegistrySimple* pref_registry) {}
-
- private:
-  friend class base::RefCountedThreadSafe<BrowserContext,
-                                          BrowserContextDeleter>;
-  friend class base::DeleteHelper<BrowserContext>;
-  friend struct BrowserContextDeleter;
-
-  void RegisterInternalPrefs(PrefRegistrySimple* pref_registry);
-  void OnDestruct() const;
-
-  // partition_id => browser_context
-  struct PartitionKey {
-    std::string partition;
-    bool in_memory;
-
-    PartitionKey(const std::string& partition, bool in_memory)
-        : partition(partition), in_memory(in_memory) {}
-
-    bool operator<(const PartitionKey& other) const {
-      if (partition == other.partition)
-        return in_memory < other.in_memory;
-      return partition < other.partition;
-    }
-
-    bool operator==(const PartitionKey& other) const {
-      return (partition == other.partition) && (in_memory == other.in_memory);
-    }
-  };
-  using BrowserContextMap =
-      std::map<PartitionKey, base::WeakPtr<brightray::BrowserContext>>;
-  static BrowserContextMap browser_context_map_;
-
-  base::FilePath path_;
-  bool in_memory_;
-
-  scoped_refptr<storage::SpecialStoragePolicy> storage_policy_;
-  std::unique_ptr<PrefService> prefs_;
-  std::unique_ptr<MediaDeviceIDSalt> media_device_id_salt_;
-  // Self-destructing class responsible for creating URLRequestContextGetter
-  // on the UI thread and deletes itself on the IO thread.
-  URLRequestContextGetter::Handle* io_handle_;
-
-  base::WeakPtrFactory<BrowserContext> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(BrowserContext);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_BROWSER_CONTEXT_H_

brightray/browser/browser_main_parts.cc

@@ -22,7 +22,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "brightray/browser/browser_client.h"
-#include "brightray/browser/browser_context.h"
 #include "brightray/browser/devtools_manager_delegate.h"
 #include "brightray/browser/media/media_capture_devices_dispatcher.h"
 #include "brightray/browser/web_ui_controller_factory.h"
@@ -318,9 +317,6 @@ int BrowserMainParts::PreCreateThreads() {
   BrowserClient::SetApplicationLocale(
       l10n_util::GetApplicationLocale(custom_locale_));
 
-  // Manage global state of net and other IO thread related.
-  io_thread_ = std::make_unique<IOThread>();
-
   return 0;
 }
 
@@ -329,8 +325,6 @@ void BrowserMainParts::PostDestroyThreads() {
   device::BluetoothAdapterFactory::Shutdown();
   bluez::DBusBluezManagerWrapperLinux::Shutdown();
 #endif
-
-  io_thread_.reset();
 }
 
 }  // namespace brightray

brightray/browser/browser_main_parts.h

@@ -12,7 +12,6 @@
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "brightray/browser/brightray_paths.h"
-#include "brightray/browser/io_thread.h"
 #include "content/public/browser/browser_main_parts.h"
 #include "ui/views/layout/layout_provider.h"
 
@@ -29,8 +28,6 @@ class BrowserMainParts : public content::BrowserMainParts {
   BrowserMainParts();
   ~BrowserMainParts() override;
 
-  IOThread* io_thread() const { return io_thread_.get(); }
-
  protected:
   // content::BrowserMainParts:
   bool ShouldContentCreateFeatureList() override;
@@ -51,8 +48,6 @@ class BrowserMainParts : public content::BrowserMainParts {
   void OverrideAppLogsPath();
 #endif
 
-  std::unique_ptr<IOThread> io_thread_;
-
 #if defined(USE_AURA)
   std::unique_ptr<wm::WMState> wm_state_;
 #endif

brightray/browser/inspectable_web_contents.cc

@@ -6,8 +6,9 @@ namespace brightray {
 
 InspectableWebContents* InspectableWebContents::Create(
     content::WebContents* web_contents,
+    PrefService* pref_service,
     bool is_guest) {
-  return new InspectableWebContentsImpl(web_contents, is_guest);
+  return new InspectableWebContentsImpl(web_contents, pref_service, is_guest);
 }
 
 }  // namespace brightray

brightray/browser/inspectable_web_contents.h

@@ -13,6 +13,8 @@ namespace content {
 class DevToolsAgentHost;
 }
 
+class PrefService;
+
 namespace brightray {
 
 class InspectableWebContentsDelegate;
@@ -23,6 +25,7 @@ class InspectableWebContents {
   // The returned InspectableWebContents takes ownership of the passed-in
   // WebContents.
   static InspectableWebContents* Create(content::WebContents* web_contents,
+                                        PrefService* pref_service,
                                         bool is_guest);
 
   virtual ~InspectableWebContents() {}

brightray/browser/inspectable_web_contents_impl.cc

@@ -18,7 +18,6 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "brightray/browser/browser_client.h"
-#include "brightray/browser/browser_context.h"
 #include "brightray/browser/browser_main_parts.h"
 #include "brightray/browser/inspectable_web_contents_delegate.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
@@ -26,13 +25,16 @@
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/common/user_agent.h"
 #include "ipc/ipc_channel.h"
+#include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_response_writer.h"
@@ -203,13 +205,12 @@ void InspectableWebContentsImpl::RegisterPrefs(PrefRegistrySimple* registry) {
 
 InspectableWebContentsImpl::InspectableWebContentsImpl(
     content::WebContents* web_contents,
+    PrefService* pref_service,
     bool is_guest)
     : frontend_loaded_(false),
       can_dock_(true),
       delegate_(nullptr),
-      pref_service_(
-          static_cast<BrowserContext*>(web_contents->GetBrowserContext())
-              ->prefs()),
+      pref_service_(pref_service),
       web_contents_(web_contents),
       is_guest_(is_guest),
       view_(CreateInspectableContentsView(this)),
@@ -485,13 +486,14 @@ void InspectableWebContentsImpl::LoadNetworkResource(
     return;
   }
 
-  auto* browser_context = static_cast<BrowserContext*>(
-      GetDevToolsWebContents()->GetBrowserContext());
+  auto* browser_context = GetDevToolsWebContents()->GetBrowserContext();
 
   net::URLFetcher* fetcher =
       (net::URLFetcher::Create(gurl, net::URLFetcher::GET, this)).release();
   pending_requests_[fetcher] = callback;
-  fetcher->SetRequestContext(browser_context->GetRequestContext());
+  fetcher->SetRequestContext(
+      content::BrowserContext::GetDefaultStoragePartition(browser_context)
+          ->GetURLRequestContext());
   fetcher->SetExtraRequestHeaders(headers);
   fetcher->SaveResponseWithWriter(
       std::unique_ptr<net::URLFetcherResponseWriter>(

brightray/browser/inspectable_web_contents_impl.h

@@ -39,7 +39,9 @@ class InspectableWebContentsImpl
  public:
   static void RegisterPrefs(PrefRegistrySimple* pref_registry);
 
-  InspectableWebContentsImpl(content::WebContents* web_contents, bool is_guest);
+  InspectableWebContentsImpl(content::WebContents* web_contents,
+                             PrefService* pref_service,
+                             bool is_guest);
   ~InspectableWebContentsImpl() override;
 
   InspectableWebContentsView* GetView() const override;

brightray/browser/io_thread.cc

@@ -1,54 +0,0 @@
-// Copyright (c) 2017 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "brightray/browser/io_thread.h"
-
-#include "content/public/browser/browser_thread.h"
-#include "net/proxy_resolution/proxy_service.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_builder.h"
-#include "net/url_request/url_request_context_getter.h"
-
-#if defined(USE_NSS_CERTS)
-#include "net/cert_net/nss_ocsp.h"
-#endif
-
-using content::BrowserThread;
-
-namespace brightray {
-
-IOThread::IOThread() {
-  BrowserThread::SetIOThreadDelegate(this);
-}
-
-IOThread::~IOThread() {
-  BrowserThread::SetIOThreadDelegate(nullptr);
-}
-
-void IOThread::Init() {
-  net::URLRequestContextBuilder builder;
-  builder.set_proxy_resolution_service(
-      net::ProxyResolutionService::CreateDirect());
-  url_request_context_ = builder.Build();
-  url_request_context_getter_ = new net::TrivialURLRequestContextGetter(
-      url_request_context_.get(), base::ThreadTaskRunnerHandle::Get());
-  url_request_context_getter_->AddRef();
-
-#if defined(USE_NSS_CERTS)
-  net::SetMessageLoopForNSSHttpIO();
-  net::SetURLRequestContextForNSSHttpIO(url_request_context_.get());
-#endif
-}
-
-void IOThread::CleanUp() {
-#if defined(USE_NSS_CERTS)
-  net::ShutdownNSSHttpIO();
-  net::SetURLRequestContextForNSSHttpIO(nullptr);
-#endif
-  // Explicitly release before the IO thread gets destroyed.
-  url_request_context_getter_->Release();
-  url_request_context_.reset();
-}
-
-}  // namespace brightray

brightray/browser/mac/cocoa_notification.mm

@@ -13,8 +13,6 @@
 
 namespace brightray {
 
-int g_identifier_ = 1;
-
 CocoaNotification::CocoaNotification(NotificationDelegate* delegate,
                                      NotificationPresenter* presenter)
     : Notification(delegate, presenter) {}
@@ -29,7 +27,9 @@ void CocoaNotification::Show(const NotificationOptions& options) {
   notification_.reset([[NSUserNotification alloc] init]);
 
   NSString* identifier =
-      [NSString stringWithFormat:@"ElectronNotification%d", g_identifier_++];
+      [NSString stringWithFormat:@"%@:notification:%@",
+                                 [[NSBundle mainBundle] bundleIdentifier],
+                                 [[[NSUUID alloc] init] UUIDString]];
 
   [notification_ setTitle:base::SysUTF16ToNSString(options.title)];
   [notification_ setSubtitle:base::SysUTF16ToNSString(options.subtitle)];

brightray/browser/net_log.cc

@@ -1,103 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "brightray/browser/net_log.h"
-
-#include <utility>
-
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/values.h"
-#include "net/log/file_net_log_observer.h"
-#include "net/log/net_log_util.h"
-#include "services/network/public/cpp/network_switches.h"
-
-namespace brightray {
-
-namespace {
-
-std::unique_ptr<base::DictionaryValue> GetConstants() {
-  std::unique_ptr<base::DictionaryValue> constants = net::GetNetConstants();
-
-  // Adding client information to constants dictionary.
-  auto client_info = std::make_unique<base::DictionaryValue>();
-  client_info->SetString(
-      "command_line",
-      base::CommandLine::ForCurrentProcess()->GetCommandLineString());
-
-  constants->Set("clientInfo", std::move(client_info));
-  return constants;
-}
-
-}  // namespace
-
-NetLog::NetLog() {}
-
-NetLog::~NetLog() {
-  StopDynamicLogging();
-  StopLogging();
-}
-
-void NetLog::StartLogging() {
-  auto* command_line = base::CommandLine::ForCurrentProcess();
-  if (!command_line->HasSwitch(network::switches::kLogNetLog))
-    return;
-
-  base::FilePath log_path =
-      command_line->GetSwitchValuePath(network::switches::kLogNetLog);
-  if (log_path.empty())
-    return;
-
-  std::unique_ptr<base::Value> constants(GetConstants());  // Net constants
-  net::NetLogCaptureMode capture_mode = net::NetLogCaptureMode::Default();
-
-  file_net_log_observer_ =
-      net::FileNetLogObserver::CreateUnbounded(log_path, std::move(constants));
-  file_net_log_observer_->StartObserving(this, capture_mode);
-}
-
-void NetLog::StopLogging() {
-  if (!file_net_log_observer_)
-    return;
-
-  file_net_log_observer_->StopObserving(nullptr, base::OnceClosure());
-  file_net_log_observer_.reset();
-}
-
-void NetLog::StartDynamicLogging(const base::FilePath& log_path) {
-  if (dynamic_file_net_log_observer_ || log_path.empty())
-    return;
-
-  dynamic_file_net_log_path_ = log_path;
-
-  std::unique_ptr<base::Value> constants(GetConstants());  // Net constants
-  net::NetLogCaptureMode capture_mode = net::NetLogCaptureMode::Default();
-
-  dynamic_file_net_log_observer_ = net::FileNetLogObserver::CreateUnbounded(
-      dynamic_file_net_log_path_, std::move(constants));
-  dynamic_file_net_log_observer_->StartObserving(this, capture_mode);
-}
-
-bool NetLog::IsDynamicLogging() {
-  return !!dynamic_file_net_log_observer_;
-}
-
-base::FilePath NetLog::GetDynamicLoggingPath() {
-  return dynamic_file_net_log_path_;
-}
-
-void NetLog::StopDynamicLogging(base::OnceClosure callback) {
-  if (!dynamic_file_net_log_observer_) {
-    if (callback)
-      std::move(callback).Run();
-    return;
-  }
-
-  dynamic_file_net_log_observer_->StopObserving(nullptr, std::move(callback));
-  dynamic_file_net_log_observer_.reset();
-
-  dynamic_file_net_log_path_ = base::FilePath();
-}
-
-}  // namespace brightray

brightray/browser/net_log.h

@@ -1,42 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef BRIGHTRAY_BROWSER_NET_LOG_H_
-#define BRIGHTRAY_BROWSER_NET_LOG_H_
-
-#include "base/callback.h"
-#include "base/files/file_path.h"
-#include "net/log/net_log.h"
-
-namespace net {
-class FileNetLogObserver;
-}
-
-namespace brightray {
-
-class NetLog : public net::NetLog {
- public:
-  NetLog();
-  ~NetLog() override;
-
-  void StartLogging();
-  void StopLogging();
-
-  void StartDynamicLogging(const base::FilePath& path);
-  bool IsDynamicLogging();
-  base::FilePath GetDynamicLoggingPath();
-  void StopDynamicLogging(base::OnceClosure callback = base::OnceClosure());
-
- private:
-  // This observer handles writing NetLogs.
-  std::unique_ptr<net::FileNetLogObserver> file_net_log_observer_;
-  std::unique_ptr<net::FileNetLogObserver> dynamic_file_net_log_observer_;
-  base::FilePath dynamic_file_net_log_path_;
-
-  DISALLOW_COPY_AND_ASSIGN(NetLog);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_NET_LOG_H_

brightray/browser/url_request_context_getter.cc

@@ -1,426 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE-CHROMIUM file.
-
-#include "brightray/browser/url_request_context_getter.h"
-
-#include <algorithm>
-
-#include "base/command_line.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-#include "base/task_scheduler/post_task.h"
-#include "brightray/browser/browser_client.h"
-#include "brightray/browser/browser_context.h"
-#include "brightray/browser/net/require_ct_delegate.h"
-#include "brightray/browser/net_log.h"
-#include "brightray/common/switches.h"
-#include "components/network_session_configurator/common/network_switches.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/cookie_store_factory.h"
-#include "content/public/browser/devtools_network_transaction_factory.h"
-#include "content/public/browser/resource_context.h"
-#include "net/base/host_mapping_rules.h"
-#include "net/cert/cert_verifier.h"
-#include "net/cert/ct_known_logs.h"
-#include "net/cert/ct_log_verifier.h"
-#include "net/cert/ct_policy_enforcer.h"
-#include "net/cert/multi_log_ct_verifier.h"
-#include "net/cookies/cookie_monster.h"
-#include "net/cookies/cookie_store.h"
-#include "net/dns/mapped_host_resolver.h"
-#include "net/extras/sqlite/sqlite_channel_id_store.h"
-#include "net/http/http_auth_filter.h"
-#include "net/http/http_auth_handler_factory.h"
-#include "net/http/http_auth_preferences.h"
-#include "net/http/http_server_properties_impl.h"
-#include "net/log/net_log.h"
-#include "net/proxy_resolution/dhcp_pac_file_fetcher_factory.h"
-#include "net/proxy_resolution/pac_file_fetcher_impl.h"
-#include "net/proxy_resolution/proxy_config.h"
-#include "net/proxy_resolution/proxy_config_service.h"
-#include "net/proxy_resolution/proxy_service.h"
-#include "net/ssl/channel_id_service.h"
-#include "net/ssl/default_channel_id_store.h"
-#include "net/ssl/ssl_config_service_defaults.h"
-#include "net/url_request/data_protocol_handler.h"
-#include "net/url_request/file_protocol_handler.h"
-#include "net/url_request/static_http_user_agent_settings.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_builder.h"
-#include "net/url_request/url_request_context_storage.h"
-#include "net/url_request/url_request_intercepting_job_factory.h"
-#include "net/url_request/url_request_job_factory_impl.h"
-#include "services/network/public/cpp/network_switches.h"
-#include "storage/browser/quota/special_storage_policy.h"
-#include "url/url_constants.h"
-
-using content::BrowserThread;
-
-namespace brightray {
-
-class ResourceContext : public content::ResourceContext {
- public:
-  ResourceContext() = default;
-  ~ResourceContext() override = default;
-
-  net::HostResolver* GetHostResolver() override {
-    if (request_context_)
-      return request_context_->host_resolver();
-    return nullptr;
-  }
-
-  net::URLRequestContext* GetRequestContext() override {
-    return request_context_;
-  }
-
- private:
-  friend class URLRequestContextGetter;
-
-  net::URLRequestContext* request_context_ = nullptr;
-
-  DISALLOW_COPY_AND_ASSIGN(ResourceContext);
-};
-
-URLRequestContextGetter::Handle::Handle(
-    base::WeakPtr<BrowserContext> browser_context)
-    : resource_context_(new ResourceContext),
-      browser_context_(browser_context),
-      initialized_(false) {}
-
-URLRequestContextGetter::Handle::~Handle() {}
-
-content::ResourceContext* URLRequestContextGetter::Handle::GetResourceContext()
-    const {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  LazyInitialize();
-  return resource_context_.get();
-}
-
-scoped_refptr<URLRequestContextGetter>
-URLRequestContextGetter::Handle::CreateMainRequestContextGetter(
-    content::ProtocolHandlerMap* protocol_handlers,
-    content::URLRequestInterceptorScopedVector protocol_interceptors) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(!main_request_context_getter_.get());
-  main_request_context_getter_ = new URLRequestContextGetter(
-      BrowserClient::Get()->GetNetLog(), resource_context_.get(),
-      browser_context_->IsOffTheRecord(), browser_context_->GetUserAgent(),
-      browser_context_->GetPath(), protocol_handlers,
-      std::move(protocol_interceptors));
-  browser_context_->OnMainRequestContextCreated(
-      main_request_context_getter_.get());
-  return main_request_context_getter_;
-}
-
-scoped_refptr<URLRequestContextGetter>
-URLRequestContextGetter::Handle::GetMainRequestContextGetter() const {
-  return main_request_context_getter_;
-}
-
-void URLRequestContextGetter::Handle::LazyInitialize() const {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (initialized_)
-    return;
-
-  initialized_ = true;
-  content::BrowserContext::EnsureResourceContextInitialized(
-      browser_context_.get());
-}
-
-void URLRequestContextGetter::Handle::ShutdownOnUIThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (main_request_context_getter_.get()) {
-    if (BrowserThread::IsThreadInitialized(BrowserThread::IO)) {
-      BrowserThread::PostTask(
-          BrowserThread::IO, FROM_HERE,
-          base::BindOnce(&URLRequestContextGetter::NotifyContextShuttingDown,
-                         base::RetainedRef(main_request_context_getter_),
-                         std::move(resource_context_)));
-    }
-  }
-
-  if (!BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this))
-    delete this;
-}
-
-URLRequestContextGetter::URLRequestContextGetter(
-    NetLog* net_log,
-    ResourceContext* resource_context,
-    bool in_memory,
-    const std::string& user_agent,
-    const base::FilePath& base_path,
-    content::ProtocolHandlerMap* protocol_handlers,
-    content::URLRequestInterceptorScopedVector protocol_interceptors)
-    : job_factory_(nullptr),
-      delegate_(nullptr),
-      net_log_(net_log),
-      resource_context_(resource_context),
-      protocol_interceptors_(std::move(protocol_interceptors)),
-      base_path_(base_path),
-      in_memory_(in_memory),
-      user_agent_(user_agent),
-      context_shutting_down_(false) {
-  // Must first be created on the UI thread.
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  if (protocol_handlers)
-    std::swap(protocol_handlers_, *protocol_handlers);
-
-  // We must create the proxy config service on the UI loop on Linux because it
-  // must synchronously run on the glib message loop. This will be passed to
-  // the URLRequestContextStorage on the IO thread in GetURLRequestContext().
-  proxy_config_service_ =
-      net::ProxyResolutionService::CreateSystemProxyConfigService(
-          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
-}
-
-URLRequestContextGetter::~URLRequestContextGetter() {}
-
-void URLRequestContextGetter::NotifyContextShuttingDown(
-    std::unique_ptr<ResourceContext> resource_context) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  context_shutting_down_ = true;
-  cookie_change_sub_.reset();
-  resource_context.reset();
-  net::URLRequestContextGetter::NotifyContextShuttingDown();
-  url_request_context_.reset();
-  storage_.reset();
-  http_network_session_.reset();
-  http_auth_preferences_.reset();
-  host_mapping_rules_.reset();
-  ct_delegate_.reset();
-}
-
-net::URLRequestContext* URLRequestContextGetter::GetURLRequestContext() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (context_shutting_down_)
-    return nullptr;
-
-  if (!url_request_context_.get()) {
-    ct_delegate_.reset(new RequireCTDelegate);
-    auto& command_line = *base::CommandLine::ForCurrentProcess();
-    url_request_context_.reset(new net::URLRequestContext);
-
-    // --log-net-log
-    if (net_log_) {
-      net_log_->StartLogging();
-      url_request_context_->set_net_log(net_log_);
-    }
-
-    storage_.reset(
-        new net::URLRequestContextStorage(url_request_context_.get()));
-
-    storage_->set_network_delegate(delegate_->CreateNetworkDelegate());
-
-    std::unique_ptr<net::CookieStore> cookie_store;
-    scoped_refptr<net::SQLiteChannelIDStore> channel_id_db;
-    // Create a single task runner to use with the CookieStore and
-    // ChannelIDStore.
-    scoped_refptr<base::SequencedTaskRunner> cookie_background_task_runner =
-        base::CreateSequencedTaskRunnerWithTraits(
-            {base::MayBlock(), base::TaskPriority::BACKGROUND,
-             base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
-    auto cookie_path = in_memory_
-                           ? base::FilePath()
-                           : base_path_.Append(FILE_PATH_LITERAL("Cookies"));
-    if (!in_memory_) {
-      channel_id_db = new net::SQLiteChannelIDStore(
-          base_path_.Append(FILE_PATH_LITERAL("Origin Bound Certs")),
-          cookie_background_task_runner);
-    }
-    std::unique_ptr<net::ChannelIDService> channel_id_service(
-        new net::ChannelIDService(
-            new net::DefaultChannelIDStore(channel_id_db.get())));
-    content::CookieStoreConfig cookie_config(cookie_path, false, false,
-                                             nullptr);
-    cookie_config.channel_id_service = channel_id_service.get();
-    cookie_config.background_task_runner = cookie_background_task_runner;
-    cookie_store = content::CreateCookieStore(cookie_config);
-    cookie_store->SetChannelIDServiceID(channel_id_service->GetUniqueID());
-
-    // Set custom schemes that can accept cookies.
-    net::CookieMonster* cookie_monster =
-        static_cast<net::CookieMonster*>(cookie_store.get());
-    std::vector<std::string> cookie_schemes({"http", "https", "ws", "wss"});
-    delegate_->GetCookieableSchemes(&cookie_schemes);
-    cookie_monster->SetCookieableSchemes(cookie_schemes);
-    // Cookie store will outlive notifier by order of declaration
-    // in the header.
-    cookie_change_sub_ =
-        cookie_store->GetChangeDispatcher().AddCallbackForAllChanges(
-            base::Bind(&URLRequestContextGetter::OnCookieChanged,
-                       base::RetainedRef(this)));
-    storage_->set_cookie_store(std::move(cookie_store));
-    storage_->set_channel_id_service(std::move(channel_id_service));
-
-    storage_->set_http_user_agent_settings(
-        base::WrapUnique(new net::StaticHttpUserAgentSettings(
-            net::HttpUtil::GenerateAcceptLanguageHeader(
-                BrowserClient::Get()->GetApplicationLocale()),
-            user_agent_)));
-
-    std::unique_ptr<net::HostResolver> host_resolver(
-        net::HostResolver::CreateDefaultResolver(nullptr));
-
-    // --host-resolver-rules
-    if (command_line.HasSwitch(network::switches::kHostResolverRules)) {
-      std::unique_ptr<net::MappedHostResolver> remapped_resolver(
-          new net::MappedHostResolver(std::move(host_resolver)));
-      remapped_resolver->SetRulesFromString(command_line.GetSwitchValueASCII(
-          network::switches::kHostResolverRules));
-      host_resolver = std::move(remapped_resolver);
-    }
-
-    // --proxy-server
-    if (command_line.HasSwitch(switches::kNoProxyServer)) {
-      storage_->set_proxy_resolution_service(
-          net::ProxyResolutionService::CreateDirect());
-    } else if (command_line.HasSwitch(switches::kProxyServer)) {
-      net::ProxyConfig proxy_config;
-      proxy_config.proxy_rules().ParseFromString(
-          command_line.GetSwitchValueASCII(switches::kProxyServer));
-      proxy_config.proxy_rules().bypass_rules.ParseFromString(
-          command_line.GetSwitchValueASCII(switches::kProxyBypassList));
-      storage_->set_proxy_resolution_service(
-          net::ProxyResolutionService::CreateFixed(proxy_config));
-    } else if (command_line.HasSwitch(switches::kProxyPacUrl)) {
-      auto proxy_config = net::ProxyConfig::CreateFromCustomPacURL(
-          GURL(command_line.GetSwitchValueASCII(switches::kProxyPacUrl)));
-      proxy_config.set_pac_mandatory(true);
-      storage_->set_proxy_resolution_service(
-          net::ProxyResolutionService::CreateFixed(proxy_config));
-    } else {
-      storage_->set_proxy_resolution_service(
-          net::ProxyResolutionService::CreateUsingSystemProxyResolver(
-              std::move(proxy_config_service_), net_log_));
-    }
-
-    std::vector<std::string> schemes;
-    schemes.push_back(std::string("basic"));
-    schemes.push_back(std::string("digest"));
-    schemes.push_back(std::string("ntlm"));
-    schemes.push_back(std::string("negotiate"));
-#if defined(OS_POSIX)
-    http_auth_preferences_.reset(
-        new net::HttpAuthPreferences(schemes, std::string()));
-#else
-    http_auth_preferences_.reset(new net::HttpAuthPreferences(schemes));
-#endif
-
-    // --auth-server-whitelist
-    if (command_line.HasSwitch(switches::kAuthServerWhitelist)) {
-      http_auth_preferences_->SetServerWhitelist(
-          command_line.GetSwitchValueASCII(switches::kAuthServerWhitelist));
-    }
-
-    // --auth-negotiate-delegate-whitelist
-    if (command_line.HasSwitch(switches::kAuthNegotiateDelegateWhitelist)) {
-      http_auth_preferences_->SetDelegateWhitelist(
-          command_line.GetSwitchValueASCII(
-              switches::kAuthNegotiateDelegateWhitelist));
-    }
-
-    auto auth_handler_factory = net::HttpAuthHandlerRegistryFactory::Create(
-        http_auth_preferences_.get(), host_resolver.get());
-
-    std::unique_ptr<net::TransportSecurityState> transport_security_state =
-        base::WrapUnique(new net::TransportSecurityState);
-    transport_security_state->SetRequireCTDelegate(ct_delegate_.get());
-    storage_->set_transport_security_state(std::move(transport_security_state));
-    storage_->set_cert_verifier(
-        delegate_->CreateCertVerifier(ct_delegate_.get()));
-    storage_->set_ssl_config_service(new net::SSLConfigServiceDefaults());
-    storage_->set_http_auth_handler_factory(std::move(auth_handler_factory));
-    std::unique_ptr<net::HttpServerProperties> server_properties(
-        new net::HttpServerPropertiesImpl);
-    storage_->set_http_server_properties(std::move(server_properties));
-
-    std::unique_ptr<net::MultiLogCTVerifier> ct_verifier =
-        std::make_unique<net::MultiLogCTVerifier>();
-    ct_verifier->AddLogs(net::ct::CreateLogVerifiersForKnownLogs());
-    storage_->set_cert_transparency_verifier(std::move(ct_verifier));
-    storage_->set_ct_policy_enforcer(std::make_unique<net::CTPolicyEnforcer>());
-
-    net::HttpNetworkSession::Params network_session_params;
-    network_session_params.ignore_certificate_errors = false;
-
-    // --disable-http2
-    if (command_line.HasSwitch(switches::kDisableHttp2))
-      network_session_params.enable_http2 = false;
-
-    // --ignore-certificate-errors
-    if (command_line.HasSwitch(::switches::kIgnoreCertificateErrors))
-      network_session_params.ignore_certificate_errors = true;
-
-    // --host-rules
-    if (command_line.HasSwitch(switches::kHostRules)) {
-      host_mapping_rules_.reset(new net::HostMappingRules);
-      host_mapping_rules_->SetRulesFromString(
-          command_line.GetSwitchValueASCII(switches::kHostRules));
-      network_session_params.host_mapping_rules = *host_mapping_rules_.get();
-    }
-
-    // Give |storage_| ownership at the end in case it's |mapped_host_resolver|.
-    storage_->set_host_resolver(std::move(host_resolver));
-
-    net::HttpNetworkSession::Context network_session_context;
-    net::URLRequestContextBuilder::SetHttpNetworkSessionComponents(
-        url_request_context_.get(), &network_session_context);
-    http_network_session_.reset(new net::HttpNetworkSession(
-        network_session_params, network_session_context));
-
-    std::unique_ptr<net::HttpCache::BackendFactory> backend;
-    if (in_memory_) {
-      backend = net::HttpCache::DefaultBackend::InMemory(0);
-    } else {
-      backend.reset(delegate_->CreateHttpCacheBackendFactory(base_path_));
-    }
-
-    storage_->set_http_transaction_factory(std::make_unique<net::HttpCache>(
-        content::CreateDevToolsNetworkTransactionFactory(
-            http_network_session_.get()),
-        std::move(backend), false));
-
-    std::unique_ptr<net::URLRequestJobFactory> job_factory =
-        delegate_->CreateURLRequestJobFactory(url_request_context_.get(),
-                                              &protocol_handlers_);
-    job_factory_ = job_factory.get();
-
-    // Set up interceptors in the reverse order.
-    std::unique_ptr<net::URLRequestJobFactory> top_job_factory =
-        std::move(job_factory);
-    if (!protocol_interceptors_.empty()) {
-      for (auto it = protocol_interceptors_.rbegin();
-           it != protocol_interceptors_.rend(); ++it) {
-        top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
-            std::move(top_job_factory), std::move(*it)));
-      }
-      protocol_interceptors_.clear();
-    }
-
-    storage_->set_job_factory(std::move(top_job_factory));
-  }
-
-  if (resource_context_)
-    resource_context_->request_context_ = url_request_context_.get();
-
-  return url_request_context_.get();
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-URLRequestContextGetter::GetNetworkTaskRunner() const {
-  return BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
-}
-
-void URLRequestContextGetter::OnCookieChanged(
-    const net::CanonicalCookie& cookie,
-    net::CookieChangeCause cause) const {
-  if (delegate_)
-    delegate_->OnCookieChanged(cookie, cause);
-}
-
-}  // namespace brightray

brightray/browser/url_request_context_getter.h

@@ -1,149 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE-CHROMIUM file.
-
-#ifndef BRIGHTRAY_BROWSER_URL_REQUEST_CONTEXT_GETTER_H_
-#define BRIGHTRAY_BROWSER_URL_REQUEST_CONTEXT_GETTER_H_
-
-#include <string>
-#include <vector>
-
-#include "base/files/file_path.h"
-#include "content/public/browser/browser_context.h"
-#include "content/public/browser/content_browser_client.h"
-#include "net/cookies/cookie_change_dispatcher.h"
-#include "net/http/http_cache.h"
-#include "net/http/transport_security_state.h"
-#include "net/http/url_security_manager.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_getter.h"
-
-#if DCHECK_IS_ON()
-#include "base/debug/leak_tracker.h"
-#endif
-
-namespace net {
-class HostMappingRules;
-class HostResolver;
-class HttpAuthPreferences;
-class NetworkDelegate;
-class ProxyConfigService;
-class URLRequestContextStorage;
-class URLRequestJobFactory;
-}  // namespace net
-
-namespace brightray {
-
-class BrowserContext;
-class ResourceContext;
-class RequireCTDelegate;
-class NetLog;
-
-class URLRequestContextGetter : public net::URLRequestContextGetter {
- public:
-  class Delegate {
-   public:
-    Delegate() {}
-    virtual ~Delegate() {}
-
-    virtual std::unique_ptr<net::NetworkDelegate> CreateNetworkDelegate() = 0;
-    virtual std::unique_ptr<net::URLRequestJobFactory>
-    CreateURLRequestJobFactory(
-        net::URLRequestContext* url_request_context,
-        content::ProtocolHandlerMap* protocol_handlers) = 0;
-    virtual net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
-        const base::FilePath& base_path) = 0;
-    virtual std::unique_ptr<net::CertVerifier> CreateCertVerifier(
-        RequireCTDelegate* ct_delegate) = 0;
-    virtual void GetCookieableSchemes(
-        std::vector<std::string>* cookie_schemes) {}
-    virtual void OnCookieChanged(const net::CanonicalCookie& cookie,
-                                 net::CookieChangeCause cause) {}
-  };
-
-  URLRequestContextGetter(
-      NetLog* net_log,
-      ResourceContext* resource_context,
-      bool in_memory,
-      const std::string& user_agent,
-      const base::FilePath& base_path,
-      content::ProtocolHandlerMap* protocol_handlers,
-      content::URLRequestInterceptorScopedVector protocol_interceptors);
-
-  // net::URLRequestContextGetter:
-  net::URLRequestContext* GetURLRequestContext() override;
-  scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
-      const override;
-
-  net::URLRequestJobFactory* job_factory() const { return job_factory_; }
-  void set_delegate(Delegate* delegate) { delegate_ = delegate; }
-
-  // Discard reference to URLRequestContext and inform observers to
-  // shutdown. Must be called only on IO thread.
-  void NotifyContextShuttingDown(std::unique_ptr<ResourceContext>);
-
- private:
-  friend class BrowserContext;
-
-  // Responsible for destroying URLRequestContextGetter
-  // on the IO thread.
-  class Handle {
-   public:
-    explicit Handle(base::WeakPtr<BrowserContext> browser_context);
-    ~Handle();
-
-    scoped_refptr<URLRequestContextGetter> CreateMainRequestContextGetter(
-        content::ProtocolHandlerMap* protocol_handlers,
-        content::URLRequestInterceptorScopedVector protocol_interceptors);
-    content::ResourceContext* GetResourceContext() const;
-    scoped_refptr<URLRequestContextGetter> GetMainRequestContextGetter() const;
-
-    void ShutdownOnUIThread();
-
-   private:
-    void LazyInitialize() const;
-
-    scoped_refptr<URLRequestContextGetter> main_request_context_getter_;
-    std::unique_ptr<ResourceContext> resource_context_;
-    base::WeakPtr<BrowserContext> browser_context_;
-    mutable bool initialized_;
-
-    DISALLOW_COPY_AND_ASSIGN(Handle);
-  };
-
-  ~URLRequestContextGetter() override;
-
-  // net::CookieChangeDispatcher::CookieChangedCallback implementation.
-  void OnCookieChanged(const net::CanonicalCookie& cookie,
-                       net::CookieChangeCause cause) const;
-
-#if DCHECK_IS_ON()
-  base::debug::LeakTracker<URLRequestContextGetter> leak_tracker_;
-#endif
-
-  std::unique_ptr<RequireCTDelegate> ct_delegate_;
-  std::unique_ptr<net::ProxyConfigService> proxy_config_service_;
-  std::unique_ptr<net::URLRequestContextStorage> storage_;
-  std::unique_ptr<net::URLRequestContext> url_request_context_;
-  std::unique_ptr<net::HostMappingRules> host_mapping_rules_;
-  std::unique_ptr<net::HttpAuthPreferences> http_auth_preferences_;
-  std::unique_ptr<net::HttpNetworkSession> http_network_session_;
-  std::unique_ptr<net::CookieChangeSubscription> cookie_change_sub_;
-
-  net::URLRequestJobFactory* job_factory_;
-  Delegate* delegate_;
-  NetLog* net_log_;
-  ResourceContext* resource_context_;
-  content::ProtocolHandlerMap protocol_handlers_;
-  content::URLRequestInterceptorScopedVector protocol_interceptors_;
-  base::FilePath base_path_;
-  bool in_memory_;
-  std::string user_agent_;
-  bool context_shutting_down_;
-
-  DISALLOW_COPY_AND_ASSIGN(URLRequestContextGetter);
-};
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_BROWSER_URL_REQUEST_CONTEXT_GETTER_H_

brightray/common/switches.cc

@@ -1,55 +0,0 @@
-// Copyright (c) 2016 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "brightray/common/switches.h"
-
-namespace brightray {
-
-namespace switches {
-
-// Comma-separated list of rules that control how hostnames are mapped.
-//
-// For example:
-//    "MAP * 127.0.0.1" --> Forces all hostnames to be mapped to 127.0.0.1
-//    "MAP *.google.com proxy" --> Forces all google.com subdomains to be
-//                                 resolved to "proxy".
-//    "MAP test.com [::1]:77 --> Forces "test.com" to resolve to IPv6 loopback.
-//                               Will also force the port of the resulting
-//                               socket address to be 77.
-//    "MAP * baz, EXCLUDE www.google.com" --> Remaps everything to "baz",
-//                                            except for "www.google.com".
-//
-// These mappings apply to the endpoint host in a net::URLRequest (the TCP
-// connect and host resolver in a direct connection, and the CONNECT in an http
-// proxy connection, and the endpoint host in a SOCKS proxy connection).
-const char kHostRules[] = "host-rules";
-
-// Don't use a proxy server, always make direct connections. Overrides any
-// other proxy server flags that are passed.
-const char kNoProxyServer[] = "no-proxy-server";
-
-// Uses a specified proxy server, overrides system settings. This switch only
-// affects HTTP and HTTPS requests.
-const char kProxyServer[] = "proxy-server";
-
-// Bypass specified proxy for the given semi-colon-separated list of hosts. This
-// flag has an effect only when --proxy-server is set.
-const char kProxyBypassList[] = "proxy-bypass-list";
-
-// Uses the pac script at the given URL.
-const char kProxyPacUrl[] = "proxy-pac-url";
-
-// Disable HTTP/2 and SPDY/3.1 protocols.
-const char kDisableHttp2[] = "disable-http2";
-
-// Whitelist containing servers for which Integrated Authentication is enabled.
-const char kAuthServerWhitelist[] = "auth-server-whitelist";
-
-// Whitelist containing servers for which Kerberos delegation is allowed.
-const char kAuthNegotiateDelegateWhitelist[] =
-    "auth-negotiate-delegate-whitelist";
-
-}  // namespace switches
-
-}  // namespace brightray

brightray/common/switches.h

@@ -1,25 +0,0 @@
-// Copyright (c) 2016 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef BRIGHTRAY_COMMON_SWITCHES_H_
-#define BRIGHTRAY_COMMON_SWITCHES_H_
-
-namespace brightray {
-
-namespace switches {
-
-extern const char kHostRules[];
-extern const char kNoProxyServer[];
-extern const char kProxyServer[];
-extern const char kProxyBypassList[];
-extern const char kProxyPacUrl[];
-extern const char kDisableHttp2[];
-extern const char kAuthServerWhitelist[];
-extern const char kAuthNegotiateDelegateWhitelist[];
-
-}  // namespace switches
-
-}  // namespace brightray
-
-#endif  // BRIGHTRAY_COMMON_SWITCHES_H_

brightray/filenames.gypi

@@ -4,8 +4,6 @@
       'browser/brightray_paths.h',
       'browser/browser_client.cc',
       'browser/browser_client.h',
-      'browser/browser_context.cc',
-      'browser/browser_context.h',
       'browser/browser_main_parts.cc',
       'browser/browser_main_parts.h',
       'browser/browser_main_parts_mac.mm',
@@ -29,8 +27,6 @@
       'browser/inspectable_web_contents_view.h',
       'browser/inspectable_web_contents_view_mac.h',
       'browser/inspectable_web_contents_view_mac.mm',
-      'browser/io_thread.cc',
-      'browser/io_thread.h',
       'browser/mac/bry_inspectable_web_contents_view.h',
       'browser/mac/bry_inspectable_web_contents_view.mm',
       'browser/mac/cocoa_notification.h',
@@ -49,8 +45,6 @@
       'browser/media/media_stream_devices_controller.h',
       'browser/net/require_ct_delegate.cc',
       'browser/net/require_ct_delegate.h',
-      'browser/net_log.cc',
-      'browser/net_log.h',
       'browser/notification_delegate.h',
       'browser/notification_presenter.cc',
       'browser/notification_presenter.h',
@@ -81,8 +75,6 @@
       'browser/win/windows_toast_notification.h',
       'browser/special_storage_policy.cc',
       'browser/special_storage_policy.h',
-      'browser/url_request_context_getter.cc',
-      'browser/url_request_context_getter.h',
       'browser/views/inspectable_web_contents_view_views.h',
       'browser/views/inspectable_web_contents_view_views.cc',
       'browser/views/views_delegate.cc',
@@ -102,8 +94,6 @@
       'common/main_delegate.cc',
       'common/main_delegate.h',
       'common/main_delegate_mac.mm',
-      'common/switches.cc',
-      'common/switches.h',
       'common/platform_util_linux.cc',
       'common/platform_util.h',
     ],

default_app/main.js

@@ -176,8 +176,7 @@ app.once('ready', () => {
           type: 'separator'
         },
         {
-          role: 'services',
-          submenu: []
+          role: 'services'
         },
         {
           type: 'separator'

docs/api/browser-window.md

@@ -222,11 +222,11 @@ It creates a new `BrowserWindow` with native properties as set by the `options`.
       the top left.
     * `hiddenInset` - Results in a hidden title bar with an alternative look
       where the traffic light buttons are slightly more inset from the window edge.
-    * `customButtonsOnHover` Boolean (optional) - Draw custom close, minimize,
-      and full screen buttons on macOS frameless windows. These buttons will not
-      display unless hovered over in the top left of the window. These custom
-      buttons prevent issues with mouse events that occur with the standard
-      window toolbar buttons. **Note:** This option is currently experimental.
+    * `customButtonsOnHover` Boolean (optional) - Draw custom close,
+      and minimize buttons on macOS frameless windows. These buttons will not display
+      unless hovered over in the top left of the window. These custom buttons prevent
+      issues with mouse events that occur with the standard window toolbar buttons.
+      **Note:** This option is currently experimental.
   * `fullscreenWindowTitle` Boolean (optional) - Shows the title in the
     title bar in full screen mode on macOS for all `titleBarStyle` options.
     Default is `false`.
@@ -351,8 +351,10 @@ It creates a new `BrowserWindow` with native properties as set by the `options`.
       Console tab. **Note:** This option is currently experimental and may
       change or be removed in future Electron releases.
     * `nativeWindowOpen` Boolean (optional) - Whether to use native
-      `window.open()`. Defaults to `false`. **Note:** This option is currently
-      experimental.
+      `window.open()`. If set to `true`, the `webPreferences` of child window
+      will always be the same with parent window, regardless of the parameters
+      passed to `window.open()`. Defaults to `false`. **Note:** This option is
+      currently experimental.
     * `webviewTag` Boolean (optional) - Whether to enable the [`<webview>` tag](webview-tag.md).
       Defaults to the value of the `nodeIntegration` option. **Note:** The
       `preload` script configured for the `<webview>` will have node integration

docs/api/content-tracing.md

@@ -51,9 +51,7 @@ Once all child processes have acknowledged the `getCategories` request the
 
 ### `contentTracing.startRecording(options, callback)`
 
-* `options` Object
-  * `categoryFilter` String
-  * `traceOptions` String
+* `options` ([TraceCategoriesAndOptions](structures/trace-categories-and-options.md) | [TraceConfig](structures/trace-config.md))
 * `callback` Function
 
 Start recording on all processes.
@@ -62,35 +60,6 @@ Recording begins immediately locally and asynchronously on child processes
 as soon as they receive the EnableRecording request. The `callback` will be
 called once all child processes have acknowledged the `startRecording` request.
 
-`categoryFilter` is a filter to control what category groups should be
-traced. A filter can have an optional `-` prefix to exclude category groups
-that contain a matching category. Having both included and excluded
-category patterns in the same list is not supported.
-
-Examples:
-
-* `test_MyTest*`,
-* `test_MyTest*,test_OtherStuff`,
-* `"-excluded_category1,-excluded_category2`
-
-`traceOptions` controls what kind of tracing is enabled, it is a comma-delimited
-list. Possible options are:
-
-* `record-until-full`
-* `record-continuously`
-* `trace-to-console`
-* `enable-sampling`
-* `enable-systrace`
-
-The first 3 options are trace recording modes and hence mutually exclusive.
-If more than one trace recording modes appear in the `traceOptions` string,
-the last one takes precedence. If none of the trace recording modes are
-specified, recording mode is `record-until-full`.
-
-The trace option will first be reset to the default option (`record_mode` set to
-`record-until-full`, `enable_sampling` and `enable_systrace` set to `false`)
-before options parsed from `traceOptions` are applied on it.
-
 ### `contentTracing.stopRecording(resultFilePath, callback)`
 
 * `resultFilePath` String

docs/api/frameless-window.md

@@ -50,10 +50,12 @@ win.show()
 
 #### `customButtonsOnHover`
 
-Uses custom drawn close, miniaturize, and fullscreen buttons that display
-when hovering in the top left of the window. These custom buttons prevent issues
-with mouse events that occur with the standard window toolbar buttons. This
-option is only applicable for frameless windows.
+Uses custom drawn close, and miniaturize buttons that display
+when hovering in the top left of the window. The fullscreen button
+is not available due to restrictions of frameless windows as they
+interface with Apple's MacOS window masks. These custom buttons prevent
+issues with mouse events that occur with the standard window toolbar buttons.
+This option is only applicable for frameless windows.
 
 ```javascript
 const {BrowserWindow} = require('electron')

docs/api/global-shortcut.md

@@ -54,6 +54,14 @@ When the accelerator is already taken by other applications, this call will
 silently fail. This behavior is intended by operating systems, since they don't
 want applications to fight for global shortcuts.
 
+The following accelerators will not be registered successfully on macOS 10.14 Mojave unless
+the app has been authorized as a [trusted accessibility client](https://developer.apple.com/library/archive/documentation/Accessibility/Conceptual/AccessibilityMacOSX/OSXAXTestingApps.html):
+
+* "Media Play/Pause"
+* "Media Next Track"
+* "Media Previous Track"
+* "Media Stop"
+
 ### `globalShortcut.isRegistered(accelerator)`
 
 * `accelerator` [Accelerator](accelerator.md)

docs/api/menu-item.md

@@ -27,6 +27,8 @@ See [`Menu`](menu.md) for examples.
   * `visible` Boolean (optional) - If false, the menu item will be entirely hidden.
   * `checked` Boolean (optional) - Should only be specified for `checkbox` or `radio` type
     menu items.
+  * `registerAccelerator` Boolean (optional) - If false, the accelerator won't be registered
+    with the system, but it will still be displayed. Defaults to true.
   * `submenu` (MenuItemConstructorOptions[] | [Menu](menu.md)) (optional) - Should be specified for `submenu` type menu items. If
     `submenu` is specified, the `type: 'submenu'` can be omitted. If the value
     is not a [`Menu`](menu.md) then it will be automatically converted to one using

docs/api/menu.md

@@ -204,7 +204,7 @@ if (process.platform === 'darwin') {
     submenu: [
       {role: 'about'},
       {type: 'separator'},
-      {role: 'services', submenu: []},
+      {role: 'services'},
       {type: 'separator'},
       {role: 'hide'},
       {role: 'hideothers'},

docs/api/net-log.md

@@ -1,21 +1,26 @@
 # netLog
 
-> Logging network events.
+> Logging network events for a session.
 
 Process: [Main](../glossary.md#main-process)
 
 ```javascript
-const {netLog} = require('electron')
-console.log('Start recording net-logs')
-netLog.startLogging('/path/to/net-log')
-// After some network events
-netLog.stopLogging(path => {
-  console.log('Net-logs written to', path)
+const { netLog } = require('electron')
+
+app.on('ready', function () {
+  netLog.startLogging('/path/to/net-log')
+  // After some network events
+  netLog.stopLogging(path => {
+    console.log('Net-logs written to', path)
+  })
 })
 ```
 
 See [`--log-net-log`](chrome-command-line-switches.md#--log-net-logpath) to log network events throughout the app's lifecycle.
 
+**Note:** All methods unless specified can only be used after the `ready` event
+of the `app` module gets emitted.
+
 ## Methods
 
 ### `netLog.startLogging(path)`