Bump v1.6.1

add translations files for zh-CN

.clang-format

@@ -0,0 +1,35 @@
+# Defines the Chromium style for automatic reformatting.
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+BasedOnStyle: Chromium
+# This defaults to 'Auto'. Explicitly set it for a while, so that
+# 'vector<vector<int> >' in existing files gets formatted to
+# 'vector<vector<int>>'. ('Auto' means that clang-format will only use
+# 'int>>' if the file already contains at least one such instance.)
+Standard: Cpp11
+# Make sure code like:
+# IPC_BEGIN_MESSAGE_MAP()
+#   IPC_MESSAGE_HANDLER(WidgetHostViewHost_Update, OnUpdate)
+# IPC_END_MESSAGE_MAP()
+# gets correctly indented.
+MacroBlockBegin: "^\
+BEGIN_MSG_MAP|\
+BEGIN_MSG_MAP_EX|\
+BEGIN_SAFE_MSG_MAP_EX|\
+CR_BEGIN_MSG_MAP_EX|\
+IPC_BEGIN_MESSAGE_MAP|\
+IPC_BEGIN_MESSAGE_MAP_WITH_PARAM|\
+IPC_PROTOBUF_MESSAGE_TRAITS_BEGIN|\
+IPC_STRUCT_BEGIN|\
+IPC_STRUCT_BEGIN_WITH_PARENT|\
+IPC_STRUCT_TRAITS_BEGIN|\
+POLPARAMS_BEGIN|\
+PPAPI_BEGIN_MESSAGE_MAP$"
+MacroBlockEnd: "^\
+CR_END_MSG_MAP|\
+END_MSG_MAP|\
+IPC_END_MESSAGE_MAP|\
+IPC_PROTOBUF_MESSAGE_TRAITS_END|\
+IPC_STRUCT_END|\
+IPC_STRUCT_TRAITS_END|\
+POLPARAMS_END|\
+PPAPI_END_MESSAGE_MAP$"

.gitignore

@@ -26,5 +26,4 @@ node_modules/
 *.vcxproj.user
 *.vcxproj.filters
 *.sln
-debug.log
-npm-debug.log
+*.log

.gitmodules

@@ -12,7 +12,7 @@
 	url = https://github.com/electron/chromium-breakpad.git
 [submodule "vendor/native_mate"]
 	path = vendor/native_mate
-	url = https://github.com/zcbenz/native-mate.git
+	url = https://github.com/electron/native-mate.git
 [submodule "vendor/crashpad"]
 	path = vendor/crashpad
 	url = https://github.com/electron/crashpad.git

.node-version

@@ -1 +1 @@
-v6.3.0
+v7.4.0

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing to Electron
 
-:memo: Available Translations: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/CONTRIBUTING.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/CONTRIBUTING.md)
+:memo: Available Translations: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/CONTRIBUTING.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/CONTRIBUTING.md) | [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR/project/CONTRIBUTING.md) | [Dutch](https://github.com/electron/electron/tree/master/docs-translations/nl/project/CONTRIBUTING.md)
 
 :+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
 

ISSUE_TEMPLATE.md

@@ -1,2 +1,23 @@
+<!--
+Thanks for opening an issue! A few things to keep in mind:
+
+- The issue tracker is only for bugs and feature requests.
+- Before reporting a bug, please try reproducing your issue against
+  the latest version of Electron.
+- If you need general advice, join our Slack: http://atom-slack.herokuapp.com
+-->
+
 * Electron version:
 * Operating system:
+
+### Expected behavior
+
+<!-- What do you think should happen? -->
+
+### Actual behavior
+
+<!-- What actually happens? -->
+
+### How to reproduce
+
+<!-- For bugs, provide sample code or a repo URL that demos the problem -->

LICENSE

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

README.md

@@ -2,10 +2,10 @@
 
 [![Travis Build Status](https://travis-ci.org/electron/electron.svg?branch=master)](https://travis-ci.org/electron/electron)
 [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/kvxe4byi7jcxbe26/branch/master?svg=true)](https://ci.appveyor.com/project/Atom/electron)
-[![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron#info=devDependencies)
+[![devDependency Status](https://david-dm.org/electron/electron/dev-status.svg)](https://david-dm.org/electron/electron?type=dev)
 [![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
 
-:memo: Available Translations: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/README.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/README.md)
+:memo: Available Translations: [Korean](https://github.com/electron/electron/tree/master/docs-translations/ko-KR/project/README.md) | [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN/project/README.md) | [Brazilian Portuguese](https://github.com/electron/electron/tree/master/docs-translations/pt-BR/project/README.md) | [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW/project/README.md)
 
 The Electron framework lets you write cross-platform desktop applications
 using JavaScript, HTML and CSS. It is based on [Node.js](https://nodejs.org/) and
@@ -21,20 +21,20 @@ behavior to electron@github.com.
 
 ## Downloads
 
-Prebuilt binaries and debug symbols of Electron for Linux, Windows and macOS can
-be found on the [releases](https://github.com/electron/electron/releases) page.
-
-You can also use [`npm`](https://docs.npmjs.com/) to install prebuilt electron
-binaries:
+To install prebuilt Electron binaries, use
+[`npm`](https://docs.npmjs.com/):
 
 ```sh
-# Install the `electron` command globally in your $PATH
-npm install electron -g
-
 # Install as a development dependency
 npm install electron --save-dev
+
+# Install the `electron` command globally in your $PATH
+npm install electron -g
 ```
 
+See the [releases page](https://github.com/electron/electron/releases) for
+prebuilt binaries, debug symbols, and more.
+
 ### Mirrors
 
 - [China](https://npm.taobao.org/mirrors/electron)
@@ -54,6 +54,7 @@ contains documents describing how to build and contribute to Electron.
 - [Simplified Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-CN)
 - [Traditional Chinese](https://github.com/electron/electron/tree/master/docs-translations/zh-TW)
 - [Turkish](https://github.com/electron/electron/tree/master/docs-translations/tr-TR)
+- [Thai](https://github.com/electron/electron/tree/master/docs-Translations/th-TH)
 - [Ukrainian](https://github.com/electron/electron/tree/master/docs-translations/uk-UA)
 - [Russian](https://github.com/electron/electron/tree/master/docs-translations/ru-RU)
 - [French](https://github.com/electron/electron/tree/master/docs-translations/fr-FR)
@@ -73,9 +74,15 @@ forums
 - [`Atom`](http://atom-slack.herokuapp.com/) channel on Slack
 - [`electron-br`](https://electron-br.slack.com) *(Brazilian Portuguese)*
 - [`electron-kr`](http://www.meetup.com/electron-kr/) *(Korean)*
-- [`electron-jp`](https://electron-jp-slackin.herokuapp.com/) *(Japanese)*
+- [`electron-jp`](https://electron-jp.slack.com) *(Japanese)*
 - [`electron-tr`](http://www.meetup.com/Electron-JS-Istanbul/) *(Turkish)*
 - [`electron-id`](https://electron-id.slack.com) *(Indonesia)*
 
 Check out [awesome-electron](https://github.com/sindresorhus/awesome-electron)
 for a community maintained list of useful example apps, tools and resources.
+
+## License
+
+[MIT](https://github.com/electron/electron/blob/master/LICENSE)
+
+When using the Electron or other GitHub logos, be sure to follow the [GitHub logo guidelines](https://github.com/logos).

SECURITY.md

@@ -0,0 +1,9 @@
+# Reporting Security Issues
+
+The Electron team and community take security bugs in Electron seriously. We appreciate your efforts to responsibly disclose your findings, and will make every effort to acknowledge your contributions.
+
+To report a security issue, email [electron@github.com](mailto:electron@github.com) and include the word "SECURITY" in the subject line.
+
+The Electron team will send a response indicating the next steps in handling your report. After the initial reply to your report, the security team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance.
+
+Report security bugs in third-party modules to the person or team maintaining the module. You can also report a vulnerability through the [Node Security Project](https://nodesecurity.io/report).

atom/app/atom_content_client.cc

@@ -23,7 +23,7 @@
 #include "ui/base/l10n/l10n_util.h"
 #include "url/url_constants.h"
 
-#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
+#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
 #include "chrome/common/widevine_cdm_constants.h"
 #endif
 
@@ -71,7 +71,7 @@ content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
   return plugin;
 }
 
-#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
+#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
 content::PepperPluginInfo CreateWidevineCdmInfo(const base::FilePath& path,
                                                 const std::string& version) {
   content::PepperPluginInfo widevine_cdm;
@@ -135,7 +135,7 @@ void AddPepperFlashFromCommandLine(
   plugins->push_back(CreatePepperFlashInfo(flash_path, flash_version));
 }
 
-#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
+#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
 void AddWidevineCdmFromCommandLine(
     std::vector<content::PepperPluginInfo>* plugins) {
   auto command_line = base::CommandLine::ForCurrentProcess();
@@ -187,7 +187,7 @@ void AtomContentClient::AddAdditionalSchemes(
 void AtomContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
   AddPepperFlashFromCommandLine(plugins);
-#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
+#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
   AddWidevineCdmFromCommandLine(plugins);
 #endif
 }
@@ -197,11 +197,20 @@ void AtomContentClient::AddServiceWorkerSchemes(
   std::vector<std::string> schemes;
   ConvertStringWithSeparatorToVector(&schemes, ",",
                                      switches::kRegisterServiceWorkerSchemes);
-  if (!schemes.empty()) {
-    for (const std::string& scheme : schemes)
-      service_worker_schemes->insert(scheme);
-  }
+  for (const std::string& scheme : schemes)
+    service_worker_schemes->insert(scheme);
+
   service_worker_schemes->insert(url::kFileScheme);
 }
 
+void AtomContentClient::AddSecureSchemesAndOrigins(
+    std::set<std::string>* secure_schemes,
+    std::set<GURL>* secure_origins) {
+  std::vector<std::string> schemes;
+  ConvertStringWithSeparatorToVector(&schemes, ",", switches::kSecureSchemes);
+  for (const std::string& scheme : schemes)
+    secure_schemes->insert(scheme);
+}
+
+
 }  // namespace atom

atom/app/atom_content_client.h

@@ -31,6 +31,9 @@ class AtomContentClient : public brightray::ContentClient {
       std::vector<content::PepperPluginInfo>* plugins) override;
   void AddServiceWorkerSchemes(
       std::set<std::string>* service_worker_schemes) override;
+  void AddSecureSchemesAndOrigins(
+      std::set<std::string>* secure_schemes,
+      std::set<GURL>* secure_origins) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AtomContentClient);

atom/app/atom_main_delegate.cc

@@ -11,7 +11,9 @@
 #include "atom/browser/atom_browser_client.h"
 #include "atom/browser/relauncher.h"
 #include "atom/common/google_api_key.h"
+#include "atom/common/options_switches.h"
 #include "atom/renderer/atom_renderer_client.h"
+#include "atom/renderer/atom_sandboxed_renderer_client.h"
 #include "atom/utility/atom_content_utility_client.h"
 #include "base/command_line.h"
 #include "base/debug/stack_trace.h"
@@ -29,7 +31,7 @@ namespace {
 const char* kRelauncherProcess = "relauncher";
 
 bool IsBrowserProcess(base::CommandLine* cmd) {
-  std::string process_type = cmd->GetSwitchValueASCII(switches::kProcessType);
+  std::string process_type = cmd->GetSwitchValueASCII(::switches::kProcessType);
   return process_type.empty();
 }
 
@@ -72,7 +74,7 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 
   // Only enable logging when --enable-logging is specified.
   std::unique_ptr<base::Environment> env(base::Environment::Create());
-  if (!command_line->HasSwitch(switches::kEnableLogging) &&
+  if (!command_line->HasSwitch(::switches::kEnableLogging) &&
       !env->HasVar("ELECTRON_ENABLE_LOGGING")) {
     settings.logging_dest = logging::LOG_NONE;
     logging::SetMinLogLevel(logging::LOG_NUM_SEVERITIES);
@@ -100,6 +102,9 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 #if defined(OS_WIN)
   // Ignore invalid parameter errors.
   _set_invalid_parameter_handler(InvalidParameterHandler);
+  // Disable the ActiveVerifier, which is used by Chrome to track possible
+  // bugs, but no use in Electron.
+  base::win::DisableHandleVerifier();
 #endif
 
   return brightray::MainDelegate::BasicStartupComplete(exit_code);
@@ -115,17 +120,23 @@ void AtomMainDelegate::PreSandboxStartup() {
 
   auto command_line = base::CommandLine::ForCurrentProcess();
   std::string process_type = command_line->GetSwitchValueASCII(
-      switches::kProcessType);
+      ::switches::kProcessType);
 
   // Only append arguments for browser process.
   if (!IsBrowserProcess(command_line))
     return;
 
-  // Disable renderer sandbox for most of node's functions.
-  command_line->AppendSwitch(switches::kNoSandbox);
+  if (command_line->HasSwitch(switches::kEnableSandbox)) {
+    // Disable setuid sandbox since it is not longer required on linux(namespace
+    // sandbox is available on most distros).
+    command_line->AppendSwitch(::switches::kDisableSetuidSandbox);
+  } else {
+    // Disable renderer sandbox for most of node's functions.
+    command_line->AppendSwitch(::switches::kNoSandbox);
+  }
 
   // Allow file:// URIs to read other file:// URIs by default.
-  command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
+  command_line->AppendSwitch(::switches::kAllowFileAccessFromFiles);
 
 #if defined(OS_MACOSX)
   // Enable AVFoundation.
@@ -140,7 +151,13 @@ content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
 
 content::ContentRendererClient*
     AtomMainDelegate::CreateContentRendererClient() {
-  renderer_client_.reset(new AtomRendererClient);
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kEnableSandbox)) {
+    renderer_client_.reset(new AtomSandboxedRendererClient);
+  } else {
+    renderer_client_.reset(new AtomRendererClient);
+  }
+
   return renderer_client_.get();
 }
 

atom/app/node_main.cc

@@ -7,12 +7,16 @@
 #include "atom/app/uv_task_runner.h"
 #include "atom/browser/javascript_environment.h"
 #include "atom/browser/node_debugger.h"
+#include "atom/common/api/atom_bindings.h"
+#include "atom/common/crash_reporter/crash_reporter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/v8_initializer.h"
+#include "native_mate/dictionary.h"
 
 #include "atom/common/node_includes.h"
 
@@ -42,14 +46,26 @@ int NodeMain(int argc, char *argv[]) {
     const char** exec_argv;
     node::Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv);
 
+    node::IsolateData isolate_data(gin_env.isolate(), loop);
     node::Environment* env = node::CreateEnvironment(
-        gin_env.isolate(), loop, gin_env.context(), argc, argv,
+        &isolate_data, gin_env.context(), argc, argv,
         exec_argc, exec_argv);
 
     // Start our custom debugger implementation.
     NodeDebugger node_debugger(gin_env.isolate());
     if (node_debugger.IsRunning())
-      env->AssignToContext(v8::Debug::GetDebugContext());
+      env->AssignToContext(v8::Debug::GetDebugContext(gin_env.isolate()));
+
+    mate::Dictionary process(gin_env.isolate(), env->process_object());
+#if defined(OS_WIN)
+    process.SetMethod("log", &AtomBindings::Log);
+#endif
+    process.SetMethod("crash", &AtomBindings::Crash);
+
+    // Setup process.crashReporter.start in child node processes
+    auto reporter = mate::Dictionary::CreateEmpty(gin_env.isolate());
+    reporter.SetMethod("start", &crash_reporter::CrashReporter::StartInstance);
+    process.Set("crashReporter", reporter);
 
     node::LoadEnvironment(env);
 

atom/browser/api/atom_api_app.cc

@@ -12,7 +12,6 @@
 #include "atom/browser/api/atom_api_web_contents.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/browser.h"
 #include "atom/browser/login_handler.h"
 #include "atom/browser/relauncher.h"
 #include "atom/common/atom_command_line.h"
@@ -31,12 +30,15 @@
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "brightray/browser/brightray_paths.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/icon_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/browser_accessibility_state.h"
 #include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/common/content_switches.h"
+#include "media/audio/audio_manager.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 #include "net/ssl/ssl_cert_request_info.h"
@@ -297,6 +299,8 @@ struct Converter<Browser::LoginItemSettings> {
 
     dict.Get("openAtLogin", &(out->open_at_login));
     dict.Get("openAsHidden", &(out->open_as_hidden));
+    dict.Get("path", &(out->path));
+    dict.Get("args", &(out->args));
     return true;
   }
 
@@ -311,8 +315,21 @@ struct Converter<Browser::LoginItemSettings> {
     return dict.GetHandle();
   }
 };
-}  // namespace mate
 
+template<>
+struct Converter<content::CertificateRequestResultType> {
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
+                     content::CertificateRequestResultType* out) {
+    bool b;
+    if (!ConvertFromV8(isolate, val, &b))
+      return false;
+    *out = b ? content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE :
+               content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL;
+    return true;
+  }
+};
+
+}  // namespace mate
 
 namespace atom {
 
@@ -320,6 +337,15 @@ namespace api {
 
 namespace {
 
+IconLoader::IconSize GetIconSizeByString(const std::string& size) {
+  if (size == "small") {
+    return IconLoader::IconSize::SMALL;
+  } else if (size == "large") {
+    return IconLoader::IconSize::LARGE;
+  }
+  return IconLoader::IconSize::NORMAL;
+}
+
 // Return the path constant from string.
 int GetPathConstant(const std::string& name) {
   if (name == "appData")
@@ -377,9 +403,21 @@ void OnClientCertificateSelected(
     v8::Isolate* isolate,
     std::shared_ptr<content::ClientCertificateDelegate> delegate,
     mate::Arguments* args) {
+  if (args->Length() == 2) {
+    delegate->ContinueWithCertificate(nullptr);
+    return;
+  }
+
+  v8::Local<v8::Value> val;
+  args->GetNext(&val);
+  if (val->IsNull()) {
+    delegate->ContinueWithCertificate(nullptr);
+    return;
+  }
+
   mate::Dictionary cert_data;
-  if (!args->GetNext(&cert_data)) {
-    args->ThrowError();
+  if (!mate::ConvertFromV8(isolate, val, &cert_data)) {
+    args->ThrowError("Must pass valid certificate object.");
     return;
   }
 
@@ -435,6 +473,21 @@ int ImportIntoCertStore(
 }
 #endif
 
+void OnIconDataAvailable(v8::Isolate* isolate,
+                         const App::FileIconCallback& callback,
+                         gfx::Image* icon) {
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+
+  if (icon && !icon->IsEmpty()) {
+    callback.Run(v8::Null(isolate), *icon);
+  } else {
+    v8::Local<v8::String> error_message =
+      v8::String::NewFromUtf8(isolate, "Failed to get file icon.");
+    callback.Run(v8::Exception::Error(error_message), gfx::Image());
+  }
+}
+
 }  // namespace
 
 App::App(v8::Isolate* isolate) {
@@ -490,6 +543,11 @@ void App::OnWillFinishLaunching() {
 }
 
 void App::OnFinishLaunching(const base::DictionaryValue& launch_info) {
+#if defined(OS_LINUX)
+  // Set the application name for audio streams shown in external
+  // applications. Only affects pulseaudio currently.
+  media::AudioManager::SetGlobalAppName(Browser::Get()->GetName());
+#endif
   Emit("ready", launch_info);
 }
 
@@ -522,11 +580,14 @@ void App::OnLogin(LoginHandler* login_handler,
     login_handler->CancelAuth();
 }
 
-void App::OnCreateWindow(const GURL& target_url,
-                         const std::string& frame_name,
-                         WindowOpenDisposition disposition,
-                         int render_process_id,
-                         int render_frame_id) {
+void App::OnCreateWindow(
+    const GURL& target_url,
+    const std::string& frame_name,
+    WindowOpenDisposition disposition,
+    const std::vector<std::string>& features,
+    const scoped_refptr<content::ResourceRequestBodyImpl>& body,
+    int render_process_id,
+    int render_frame_id) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
   content::RenderFrameHost* rfh =
@@ -535,7 +596,11 @@ void App::OnCreateWindow(const GURL& target_url,
       content::WebContents::FromRenderFrameHost(rfh);
   if (web_contents) {
     auto api_web_contents = WebContents::CreateFrom(isolate(), web_contents);
-    api_web_contents->OnCreateWindow(target_url, frame_name, disposition);
+    api_web_contents->OnCreateWindow(target_url,
+                                     frame_name,
+                                     disposition,
+                                     features,
+                                     body);
   }
 }
 
@@ -548,8 +613,8 @@ void App::AllowCertificateError(
     bool overridable,
     bool strict_enforcement,
     bool expired_previous_decision,
-    const base::Callback<void(bool)>& callback,
-    content::CertificateRequestResultType* request) {
+    const base::Callback<void(content::CertificateRequestResultType)>&
+        callback) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
   bool prevent_default = Emit("certificate-error",
@@ -561,7 +626,7 @@ void App::AllowCertificateError(
 
   // Deny the certificate by default.
   if (!prevent_default)
-    *request = content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY;
+    callback.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
 }
 
 void App::SelectClientCertificate(
@@ -585,8 +650,9 @@ void App::SelectClientCertificate(
         cert_request_info->client_certs[0].get());
 }
 
-void App::OnGpuProcessCrashed(base::TerminationStatus exit_code) {
-  Emit("gpu-process-crashed");
+void App::OnGpuProcessCrashed(base::TerminationStatus status) {
+  Emit("gpu-process-crashed",
+    status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED);
 }
 
 base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
@@ -596,7 +662,7 @@ base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
   if (key >= 0)
     succeed = PathService::Get(key, &path);
   if (!succeed)
-    args->ThrowError("Failed to get path");
+    args->ThrowError("Failed to get '" + name + "' path");
   return path;
 }
 
@@ -604,7 +670,7 @@ void App::SetPath(mate::Arguments* args,
                   const std::string& name,
                   const base::FilePath& path) {
   if (!path.IsAbsolute()) {
-    args->ThrowError("path must be absolute");
+    args->ThrowError("Path must be absolute");
     return;
   }
 
@@ -707,6 +773,12 @@ bool App::IsAccessibilitySupportEnabled() {
   return ax_state->IsAccessibleBrowser();
 }
 
+Browser::LoginItemSettings App::GetLoginItemSettings(mate::Arguments* args) {
+  Browser::LoginItemSettings options;
+  args->GetNext(&options);
+  return Browser::Get()->GetLoginItemSettings(options);
+}
+
 #if defined(USE_NSS_CERTS)
 void App::ImportCertificate(
     const base::DictionaryValue& options,
@@ -795,6 +867,43 @@ JumpListResult App::SetJumpList(v8::Local<v8::Value> val,
 }
 #endif  // defined(OS_WIN)
 
+void App::GetFileIcon(const base::FilePath& path,
+                      mate::Arguments* args) {
+  mate::Dictionary options;
+  IconLoader::IconSize icon_size;
+  FileIconCallback callback;
+
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+
+  base::FilePath normalized_path = path.NormalizePathSeparators();
+
+  if (!args->GetNext(&options)) {
+    icon_size = IconLoader::IconSize::NORMAL;
+  } else {
+    std::string icon_size_string;
+    options.Get("size", &icon_size_string);
+    icon_size = GetIconSizeByString(icon_size_string);
+  }
+
+  if (!args->GetNext(&callback)) {
+    args->ThrowError("Missing required callback function");
+    return;
+  }
+
+  auto icon_manager = g_browser_process->GetIconManager();
+  gfx::Image* icon =
+      icon_manager->LookupIconFromFilepath(normalized_path, icon_size);
+  if (icon) {
+    callback.Run(v8::Null(isolate()), *icon);
+  } else {
+    icon_manager->LoadIcon(
+        normalized_path, icon_size,
+        base::Bind(&OnIconDataAvailable, isolate(), callback),
+        &cancelable_task_tracker_);
+  }
+}
+
 // static
 mate::Handle<App> App::Create(v8::Isolate* isolate) {
   return mate::CreateHandle(isolate, new App(isolate));
@@ -828,8 +937,7 @@ void App::BuildPrototype(
                  base::Bind(&Browser::RemoveAsDefaultProtocolClient, browser))
       .SetMethod("setBadgeCount", base::Bind(&Browser::SetBadgeCount, browser))
       .SetMethod("getBadgeCount", base::Bind(&Browser::GetBadgeCount, browser))
-      .SetMethod("getLoginItemSettings",
-                 base::Bind(&Browser::GetLoginItemSettings, browser))
+      .SetMethod("getLoginItemSettings", &App::GetLoginItemSettings)
       .SetMethod("setLoginItemSettings",
                  base::Bind(&Browser::SetLoginItemSettings, browser))
 #if defined(OS_MACOSX)
@@ -839,6 +947,8 @@ void App::BuildPrototype(
                  base::Bind(&Browser::SetUserActivity, browser))
       .SetMethod("getCurrentActivityType",
                  base::Bind(&Browser::GetCurrentActivityType, browser))
+      .SetMethod("setAboutPanelOptions",
+                 base::Bind(&Browser::SetAboutPanelOptions, browser))
 #endif
 #if defined(OS_WIN)
       .SetMethod("setUserTasks", base::Bind(&Browser::SetUserTasks, browser))
@@ -862,7 +972,8 @@ void App::BuildPrototype(
       .SetMethod("isAccessibilitySupportEnabled",
                  &App::IsAccessibilitySupportEnabled)
       .SetMethod("disableHardwareAcceleration",
-                 &App::DisableHardwareAcceleration);
+                 &App::DisableHardwareAcceleration)
+      .SetMethod("getFileIcon", &App::GetFileIcon);
 }
 
 }  // namespace api

atom/browser/api/atom_api_app.h

@@ -6,11 +6,15 @@
 #define ATOM_BROWSER_API_ATOM_API_APP_H_
 
 #include <string>
+#include <vector>
 
 #include "atom/browser/api/event_emitter.h"
 #include "atom/browser/atom_browser_client.h"
+#include "atom/browser/browser.h"
 #include "atom/browser/browser_observer.h"
 #include "atom/common/native_mate_converters/callback.h"
+#include "base/task/cancelable_task_tracker.h"
+#include "chrome/browser/icon_manager.h"
 #include "chrome/browser/process_singleton.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "native_mate/handle.h"
@@ -41,17 +45,23 @@ class App : public AtomBrowserClient::Delegate,
             public BrowserObserver,
             public content::GpuDataManagerObserver {
  public:
+  using FileIconCallback = base::Callback<void(v8::Local<v8::Value>,
+                                               const gfx::Image&)>;
+
   static mate::Handle<App> Create(v8::Isolate* isolate);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
 
   // Called when window with disposition needs to be created.
-  void OnCreateWindow(const GURL& target_url,
-                      const std::string& frame_name,
-                      WindowOpenDisposition disposition,
-                      int render_process_id,
-                      int render_frame_id);
+  void OnCreateWindow(
+      const GURL& target_url,
+      const std::string& frame_name,
+      WindowOpenDisposition disposition,
+      const std::vector<std::string>& features,
+      const scoped_refptr<content::ResourceRequestBodyImpl>& body,
+      int render_process_id,
+      int render_frame_id);
 
 #if defined(USE_NSS_CERTS)
   void OnCertificateManagerModelCreated(
@@ -94,15 +104,15 @@ class App : public AtomBrowserClient::Delegate,
       bool overridable,
       bool strict_enforcement,
       bool expired_previous_decision,
-      const base::Callback<void(bool)>& callback,
-      content::CertificateRequestResultType* request) override;
+      const base::Callback<void(content::CertificateRequestResultType)>&
+          callback) override;
   void SelectClientCertificate(
       content::WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
       std::unique_ptr<content::ClientCertificateDelegate> delegate) override;
 
   // content::GpuDataManagerObserver:
-  void OnGpuProcessCrashed(base::TerminationStatus exit_code) override;
+  void OnGpuProcessCrashed(base::TerminationStatus status) override;
 
  private:
   // Get/Set the pre-defined path in PathService.
@@ -119,10 +129,13 @@ class App : public AtomBrowserClient::Delegate,
   bool Relaunch(mate::Arguments* args);
   void DisableHardwareAcceleration(mate::Arguments* args);
   bool IsAccessibilitySupportEnabled();
+  Browser::LoginItemSettings GetLoginItemSettings(mate::Arguments* args);
 #if defined(USE_NSS_CERTS)
   void ImportCertificate(const base::DictionaryValue& options,
                          const net::CompletionCallback& callback);
 #endif
+  void GetFileIcon(const base::FilePath& path,
+                   mate::Arguments* args);
 
 #if defined(OS_WIN)
   // Get the current Jump List settings.
@@ -138,6 +151,9 @@ class App : public AtomBrowserClient::Delegate,
   std::unique_ptr<CertificateManagerModel> certificate_manager_model_;
 #endif
 
+  // Tracks tasks requesting file icons.
+  base::CancelableTaskTracker cancelable_task_tracker_;
+
   DISALLOW_COPY_AND_ASSIGN(App);
 };
 

atom/browser/api/atom_api_content_tracing.cc

@@ -7,12 +7,13 @@
 
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
-#include "atom/common/node_includes.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "content/public/browser/tracing_controller.h"
 #include "native_mate/dictionary.h"
 
+#include "atom/common/node_includes.h"
+
 using content::TracingController;
 
 namespace mate {
@@ -68,10 +69,6 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
   dict.SetMethod("stopRecording", &StopRecording);
   dict.SetMethod("getTraceBufferUsage", base::Bind(
       &TracingController::GetTraceBufferUsage, controller));
-  dict.SetMethod("setWatchEvent", base::Bind(
-      &TracingController::SetWatchEvent, controller));
-  dict.SetMethod("cancelWatchEvent", base::Bind(
-      &TracingController::CancelWatchEvent, controller));
 }
 
 }  // namespace

atom/browser/api/atom_api_cookies.cc

@@ -20,6 +20,7 @@
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
+using atom::AtomCookieDelegate;
 using content::BrowserThread;
 
 namespace mate {
@@ -54,6 +55,28 @@ struct Converter<net::CanonicalCookie> {
   }
 };
 
+template<>
+struct Converter<net::CookieStore::ChangeCause> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const net::CookieStore::ChangeCause& val) {
+    switch (val) {
+      case net::CookieStore::ChangeCause::INSERTED:
+      case net::CookieStore::ChangeCause::EXPLICIT:
+        return mate::StringToV8(isolate, "explicit");
+      case net::CookieStore::ChangeCause::OVERWRITE:
+        return mate::StringToV8(isolate, "overwrite");
+      case net::CookieStore::ChangeCause::EXPIRED:
+        return mate::StringToV8(isolate, "expired");
+      case net::CookieStore::ChangeCause::EVICTED:
+        return mate::StringToV8(isolate, "evicted");
+      case net::CookieStore::ChangeCause::EXPIRED_OVERWRITE:
+        return mate::StringToV8(isolate, "expired-overwrite");
+      default:
+        return mate::StringToV8(isolate, "unknown");
+    }
+  }
+};
+
 }  // namespace mate
 
 namespace atom {
@@ -206,11 +229,14 @@ void SetCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
 
 Cookies::Cookies(v8::Isolate* isolate,
                  AtomBrowserContext* browser_context)
-      : request_context_getter_(browser_context->url_request_context_getter()) {
+      : request_context_getter_(browser_context->url_request_context_getter()),
+        cookie_delegate_(browser_context->cookie_delegate()) {
   Init(isolate);
+  cookie_delegate_->AddObserver(this);
 }
 
 Cookies::~Cookies() {
+  cookie_delegate_->RemoveObserver(this);
 }
 
 void Cookies::Get(const base::DictionaryValue& filter,
@@ -239,6 +265,13 @@ void Cookies::Set(const base::DictionaryValue& details,
       base::Bind(SetCookieOnIO, getter, Passed(&copied), callback));
 }
 
+void Cookies::OnCookieChanged(const net::CanonicalCookie& cookie,
+                              bool removed,
+                              net::CookieStore::ChangeCause cause) {
+  Emit("changed", cookie, cause, removed);
+}
+
+
 // static
 mate::Handle<Cookies> Cookies::Create(
     v8::Isolate* isolate,

atom/browser/api/atom_api_cookies.h

@@ -8,6 +8,7 @@
 #include <string>
 
 #include "atom/browser/api/trackable_object.h"
+#include "atom/browser/net/atom_cookie_delegate.h"
 #include "base/callback.h"
 #include "native_mate/handle.h"
 #include "net/cookies/canonical_cookie.h"
@@ -26,7 +27,8 @@ class AtomBrowserContext;
 
 namespace api {
 
-class Cookies : public mate::TrackableObject<Cookies> {
+class Cookies : public mate::TrackableObject<Cookies>,
+                public AtomCookieDelegate::Observer {
  public:
   enum Error {
     SUCCESS,
@@ -52,8 +54,14 @@ class Cookies : public mate::TrackableObject<Cookies> {
               const base::Closure& callback);
   void Set(const base::DictionaryValue& details, const SetCallback& callback);
 
+  // AtomCookieDelegate::Observer:
+  void OnCookieChanged(const net::CanonicalCookie& cookie,
+                       bool removed,
+                       net::CookieStore::ChangeCause cause) override;
+
  private:
   net::URLRequestContextGetter* request_context_getter_;
+  scoped_refptr<AtomCookieDelegate> cookie_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(Cookies);
 };

atom/browser/api/atom_api_debugger.cc

@@ -9,7 +9,6 @@
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/value_converter.h"
-#include "atom/common/node_includes.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "content/public/browser/devtools_agent_host.h"
@@ -17,6 +16,8 @@
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 
+#include "atom/common/node_includes.h"
+
 using content::DevToolsAgentHost;
 
 namespace atom {
@@ -107,7 +108,7 @@ bool Debugger::IsAttached() {
 void Debugger::Detach() {
   if (!agent_host_.get())
     return;
-  agent_host_->DetachClient();
+  agent_host_->DetachClient(this);
   AgentHostClosed(agent_host_.get(), false);
   agent_host_ = nullptr;
 }
@@ -136,7 +137,7 @@ void Debugger::SendCommand(mate::Arguments* args) {
 
   std::string json_args;
   base::JSONWriter::Write(request, &json_args);
-  agent_host_->DispatchProtocolMessage(json_args);
+  agent_host_->DispatchProtocolMessage(this, json_args);
 }
 
 // static

atom/browser/api/atom_api_desktop_capturer.cc

@@ -10,8 +10,7 @@
 #include "chrome/browser/media/desktop_media_list.h"
 #include "native_mate/dictionary.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
-#include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
-#include "third_party/webrtc/modules/desktop_capture/window_capturer.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 
 #include "atom/common/node_includes.h"
 
@@ -61,10 +60,12 @@ void DesktopCapturer::StartHandling(bool capture_window,
   options.set_disable_effects(false);
 #endif
 
-  std::unique_ptr<webrtc::ScreenCapturer> screen_capturer(
-      capture_screen ? webrtc::ScreenCapturer::Create(options) : nullptr);
-  std::unique_ptr<webrtc::WindowCapturer> window_capturer(
-      capture_window ? webrtc::WindowCapturer::Create(options) : nullptr);
+  std::unique_ptr<webrtc::DesktopCapturer> screen_capturer(
+      capture_screen ? webrtc::DesktopCapturer::CreateScreenCapturer(options)
+                     : nullptr);
+  std::unique_ptr<webrtc::DesktopCapturer> window_capturer(
+      capture_window ? webrtc::DesktopCapturer::CreateWindowCapturer(options)
+                     : nullptr);
   media_list_.reset(new NativeDesktopMediaList(
       std::move(screen_capturer), std::move(window_capturer)));
 

atom/browser/api/atom_api_dialog.cc

@@ -35,6 +35,27 @@ struct Converter<file_dialog::Filter> {
   }
 };
 
+template<>
+struct Converter<file_dialog::DialogSettings> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     file_dialog::DialogSettings* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
+      return false;
+    dict.Get("window", &(out->parent_window));
+    dict.Get("title", &(out->title));
+    dict.Get("message", &(out->message));
+    dict.Get("buttonLabel", &(out->button_label));
+    dict.Get("nameFieldLabel", &(out->name_field_label));
+    dict.Get("defaultPath", &(out->default_path));
+    dict.Get("filters", &(out->filters));
+    dict.Get("properties", &(out->properties));
+    dict.Get("showsTagField", &(out->shows_tag_field));
+    return true;
+  }
+};
+
 }  // namespace mate
 
 namespace {
@@ -47,6 +68,8 @@ void ShowMessageBox(int type,
                     const std::string& title,
                     const std::string& message,
                     const std::string& detail,
+                    const std::string& checkbox_label,
+                    bool checkbox_checked,
                     const gfx::ImageSkia& icon,
                     atom::NativeWindow* window,
                     mate::Arguments* args) {
@@ -56,8 +79,8 @@ void ShowMessageBox(int type,
                                                         peek,
                                                         &callback)) {
     atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons,
-                         default_id, cancel_id, options, title,
-                         message, detail, icon, callback);
+                         default_id, cancel_id, options, title, message, detail,
+                         checkbox_label, checkbox_checked, icon, callback);
   } else {
     int chosen = atom::ShowMessageBox(window, (atom::MessageBoxType)type,
                                       buttons, default_id, cancel_id,
@@ -66,45 +89,32 @@ void ShowMessageBox(int type,
   }
 }
 
-void ShowOpenDialog(const std::string& title,
-                    const std::string& button_label,
-                    const base::FilePath& default_path,
-                    const file_dialog::Filters& filters,
-                    int properties,
-                    atom::NativeWindow* window,
+void ShowOpenDialog(const file_dialog::DialogSettings& settings,
                     mate::Arguments* args) {
   v8::Local<v8::Value> peek = args->PeekNext();
   file_dialog::OpenDialogCallback callback;
   if (mate::Converter<file_dialog::OpenDialogCallback>::FromV8(args->isolate(),
                                                                peek,
                                                                &callback)) {
-    file_dialog::ShowOpenDialog(window, title, button_label, default_path,
-                                filters, properties, callback);
+    file_dialog::ShowOpenDialog(settings, callback);
   } else {
     std::vector<base::FilePath> paths;
-    if (file_dialog::ShowOpenDialog(window, title, button_label, default_path,
-                                    filters, properties, &paths))
+    if (file_dialog::ShowOpenDialog(settings, &paths))
       args->Return(paths);
   }
 }
 
-void ShowSaveDialog(const std::string& title,
-                    const std::string& button_label,
-                    const base::FilePath& default_path,
-                    const file_dialog::Filters& filters,
-                    atom::NativeWindow* window,
+void ShowSaveDialog(const file_dialog::DialogSettings& settings,
                     mate::Arguments* args) {
   v8::Local<v8::Value> peek = args->PeekNext();
   file_dialog::SaveDialogCallback callback;
   if (mate::Converter<file_dialog::SaveDialogCallback>::FromV8(args->isolate(),
                                                                peek,
                                                                &callback)) {
-    file_dialog::ShowSaveDialog(window, title, button_label, default_path,
-                                filters, callback);
+    file_dialog::ShowSaveDialog(settings, callback);
   } else {
     base::FilePath path;
-    if (file_dialog::ShowSaveDialog(window, title, button_label, default_path,
-                                    filters, &path))
+    if (file_dialog::ShowSaveDialog(settings, &path))
       args->Return(path);
   }
 }

atom/browser/api/atom_api_download_item.cc

@@ -10,12 +10,13 @@
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
-#include "atom/common/node_includes.h"
-#include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "native_mate/dictionary.h"
 #include "net/base/filename_util.h"
 
+#include "atom/common/node_includes.h"
+
 namespace mate {
 
 template<>
@@ -79,7 +80,8 @@ void DownloadItem::OnDownloadUpdated(content::DownloadItem* item) {
     Emit("done", item->GetState());
 
     // Destroy the item once item is downloaded.
-    base::MessageLoop::current()->PostTask(FROM_HERE, GetDestroyClosure());
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, GetDestroyClosure());
   } else {
     Emit("updated", item->GetState());
   }
@@ -134,7 +136,7 @@ std::string DownloadItem::GetFilename() const {
                            std::string(),
                            download_item_->GetSuggestedFilename(),
                            GetMimeType(),
-                           std::string()).LossyDisplayName());
+                           "download").LossyDisplayName());
 }
 
 std::string DownloadItem::GetContentDisposition() const {
@@ -145,6 +147,10 @@ const GURL& DownloadItem::GetURL() const {
   return download_item_->GetURL();
 }
 
+const std::vector<GURL>& DownloadItem::GetURLChain() const {
+  return download_item_->GetUrlChain();
+}
+
 content::DownloadItem::DownloadState DownloadItem::GetState() const {
   return download_item_->GetState();
 }
@@ -161,6 +167,18 @@ base::FilePath DownloadItem::GetSavePath() const {
   return save_path_;
 }
 
+std::string DownloadItem::GetLastModifiedTime() const {
+  return download_item_->GetLastModifiedTime();
+}
+
+std::string DownloadItem::GetETag() const {
+  return download_item_->GetETag();
+}
+
+double DownloadItem::GetStartTime() const {
+  return download_item_->GetStartTime().ToDoubleT();
+}
+
 // static
 void DownloadItem::BuildPrototype(v8::Isolate* isolate,
                                   v8::Local<v8::FunctionTemplate> prototype) {
@@ -179,10 +197,14 @@ void DownloadItem::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getFilename", &DownloadItem::GetFilename)
       .SetMethod("getContentDisposition", &DownloadItem::GetContentDisposition)
       .SetMethod("getURL", &DownloadItem::GetURL)
+      .SetMethod("getURLChain", &DownloadItem::GetURLChain)
       .SetMethod("getState", &DownloadItem::GetState)
       .SetMethod("isDone", &DownloadItem::IsDone)
       .SetMethod("setSavePath", &DownloadItem::SetSavePath)
-      .SetMethod("getSavePath", &DownloadItem::GetSavePath);
+      .SetMethod("getSavePath", &DownloadItem::GetSavePath)
+      .SetMethod("getLastModifiedTime", &DownloadItem::GetLastModifiedTime)
+      .SetMethod("getETag", &DownloadItem::GetETag)
+      .SetMethod("getStartTime", &DownloadItem::GetStartTime);
 }
 
 // static

atom/browser/api/atom_api_download_item.h

@@ -6,6 +6,7 @@
 #define ATOM_BROWSER_API_ATOM_API_DOWNLOAD_ITEM_H_
 
 #include <string>
+#include <vector>
 
 #include "atom/browser/api/trackable_object.h"
 #include "base/files/file_path.h"
@@ -38,10 +39,14 @@ class DownloadItem : public mate::TrackableObject<DownloadItem>,
   std::string GetFilename() const;
   std::string GetContentDisposition() const;
   const GURL& GetURL() const;
+  const std::vector<GURL>& GetURLChain() const;
   content::DownloadItem::DownloadState GetState() const;
   bool IsDone() const;
   void SetSavePath(const base::FilePath& path);
   base::FilePath GetSavePath() const;
+  std::string GetLastModifiedTime() const;
+  std::string GetETag() const;
+  double GetStartTime() const;
 
  protected:
   DownloadItem(v8::Isolate* isolate, content::DownloadItem* download_item);

atom/browser/api/atom_api_net.cc

@@ -0,0 +1,61 @@
+// 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 "atom/browser/api/atom_api_net.h"
+#include "atom/browser/api/atom_api_url_request.h"
+#include "atom/common/node_includes.h"
+#include "native_mate/dictionary.h"
+
+namespace atom {
+
+namespace api {
+
+Net::Net(v8::Isolate* isolate) {
+  Init(isolate);
+}
+
+Net::~Net() {}
+
+// static
+v8::Local<v8::Value> Net::Create(v8::Isolate* isolate) {
+  return mate::CreateHandle(isolate, new Net(isolate)).ToV8();
+}
+
+// static
+void Net::BuildPrototype(v8::Isolate* isolate,
+                         v8::Local<v8::FunctionTemplate> prototype) {
+  prototype->SetClassName(mate::StringToV8(isolate, "Net"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .SetProperty("URLRequest", &Net::URLRequest);
+}
+
+v8::Local<v8::Value> Net::URLRequest(v8::Isolate* isolate) {
+  return URLRequest::GetConstructor(isolate)->GetFunction();
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+using atom::api::Net;
+using atom::api::URLRequest;
+
+void Initialize(v8::Local<v8::Object> exports,
+                v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context,
+                void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+
+  URLRequest::SetConstructor(isolate, base::Bind(URLRequest::New));
+
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("net", Net::Create(isolate));
+  dict.Set("Net", Net::GetConstructor(isolate)->GetFunction());
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_net, Initialize)

atom/browser/api/atom_api_net.h

@@ -0,0 +1,35 @@
+// 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 ATOM_BROWSER_API_ATOM_API_NET_H_
+#define ATOM_BROWSER_API_ATOM_API_NET_H_
+
+#include "atom/browser/api/event_emitter.h"
+
+namespace atom {
+
+namespace api {
+
+class Net : public mate::EventEmitter<Net> {
+ public:
+  static v8::Local<v8::Value> Create(v8::Isolate* isolate);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
+
+  v8::Local<v8::Value> URLRequest(v8::Isolate* isolate);
+
+ protected:
+  explicit Net(v8::Isolate* isolate);
+  ~Net() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Net);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_NET_H_

atom/browser/api/atom_api_power_monitor.cc

@@ -5,11 +5,12 @@
 #include "atom/browser/api/atom_api_power_monitor.h"
 
 #include "atom/browser/browser.h"
-#include "atom/common/node_includes.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "native_mate/dictionary.h"
 
+#include "atom/common/node_includes.h"
+
 namespace atom {
 
 namespace api {
@@ -43,7 +44,7 @@ v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
     isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
         isolate,
-        "Cannot initialize \"power-monitor\" module before app is ready")));
+        "Cannot require \"powerMonitor\" module before app is ready")));
     return v8::Null(isolate);
   }
 

atom/browser/api/atom_api_power_save_blocker.cc

@@ -6,18 +6,21 @@
 
 #include <string>
 
-#include "atom/common/node_includes.h"
-#include "content/public/browser/power_save_blocker.h"
+#include "content/public/browser/browser_thread.h"
 #include "native_mate/dictionary.h"
 
+#include "atom/common/node_includes.h"
+
+using content::BrowserThread;
+
 namespace mate {
 
 template<>
-struct Converter<content::PowerSaveBlocker::PowerSaveBlockerType> {
+struct Converter<device::PowerSaveBlocker::PowerSaveBlockerType> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     content::PowerSaveBlocker::PowerSaveBlockerType* out) {
-    using content::PowerSaveBlocker;
+                     device::PowerSaveBlocker::PowerSaveBlockerType* out) {
+    using device::PowerSaveBlocker;
     std::string type;
     if (!ConvertFromV8(isolate, val, &type))
       return false;
@@ -39,7 +42,7 @@ namespace api {
 
 PowerSaveBlocker::PowerSaveBlocker(v8::Isolate* isolate)
     : current_blocker_type_(
-          content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension) {
+          device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension) {
   Init(isolate);
 }
 
@@ -58,30 +61,32 @@ void PowerSaveBlocker::UpdatePowerSaveBlocker() {
   // higher precedence level than |kPowerSaveBlockPreventAppSuspension|.
   //
   // Only the highest-precedence blocker type takes effect.
-  content::PowerSaveBlocker::PowerSaveBlockerType new_blocker_type =
-      content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension;
+  device::PowerSaveBlocker::PowerSaveBlockerType new_blocker_type =
+      device::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension;
   for (const auto& element : power_save_blocker_types_) {
     if (element.second ==
-        content::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep) {
+        device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep) {
       new_blocker_type =
-          content::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep;
+          device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep;
       break;
     }
   }
 
   if (!power_save_blocker_ || new_blocker_type != current_blocker_type_) {
-    std::unique_ptr<content::PowerSaveBlocker> new_blocker =
-        content::PowerSaveBlocker::Create(
+    std::unique_ptr<device::PowerSaveBlocker> new_blocker(
+        new device::PowerSaveBlocker(
             new_blocker_type,
-            content::PowerSaveBlocker::kReasonOther,
-            ATOM_PRODUCT_NAME);
+            device::PowerSaveBlocker::kReasonOther,
+            ATOM_PRODUCT_NAME,
+            BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
+            BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
     power_save_blocker_.swap(new_blocker);
     current_blocker_type_ = new_blocker_type;
   }
 }
 
 int PowerSaveBlocker::Start(
-    content::PowerSaveBlocker::PowerSaveBlockerType type) {
+    device::PowerSaveBlocker::PowerSaveBlockerType type) {
   static int count = 0;
   power_save_blocker_types_[count] = type;
   UpdatePowerSaveBlocker();

atom/browser/api/atom_api_power_save_blocker.h

@@ -9,7 +9,7 @@
 #include <memory>
 
 #include "atom/browser/api/trackable_object.h"
-#include "content/public/browser/power_save_blocker.h"
+#include "device/power_save_blocker/power_save_blocker.h"
 #include "native_mate/handle.h"
 
 namespace mate {
@@ -33,18 +33,18 @@ class PowerSaveBlocker : public mate::TrackableObject<PowerSaveBlocker> {
 
  private:
   void UpdatePowerSaveBlocker();
-  int Start(content::PowerSaveBlocker::PowerSaveBlockerType type);
+  int Start(device::PowerSaveBlocker::PowerSaveBlockerType type);
   bool Stop(int id);
   bool IsStarted(int id);
 
-  std::unique_ptr<content::PowerSaveBlocker> power_save_blocker_;
+  std::unique_ptr<device::PowerSaveBlocker> power_save_blocker_;
 
   // Currnet blocker type used by |power_save_blocker_|
-  content::PowerSaveBlocker::PowerSaveBlockerType current_blocker_type_;
+  device::PowerSaveBlocker::PowerSaveBlockerType current_blocker_type_;
 
   // Map from id to the corresponding blocker type for each request.
   using PowerSaveBlockerTypeMap =
-      std::map<int, content::PowerSaveBlocker::PowerSaveBlockerType>;
+      std::map<int, device::PowerSaveBlocker::PowerSaveBlockerType>;
   PowerSaveBlockerTypeMap power_save_blocker_types_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerSaveBlocker);

atom/browser/api/atom_api_protocol.cc

@@ -46,7 +46,8 @@ std::vector<std::string> GetStandardSchemes() {
   return g_standard_schemes;
 }
 
-void RegisterStandardSchemes(const std::vector<std::string>& schemes) {
+void RegisterStandardSchemes(const std::vector<std::string>& schemes,
+                             mate::Arguments* args) {
   g_standard_schemes = schemes;
 
   auto* policy = content::ChildProcessSecurityPolicy::GetInstance();
@@ -55,8 +56,17 @@ void RegisterStandardSchemes(const std::vector<std::string>& schemes) {
     policy->RegisterWebSafeScheme(scheme);
   }
 
+  // add switches to register as standard
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       atom::switches::kStandardSchemes, base::JoinString(schemes, ","));
+
+  mate::Dictionary opts;
+  bool secure = false;
+  if (args->GetNext(&opts) && opts.Get("secure", &secure) && secure) {
+    // add switches to register as secure
+    base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      atom::switches::kSecureSchemes, base::JoinString(schemes, ","));
+  }
 }
 
 Protocol::Protocol(v8::Isolate* isolate, AtomBrowserContext* browser_context)
@@ -220,7 +230,7 @@ void RegisterStandardSchemes(
     return;
   }
 
-  atom::api::RegisterStandardSchemes(schemes);
+  atom::api::RegisterStandardSchemes(schemes, args);
 }
 
 void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,

atom/browser/api/atom_api_protocol.h

@@ -29,7 +29,8 @@ namespace atom {
 namespace api {
 
 std::vector<std::string> GetStandardSchemes();
-void RegisterStandardSchemes(const std::vector<std::string>& schemes);
+void RegisterStandardSchemes(const std::vector<std::string>& schemes,
+                             mate::Arguments* args);
 
 class Protocol : public mate::TrackableObject<Protocol> {
  public:

atom/browser/api/atom_api_render_process_preferences.cc

@@ -7,11 +7,12 @@
 #include "atom/browser/api/atom_api_web_contents.h"
 #include "atom/browser/atom_browser_client.h"
 #include "atom/common/native_mate_converters/value_converter.h"
-#include "atom/common/node_includes.h"
 #include "content/public/browser/render_process_host.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 
+#include "atom/common/node_includes.h"
+
 namespace atom {
 
 namespace api {

atom/browser/api/atom_api_screen.cc

@@ -97,7 +97,7 @@ v8::Local<v8::Value> Screen::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
     isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
         isolate,
-        "Cannot initialize \"screen\" module before app is ready")));
+        "Cannot require \"screen\" module before app is ready")));
     return v8::Null(isolate);
   }
 

atom/browser/api/atom_api_session.cc

@@ -29,11 +29,13 @@
 #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 "brightray/browser/net/devtools_network_conditions.h"
 #include "brightray/browser/net/devtools_network_controller_handle.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/download_manager_delegate.h"
 #include "content/public/browser/storage_partition.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
@@ -49,6 +51,7 @@
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using atom::api::Cookies;
 using content::BrowserThread;
 using content::StoragePartition;
 
@@ -60,6 +63,15 @@ struct ClearStorageDataOptions {
   uint32_t quota_types = StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL;
 };
 
+struct ClearAuthCacheOptions {
+  std::string type;
+  GURL origin;
+  std::string realm;
+  base::string16 username;
+  base::string16 password;
+  net::HttpAuth::Scheme auth_scheme;
+};
+
 uint32_t GetStorageMask(const std::vector<std::string>& storage_types) {
   uint32_t storage_mask = 0;
   for (const auto& it : storage_types) {
@@ -98,6 +110,18 @@ uint32_t GetQuotaMask(const std::vector<std::string>& quota_types) {
   return quota_mask;
 }
 
+net::HttpAuth::Scheme GetAuthSchemeFromString(const std::string& scheme) {
+  if (scheme == "basic")
+    return net::HttpAuth::AUTH_SCHEME_BASIC;
+  if (scheme == "digest")
+    return net::HttpAuth::AUTH_SCHEME_DIGEST;
+  if (scheme == "ntlm")
+    return net::HttpAuth::AUTH_SCHEME_NTLM;
+  if (scheme == "negotiate")
+    return net::HttpAuth::AUTH_SCHEME_NEGOTIATE;
+  return net::HttpAuth::AUTH_SCHEME_MAX;
+}
+
 void SetUserAgentInIO(scoped_refptr<net::URLRequestContextGetter> getter,
                       const std::string& accept_lang,
                       const std::string& user_agent) {
@@ -129,7 +153,27 @@ struct Converter<ClearStorageDataOptions> {
   }
 };
 
-template<>
+template <>
+struct Converter<ClearAuthCacheOptions> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     ClearAuthCacheOptions* out) {
+    mate::Dictionary options;
+    if (!ConvertFromV8(isolate, val, &options))
+      return false;
+    options.Get("type", &out->type);
+    options.Get("origin", &out->origin);
+    options.Get("realm", &out->realm);
+    options.Get("username", &out->username);
+    options.Get("password", &out->password);
+    std::string scheme;
+    if (options.Get("scheme", &scheme))
+      out->auth_scheme = GetAuthSchemeFromString(scheme);
+    return true;
+  }
+};
+
+template <>
 struct Converter<net::ProxyConfig> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
@@ -160,6 +204,18 @@ struct Converter<net::ProxyConfig> {
   }
 };
 
+template<>
+struct Converter<atom::VerifyRequestParams> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   atom::VerifyRequestParams val) {
+    mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
+    dict.Set("hostname", val.hostname);
+    dict.Set("certificate", val.certificate);
+    dict.Set("verificationResult", val.default_result);
+    return dict.GetHandle();
+  }
+};
+
 }  // namespace mate
 
 namespace atom {
@@ -210,8 +266,8 @@ class ResolveProxyHelper {
 
     // Start the request.
     int result = proxy_service->ResolveProxy(
-        url, "GET", net::LOAD_NORMAL, &proxy_info_, completion_callback,
-        &pac_req_, nullptr, net::BoundNetLog());
+        url, "GET", &proxy_info_, completion_callback, &pac_req_, nullptr,
+        net::NetLogWithSource());
 
     // Completed synchronously.
     if (result != net::ERR_IO_PENDING)
@@ -227,6 +283,9 @@ class ResolveProxyHelper {
 };
 
 // Runs the callback in UI thread.
+void RunCallbackInUI(const base::Callback<void()>& callback) {
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
+}
 template<typename ...T>
 void RunCallbackInUI(const base::Callback<void(T...)>& callback, T... result) {
   BrowserThread::PostTask(
@@ -312,6 +371,33 @@ void ClearHostResolverCacheInIO(
   }
 }
 
+void ClearAuthCacheInIO(
+    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
+    const ClearAuthCacheOptions& options,
+    const base::Closure& callback) {
+  auto request_context = context_getter->GetURLRequestContext();
+  auto network_session =
+      request_context->http_transaction_factory()->GetSession();
+  if (network_session) {
+    if (options.type == "password") {
+      auto auth_cache = network_session->http_auth_cache();
+      if (!options.origin.is_empty()) {
+        auth_cache->Remove(
+            options.origin, options.realm, options.auth_scheme,
+            net::AuthCredentials(options.username, options.password));
+      } else {
+        auth_cache->ClearEntriesAddedWithin(base::TimeDelta::Max());
+      }
+    } else if (options.type == "clientCertificate") {
+      auto client_auth_cache = network_session->ssl_client_auth_cache();
+      client_auth_cache->Remove(net::HostPortPair::FromURL(options.origin));
+    }
+    network_session->CloseAllConnections();
+  }
+  if (!callback.is_null())
+    RunCallbackInUI(callback);
+}
+
 void AllowNTLMCredentialsForDomainsInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
     const std::string& domains) {
@@ -330,12 +416,31 @@ void OnClearStorageDataDone(const base::Closure& callback) {
     callback.Run();
 }
 
+void DownloadIdCallback(content::DownloadManager* download_manager,
+                        const base::FilePath& path,
+                        const std::vector<GURL>& url_chain,
+                        const std::string& mime_type,
+                        int64_t offset,
+                        int64_t length,
+                        const std::string& last_modified,
+                        const std::string& etag,
+                        const base::Time& start_time,
+                        uint32_t id) {
+  download_manager->CreateDownloadItem(
+      base::GenerateGUID(), id, path, path, url_chain, GURL(), GURL(), GURL(),
+      GURL(), mime_type, mime_type, start_time, base::Time(), etag,
+      last_modified, offset, length, std::string(),
+      content::DownloadItem::INTERRUPTED,
+      content::DownloadDangerType::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      content::DOWNLOAD_INTERRUPT_REASON_NETWORK_TIMEOUT, false);
+}
+
 }  // namespace
 
 Session::Session(v8::Isolate* isolate, AtomBrowserContext* browser_context)
     : devtools_network_emulation_client_id_(base::GenerateGUID()),
       browser_context_(browser_context) {
-  // Observe DownloadManger to get download notifications.
+  // Observe DownloadManager to get download notifications.
   content::BrowserContext::GetDownloadManager(browser_context)->
       AddObserver(this);
 
@@ -356,10 +461,10 @@ void Session::OnDownloadCreated(content::DownloadManager* manager,
 
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  bool prevent_default = Emit(
-      "will-download",
-      DownloadItem::Create(isolate(), item),
-      item->GetWebContents());
+  auto handle = DownloadItem::Create(isolate(), item);
+  if (item->GetState() == content::DownloadItem::INTERRUPTED)
+    handle->SetSavePath(item->GetTargetFilePath());
+  bool prevent_default = Emit("will-download", handle, item->GetWebContents());
   if (prevent_default) {
     item->Cancel(true);
     item->Remove();
@@ -388,6 +493,11 @@ void Session::ClearStorageData(mate::Arguments* args) {
 
   auto storage_partition =
       content::BrowserContext::GetStoragePartition(browser_context(), nullptr);
+  if (options.storage_types & StoragePartition::REMOVE_DATA_MASK_COOKIES) {
+    // Reset media device id salt when cookies are cleared.
+    // https://w3c.github.io/mediacapture-main/#dom-mediadeviceinfo-deviceid
+    brightray::MediaDeviceIDSalt::Reset(browser_context()->prefs());
+  }
   storage_partition->ClearData(
       options.storage_types, options.quota_types, options.origin,
       content::StoragePartition::OriginMatcherFunction(),
@@ -480,6 +590,22 @@ void Session::ClearHostResolverCache(mate::Arguments* args) {
                  callback));
 }
 
+void Session::ClearAuthCache(mate::Arguments* args) {
+  ClearAuthCacheOptions options;
+  if (!args->GetNext(&options)) {
+    args->ThrowError("Must specify options object");
+    return;
+  }
+  base::Closure callback;
+  args->GetNext(&callback);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&ClearAuthCacheInIO,
+                 make_scoped_refptr(browser_context_->GetRequestContext()),
+                 options, callback));
+}
+
 void Session::AllowNTLMCredentialsForDomains(const std::string& domains) {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&AllowNTLMCredentialsForDomainsInIO,
@@ -504,9 +630,55 @@ std::string Session::GetUserAgent() {
   return browser_context_->GetUserAgent();
 }
 
+void Session::GetBlobData(
+    const std::string& uuid,
+    const AtomBlobReader::CompletionCallback& callback) {
+  if (callback.is_null())
+    return;
+
+  AtomBlobReader* blob_reader =
+      browser_context()->GetBlobReader();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&AtomBlobReader::StartReading,
+                 base::Unretained(blob_reader),
+                 uuid,
+                 callback));
+}
+
+void Session::CreateInterruptedDownload(const mate::Dictionary& options) {
+  int64_t offset = 0, length = 0;
+  double start_time = 0.0;
+  std::string mime_type, last_modified, etag;
+  base::FilePath path;
+  std::vector<GURL> url_chain;
+  options.Get("path", &path);
+  options.Get("urlChain", &url_chain);
+  options.Get("mimeType", &mime_type);
+  options.Get("offset", &offset);
+  options.Get("length", &length);
+  options.Get("lastModified", &last_modified);
+  options.Get("eTag", &etag);
+  options.Get("startTime", &start_time);
+  if (path.empty() || url_chain.empty() || length == 0) {
+    isolate()->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate(), "Must pass non-empty path, urlChain and length.")));
+    return;
+  }
+  if (offset >= length) {
+    isolate()->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate(), "Must pass an offset value less than length.")));
+    return;
+  }
+  auto download_manager =
+      content::BrowserContext::GetDownloadManager(browser_context());
+  download_manager->GetDelegate()->GetNextId(base::Bind(
+      &DownloadIdCallback, download_manager, path, url_chain, mime_type, offset,
+      length, last_modified, etag, base::Time::FromDoubleT(start_time)));
+}
+
 v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
   if (cookies_.IsEmpty()) {
-    auto handle = atom::api::Cookies::Create(isolate, browser_context());
+    auto handle = Cookies::Create(isolate, browser_context());
     cookies_.Reset(isolate, handle.ToV8());
   }
   return v8::Local<v8::Value>::New(isolate, cookies_);
@@ -578,14 +750,18 @@ void Session::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setDownloadPath", &Session::SetDownloadPath)
       .SetMethod("enableNetworkEmulation", &Session::EnableNetworkEmulation)
       .SetMethod("disableNetworkEmulation", &Session::DisableNetworkEmulation)
-      .SetMethod("setCertificateVerifyProc", &Session::SetCertVerifyProc)
+      .SetMethod("_setCertificateVerifyProc", &Session::SetCertVerifyProc)
       .SetMethod("setPermissionRequestHandler",
                  &Session::SetPermissionRequestHandler)
       .SetMethod("clearHostResolverCache", &Session::ClearHostResolverCache)
+      .SetMethod("clearAuthCache", &Session::ClearAuthCache)
       .SetMethod("allowNTLMCredentialsForDomains",
                  &Session::AllowNTLMCredentialsForDomains)
       .SetMethod("setUserAgent", &Session::SetUserAgent)
       .SetMethod("getUserAgent", &Session::GetUserAgent)
+      .SetMethod("getBlobData", &Session::GetBlobData)
+      .SetMethod("createInterruptedDownload",
+                 &Session::CreateInterruptedDownload)
       .SetProperty("cookies", &Session::Cookies)
       .SetProperty("protocol", &Session::Protocol)
       .SetProperty("webRequest", &Session::WebRequest);
@@ -615,6 +791,7 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("Session", Session::GetConstructor(isolate)->GetFunction());
+  dict.Set("Cookies", Cookies::GetConstructor(isolate)->GetFunction());
   dict.SetMethod("fromPartition", &FromPartition);
 }
 

atom/browser/api/atom_api_session.h

@@ -8,6 +8,7 @@
 #include <string>
 
 #include "atom/browser/api/trackable_object.h"
+#include "atom/browser/atom_blob_reader.h"
 #include "base/values.h"
 #include "content/public/browser/download_manager.h"
 #include "native_mate/handle.h"
@@ -73,9 +74,13 @@ class Session: public mate::TrackableObject<Session>,
   void SetPermissionRequestHandler(v8::Local<v8::Value> val,
                                    mate::Arguments* args);
   void ClearHostResolverCache(mate::Arguments* args);
+  void ClearAuthCache(mate::Arguments* args);
   void AllowNTLMCredentialsForDomains(const std::string& domains);
   void SetUserAgent(const std::string& user_agent, mate::Arguments* args);
   std::string GetUserAgent();
+  void GetBlobData(const std::string& uuid,
+                   const AtomBlobReader::CompletionCallback& callback);
+  void CreateInterruptedDownload(const mate::Dictionary& options);
   v8::Local<v8::Value> Cookies(v8::Isolate* isolate);
   v8::Local<v8::Value> Protocol(v8::Isolate* isolate);
   v8::Local<v8::Value> WebRequest(v8::Isolate* isolate);

atom/browser/api/atom_api_system_preferences.cc

@@ -8,10 +8,7 @@
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "atom/common/node_includes.h"
 #include "native_mate/dictionary.h"
-
-#if defined(OS_WIN)
-#include "ui/base/win/shell.h"
-#endif
+#include "ui/gfx/color_utils.h"
 
 namespace atom {
 
@@ -19,16 +16,16 @@ namespace api {
 
 SystemPreferences::SystemPreferences(v8::Isolate* isolate) {
   Init(isolate);
+#if defined(OS_WIN)
+  InitializeWindow();
+#endif
 }
 
 SystemPreferences::~SystemPreferences() {
-}
-
 #if defined(OS_WIN)
-bool SystemPreferences::IsAeroGlassEnabled() {
-  return ui::win::IsAeroGlassEnabled();
-}
+  Browser::Get()->RemoveObserver(this);
 #endif
+}
 
 #if !defined(OS_MACOSX)
 bool SystemPreferences::IsDarkMode() {
@@ -36,6 +33,10 @@ bool SystemPreferences::IsDarkMode() {
 }
 #endif
 
+bool SystemPreferences::IsInvertedColorScheme() {
+  return color_utils::IsInvertedColorScheme();
+}
+
 // static
 mate::Handle<SystemPreferences> SystemPreferences::Create(
     v8::Isolate* isolate) {
@@ -48,7 +49,9 @@ void SystemPreferences::BuildPrototype(
   prototype->SetClassName(mate::StringToV8(isolate, "SystemPreferences"));
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
 #if defined(OS_WIN)
+      .SetMethod("getAccentColor", &SystemPreferences::GetAccentColor)
       .SetMethod("isAeroGlassEnabled", &SystemPreferences::IsAeroGlassEnabled)
+      .SetMethod("getColor", &SystemPreferences::GetColor)
 #elif defined(OS_MACOSX)
       .SetMethod("postNotification",
                  &SystemPreferences::PostNotification)
@@ -63,9 +66,12 @@ void SystemPreferences::BuildPrototype(
       .SetMethod("unsubscribeLocalNotification",
                  &SystemPreferences::UnsubscribeLocalNotification)
       .SetMethod("getUserDefault", &SystemPreferences::GetUserDefault)
+      .SetMethod("setUserDefault", &SystemPreferences::SetUserDefault)
       .SetMethod("isSwipeTrackingFromScrollEventsEnabled",
                  &SystemPreferences::IsSwipeTrackingFromScrollEventsEnabled)
 #endif
+      .SetMethod("isInvertedColorScheme",
+                 &SystemPreferences::IsInvertedColorScheme)
       .SetMethod("isDarkMode", &SystemPreferences::IsDarkMode);
 }
 

atom/browser/api/atom_api_system_preferences.h

@@ -12,6 +12,12 @@
 #include "base/values.h"
 #include "native_mate/handle.h"
 
+#if defined(OS_WIN)
+#include "atom/browser/browser.h"
+#include "atom/browser/browser_observer.h"
+#include "ui/gfx/sys_color_change_listener.h"
+#endif
+
 namespace base {
 class DictionaryValue;
 }
@@ -20,7 +26,12 @@ namespace atom {
 
 namespace api {
 
-class SystemPreferences : public mate::EventEmitter<SystemPreferences> {
+class SystemPreferences : public mate::EventEmitter<SystemPreferences>
+#if defined(OS_WIN)
+    , public BrowserObserver
+    , public gfx::SysColorChangeListener
+#endif
+  {
  public:
   static mate::Handle<SystemPreferences> Create(v8::Isolate* isolate);
 
@@ -29,6 +40,23 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences> {
 
 #if defined(OS_WIN)
   bool IsAeroGlassEnabled();
+
+  typedef HRESULT (STDAPICALLTYPE *DwmGetColorizationColor)(DWORD *, BOOL *);
+  DwmGetColorizationColor dwmGetColorizationColor =
+    (DwmGetColorizationColor) GetProcAddress(LoadLibraryW(L"dwmapi.dll"),
+                                            "DwmGetColorizationColor");
+
+  std::string GetAccentColor();
+  std::string GetColor(const std::string& color, mate::Arguments* args);
+
+  void InitializeWindow();
+
+  // gfx::SysColorChangeListener:
+  void OnSysColorChange() override;
+
+  // BrowserObserver:
+  void OnFinishLaunching(const base::DictionaryValue& launch_info) override;
+
 #elif defined(OS_MACOSX)
   using NotificationCallback = base::Callback<
     void(const std::string&, const base::DictionaryValue&)>;
@@ -45,9 +73,13 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences> {
   void UnsubscribeLocalNotification(int request_id);
   v8::Local<v8::Value> GetUserDefault(const std::string& name,
                                       const std::string& type);
+  void SetUserDefault(const std::string& name,
+                      const std::string& type,
+                      mate::Arguments* args);
   bool IsSwipeTrackingFromScrollEventsEnabled();
 #endif
   bool IsDarkMode();
+  bool IsInvertedColorScheme();
 
  protected:
   explicit SystemPreferences(v8::Isolate* isolate);
@@ -64,6 +96,29 @@ class SystemPreferences : public mate::EventEmitter<SystemPreferences> {
 #endif
 
  private:
+#if defined(OS_WIN)
+  // Static callback invoked when a message comes in to our messaging window.
+  static LRESULT CALLBACK
+      WndProcStatic(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+
+  LRESULT CALLBACK
+      WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
+
+  // The window class of |window_|.
+  ATOM atom_;
+
+  // The handle of the module that contains the window procedure of |window_|.
+  HMODULE instance_;
+
+  // The window used for processing events.
+  HWND window_;
+
+  std::string current_color_;
+
+  bool invertered_color_scheme_;
+
+  std::unique_ptr<gfx::ScopedSysColorChangeListener> color_change_listener_;
+#endif
   DISALLOW_COPY_AND_ASSIGN(SystemPreferences);
 };
 

atom/browser/api/atom_api_system_preferences_mac.mm

@@ -28,17 +28,17 @@ std::map<int, id> g_id_map;
 
 }  // namespace
 
-void SystemPreferences::PostNotification(const std::string& name, 
+void SystemPreferences::PostNotification(const std::string& name,
     const base::DictionaryValue& user_info) {
   DoPostNotification(name, user_info, false);
 }
 
-void SystemPreferences::PostLocalNotification(const std::string& name, 
+void SystemPreferences::PostLocalNotification(const std::string& name,
     const base::DictionaryValue& user_info) {
   DoPostNotification(name, user_info, true);
 }
 
-void SystemPreferences::DoPostNotification(const std::string& name, 
+void SystemPreferences::DoPostNotification(const std::string& name,
     const base::DictionaryValue& user_info, bool is_local) {
   NSNotificationCenter* center = is_local ?
     [NSNotificationCenter defaultCenter] :
@@ -128,16 +128,107 @@ v8::Local<v8::Value> SystemPreferences::GetUserDefault(
     return mate::ConvertToV8(isolate(),
       net::GURLWithNSURL([defaults URLForKey:key]));
   } else if (type == "array") {
-    return mate::ConvertToV8(isolate(),
-      *NSArrayToListValue([defaults arrayForKey:key]));
+    std::unique_ptr<base::ListValue> list =
+        NSArrayToListValue([defaults arrayForKey:key]);
+    if (list == nullptr)
+      list.reset(new base::ListValue());
+    return mate::ConvertToV8(isolate(), *list);
   } else if (type == "dictionary") {
-    return mate::ConvertToV8(isolate(),
-      *NSDictionaryToDictionaryValue([defaults dictionaryForKey:key]));
+    std::unique_ptr<base::DictionaryValue> dictionary =
+        NSDictionaryToDictionaryValue([defaults dictionaryForKey:key]);
+    if (dictionary == nullptr)
+      dictionary.reset(new base::DictionaryValue());
+    return mate::ConvertToV8(isolate(), *dictionary);
   } else {
     return v8::Undefined(isolate());
   }
 }
 
+void SystemPreferences::SetUserDefault(const std::string& name,
+                                       const std::string& type,
+                                       mate::Arguments* args) {
+  const auto throwConversionError = [&] {
+    args->ThrowError("Unable to convert value to: " + type);
+  };
+
+  NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
+  NSString* key = base::SysUTF8ToNSString(name);
+  if (type == "string") {
+    std::string value;
+    if (!args->GetNext(&value)) {
+      throwConversionError();
+      return;
+    }
+
+    [defaults setObject:base::SysUTF8ToNSString(value) forKey:key];
+  } else if (type == "boolean") {
+    bool value;
+    if (!args->GetNext(&value)) {
+      throwConversionError();
+      return;
+    }
+
+    [defaults setBool:value forKey:key];
+  } else if (type == "float") {
+    float value;
+    if (!args->GetNext(&value)) {
+      throwConversionError();
+      return;
+    }
+
+    [defaults setFloat:value forKey:key];
+  } else if (type == "integer") {
+    int value;
+    if (!args->GetNext(&value)) {
+      throwConversionError();
+      return;
+    }
+
+    [defaults setInteger:value forKey:key];
+  } else if (type == "double") {
+    double value;
+    if (!args->GetNext(&value)) {
+      throwConversionError();
+      return;
+    }
+
+    [defaults setDouble:value forKey:key];
+  } else if (type == "url") {
+    GURL value;
+    if (!args->GetNext(&value)) {
+      throwConversionError();
+      return;
+    }
+
+    if (NSURL* url = net::NSURLWithGURL(value)) {
+      [defaults setURL:url forKey:key];
+    }
+  } else if (type == "array") {
+    base::ListValue value;
+    if (!args->GetNext(&value)) {
+      throwConversionError();
+      return;
+    }
+
+    if (NSArray* array = ListValueToNSArray(value)) {
+      [defaults setObject:array forKey:key];
+    }
+  } else if (type == "dictionary") {
+    base::DictionaryValue value;
+    if (!args->GetNext(&value)) {
+      throwConversionError();
+      return;
+    }
+
+    if (NSDictionary* dict = DictionaryValueToNSDictionary(value)) {
+      [defaults setObject:dict forKey:key];
+    }
+  } else {
+    args->ThrowError("Invalid type: " + type);
+    return;
+  }
+}
+
 bool SystemPreferences::IsDarkMode() {
   NSString* mode = [[NSUserDefaults standardUserDefaults]
       stringForKey:@"AppleInterfaceStyle"];

atom/browser/api/atom_api_system_preferences_win.cc

@@ -0,0 +1,190 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_system_preferences.h"
+
+#include "atom/common/color_util.h"
+#include "base/win/wrapped_window_proc.h"
+#include "ui/base/win/shell.h"
+#include "ui/gfx/color_utils.h"
+#include "ui/gfx/win/hwnd_util.h"
+
+namespace atom {
+
+namespace {
+
+const wchar_t kSystemPreferencesWindowClass[] =
+  L"Electron_SystemPreferencesHostWindow";
+
+}  // namespace
+
+namespace api {
+
+bool SystemPreferences::IsAeroGlassEnabled() {
+  return ui::win::IsAeroGlassEnabled();
+}
+
+std::string hexColorDWORDToRGBA(DWORD color) {
+  std::ostringstream stream;
+  stream << std::hex << color;
+  std::string hexColor = stream.str();
+  return hexColor.substr(2) + hexColor.substr(0, 2);
+}
+
+std::string SystemPreferences::GetAccentColor() {
+  DWORD color = 0;
+  BOOL opaque = FALSE;
+
+  if (FAILED(dwmGetColorizationColor(&color, &opaque))) {
+    return "";
+  }
+
+  return hexColorDWORDToRGBA(color);
+}
+
+std::string SystemPreferences::GetColor(const std::string& color,
+                                        mate::Arguments* args) {
+  int id;
+  if (color == "3d-dark-shadow") {
+    id = COLOR_3DDKSHADOW;
+  } else if (color == "3d-face") {
+    id = COLOR_3DFACE;
+  } else if (color == "3d-highlight") {
+    id = COLOR_3DHIGHLIGHT;
+  } else if (color == "3d-light") {
+    id = COLOR_3DLIGHT;
+  } else if (color == "3d-shadow") {
+    id = COLOR_3DSHADOW;
+  } else if (color == "active-border") {
+    id = COLOR_ACTIVEBORDER;
+  } else if (color == "active-caption") {
+    id = COLOR_ACTIVECAPTION;
+  } else if (color == "active-caption-gradient") {
+    id = COLOR_GRADIENTACTIVECAPTION;
+  } else if (color == "app-workspace") {
+    id = COLOR_APPWORKSPACE;
+  } else if (color == "button-text") {
+    id = COLOR_BTNTEXT;
+  } else if (color == "caption-text") {
+    id = COLOR_CAPTIONTEXT;
+  } else if (color == "desktop") {
+    id = COLOR_DESKTOP;
+  } else if (color == "disabled-text") {
+    id = COLOR_GRAYTEXT;
+  } else if (color == "highlight") {
+    id = COLOR_HIGHLIGHT;
+  } else if (color == "highlight-text") {
+    id = COLOR_HIGHLIGHTTEXT;
+  } else if (color == "hotlight") {
+    id = COLOR_HOTLIGHT;
+  } else if (color == "inactive-border") {
+    id = COLOR_INACTIVEBORDER;
+  } else if (color == "inactive-caption") {
+    id = COLOR_INACTIVECAPTION;
+  } else if (color == "inactive-caption-gradient") {
+    id = COLOR_GRADIENTINACTIVECAPTION;
+  } else if (color == "inactive-caption-text") {
+    id = COLOR_INACTIVECAPTIONTEXT;
+  } else if (color == "info-background") {
+    id = COLOR_INFOBK;
+  } else if (color == "info-text") {
+    id = COLOR_INFOTEXT;
+  } else if (color == "menu") {
+    id = COLOR_MENU;
+  } else if (color == "menu-highlight") {
+    id = COLOR_MENUHILIGHT;
+  } else if (color == "menubar") {
+    id = COLOR_MENUBAR;
+  } else if (color == "menu-text") {
+    id = COLOR_MENUTEXT;
+  } else if (color == "scrollbar") {
+    id = COLOR_SCROLLBAR;
+  } else if (color == "window") {
+    id = COLOR_WINDOW;
+  } else if (color == "window-frame") {
+    id = COLOR_WINDOWFRAME;
+  } else if (color == "window-text") {
+    id = COLOR_WINDOWTEXT;
+  } else {
+    args->ThrowError("Unknown color: " + color);
+    return "";
+  }
+
+  return ToRGBHex(color_utils::GetSysSkColor(id));
+}
+
+void SystemPreferences::InitializeWindow() {
+  invertered_color_scheme_ = IsInvertedColorScheme();
+
+  // Wait until app is ready before creating sys color listener
+  // Creating this listener before the app is ready causes global shortcuts
+  // to not fire
+  if (Browser::Get()->is_ready())
+    color_change_listener_.reset(new gfx::ScopedSysColorChangeListener(this));
+  else
+    Browser::Get()->AddObserver(this);
+
+  WNDCLASSEX window_class;
+  base::win::InitializeWindowClass(
+      kSystemPreferencesWindowClass,
+      &base::win::WrappedWindowProc<SystemPreferences::WndProcStatic>,
+      0, 0, 0, NULL, NULL, NULL, NULL, NULL,
+      &window_class);
+  instance_ = window_class.hInstance;
+  atom_ = RegisterClassEx(&window_class);
+
+  // Create an offscreen window for receiving broadcast messages for the system
+  // colorization color.  Create a hidden WS_POPUP window instead of an
+  // HWND_MESSAGE window, because only top-level windows such as popups can
+  // receive broadcast messages like "WM_DWMCOLORIZATIONCOLORCHANGED".
+  window_ = CreateWindow(MAKEINTATOM(atom_),
+                         0, WS_POPUP, 0, 0, 0, 0, 0, 0, instance_, 0);
+  gfx::CheckWindowCreated(window_);
+  gfx::SetWindowUserData(window_, this);
+}
+
+LRESULT CALLBACK SystemPreferences::WndProcStatic(HWND hwnd,
+                                              UINT message,
+                                              WPARAM wparam,
+                                              LPARAM lparam) {
+  SystemPreferences* msg_wnd = reinterpret_cast<SystemPreferences*>(
+      GetWindowLongPtr(hwnd, GWLP_USERDATA));
+  if (msg_wnd)
+    return msg_wnd->WndProc(hwnd, message, wparam, lparam);
+  else
+    return ::DefWindowProc(hwnd, message, wparam, lparam);
+}
+
+LRESULT CALLBACK SystemPreferences::WndProc(HWND hwnd,
+                                        UINT message,
+                                        WPARAM wparam,
+                                        LPARAM lparam) {
+  if (message == WM_DWMCOLORIZATIONCOLORCHANGED) {
+    DWORD new_color = (DWORD) wparam;
+    std::string new_color_string = hexColorDWORDToRGBA(new_color);
+    if (new_color_string != current_color_) {
+      Emit("accent-color-changed", hexColorDWORDToRGBA(new_color));
+      current_color_ = new_color_string;
+    }
+  }
+  return ::DefWindowProc(hwnd, message, wparam, lparam);
+}
+
+void SystemPreferences::OnSysColorChange() {
+  bool new_invertered_color_scheme = IsInvertedColorScheme();
+  if (new_invertered_color_scheme != invertered_color_scheme_) {
+    invertered_color_scheme_ = new_invertered_color_scheme;
+    Emit("inverted-color-scheme-changed", new_invertered_color_scheme);
+  }
+  Emit("color-changed");
+}
+
+void SystemPreferences::OnFinishLaunching(
+    const base::DictionaryValue& launch_info) {
+  color_change_listener_.reset(new gfx::ScopedSysColorChangeListener(this));
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_tray.cc

@@ -13,6 +13,7 @@
 #include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "atom/common/node_includes.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
 #include "ui/gfx/image/image.h"
@@ -71,7 +72,8 @@ Tray::Tray(v8::Isolate* isolate, v8::Local<v8::Object> wrapper,
 
 Tray::~Tray() {
   // Destroy the native tray in next tick.
-  base::MessageLoop::current()->DeleteSoon(FROM_HERE, tray_icon_.release());
+  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
+      FROM_HERE, tray_icon_.release());
 }
 
 // static

atom/browser/api/atom_api_url_request.cc

@@ -0,0 +1,448 @@
+// 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 "atom/browser/api/atom_api_url_request.h"
+#include <string>
+#include "atom/browser/api/atom_api_session.h"
+#include "atom/browser/net/atom_url_request.h"
+#include "atom/common/api/event_emitter_caller.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/net_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_includes.h"
+#include "native_mate/dictionary.h"
+
+namespace mate {
+
+template <>
+struct Converter<scoped_refptr<const net::IOBufferWithSize>> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      scoped_refptr<const net::IOBufferWithSize> buffer) {
+    return node::Buffer::Copy(isolate, buffer->data(), buffer->size())
+        .ToLocalChecked();
+  }
+
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     scoped_refptr<const net::IOBufferWithSize>* out) {
+    auto size = node::Buffer::Length(val);
+
+    if (size == 0) {
+      // Support conversion from empty buffer. A use case is
+      // a GET request without body.
+      // Since zero-sized IOBuffer(s) are not supported, we set the
+      // out pointer to null.
+      *out = nullptr;
+      return true;
+    }
+    auto data = node::Buffer::Data(val);
+    if (!data) {
+      // This is an error as size is positive but data is null.
+      return false;
+    }
+
+    *out = new net::IOBufferWithSize(size);
+    // We do a deep copy. We could have used Buffer's internal memory
+    // but that is much more complicated to be properly handled.
+    memcpy((*out)->data(), data, size);
+    return true;
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+namespace api {
+
+template <typename Flags>
+URLRequest::StateBase<Flags>::StateBase(Flags initialState)
+    : state_(initialState) {}
+
+template <typename Flags>
+void URLRequest::StateBase<Flags>::SetFlag(Flags flag) {
+  state_ =
+      static_cast<Flags>(static_cast<int>(state_) | static_cast<int>(flag));
+}
+
+template <typename Flags>
+bool URLRequest::StateBase<Flags>::operator==(Flags flag) const {
+  return state_ == flag;
+}
+
+template <typename Flags>
+bool URLRequest::StateBase<Flags>::IsFlagSet(Flags flag) const {
+  return static_cast<int>(state_) & static_cast<int>(flag);
+}
+
+URLRequest::RequestState::RequestState()
+    : StateBase(RequestStateFlags::kNotStarted) {}
+
+bool URLRequest::RequestState::NotStarted() const {
+  return *this == RequestStateFlags::kNotStarted;
+}
+
+bool URLRequest::RequestState::Started() const {
+  return IsFlagSet(RequestStateFlags::kStarted);
+}
+
+bool URLRequest::RequestState::Finished() const {
+  return IsFlagSet(RequestStateFlags::kFinished);
+}
+
+bool URLRequest::RequestState::Canceled() const {
+  return IsFlagSet(RequestStateFlags::kCanceled);
+}
+
+bool URLRequest::RequestState::Failed() const {
+  return IsFlagSet(RequestStateFlags::kFailed);
+}
+
+bool URLRequest::RequestState::Closed() const {
+  return IsFlagSet(RequestStateFlags::kClosed);
+}
+
+URLRequest::ResponseState::ResponseState()
+    : StateBase(ResponseStateFlags::kNotStarted) {}
+
+bool URLRequest::ResponseState::NotStarted() const {
+  return *this == ResponseStateFlags::kNotStarted;
+}
+
+bool URLRequest::ResponseState::Started() const {
+  return IsFlagSet(ResponseStateFlags::kStarted);
+}
+
+bool URLRequest::ResponseState::Ended() const {
+  return IsFlagSet(ResponseStateFlags::kEnded);
+}
+
+bool URLRequest::ResponseState::Failed() const {
+  return IsFlagSet(ResponseStateFlags::kFailed);
+}
+
+URLRequest::URLRequest(v8::Isolate* isolate, v8::Local<v8::Object> wrapper) {
+  InitWith(isolate, wrapper);
+}
+
+URLRequest::~URLRequest() {
+  // A request has been created in JS, it was not used and then
+  // it got collected, no close event to cleanup, only destructor
+  // is called.
+  if (atom_request_) {
+    atom_request_->Terminate();
+  }
+}
+
+// static
+mate::WrappableBase* URLRequest::New(mate::Arguments* args) {
+  auto isolate = args->isolate();
+  v8::Local<v8::Object> options;
+  args->GetNext(&options);
+  mate::Dictionary dict(isolate, options);
+  std::string method;
+  dict.Get("method", &method);
+  std::string url;
+  dict.Get("url", &url);
+  std::string partition;
+  mate::Handle<api::Session> session;
+  if (dict.Get("session", &session)) {
+  } else if (dict.Get("partition", &partition)) {
+    session = Session::FromPartition(isolate, partition);
+  } else {
+    // Use the default session if not specified.
+    session = Session::FromPartition(isolate, "");
+  }
+  auto browser_context = session->browser_context();
+  auto api_url_request = new URLRequest(args->isolate(), args->GetThis());
+  auto atom_url_request =
+      AtomURLRequest::Create(browser_context, method, url, api_url_request);
+
+  api_url_request->atom_request_ = atom_url_request;
+
+  return api_url_request;
+}
+
+// static
+void URLRequest::BuildPrototype(v8::Isolate* isolate,
+                                v8::Local<v8::FunctionTemplate> prototype) {
+  prototype->SetClassName(mate::StringToV8(isolate, "URLRequest"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      // Request API
+      .MakeDestroyable()
+      .SetMethod("write", &URLRequest::Write)
+      .SetMethod("cancel", &URLRequest::Cancel)
+      .SetMethod("setExtraHeader", &URLRequest::SetExtraHeader)
+      .SetMethod("removeExtraHeader", &URLRequest::RemoveExtraHeader)
+      .SetMethod("setChunkedUpload", &URLRequest::SetChunkedUpload)
+      .SetMethod("_setLoadFlags", &URLRequest::SetLoadFlags)
+      .SetProperty("notStarted", &URLRequest::NotStarted)
+      .SetProperty("finished", &URLRequest::Finished)
+      // Response APi
+      .SetProperty("statusCode", &URLRequest::StatusCode)
+      .SetProperty("statusMessage", &URLRequest::StatusMessage)
+      .SetProperty("rawResponseHeaders", &URLRequest::RawResponseHeaders)
+      .SetProperty("httpVersionMajor", &URLRequest::ResponseHttpVersionMajor)
+      .SetProperty("httpVersionMinor", &URLRequest::ResponseHttpVersionMinor);
+}
+
+bool URLRequest::NotStarted() const {
+  return request_state_.NotStarted();
+}
+
+bool URLRequest::Finished() const {
+  return request_state_.Finished();
+}
+
+bool URLRequest::Canceled() const {
+  return request_state_.Canceled();
+}
+
+bool URLRequest::Write(scoped_refptr<const net::IOBufferWithSize> buffer,
+                       bool is_last) {
+  if (request_state_.Canceled() || request_state_.Failed() ||
+      request_state_.Finished() || request_state_.Closed()) {
+    return false;
+  }
+
+  if (request_state_.NotStarted()) {
+    request_state_.SetFlag(RequestStateFlags::kStarted);
+    // Pin on first write.
+    Pin();
+  }
+
+  if (is_last) {
+    request_state_.SetFlag(RequestStateFlags::kFinished);
+    EmitRequestEvent(true, "finish");
+  }
+
+  DCHECK(atom_request_);
+  if (atom_request_) {
+    return atom_request_->Write(buffer, is_last);
+  }
+  return false;
+}
+
+void URLRequest::Cancel() {
+  if (request_state_.Canceled() || request_state_.Closed()) {
+    // Cancel only once.
+    return;
+  }
+
+  // Mark as canceled.
+  request_state_.SetFlag(RequestStateFlags::kCanceled);
+
+  DCHECK(atom_request_);
+  if (atom_request_ && request_state_.Started()) {
+    // Really cancel if it was started.
+    atom_request_->Cancel();
+  }
+  EmitRequestEvent(true, "abort");
+
+  if (response_state_.Started() && !response_state_.Ended()) {
+    EmitResponseEvent(true, "aborted");
+  }
+  Close();
+}
+
+bool URLRequest::SetExtraHeader(const std::string& name,
+                                const std::string& value) {
+  // Request state must be in the initial non started state.
+  if (!request_state_.NotStarted()) {
+    // Cannot change headers after send.
+    return false;
+  }
+
+  if (!net::HttpUtil::IsValidHeaderName(name)) {
+    return false;
+  }
+
+  if (!net::HttpUtil::IsValidHeaderValue(value)) {
+    return false;
+  }
+
+  DCHECK(atom_request_);
+  if (atom_request_) {
+    atom_request_->SetExtraHeader(name, value);
+  }
+  return true;
+}
+
+void URLRequest::RemoveExtraHeader(const std::string& name) {
+  // State must be equal to not started.
+  if (!request_state_.NotStarted()) {
+    // Cannot change headers after send.
+    return;
+  }
+  DCHECK(atom_request_);
+  if (atom_request_) {
+    atom_request_->RemoveExtraHeader(name);
+  }
+}
+
+void URLRequest::SetChunkedUpload(bool is_chunked_upload) {
+  // State must be equal to not started.
+  if (!request_state_.NotStarted()) {
+    // Cannot change headers after send.
+    return;
+  }
+  DCHECK(atom_request_);
+  if (atom_request_) {
+    atom_request_->SetChunkedUpload(is_chunked_upload);
+  }
+}
+
+void URLRequest::SetLoadFlags(int flags) {
+  // State must be equal to not started.
+  if (!request_state_.NotStarted()) {
+    // Cannot change load flags after start.
+    return;
+  }
+  DCHECK(atom_request_);
+  if (atom_request_) {
+    atom_request_->SetLoadFlags(flags);
+  }
+}
+
+void URLRequest::OnAuthenticationRequired(
+    scoped_refptr<const net::AuthChallengeInfo> auth_info) {
+  if (request_state_.Canceled() || request_state_.Closed()) {
+    return;
+  }
+
+  DCHECK(atom_request_);
+  if (!atom_request_) {
+    return;
+  }
+
+  Emit("login", auth_info.get(),
+       base::Bind(&AtomURLRequest::PassLoginInformation, atom_request_));
+}
+
+void URLRequest::OnResponseStarted(
+    scoped_refptr<net::HttpResponseHeaders> response_headers) {
+  if (request_state_.Canceled() || request_state_.Failed() ||
+      request_state_.Closed()) {
+    // Don't emit any event after request cancel.
+    return;
+  }
+  response_headers_ = response_headers;
+  response_state_.SetFlag(ResponseStateFlags::kStarted);
+  Emit("response");
+}
+
+void URLRequest::OnResponseData(
+    scoped_refptr<const net::IOBufferWithSize> buffer) {
+  if (request_state_.Canceled() || request_state_.Closed() ||
+      request_state_.Failed() || response_state_.Failed()) {
+    // In case we received an unexpected event from Chromium net,
+    // don't emit any data event after request cancel/error/close.
+    return;
+  }
+  if (!buffer || !buffer->data() || !buffer->size()) {
+    return;
+  }
+  Emit("data", buffer);
+}
+
+void URLRequest::OnResponseCompleted() {
+  if (request_state_.Canceled() || request_state_.Closed() ||
+      request_state_.Failed() || response_state_.Failed()) {
+    // In case we received an unexpected event from Chromium net,
+    // don't emit any data event after request cancel/error/close.
+    return;
+  }
+  response_state_.SetFlag(ResponseStateFlags::kEnded);
+  Emit("end");
+  Close();
+}
+
+void URLRequest::OnError(const std::string& error, bool isRequestError) {
+  auto error_object = v8::Exception::Error(mate::StringToV8(isolate(), error));
+  if (isRequestError) {
+    request_state_.SetFlag(RequestStateFlags::kFailed);
+    EmitRequestEvent(false, "error", error_object);
+  } else {
+    response_state_.SetFlag(ResponseStateFlags::kFailed);
+    EmitResponseEvent(false, "error", error_object);
+  }
+  Close();
+}
+
+int URLRequest::StatusCode() const {
+  if (response_headers_) {
+    return response_headers_->response_code();
+  }
+  return -1;
+}
+
+std::string URLRequest::StatusMessage() const {
+  std::string result;
+  if (response_headers_) {
+    result = response_headers_->GetStatusText();
+  }
+  return result;
+}
+
+net::HttpResponseHeaders* URLRequest::RawResponseHeaders() const {
+  return response_headers_.get();
+}
+
+uint32_t URLRequest::ResponseHttpVersionMajor() const {
+  if (response_headers_) {
+    return response_headers_->GetHttpVersion().major_value();
+  }
+  return 0;
+}
+
+uint32_t URLRequest::ResponseHttpVersionMinor() const {
+  if (response_headers_) {
+    return response_headers_->GetHttpVersion().minor_value();
+  }
+  return 0;
+}
+
+void URLRequest::Close() {
+  if (!request_state_.Closed()) {
+    request_state_.SetFlag(RequestStateFlags::kClosed);
+    if (response_state_.Started()) {
+      // Emit a close event if we really have a response object.
+      EmitResponseEvent(true, "close");
+    }
+    EmitRequestEvent(true, "close");
+  }
+  Unpin();
+  if (atom_request_) {
+    // A request has been created in JS, used and then it ended.
+    // We release unneeded net resources.
+    atom_request_->Terminate();
+  }
+  atom_request_ = nullptr;
+}
+
+void URLRequest::Pin() {
+  if (wrapper_.IsEmpty()) {
+    wrapper_.Reset(isolate(), GetWrapper());
+  }
+}
+
+void URLRequest::Unpin() {
+  wrapper_.Reset();
+}
+
+template <typename... Args>
+void URLRequest::EmitRequestEvent(Args... args) {
+  v8::HandleScope handle_scope(isolate());
+  mate::CustomEmit(isolate(), GetWrapper(), "_emitRequestEvent", args...);
+}
+
+template <typename... Args>
+void URLRequest::EmitResponseEvent(Args... args) {
+  v8::HandleScope handle_scope(isolate());
+  mate::CustomEmit(isolate(), GetWrapper(), "_emitResponseEvent", args...);
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_url_request.h

@@ -0,0 +1,207 @@
+// 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 ATOM_BROWSER_API_ATOM_API_URL_REQUEST_H_
+#define ATOM_BROWSER_API_ATOM_API_URL_REQUEST_H_
+
+#include <array>
+#include <string>
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/api/trackable_object.h"
+#include "base/memory/weak_ptr.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/handle.h"
+#include "native_mate/wrappable_base.h"
+#include "net/base/auth.h"
+#include "net/base/io_buffer.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_request_context.h"
+
+namespace atom {
+
+class AtomURLRequest;
+
+namespace api {
+
+//
+// The URLRequest class implements the V8 binding between the JavaScript API
+// and Chromium native net library. It is responsible for handling HTTP/HTTPS
+// requests.
+//
+// The current class provides only the binding layer. Two other JavaScript
+// classes (ClientRequest and IncomingMessage) in the net module provide the
+// final API, including some state management and arguments validation.
+//
+// URLRequest's methods fall into two main categories: command and event
+// methods. They are always executed on the Browser's UI thread.
+// Command methods are called directly from JavaScript code via the API defined
+// in BuildPrototype. A command method is generally implemented by forwarding
+// the call to a corresponding method on AtomURLRequest which does the
+// synchronization on the Browser IO thread. The latter then calls into Chromium
+// net library. On the other hand, net library events originate on the IO
+// thread in AtomURLRequest and are synchronized back on the UI thread, then
+// forwarded to a corresponding event method in URLRequest and then to
+// JavaScript via the EmitRequestEvent/EmitResponseEvent helpers.
+//
+// URLRequest lifetime management: we followed the Wrapper/Wrappable pattern
+// defined in native_mate. However, we augment that pattern with a pin/unpin
+// mechanism. The main reason is that we want the JS API to provide a similar
+// lifetime guarantees as the XMLHttpRequest.
+// https://xhr.spec.whatwg.org/#garbage-collection
+//
+// The primary motivation is to not garbage collect a URLInstance as long as the
+// object is emitting network events. For instance, in the following JS code
+//
+// (function() {
+//   let request = new URLRequest(...);
+//   request.on('response', (response)=>{
+//    response.on('data', (data) = > {
+//      console.log(data.toString());
+//    });
+//  });
+// })();
+//
+// we still want data to be logged even if the response/request objects are n
+// more referenced in JavaScript.
+//
+// Binding by simply following the native_mate Wrapper/Wrappable pattern will
+// delete the URLRequest object when the corresponding JS object is collected.
+// The v8 handle is a private member in WrappableBase and it is always weak,
+// there is no way to make it strong without changing native_mate.
+// The solution we implement consists of maintaining some kind of state that
+// prevents collection of JS wrappers as long as the request is emitting network
+// events. At initialization, the object is unpinned. When the request starts,
+// it is pinned. When no more events would be emitted, the object is unpinned
+// and lifetime is again managed by the standard native mate Wrapper/Wrappable
+// pattern.
+//
+// pin/unpin: are implemented by constructing/reseting a V8 strong persistent
+// handle.
+//
+// The URLRequest/AtmURLRequest interaction could have been implemented in a
+// single class. However, it implies that the resulting class lifetime will be
+// managed by two conflicting mechanisms: JavaScript garbage collection and
+// Chromium reference counting. Reasoning about lifetime issues become much
+// more complex.
+//
+// We chose to split the implementation into two classes linked via a
+// reference counted/raw pointers. A URLRequest instance is deleted if it is
+// unpinned and the corresponding JS wrapper object is garbage collected. On the
+// other hand, an AtmURLRequest instance lifetime is totally governed by
+// reference counting.
+//
+class URLRequest : public mate::EventEmitter<URLRequest> {
+ public:
+  static mate::WrappableBase* New(mate::Arguments* args);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
+
+  // Methods for reporting events into JavaScript.
+  void OnAuthenticationRequired(
+      scoped_refptr<const net::AuthChallengeInfo> auth_info);
+  void OnResponseStarted(
+      scoped_refptr<net::HttpResponseHeaders> response_headers);
+  void OnResponseData(scoped_refptr<const net::IOBufferWithSize> data);
+  void OnResponseCompleted();
+  void OnError(const std::string& error, bool isRequestError);
+
+ protected:
+  explicit URLRequest(v8::Isolate* isolate, v8::Local<v8::Object> wrapper);
+  ~URLRequest() override;
+
+ private:
+  template <typename Flags>
+  class StateBase {
+   public:
+    void SetFlag(Flags flag);
+
+   protected:
+    explicit StateBase(Flags initialState);
+    bool operator==(Flags flag) const;
+    bool IsFlagSet(Flags flag) const;
+
+   private:
+    Flags state_;
+  };
+
+  enum class RequestStateFlags {
+    kNotStarted = 0x0,
+    kStarted = 0x1,
+    kFinished = 0x2,
+    kCanceled = 0x4,
+    kFailed = 0x8,
+    kClosed = 0x10
+  };
+
+  class RequestState : public StateBase<RequestStateFlags> {
+   public:
+    RequestState();
+    bool NotStarted() const;
+    bool Started() const;
+    bool Finished() const;
+    bool Canceled() const;
+    bool Failed() const;
+    bool Closed() const;
+  };
+
+  enum class ResponseStateFlags {
+    kNotStarted = 0x0,
+    kStarted = 0x1,
+    kEnded = 0x2,
+    kFailed = 0x4
+  };
+
+  class ResponseState : public StateBase<ResponseStateFlags> {
+   public:
+    ResponseState();
+    bool NotStarted() const;
+    bool Started() const;
+    bool Ended() const;
+    bool Canceled() const;
+    bool Failed() const;
+    bool Closed() const;
+  };
+
+  bool NotStarted() const;
+  bool Finished() const;
+  bool Canceled() const;
+  bool Failed() const;
+  bool Write(scoped_refptr<const net::IOBufferWithSize> buffer, bool is_last);
+  void Cancel();
+  bool SetExtraHeader(const std::string& name, const std::string& value);
+  void RemoveExtraHeader(const std::string& name);
+  void SetChunkedUpload(bool is_chunked_upload);
+  void SetLoadFlags(int flags);
+
+  int StatusCode() const;
+  std::string StatusMessage() const;
+  net::HttpResponseHeaders* RawResponseHeaders() const;
+  uint32_t ResponseHttpVersionMajor() const;
+  uint32_t ResponseHttpVersionMinor() const;
+
+  void Close();
+  void Pin();
+  void Unpin();
+  template <typename... Args>
+  void EmitRequestEvent(Args... args);
+  template <typename... Args>
+  void EmitResponseEvent(Args... args);
+
+  scoped_refptr<AtomURLRequest> atom_request_;
+  RequestState request_state_;
+  ResponseState response_state_;
+
+  // Used to implement pin/unpin.
+  v8::Global<v8::Object> wrapper_;
+  scoped_refptr<net::HttpResponseHeaders> response_headers_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequest);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_URL_REQUEST_H_

atom/browser/api/atom_api_web_contents.cc

@@ -13,7 +13,6 @@
 #include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/atom_security_state_model_client.h"
 #include "atom/browser/lib/bluetooth_chooser.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/net/atom_network_delegate.h"
@@ -23,6 +22,7 @@
 #include "atom/browser/ui/drag_util.h"
 #include "atom/browser/web_contents_permission_helper.h"
 #include "atom/browser/web_contents_preferences.h"
+#include "atom/browser/web_contents_zoom_controller.h"
 #include "atom/browser/web_view_guest_delegate.h"
 #include "atom/common/api/api_messages.h"
 #include "atom/common/api/event_emitter_caller.h"
@@ -35,16 +35,17 @@
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
-#include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
-#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "brightray/browser/inspectable_web_contents.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
 #include "chrome/browser/printing/print_preview_message_handler.h"
 #include "chrome/browser/printing/print_view_manager_basic.h"
+#include "chrome/browser/ssl/security_state_tab_helper.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
@@ -67,16 +68,17 @@
 #include "content/public/common/context_menu_params.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
-#include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
+#include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
-#include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/display/screen.h"
 
 #if !defined(OS_MACOSX)
 #include "ui/aura/window.h"
 #endif
 
+#include "atom/common/node_includes.h"
+
 namespace {
 
 struct PrintSettings {
@@ -129,42 +131,29 @@ struct Converter<WindowOpenDisposition> {
                                    WindowOpenDisposition val) {
     std::string disposition = "other";
     switch (val) {
-      case CURRENT_TAB: disposition = "default"; break;
-      case NEW_FOREGROUND_TAB: disposition = "foreground-tab"; break;
-      case NEW_BACKGROUND_TAB: disposition = "background-tab"; break;
-      case NEW_POPUP: case NEW_WINDOW: disposition = "new-window"; break;
-      default: break;
+      case WindowOpenDisposition::CURRENT_TAB:
+        disposition = "default";
+        break;
+      case WindowOpenDisposition::NEW_FOREGROUND_TAB:
+        disposition = "foreground-tab";
+        break;
+      case WindowOpenDisposition::NEW_BACKGROUND_TAB:
+        disposition = "background-tab";
+        break;
+      case WindowOpenDisposition::NEW_POPUP:
+      case WindowOpenDisposition::NEW_WINDOW:
+        disposition = "new-window";
+        break;
+      case WindowOpenDisposition::SAVE_TO_DISK:
+        disposition = "save-to-disk";
+        break;
+      default:
+        break;
     }
     return mate::ConvertToV8(isolate, disposition);
   }
 };
 
-template<>
-struct Converter<net::HttpResponseHeaders*> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   net::HttpResponseHeaders* headers) {
-    base::DictionaryValue response_headers;
-    if (headers) {
-      size_t iter = 0;
-      std::string key;
-      std::string value;
-      while (headers->EnumerateHeaderLines(&iter, &key, &value)) {
-        key = base::ToLowerASCII(key);
-        if (response_headers.HasKey(key)) {
-          base::ListValue* values = nullptr;
-          if (response_headers.GetList(key, &values))
-            values->AppendString(value);
-        } else {
-          std::unique_ptr<base::ListValue> values(new base::ListValue());
-          values->AppendString(value);
-          response_headers.Set(key, std::move(values));
-        }
-      }
-    }
-    return ConvertToV8(isolate, response_headers);
-  }
-};
-
 template<>
 struct Converter<content::SavePageType> {
   static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
@@ -256,22 +245,30 @@ void OnCapturePageDone(base::Callback<void(const gfx::Image&)> callback,
 }  // namespace
 
 WebContents::WebContents(v8::Isolate* isolate,
-                         content::WebContents* web_contents)
+                         content::WebContents* web_contents,
+                         Type type)
     : content::WebContentsObserver(web_contents),
       embedder_(nullptr),
-      type_(REMOTE),
+      zoom_controller_(nullptr),
+      type_(type),
       request_id_(0),
       background_throttling_(true),
       enable_devtools_(true) {
-  web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());
-
-  Init(isolate);
-  AttachAsUserData(web_contents);
+  if (type == REMOTE) {
+    web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());
+    Init(isolate);
+    AttachAsUserData(web_contents);
+  } else {
+    const mate::Dictionary options = mate::Dictionary::CreateEmpty(isolate);
+    auto session = Session::CreateFrom(isolate, GetBrowserContext());
+    session_.Reset(isolate, session.ToV8());
+    InitWithSessionAndOptions(isolate, web_contents, session, options);
+  }
 }
 
-WebContents::WebContents(v8::Isolate* isolate,
-                         const mate::Dictionary& options)
+WebContents::WebContents(v8::Isolate* isolate, const mate::Dictionary& options)
     : embedder_(nullptr),
+      zoom_controller_(nullptr),
       type_(BROWSER_WINDOW),
       request_id_(0),
       background_throttling_(true),
@@ -334,6 +331,13 @@ WebContents::WebContents(v8::Isolate* isolate,
     web_contents = content::WebContents::Create(params);
   }
 
+  InitWithSessionAndOptions(isolate, web_contents, session, options);
+}
+
+void WebContents::InitWithSessionAndOptions(v8::Isolate* isolate,
+                                            content::WebContents *web_contents,
+                                            mate::Handle<api::Session> session,
+                                            const mate::Dictionary& options) {
   Observe(web_contents);
   InitWithWebContents(web_contents, session->browser_context());
 
@@ -342,10 +346,16 @@ WebContents::WebContents(v8::Isolate* isolate,
   // Save the preferences in C++.
   new WebContentsPreferences(web_contents, options);
 
-  // Intialize permission helper.
+  // Initialize permission helper.
   WebContentsPermissionHelper::CreateForWebContents(web_contents);
-  // Intialize security state client.
-  AtomSecurityStateModelClient::CreateForWebContents(web_contents);
+  // Initialize security state client.
+  SecurityStateTabHelper::CreateForWebContents(web_contents);
+  // Initialize zoom controller.
+  WebContentsZoomController::CreateForWebContents(web_contents);
+  zoom_controller_ = WebContentsZoomController::FromWebContents(web_contents);
+  double zoom_factor;
+  if (options.Get(options::kZoomFactor, &zoom_factor))
+    zoom_controller_->SetDefaultZoomFactor(zoom_factor);
 
   web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());
 
@@ -384,11 +394,11 @@ WebContents::~WebContents() {
   }
 }
 
-bool WebContents::AddMessageToConsole(content::WebContents* source,
-                                      int32_t level,
-                                      const base::string16& message,
-                                      int32_t line_no,
-                                      const base::string16& source_id) {
+bool WebContents::DidAddMessageToConsole(content::WebContents* source,
+                                         int32_t level,
+                                         const base::string16& message,
+                                         int32_t line_no,
+                                         const base::string16& source_id) {
   if (type_ == BROWSER_WINDOW || type_ == OFF_SCREEN) {
     return false;
   } else {
@@ -397,19 +407,50 @@ bool WebContents::AddMessageToConsole(content::WebContents* source,
   }
 }
 
-void WebContents::OnCreateWindow(const GURL& target_url,
-                                 const std::string& frame_name,
-                                 WindowOpenDisposition disposition) {
+void WebContents::OnCreateWindow(
+    const GURL& target_url,
+    const std::string& frame_name,
+    WindowOpenDisposition disposition,
+    const std::vector<std::string>& features,
+    const scoped_refptr<content::ResourceRequestBodyImpl>& body) {
   if (type_ == BROWSER_WINDOW || type_ == OFF_SCREEN)
-    Emit("-new-window", target_url, frame_name, disposition);
+    Emit("-new-window", target_url, frame_name, disposition, features, body);
   else
-    Emit("new-window", target_url, frame_name, disposition);
+    Emit("new-window", target_url, frame_name, disposition, features);
+}
+
+void WebContents::WebContentsCreated(content::WebContents* source_contents,
+                                     int opener_render_process_id,
+                                     int opener_render_frame_id,
+                                     const std::string& frame_name,
+                                     const GURL& target_url,
+                                     content::WebContents* new_contents) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  auto api_web_contents = CreateFrom(isolate(), new_contents, BROWSER_WINDOW);
+  Emit("-web-contents-created", api_web_contents, target_url, frame_name);
+}
+
+void WebContents::AddNewContents(content::WebContents* source,
+                                 content::WebContents* new_contents,
+                                 WindowOpenDisposition disposition,
+                                 const gfx::Rect& initial_rect,
+                                 bool user_gesture,
+                                 bool* was_blocked) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  auto api_web_contents = CreateFrom(isolate(), new_contents);
+  if (Emit("-add-new-contents", api_web_contents, disposition, user_gesture,
+      initial_rect.x(), initial_rect.y(), initial_rect.width(),
+      initial_rect.height())) {
+    api_web_contents->DestroyWebContents();
+  }
 }
 
 content::WebContents* WebContents::OpenURLFromTab(
     content::WebContents* source,
     const content::OpenURLParams& params) {
-  if (params.disposition != CURRENT_TAB) {
+  if (params.disposition != WindowOpenDisposition::CURRENT_TAB) {
     if (type_ == BROWSER_WINDOW || type_ == OFF_SCREEN)
       Emit("-new-window", params.url, "", params.disposition);
     else
@@ -421,6 +462,11 @@ content::WebContents* WebContents::OpenURLFromTab(
   if (Emit("will-navigate", params.url))
     return nullptr;
 
+  // Don't load the URL if the web contents was marked as destroyed from a
+  // will-navigate event listener
+  if (IsDestroyed())
+    return nullptr;
+
   return CommonWebContentsDelegate::OpenURLFromTab(source, params);
 }
 
@@ -470,6 +516,17 @@ void WebContents::HandleKeyboardEvent(
   }
 }
 
+bool WebContents::PreHandleKeyboardEvent(
+    content::WebContents* source,
+    const content::NativeWebKeyboardEvent& event,
+    bool* is_keyboard_shortcut) {
+  if (event.type == blink::WebInputEvent::Type::RawKeyDown
+      || event.type == blink::WebInputEvent::Type::KeyUp)
+    return Emit("before-input-event", event);
+  else
+    return false;
+}
+
 void WebContents::EnterFullscreenModeForTab(content::WebContents* source,
                                             const GURL& origin) {
   auto permission_helper =
@@ -493,7 +550,9 @@ void WebContents::ExitFullscreenModeForTab(content::WebContents* source) {
   Emit("leave-html-full-screen");
 }
 
-void WebContents::RendererUnresponsive(content::WebContents* source) {
+void WebContents::RendererUnresponsive(
+    content::WebContents* source,
+    const content::WebContentsUnresponsiveState& unresponsive_state) {
   Emit("unresponsive");
   if ((type_ == BROWSER_WINDOW || type_ == OFF_SCREEN) && owner_window())
     owner_window()->RendererUnresponsive(source);
@@ -527,22 +586,18 @@ void WebContents::FindReply(content::WebContents* web_contents,
                             const gfx::Rect& selection_rect,
                             int active_match_ordinal,
                             bool final_update) {
+  if (!final_update)
+    return;
+
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-
   mate::Dictionary result = mate::Dictionary::CreateEmpty(isolate());
-  if (number_of_matches == -1) {
-    result.Set("requestId", request_id);
-    result.Set("selectionArea", selection_rect);
-    result.Set("finalUpdate", final_update);
-    result.Set("activeMatchOrdinal", active_match_ordinal);
-    Emit("found-in-page", result);
-  } else if (final_update) {
-    result.Set("requestId", request_id);
-    result.Set("matches", number_of_matches);
-    result.Set("finalUpdate", final_update);
-    Emit("found-in-page", result);
-  }
+  result.Set("requestId", request_id);
+  result.Set("matches", number_of_matches);
+  result.Set("selectionArea", selection_rect);
+  result.Set("activeMatchOrdinal", active_match_ordinal);
+  result.Set("finalUpdate", final_update);  // Deprecate after 2.0
+  Emit("found-in-page", result);
 }
 
 bool WebContents::CheckMediaAccessPermission(
@@ -583,12 +638,20 @@ void WebContents::BeforeUnloadFired(const base::TimeTicks& proceed_time) {
   // there are two virtual functions named BeforeUnloadFired.
 }
 
+void WebContents::RenderViewCreated(content::RenderViewHost* render_view_host) {
+  const auto impl = content::RenderWidgetHostImpl::FromID(
+      render_view_host->GetProcess()->GetID(),
+      render_view_host->GetRoutingID());
+  if (impl)
+    impl->disable_hidden_ = !background_throttling_;
+}
+
 void WebContents::RenderViewDeleted(content::RenderViewHost* render_view_host) {
   Emit("render-view-deleted", render_view_host->GetProcess()->GetID());
 }
 
 void WebContents::RenderProcessGone(base::TerminationStatus status) {
-  Emit("crashed");
+  Emit("crashed", status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED);
 }
 
 void WebContents::PluginCrashed(const base::FilePath& plugin_path,
@@ -599,20 +662,18 @@ void WebContents::PluginCrashed(const base::FilePath& plugin_path,
   Emit("plugin-crashed", info.name, info.version);
 }
 
-void WebContents::MediaStartedPlaying(const MediaPlayerId& id) {
+void WebContents::MediaStartedPlaying(const MediaPlayerInfo& video_type,
+                                      const MediaPlayerId& id) {
   Emit("media-started-playing");
 }
 
-void WebContents::MediaStoppedPlaying(const MediaPlayerId& id) {
+void WebContents::MediaStoppedPlaying(const MediaPlayerInfo& video_type,
+                                      const MediaPlayerId& id) {
   Emit("media-paused");
 }
 
 void WebContents::DidChangeThemeColor(SkColor theme_color) {
-  std::string hex_theme_color = base::StringPrintf("#%02X%02X%02X",
-    SkColorGetR(theme_color),
-    SkColorGetG(theme_color),
-    SkColorGetB(theme_color));
-  Emit("did-change-theme-color", hex_theme_color);
+  Emit("did-change-theme-color", atom::ToRGBHex(theme_color));
 }
 
 void WebContents::DocumentLoadedInFrame(
@@ -661,7 +722,6 @@ void WebContents::DidGetResourceResponseStart(
 }
 
 void WebContents::DidGetRedirectForResourceRequest(
-    content::RenderFrameHost* render_frame_host,
     const content::ResourceRedirectDetails& details) {
   Emit("did-get-redirect-request",
        details.url,
@@ -759,6 +819,10 @@ bool WebContents::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
                                     OnRendererMessageSync)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_SetTemporaryZoomLevel,
+                                    OnSetTemporaryZoomLevel)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_GetZoomLevel,
+                                    OnGetZoomLevel)
     IPC_MESSAGE_HANDLER_CODE(ViewHostMsg_SetCursor, OnCursorChange,
       handled = false)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ -794,7 +858,8 @@ void WebContents::WebContentsDestroyed() {
   Emit("destroyed");
 
   // Destroy the native class in next tick.
-  base::MessageLoop::current()->PostTask(FROM_HERE, GetDestroyClosure());
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, GetDestroyClosure());
 }
 
 void WebContents::NavigationEntryCommitted(
@@ -803,7 +868,14 @@ void WebContents::NavigationEntryCommitted(
        details.is_in_page, details.did_replace_entry);
 }
 
-int WebContents::GetID() const {
+int64_t WebContents::GetID() const {
+  int64_t process_id = web_contents()->GetRenderProcessHost()->GetID();
+  int64_t routing_id = web_contents()->GetRoutingID();
+  int64_t rv = (process_id << 32) + routing_id;
+  return rv;
+}
+
+int WebContents::GetProcessID() const {
   return web_contents()->GetRenderProcessHost()->GetID();
 }
 
@@ -816,7 +888,7 @@ bool WebContents::Equal(const WebContents* web_contents) const {
 }
 
 void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
-  if (!url.is_valid()) {
+  if (!url.is_valid() || url.spec().size() > url::kMaxURLChars) {
     Emit("did-fail-load",
          static_cast<int>(net::ERR_INVALID_URL),
          net::ErrorToShortString(net::ERR_INVALID_URL),
@@ -840,6 +912,12 @@ void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
   if (options.Get("extraHeaders", &extra_headers))
     params.extra_headers = extra_headers;
 
+  scoped_refptr<content::ResourceRequestBodyImpl> body;
+  if (options.Get("postData", &body)) {
+    params.post_data = body;
+    params.load_type = content::NavigationController::LOAD_TYPE_HTTP_POST;
+  }
+
   params.transition_type = ui::PAGE_TRANSITION_TYPED;
   params.should_clear_history_list = true;
   params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
@@ -849,20 +927,17 @@ void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
   // We have to call it right after LoadURL because the RenderViewHost is only
   // created after loading a page.
   const auto view = web_contents()->GetRenderWidgetHostView();
-  WebContentsPreferences* web_preferences =
-      WebContentsPreferences::FromWebContents(web_contents());
-  std::string color_name;
-  if (web_preferences->web_preferences()->GetString(options::kBackgroundColor,
-                                                    &color_name)) {
-    view->SetBackgroundColor(ParseHexColor(color_name));
-  } else {
-    view->SetBackgroundColor(SK_ColorTRANSPARENT);
+  if (view) {
+    WebContentsPreferences* web_preferences =
+        WebContentsPreferences::FromWebContents(web_contents());
+    std::string color_name;
+    if (web_preferences->web_preferences()->GetString(options::kBackgroundColor,
+                                                      &color_name)) {
+      view->SetBackgroundColor(ParseHexColor(color_name));
+    } else {
+      view->SetBackgroundColor(SK_ColorTRANSPARENT);
+    }
   }
-
-  // For the same reason we can only disable hidden here.
-  const auto host = static_cast<content::RenderWidgetHostImpl*>(
-      view->GetRenderWidgetHost());
-  host->disable_hidden_ = !background_throttling_;
 }
 
 void WebContents::DownloadURL(const GURL& url) {
@@ -871,7 +946,8 @@ void WebContents::DownloadURL(const GURL& url) {
     content::BrowserContext::GetDownloadManager(browser_context);
 
   download_manager->DownloadUrl(
-    content::DownloadUrlParameters::FromWebContents(web_contents(), url));
+      content::DownloadUrlParameters::CreateForWebContentsMainFrame(
+          web_contents(), url));
 }
 
 GURL WebContents::GetURL() const {
@@ -930,10 +1006,6 @@ std::string WebContents::GetUserAgent() {
   return web_contents()->GetUserAgentOverride();
 }
 
-void WebContents::InsertCSS(const std::string& css) {
-  web_contents()->InsertCSS(css);
-}
-
 bool WebContents::SavePage(const base::FilePath& full_file_path,
                            const content::SavePageType& save_type,
                            const SavePageHandler::SavePageCallback& callback) {
@@ -1019,9 +1091,7 @@ void WebContents::InspectElement(int x, int y) {
 
   if (!managed_web_contents()->GetDevToolsWebContents())
     OpenDevTools(nullptr);
-  scoped_refptr<content::DevToolsAgentHost> agent(
-    content::DevToolsAgentHost::GetOrCreateFor(web_contents()));
-  agent->InspectElement(x, y);
+  managed_web_contents()->InspectElement(x, y);
 }
 
 void WebContents::InspectServiceWorker() {
@@ -1033,7 +1103,7 @@ void WebContents::InspectServiceWorker() {
 
   for (const auto& agent_host : content::DevToolsAgentHost::GetOrCreateAll()) {
     if (agent_host->GetType() ==
-        content::DevToolsAgentHost::TYPE_SERVICE_WORKER) {
+        content::DevToolsAgentHost::kTypeServiceWorker) {
       OpenDevTools(nullptr);
       managed_web_contents()->AttachTo(agent_host);
       break;
@@ -1078,7 +1148,9 @@ void WebContents::Print(mate::Arguments* args) {
   }
 
   printing::PrintViewManagerBasic::FromWebContents(web_contents())->
-      PrintNow(settings.silent, settings.print_background);
+      PrintNow(web_contents()->GetMainFrame(),
+               settings.silent,
+               settings.print_background);
 }
 
 void WebContents::PrintToPDF(const base::DictionaryValue& setting,
@@ -1177,7 +1249,7 @@ void WebContents::ShowDefinitionForSelection() {
 }
 
 void WebContents::CopyImageAt(int x, int y) {
-  const auto host = web_contents()->GetRenderViewHost();
+  const auto host = web_contents()->GetMainFrame();
   if (host)
     host->CopyImageAt(x, y);
 }
@@ -1284,17 +1356,25 @@ void WebContents::StartDrag(const mate::Dictionary& item,
 
   // Error checking.
   if (icon.IsEmpty()) {
-    args->ThrowError("icon must be set");
+    args->ThrowError("Must specify 'icon' option");
     return;
   }
 
+#if defined(OS_MACOSX)
+  // NSWindow.dragImage requires a non-empty NSImage
+  if (icon->image().IsEmpty()) {
+    args->ThrowError("Must specify non-empty 'icon' option");
+    return;
+  }
+#endif
+
   // Start dragging.
   if (!files.empty()) {
     base::MessageLoop::ScopedNestableTaskAllower allow(
         base::MessageLoop::current());
     DragFileItems(files, icon->image(), web_contents()->GetNativeView());
   } else {
-    args->ThrowError("There is nothing to drag");
+    args->ThrowError("Must specify either 'file' or 'files' option");
   }
 }
 
@@ -1419,6 +1499,49 @@ int WebContents::GetFrameRate() const {
   return osr_rwhv ? osr_rwhv->GetFrameRate() : 0;
 }
 
+void WebContents::Invalidate() {
+  if (IsOffScreen()) {
+    auto* osr_rwhv = static_cast<OffScreenRenderWidgetHostView*>(
+      web_contents()->GetRenderWidgetHostView());
+    if (osr_rwhv)
+      osr_rwhv->Invalidate();
+  } else {
+    const auto window = owner_window();
+    if (window)
+      window->Invalidate();
+  }
+}
+
+void WebContents::SetZoomLevel(double level) {
+  zoom_controller_->SetZoomLevel(level);
+}
+
+double WebContents::GetZoomLevel() {
+  return zoom_controller_->GetZoomLevel();
+}
+
+void WebContents::SetZoomFactor(double factor) {
+  auto level = content::ZoomFactorToZoomLevel(factor);
+  SetZoomLevel(level);
+}
+
+double WebContents::GetZoomFactor() {
+  auto level = GetZoomLevel();
+  return content::ZoomLevelToZoomFactor(level);
+}
+
+void WebContents::OnSetTemporaryZoomLevel(double level,
+                                          IPC::Message* reply_msg) {
+  zoom_controller_->SetTemporaryZoomLevel(level);
+  double new_level = zoom_controller_->GetZoomLevel();
+  AtomViewHostMsg_SetTemporaryZoomLevel::WriteReplyParams(reply_msg, new_level);
+  Send(reply_msg);
+}
+
+void WebContents::OnGetZoomLevel(IPC::Message* reply_msg) {
+  AtomViewHostMsg_GetZoomLevel::WriteReplyParams(reply_msg, GetZoomLevel());
+  Send(reply_msg);
+}
 
 v8::Local<v8::Value> WebContents::GetWebPreferences(v8::Isolate* isolate) {
   WebContentsPreferences* web_preferences =
@@ -1447,6 +1570,25 @@ content::WebContents* WebContents::HostWebContents() {
   return embedder_->web_contents();
 }
 
+void WebContents::SetEmbedder(const WebContents* embedder) {
+  if (embedder) {
+    NativeWindow* owner_window = nullptr;
+    auto relay = NativeWindowRelay::FromWebContents(embedder->web_contents());
+    if (relay) {
+      owner_window = relay->window.get();
+    }
+    if (owner_window)
+      SetOwnerWindow(owner_window);
+
+    content::RenderWidgetHostView* rwhv =
+        web_contents()->GetRenderWidgetHostView();
+    if (rwhv) {
+      rwhv->Hide();
+      rwhv->Show();
+    }
+  }
+}
+
 v8::Local<v8::Value> WebContents::DevToolsWebContents(v8::Isolate* isolate) {
   if (devtools_web_contents_.IsEmpty())
     return v8::Null(isolate);
@@ -1469,6 +1611,7 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
   mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
       .MakeDestroyable()
       .SetMethod("getId", &WebContents::GetID)
+      .SetMethod("getProcessId", &WebContents::GetProcessID)
       .SetMethod("equal", &WebContents::Equal)
       .SetMethod("_loadURL", &WebContents::LoadURL)
       .SetMethod("downloadURL", &WebContents::DownloadURL)
@@ -1484,7 +1627,6 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("isCrashed", &WebContents::IsCrashed)
       .SetMethod("setUserAgent", &WebContents::SetUserAgent)
       .SetMethod("getUserAgent", &WebContents::GetUserAgent)
-      .SetMethod("insertCSS", &WebContents::InsertCSS)
       .SetMethod("savePage", &WebContents::SavePage)
       .SetMethod("openDevTools", &WebContents::OpenDevTools)
       .SetMethod("closeDevTools", &WebContents::CloseDevTools)
@@ -1528,6 +1670,11 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("isPainting", &WebContents::IsPainting)
       .SetMethod("setFrameRate", &WebContents::SetFrameRate)
       .SetMethod("getFrameRate", &WebContents::GetFrameRate)
+      .SetMethod("invalidate", &WebContents::Invalidate)
+      .SetMethod("setZoomLevel", &WebContents::SetZoomLevel)
+      .SetMethod("_getZoomLevel", &WebContents::GetZoomLevel)
+      .SetMethod("setZoomFactor", &WebContents::SetZoomFactor)
+      .SetMethod("_getZoomFactor", &WebContents::GetZoomFactor)
       .SetMethod("getType", &WebContents::GetType)
       .SetMethod("getWebPreferences", &WebContents::GetWebPreferences)
       .SetMethod("getOwnerBrowserWindow", &WebContents::GetOwnerBrowserWindow)
@@ -1543,6 +1690,7 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
                  &WebContents::ShowDefinitionForSelection)
       .SetMethod("copyImageAt", &WebContents::CopyImageAt)
       .SetMethod("capturePage", &WebContents::CapturePage)
+      .SetMethod("setEmbedder", &WebContents::SetEmbedder)
       .SetProperty("id", &WebContents::ID)
       .SetProperty("session", &WebContents::Session)
       .SetProperty("hostWebContents", &WebContents::HostWebContents)
@@ -1576,7 +1724,15 @@ mate::Handle<WebContents> WebContents::CreateFrom(
     return mate::CreateHandle(isolate, static_cast<WebContents*>(existing));
 
   // Otherwise create a new WebContents wrapper object.
-  return mate::CreateHandle(isolate, new WebContents(isolate, web_contents));
+  return mate::CreateHandle(isolate, new WebContents(isolate, web_contents,
+        REMOTE));
+}
+
+mate::Handle<WebContents> WebContents::CreateFrom(
+    v8::Isolate* isolate, content::WebContents* web_contents, Type type) {
+  // Otherwise create a new WebContents wrapper object.
+  return mate::CreateHandle(isolate, new WebContents(isolate, web_contents,
+        type));
 }
 
 // static

atom/browser/api/atom_api_web_contents.h

@@ -26,6 +26,10 @@ namespace brightray {
 class InspectableWebContents;
 }
 
+namespace content {
+class ResourceRequestBodyImpl;
+}
+
 namespace mate {
 class Arguments;
 class Dictionary;
@@ -35,6 +39,7 @@ namespace atom {
 
 struct SetSizeParams;
 class AtomBrowserContext;
+class WebContentsZoomController;
 class WebViewGuestDelegate;
 
 namespace api {
@@ -58,6 +63,8 @@ class WebContents : public mate::TrackableObject<WebContents>,
   // Create from an existing WebContents.
   static mate::Handle<WebContents> CreateFrom(
       v8::Isolate* isolate, content::WebContents* web_contents);
+  static mate::Handle<WebContents> CreateFrom(
+      v8::Isolate* isolate, content::WebContents* web_contents, Type type);
 
   // Create a new WebContents.
   static mate::Handle<WebContents> Create(
@@ -66,7 +73,8 @@ class WebContents : public mate::TrackableObject<WebContents>,
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::FunctionTemplate> prototype);
 
-  int GetID() const;
+  int64_t GetID() const;
+  int GetProcessID() const;
   Type GetType() const;
   bool Equal(const WebContents* web_contents) const;
   void LoadURL(const GURL& url, const mate::Dictionary& options);
@@ -102,6 +110,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void SetAudioMuted(bool muted);
   bool IsAudioMuted();
   void Print(mate::Arguments* args);
+  void SetEmbedder(const WebContents* embedder);
 
   // Print current page as PDF.
   void PrintToPDF(const base::DictionaryValue& setting,
@@ -164,6 +173,13 @@ class WebContents : public mate::TrackableObject<WebContents>,
   bool IsPainting() const;
   void SetFrameRate(int frame_rate);
   int GetFrameRate() const;
+  void Invalidate();
+
+  // Methods for zoom handling.
+  void SetZoomLevel(double level);
+  double GetZoomLevel();
+  void SetZoomFactor(double factor);
+  double GetZoomFactor();
 
   // Callback triggered on permission response.
   void OnEnterFullscreenModeForTab(content::WebContents* source,
@@ -171,9 +187,12 @@ class WebContents : public mate::TrackableObject<WebContents>,
                                    bool allowed);
 
   // Create window with the given disposition.
-  void OnCreateWindow(const GURL& target_url,
-                      const std::string& frame_name,
-                      WindowOpenDisposition disposition);
+  void OnCreateWindow(
+      const GURL& target_url,
+      const std::string& frame_name,
+      WindowOpenDisposition disposition,
+      const std::vector<std::string>& features,
+      const scoped_refptr<content::ResourceRequestBodyImpl>& body);
 
   // Returns the web preferences of current WebContents.
   v8::Local<v8::Value> GetWebPreferences(v8::Isolate* isolate);
@@ -188,17 +207,38 @@ class WebContents : public mate::TrackableObject<WebContents>,
   v8::Local<v8::Value> DevToolsWebContents(v8::Isolate* isolate);
   v8::Local<v8::Value> Debugger(v8::Isolate* isolate);
 
+  WebContentsZoomController* GetZoomController() { return zoom_controller_; }
+
  protected:
-  WebContents(v8::Isolate* isolate, content::WebContents* web_contents);
+  WebContents(v8::Isolate* isolate,
+              content::WebContents* web_contents,
+              Type type);
   WebContents(v8::Isolate* isolate, const mate::Dictionary& options);
   ~WebContents();
 
+  void InitWithSessionAndOptions(v8::Isolate* isolate,
+                                 content::WebContents *web_contents,
+                                 mate::Handle<class Session> session,
+                                 const mate::Dictionary& options);
+
   // content::WebContentsDelegate:
-  bool AddMessageToConsole(content::WebContents* source,
-                           int32_t level,
-                           const base::string16& message,
-                           int32_t line_no,
-                           const base::string16& source_id) override;
+  bool DidAddMessageToConsole(content::WebContents* source,
+                              int32_t level,
+                              const base::string16& message,
+                              int32_t line_no,
+                              const base::string16& source_id) override;
+  void WebContentsCreated(content::WebContents* source_contents,
+                          int opener_render_process_id,
+                          int opener_render_frame_id,
+                          const std::string& frame_name,
+                          const GURL& target_url,
+                          content::WebContents* new_contents) override;
+  void AddNewContents(content::WebContents* source,
+                      content::WebContents* new_contents,
+                      WindowOpenDisposition disposition,
+                      const gfx::Rect& initial_rect,
+                      bool user_gesture,
+                      bool* was_blocked) override;
   content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) override;
@@ -214,10 +254,15 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void HandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event) override;
+  bool PreHandleKeyboardEvent(content::WebContents* source,
+                              const content::NativeWebKeyboardEvent& event,
+                              bool* is_keyboard_shortcut) override;
   void EnterFullscreenModeForTab(content::WebContents* source,
                                  const GURL& origin) override;
   void ExitFullscreenModeForTab(content::WebContents* source) override;
-  void RendererUnresponsive(content::WebContents* source) override;
+  void RendererUnresponsive(
+      content::WebContents* source,
+      const content::WebContentsUnresponsiveState& unresponsive_state) override;
   void RendererResponsive(content::WebContents* source) override;
   bool HandleContextMenu(const content::ContextMenuParams& params) override;
   bool OnGoToEntryOffset(int offset) override;
@@ -245,6 +290,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
   // content::WebContentsObserver:
   void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
+  void RenderViewCreated(content::RenderViewHost*) override;
   void RenderViewDeleted(content::RenderViewHost*) override;
   void RenderProcessGone(base::TerminationStatus status) override;
   void DocumentLoadedInFrame(
@@ -261,7 +307,6 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void DidGetResourceResponseStart(
       const content::ResourceRequestDetails& details) override;
   void DidGetRedirectForResourceRequest(
-      content::RenderFrameHost* render_frame_host,
       const content::ResourceRedirectDetails& details) override;
   void DidFinishNavigation(
       content::NavigationHandle* navigation_handle) override;
@@ -274,8 +319,10 @@ class WebContents : public mate::TrackableObject<WebContents>,
       const std::vector<content::FaviconURL>& urls) override;
   void PluginCrashed(const base::FilePath& plugin_path,
                      base::ProcessId plugin_pid) override;
-  void MediaStartedPlaying(const MediaPlayerId& id) override;
-  void MediaStoppedPlaying(const MediaPlayerId& id) override;
+  void MediaStartedPlaying(const MediaPlayerInfo& video_type,
+                           const MediaPlayerId& id) override;
+  void MediaStoppedPlaying(const MediaPlayerInfo& video_type,
+                           const MediaPlayerId& id) override;
   void DidChangeThemeColor(SkColor theme_color) override;
 
   // brightray::InspectableWebContentsDelegate:
@@ -305,6 +352,14 @@ class WebContents : public mate::TrackableObject<WebContents>,
                              const base::ListValue& args,
                              IPC::Message* message);
 
+  // Called when received a synchronous message from renderer to
+  // set temporary zoom level.
+  void OnSetTemporaryZoomLevel(double level, IPC::Message* reply_msg);
+
+  // Called when received a synchronous message from renderer to
+  // get the zoom level.
+  void OnGetZoomLevel(IPC::Message* reply_msg);
+
   v8::Global<v8::Value> session_;
   v8::Global<v8::Value> devtools_web_contents_;
   v8::Global<v8::Value> debugger_;
@@ -314,6 +369,9 @@ class WebContents : public mate::TrackableObject<WebContents>,
   // The host webcontents that may contain this webcontents.
   WebContents* embedder_;
 
+  // The zoom controller for this webContents.
+  WebContentsZoomController* zoom_controller_;
+
   // The type of current WebContents.
   Type type_;
 

atom/browser/api/atom_api_web_request.cc

@@ -20,13 +20,14 @@ using content::BrowserThread;
 namespace mate {
 
 template<>
-struct Converter<extensions::URLPattern> {
+struct Converter<URLPattern> {
   static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
-                     extensions::URLPattern* out) {
+                     URLPattern* out) {
     std::string pattern;
     if (!ConvertFromV8(isolate, val, &pattern))
       return false;
-    return out->Parse(pattern) == extensions::URLPattern::PARSE_SUCCESS;
+    *out = URLPattern(URLPattern::SCHEME_ALL);
+    return out->Parse(pattern) == URLPattern::PARSE_SUCCESS;
   }
 };
 

atom/browser/api/atom_api_web_view_manager.cc

@@ -3,10 +3,12 @@
 // found in the LICENSE file.
 
 #include "atom/browser/web_contents_preferences.h"
+#include "atom/browser/web_contents_zoom_controller.h"
 #include "atom/browser/web_view_manager.h"
 #include "atom/common/native_mate_converters/content_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "atom/common/node_includes.h"
+#include "atom/common/options_switches.h"
 #include "content/public/browser/browser_context.h"
 #include "native_mate/dictionary.h"
 
@@ -24,6 +26,12 @@ void AddGuest(int guest_instance_id,
     manager->AddGuest(guest_instance_id, element_instance_id, embedder,
                       guest_web_contents);
 
+  double zoom_factor;
+  if (options.GetDouble(atom::options::kZoomFactor, &zoom_factor)) {
+    atom::WebContentsZoomController::FromWebContents(guest_web_contents)
+        ->SetDefaultZoomFactor(zoom_factor);
+  }
+
   WebContentsPreferences::FromWebContents(guest_web_contents)->Merge(options);
 }
 

atom/browser/api/atom_api_window.cc

@@ -10,13 +10,14 @@
 #include "atom/browser/browser.h"
 #include "atom/browser/native_window.h"
 #include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
-#include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "native_mate/constructor.h"
@@ -29,8 +30,11 @@
 
 #if defined(OS_WIN)
 #include "atom/browser/ui/win/taskbar_host.h"
+#include "ui/base/win/shell.h"
 #endif
 
+#include "atom/common/node_includes.h"
+
 #if defined(OS_WIN)
 namespace mate {
 
@@ -71,20 +75,40 @@ v8::Local<v8::Value> ToBuffer(v8::Isolate* isolate, void* val, int size) {
 
 Window::Window(v8::Isolate* isolate, v8::Local<v8::Object> wrapper,
                const mate::Dictionary& options) {
-  // Use options.webPreferences to create WebContents.
-  mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
-  options.Get(options::kWebPreferences, &web_preferences);
+  mate::Handle<class WebContents> web_contents;
+  // If no WebContents was passed to the constructor, create it from options.
+  if (!options.Get("webContents", &web_contents)) {
+    // Use options.webPreferences to create WebContents.
+    mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
+    options.Get(options::kWebPreferences, &web_preferences);
 
-  // Copy the backgroundColor to webContents.
-  v8::Local<v8::Value> value;
-  if (options.Get(options::kBackgroundColor, &value))
-    web_preferences.Set(options::kBackgroundColor, value);
+    // Copy the backgroundColor to webContents.
+    v8::Local<v8::Value> value;
+    if (options.Get(options::kBackgroundColor, &value))
+      web_preferences.Set(options::kBackgroundColor, value);
 
-  v8::Local<v8::Value> transparent;
-  if (options.Get("transparent", &transparent))
-    web_preferences.Set("transparent", transparent);
-  // Creates the WebContents used by BrowserWindow.
-  auto web_contents = WebContents::Create(isolate, web_preferences);
+    v8::Local<v8::Value> transparent;
+    if (options.Get("transparent", &transparent))
+      web_preferences.Set("transparent", transparent);
+
+    // Offscreen windows are always created frameless.
+    bool offscreen;
+    if (web_preferences.Get("offscreen", &offscreen) && offscreen) {
+      auto window_options = const_cast<mate::Dictionary&>(options);
+      window_options.Set(options::kFrame, false);
+    }
+
+    // Creates the WebContents used by BrowserWindow.
+    web_contents = WebContents::Create(isolate, web_preferences);
+  }
+
+  Init(isolate, wrapper, options, web_contents);
+}
+
+void Window::Init(v8::Isolate* isolate,
+                  v8::Local<v8::Object> wrapper,
+                  const mate::Dictionary& options,
+                  mate::Handle<class WebContents> web_contents) {
   web_contents_.Reset(isolate, web_contents.ToV8());
   api_web_contents_ = web_contents.get();
 
@@ -129,7 +153,7 @@ Window::~Window() {
 
   // Destroy the native window in next tick because the native code might be
   // iterating all windows.
-  base::MessageLoop::current()->DeleteSoon(FROM_HERE, window_.release());
+  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, window_.release());
 }
 
 void Window::WillCloseWindow(bool* prevent_default) {
@@ -162,7 +186,8 @@ void Window::OnWindowClosed() {
   RemoveFromParentChildWindows();
 
   // Destroy the native class when window is closed.
-  base::MessageLoop::current()->PostTask(FROM_HERE, GetDestroyClosure());
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, GetDestroyClosure());
 }
 
 void Window::OnWindowBlur() {
@@ -229,6 +254,10 @@ void Window::OnWindowScrollTouchEnd() {
   Emit("scroll-touch-end");
 }
 
+void Window::OnWindowScrollTouchEdge() {
+  Emit("scroll-touch-edge");
+}
+
 void Window::OnWindowSwipe(const std::string& direction) {
   Emit("swipe", direction);
 }
@@ -481,8 +510,19 @@ bool Window::IsClosable() {
   return window_->IsClosable();
 }
 
-void Window::SetAlwaysOnTop(bool top) {
-  window_->SetAlwaysOnTop(top);
+void Window::SetAlwaysOnTop(bool top, mate::Arguments* args) {
+  std::string level = "floating";
+  int relativeLevel = 0;
+  std::string error;
+
+  args->GetNext(&level);
+  args->GetNext(&relativeLevel);
+
+  window_->SetAlwaysOnTop(top, level, relativeLevel, &error);
+
+  if (!error.empty()) {
+    args->ThrowError(error);
+  }
 }
 
 bool Window::IsAlwaysOnTop() {
@@ -688,6 +728,25 @@ bool Window::SetThumbnailToolTip(const std::string& tooltip) {
   return window->taskbar_host().SetThumbnailToolTip(
       window_->GetAcceleratedWidget(), tooltip);
 }
+
+void Window::SetAppDetails(const mate::Dictionary& options) {
+  base::string16 app_id;
+  base::FilePath app_icon_path;
+  int app_icon_index = 0;
+  base::string16 relaunch_command;
+  base::string16 relaunch_display_name;
+
+  options.Get("appId", &app_id);
+  options.Get("appIconPath", &app_icon_path);
+  options.Get("appIconIndex", &app_icon_index);
+  options.Get("relaunchCommand", &relaunch_command);
+  options.Get("relaunchDisplayName", &relaunch_display_name);
+
+  ui::win::SetAppDetailsForWindow(
+      app_id, app_icon_path, app_icon_index,
+      relaunch_command, relaunch_display_name,
+      window_->GetAcceleratedWidget());
+}
 #endif
 
 #if defined(TOOLKIT_VIEWS)
@@ -709,6 +768,17 @@ void Window::SetAspectRatio(double aspect_ratio, mate::Arguments* args) {
   window_->SetAspectRatio(aspect_ratio, extra_size);
 }
 
+void Window::PreviewFile(const std::string& path, mate::Arguments* args) {
+  std::string display_name;
+  if (!args->GetNext(&display_name))
+    display_name = path;
+  window_->PreviewFile(path, display_name);
+}
+
+void Window::CloseFilePreview() {
+  window_->CloseFilePreview();
+}
+
 void Window::SetParentWindow(v8::Local<v8::Value> value,
                              mate::Arguments* args) {
   if (IsModal()) {
@@ -759,6 +829,17 @@ bool Window::IsVisibleOnAllWorkspaces() {
   return window_->IsVisibleOnAllWorkspaces();
 }
 
+void Window::SetAutoHideCursor(bool auto_hide) {
+  window_->SetAutoHideCursor(auto_hide);
+}
+
+void Window::SetVibrancy(mate::Arguments* args) {
+  std::string type;
+
+  args->GetNext(&type);
+  window_->SetVibrancy(type);
+}
+
 int32_t Window::ID() const {
   return weak_map_id();
 }
@@ -805,6 +886,8 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setFullScreen", &Window::SetFullScreen)
       .SetMethod("isFullScreen", &Window::IsFullscreen)
       .SetMethod("setAspectRatio", &Window::SetAspectRatio)
+      .SetMethod("previewFile", &Window::PreviewFile)
+      .SetMethod("closeFilePreview", &Window::CloseFilePreview)
 #if !defined(OS_WIN)
       .SetMethod("setParentWindow", &Window::SetParentWindow)
 #endif
@@ -873,6 +956,10 @@ void Window::BuildPrototype(v8::Isolate* isolate,
                  &Window::SetVisibleOnAllWorkspaces)
       .SetMethod("isVisibleOnAllWorkspaces",
                  &Window::IsVisibleOnAllWorkspaces)
+#if defined(OS_MACOSX)
+      .SetMethod("setAutoHideCursor", &Window::SetAutoHideCursor)
+#endif
+      .SetMethod("setVibrancy", &Window::SetVibrancy)
 #if defined(OS_WIN)
       .SetMethod("hookWindowMessage", &Window::HookWindowMessage)
       .SetMethod("isWindowMessageHooked", &Window::IsWindowMessageHooked)
@@ -880,6 +967,7 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("unhookAllWindowMessages", &Window::UnhookAllWindowMessages)
       .SetMethod("setThumbnailClip", &Window::SetThumbnailClip)
       .SetMethod("setThumbnailToolTip", &Window::SetThumbnailToolTip)
+      .SetMethod("setAppDetails", &Window::SetAppDetails)
 #endif
 #if defined(TOOLKIT_VIEWS)
       .SetMethod("setIcon", &Window::SetIcon)

atom/browser/api/atom_api_window.h

@@ -74,6 +74,7 @@ class Window : public mate::TrackableObject<Window>,
   void OnWindowMoved() override;
   void OnWindowScrollTouchBegin() override;
   void OnWindowScrollTouchEnd() override;
+  void OnWindowScrollTouchEdge() override;
   void OnWindowSwipe(const std::string& direction) override;
   void OnWindowEnterFullScreen() override;
   void OnWindowLeaveFullScreen() override;
@@ -88,6 +89,10 @@ class Window : public mate::TrackableObject<Window>,
   #endif
 
  private:
+  void Init(v8::Isolate* isolate,
+            v8::Local<v8::Object> wrapper,
+            const mate::Dictionary& options,
+            mate::Handle<class WebContents> web_contents);
   // APIs for NativeWindow.
   void Close();
   void Focus();
@@ -131,7 +136,7 @@ class Window : public mate::TrackableObject<Window>,
   bool IsFullScreenable();
   void SetClosable(bool closable);
   bool IsClosable();
-  void SetAlwaysOnTop(bool top);
+  void SetAlwaysOnTop(bool top, mate::Arguments* args);
   bool IsAlwaysOnTop();
   void Center();
   void SetPosition(int x, int y, mate::Arguments* args);
@@ -165,6 +170,8 @@ class Window : public mate::TrackableObject<Window>,
   void SetMenuBarVisibility(bool visible);
   bool IsMenuBarVisible();
   void SetAspectRatio(double aspect_ratio, mate::Arguments* args);
+  void PreviewFile(const std::string& path, mate::Arguments* args);
+  void CloseFilePreview();
   void SetParentWindow(v8::Local<v8::Value> value, mate::Arguments* args);
   v8::Local<v8::Value> GetParentWindow() const;
   std::vector<v8::Local<v8::Object>> GetChildWindows() const;
@@ -181,6 +188,7 @@ class Window : public mate::TrackableObject<Window>,
   void UnhookAllWindowMessages();
   bool SetThumbnailClip(const gfx::Rect& region);
   bool SetThumbnailToolTip(const std::string& tooltip);
+  void SetAppDetails(const mate::Dictionary& options);
 #endif
 
 #if defined(TOOLKIT_VIEWS)
@@ -190,6 +198,10 @@ class Window : public mate::TrackableObject<Window>,
   void SetVisibleOnAllWorkspaces(bool visible);
   bool IsVisibleOnAllWorkspaces();
 
+  void SetAutoHideCursor(bool auto_hide);
+
+  void SetVibrancy(mate::Arguments* args);
+
   int32_t ID() const;
   v8::Local<v8::Value> WebContents(v8::Isolate* isolate);
 

atom/browser/api/frame_subscriber.cc

@@ -5,9 +5,12 @@
 #include "atom/browser/api/frame_subscriber.h"
 
 #include "atom/common/native_mate_converters/gfx_converter.h"
-#include "atom/common/node_includes.h"
 #include "base/bind.h"
 #include "content/public/browser/render_widget_host.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
+
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
@@ -40,6 +43,17 @@ bool FrameSubscriber::ShouldCaptureFrame(
   if (only_dirty_)
     rect = dirty_rect;
 
+  gfx::Size view_size = rect.size();
+  gfx::Size bitmap_size = view_size;
+  const gfx::NativeView native_view = view_->GetNativeView();
+  const float scale =
+      display::Screen::GetScreen()->GetDisplayNearestWindow(native_view)
+      .device_scale_factor();
+  if (scale > 1.0f)
+    bitmap_size = gfx::ScaleToCeiledSize(view_size, scale);
+
+  rect = gfx::Rect(rect.origin(), bitmap_size);
+
   host->CopyFromBackingStore(
       rect,
       rect.size(),

atom/browser/api/trackable_object.h

@@ -65,6 +65,12 @@ class TrackableObject : public TrackableObjectBase,
     Wrappable<T>::GetWrapper()->SetAlignedPointerInInternalField(0, nullptr);
   }
 
+  bool IsDestroyed() {
+    v8::Local<v8::Object> wrapper = Wrappable<T>::GetWrapper();
+    return wrapper->InternalFieldCount() == 0 ||
+           wrapper->GetAlignedPointerFromInternalField(0) == nullptr;
+  }
+
   // Finds out the TrackableObject from its ID in weak map.
   static T* FromWeakMapID(v8::Isolate* isolate, int32_t id) {
     if (!weak_map_)

atom/browser/atom_access_token_store.cc

@@ -4,28 +4,67 @@
 
 #include "atom/browser/atom_access_token_store.h"
 
+#include <string>
 #include <utility>
 
 #include "atom/browser/atom_browser_context.h"
 #include "atom/common/google_api_key.h"
+#include "base/environment.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/geolocation_provider.h"
+#include "device/geolocation/geolocation_provider.h"
+
+using content::BrowserThread;
 
 namespace atom {
 
-namespace {
+namespace internal {
 
-// Notice that we just combined the api key with the url together here, because
-// if we use the standard {url: key} format Chromium would override our key with
-// the predefined one in common.gypi of libchromiumcontent, which is empty.
-const char* kGeolocationProviderURL =
-    "https://www.googleapis.com/geolocation/v1/geolocate?key="
-    GOOGLEAPIS_API_KEY;
+// Loads access tokens and other necessary data on the UI thread, and
+// calls back to the originator on the originating thread.
+class TokenLoadingJob : public base::RefCountedThreadSafe<TokenLoadingJob> {
+ public:
+  explicit TokenLoadingJob(
+      const device::AccessTokenStore::LoadAccessTokensCallback& callback)
+      : callback_(callback), request_context_getter_(nullptr) {}
 
-}  // namespace
+  void Run(AtomBrowserContext* browser_context) {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    request_context_getter_ = browser_context->GetRequestContext();
+    std::unique_ptr<base::Environment> env(base::Environment::Create());
+    if (!env->GetVar("GOOGLE_API_KEY", &api_key_))
+      api_key_ = GOOGLEAPIS_API_KEY;
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&TokenLoadingJob::RespondOnIOThread, this));
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<TokenLoadingJob>;
+
+  ~TokenLoadingJob() {}
+
+  void RespondOnIOThread() {
+    // Equivalent to access_token_map[kGeolocationProviderURL].
+    // Somehow base::string16 is causing compilation errors when used in a pair
+    // of std::map on Linux, this can work around it.
+    device::AccessTokenStore::AccessTokenMap access_token_map;
+    std::pair<GURL, base::string16> token_pair;
+    token_pair.first = GURL(GOOGLEAPIS_ENDPOINT + api_key_);
+    access_token_map.insert(token_pair);
+
+    callback_.Run(access_token_map, request_context_getter_);
+  }
+
+  device::AccessTokenStore::LoadAccessTokensCallback callback_;
+  net::URLRequestContextGetter* request_context_getter_;
+  std::string api_key_;
+};
+
+}  // namespace internal
 
 AtomAccessTokenStore::AtomAccessTokenStore() {
-  content::GeolocationProvider::GetInstance()->UserDidOptIntoLocationServices();
+  browser_context_ = AtomBrowserContext::From("", false);
+  device::GeolocationProvider::GetInstance()->UserDidOptIntoLocationServices();
 }
 
 AtomAccessTokenStore::~AtomAccessTokenStore() {
@@ -33,35 +72,20 @@ AtomAccessTokenStore::~AtomAccessTokenStore() {
 
 void AtomAccessTokenStore::LoadAccessTokens(
     const LoadAccessTokensCallback& callback) {
-  content::BrowserThread::PostTaskAndReply(
-      content::BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&AtomAccessTokenStore::GetRequestContextOnUIThread, this),
-      base::Bind(&AtomAccessTokenStore::RespondOnOriginatingThread,
-                 this, callback));
+  scoped_refptr<internal::TokenLoadingJob> job(
+      new internal::TokenLoadingJob(callback));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&AtomAccessTokenStore::RunTokenLoadingJob,
+                                     this, base::RetainedRef(job)));
+}
+
+void AtomAccessTokenStore::RunTokenLoadingJob(
+    scoped_refptr<internal::TokenLoadingJob> job) {
+  job->Run(browser_context_.get());
 }
 
 void AtomAccessTokenStore::SaveAccessToken(const GURL& server_url,
                                            const base::string16& access_token) {
 }
 
-void AtomAccessTokenStore::GetRequestContextOnUIThread() {
-  auto browser_context = AtomBrowserContext::From("", false);
-  request_context_getter_ = browser_context->GetRequestContext();
-}
-
-void AtomAccessTokenStore::RespondOnOriginatingThread(
-    const LoadAccessTokensCallback& callback) {
-  // Equivelent to access_token_map[kGeolocationProviderURL].
-  // Somehow base::string16 is causing compilation errors when used in a pair
-  // of std::map on Linux, this can work around it.
-  AccessTokenMap access_token_map;
-  std::pair<GURL, base::string16> token_pair;
-  token_pair.first = GURL(kGeolocationProviderURL);
-  access_token_map.insert(token_pair);
-
-  callback.Run(access_token_map, request_context_getter_.get());
-  request_context_getter_ = nullptr;
-}
-
 }  // namespace atom

atom/browser/atom_access_token_store.h

@@ -5,27 +5,31 @@
 #ifndef ATOM_BROWSER_ATOM_ACCESS_TOKEN_STORE_H_
 #define ATOM_BROWSER_ATOM_ACCESS_TOKEN_STORE_H_
 
-#include "content/public/browser/access_token_store.h"
+#include "device/geolocation/access_token_store.h"
 
 namespace atom {
 
-class AtomAccessTokenStore : public content::AccessTokenStore {
+class AtomBrowserContext;
+
+namespace internal {
+class TokenLoadingJob;
+}
+
+class AtomAccessTokenStore : public device::AccessTokenStore {
  public:
   AtomAccessTokenStore();
   ~AtomAccessTokenStore();
 
-  // content::AccessTokenStore:
+  // device::AccessTokenStore:
   void LoadAccessTokens(
       const LoadAccessTokensCallback& callback) override;
   void SaveAccessToken(const GURL& server_url,
                        const base::string16& access_token) override;
 
  private:
-  void GetRequestContextOnUIThread();
-  void RespondOnOriginatingThread(const LoadAccessTokensCallback& callback);
-
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+  void RunTokenLoadingJob(scoped_refptr<internal::TokenLoadingJob> job);
 
+  scoped_refptr<AtomBrowserContext> browser_context_;
   DISALLOW_COPY_AND_ASSIGN(AtomAccessTokenStore);
 };
 

atom/browser/atom_blob_reader.cc

@@ -0,0 +1,138 @@
+// 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 "atom/browser/atom_blob_reader.h"
+
+#include "content/browser/blob_storage/chrome_blob_storage_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "storage/browser/blob/blob_data_handle.h"
+#include "storage/browser/blob/blob_reader.h"
+#include "storage/browser/blob/blob_storage_context.h"
+#include "storage/browser/fileapi/file_system_context.h"
+
+#include "atom/common/node_includes.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+void FreeNodeBufferData(char* data, void* hint) {
+  delete[] data;
+}
+
+void RunCallbackInUI(
+    const AtomBlobReader::CompletionCallback& callback,
+    char* blob_data,
+    int size) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  if (blob_data) {
+    v8::Local<v8::Value> buffer = node::Buffer::New(isolate,
+        blob_data, static_cast<size_t>(size), &FreeNodeBufferData, nullptr)
+        .ToLocalChecked();
+    callback.Run(buffer);
+  } else {
+    callback.Run(v8::Null(isolate));
+  }
+}
+
+}  // namespace
+
+AtomBlobReader::AtomBlobReader(
+    content::ChromeBlobStorageContext* blob_context,
+    storage::FileSystemContext* file_system_context)
+    : blob_context_(blob_context),
+      file_system_context_(file_system_context) {
+}
+
+AtomBlobReader::~AtomBlobReader() {
+}
+
+void AtomBlobReader::StartReading(
+    const std::string& uuid,
+    const AtomBlobReader::CompletionCallback& completion_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  auto blob_data_handle =
+      blob_context_->context()->GetBlobDataFromUUID(uuid);
+  auto callback = base::Bind(&RunCallbackInUI,
+                             completion_callback);
+  if (!blob_data_handle) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+        base::Bind(callback, nullptr, 0));
+    return;
+  }
+
+  auto blob_reader = blob_data_handle->CreateReader(
+      file_system_context_.get(),
+      BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get());
+  BlobReadHelper* blob_read_helper =
+      new BlobReadHelper(std::move(blob_reader), callback);
+  blob_read_helper->Read();
+}
+
+AtomBlobReader::BlobReadHelper::BlobReadHelper(
+    std::unique_ptr<storage::BlobReader> blob_reader,
+    const BlobReadHelper::CompletionCallback& callback)
+    : blob_reader_(std::move(blob_reader)),
+      completion_callback_(callback) {
+}
+
+AtomBlobReader::BlobReadHelper::~BlobReadHelper() {
+}
+
+void AtomBlobReader::BlobReadHelper::Read() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  storage::BlobReader::Status size_status = blob_reader_->CalculateSize(
+      base::Bind(&AtomBlobReader::BlobReadHelper::DidCalculateSize,
+                 base::Unretained(this)));
+  if (size_status != storage::BlobReader::Status::IO_PENDING)
+    DidCalculateSize(net::OK);
+}
+
+void AtomBlobReader::BlobReadHelper::DidCalculateSize(int result) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (result != net::OK) {
+    DidReadBlobData(nullptr, 0);
+    return;
+  }
+
+  uint64_t total_size = blob_reader_->total_size();
+  int bytes_read = 0;
+  scoped_refptr<net::IOBuffer> blob_data =
+      new net::IOBuffer(static_cast<size_t>(total_size));
+  auto callback = base::Bind(&AtomBlobReader::BlobReadHelper::DidReadBlobData,
+                             base::Unretained(this),
+                             base::RetainedRef(blob_data));
+  storage::BlobReader::Status read_status = blob_reader_->Read(
+      blob_data.get(),
+      total_size,
+      &bytes_read,
+      callback);
+  if (read_status != storage::BlobReader::Status::IO_PENDING)
+    callback.Run(bytes_read);
+}
+
+void AtomBlobReader::BlobReadHelper::DidReadBlobData(
+    const scoped_refptr<net::IOBuffer>& blob_data,
+    int size) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  char* data = new char[size];
+  memcpy(data, blob_data->data(), size);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      base::Bind(completion_callback_, data, size));
+  delete this;
+}
+
+}  // namespace atom

atom/browser/atom_blob_reader.h

@@ -0,0 +1,80 @@
+// 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 ATOM_BROWSER_ATOM_BLOB_READER_H_
+#define ATOM_BROWSER_ATOM_BLOB_READER_H_
+
+#include <string>
+
+#include "base/callback.h"
+
+namespace content {
+class ChromeBlobStorageContext;
+}
+
+namespace net {
+class IOBuffer;
+}
+
+namespace storage {
+class BlobDataHandle;
+class BlobReader;
+class FileSystemContext;
+}
+
+namespace v8 {
+template <class T>
+class Local;
+class Value;
+}
+
+namespace atom {
+
+// A class to keep track of the blob context. All methods,
+// except Ctor are expected to be called on IO thread.
+class AtomBlobReader {
+ public:
+  using CompletionCallback = base::Callback<void(v8::Local<v8::Value>)>;
+
+  AtomBlobReader(content::ChromeBlobStorageContext* blob_context,
+                 storage::FileSystemContext* file_system_context);
+  ~AtomBlobReader();
+
+  void StartReading(
+      const std::string& uuid,
+      const AtomBlobReader::CompletionCallback& callback);
+
+ private:
+  // A self-destroyed helper class to read the blob data.
+  // Must be accessed on IO thread.
+  class BlobReadHelper {
+   public:
+    using CompletionCallback = base::Callback<void(char*, int)>;
+
+    BlobReadHelper(std::unique_ptr<storage::BlobReader> blob_reader,
+                   const BlobReadHelper::CompletionCallback& callback);
+    ~BlobReadHelper();
+
+    void Read();
+
+   private:
+    void DidCalculateSize(int result);
+    void DidReadBlobData(const scoped_refptr<net::IOBuffer>& blob_data,
+                         int bytes_read);
+
+    std::unique_ptr<storage::BlobReader> blob_reader_;
+    BlobReadHelper::CompletionCallback completion_callback_;
+
+    DISALLOW_COPY_AND_ASSIGN(BlobReadHelper);
+  };
+
+  scoped_refptr<content::ChromeBlobStorageContext> blob_context_;
+  scoped_refptr<storage::FileSystemContext> file_system_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomBlobReader);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_BLOB_READER_H_

atom/browser/atom_browser_client.cc

@@ -10,7 +10,6 @@
 
 #include "atom/browser/api/atom_api_app.h"
 #include "atom/browser/api/atom_api_protocol.h"
-#include "atom/browser/atom_access_token_store.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_quota_permission_context.h"
@@ -30,6 +29,7 @@
 #include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
 #include "chrome/browser/renderer_host/pepper/widevine_cdm_message_filter.h"
 #include "chrome/browser/speech/tts_message_filter.h"
+#include "content/common/resource_request_body_impl.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/render_process_host.h"
@@ -37,6 +37,7 @@
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/url_constants.h"
 #include "content/public/common/web_preferences.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "ppapi/host/ppapi_host.h"
@@ -77,7 +78,7 @@ AtomBrowserClient::~AtomBrowserClient() {
 content::WebContents* AtomBrowserClient::GetWebContentsFromProcessID(
     int process_id) {
   // If the process is a pending process, we should use the old one.
-  if (ContainsKey(pending_processes_, process_id))
+  if (base::ContainsKey(pending_processes_, process_id))
     process_id = pending_processes_[process_id];
 
   // Certain render process will be created with no associated render view,
@@ -85,6 +86,44 @@ content::WebContents* AtomBrowserClient::GetWebContentsFromProcessID(
   return WebContentsPreferences::GetWebContentsFromProcessID(process_id);
 }
 
+bool AtomBrowserClient::ShouldCreateNewSiteInstance(
+    content::BrowserContext* browser_context,
+    content::SiteInstance* current_instance,
+    const GURL& url) {
+
+  if (url.SchemeIs(url::kJavaScriptScheme))
+    // "javacript:" scheme should always use same SiteInstance
+    return false;
+
+  if (!IsRendererSandboxed(current_instance->GetProcess()->GetID()))
+    // non-sandboxed renderers should always create a new SiteInstance
+    return true;
+
+  // Create new a SiteInstance if navigating to a different site.
+  auto src_url = current_instance->GetSiteURL();
+  return
+      !content::SiteInstance::IsSameWebSite(browser_context, src_url, url) &&
+      // `IsSameWebSite` doesn't seem to work for some URIs such as `file:`,
+      // handle these scenarios by comparing only the site as defined by
+      // `GetSiteForURL`.
+      content::SiteInstance::GetSiteForURL(browser_context, url) != src_url;
+}
+
+void AtomBrowserClient::AddSandboxedRendererId(int process_id) {
+  base::AutoLock auto_lock(sandboxed_renderers_lock_);
+  sandboxed_renderers_.insert(process_id);
+}
+
+void AtomBrowserClient::RemoveSandboxedRendererId(int process_id) {
+  base::AutoLock auto_lock(sandboxed_renderers_lock_);
+  sandboxed_renderers_.erase(process_id);
+}
+
+bool AtomBrowserClient::IsRendererSandboxed(int process_id) {
+  base::AutoLock auto_lock(sandboxed_renderers_lock_);
+  return sandboxed_renderers_.count(process_id);
+}
+
 void AtomBrowserClient::RenderProcessWillLaunch(
     content::RenderProcessHost* host) {
   int process_id = host->GetID();
@@ -92,6 +131,13 @@ void AtomBrowserClient::RenderProcessWillLaunch(
   host->AddFilter(new TtsMessageFilter(process_id, host->GetBrowserContext()));
   host->AddFilter(
       new WidevineCdmMessageFilter(process_id, host->GetBrowserContext()));
+
+  content::WebContents* web_contents = GetWebContentsFromProcessID(process_id);
+  if (WebContentsPreferences::IsSandboxed(web_contents)) {
+    AddSandboxedRendererId(host->GetID());
+    // ensure the sandboxed renderer id is removed later
+    host->AddObserver(this);
+  }
 }
 
 content::SpeechRecognitionManagerDelegate*
@@ -99,10 +145,6 @@ content::SpeechRecognitionManagerDelegate*
   return new AtomSpeechRecognitionManagerDelegate;
 }
 
-content::AccessTokenStore* AtomBrowserClient::CreateAccessTokenStore() {
-  return new AtomAccessTokenStore;
-}
-
 void AtomBrowserClient::OverrideWebkitPrefs(
     content::RenderViewHost* host, content::WebPreferences* prefs) {
   prefs->javascript_enabled = true;
@@ -118,7 +160,6 @@ void AtomBrowserClient::OverrideWebkitPrefs(
   prefs->allow_universal_access_from_file_urls = true;
   prefs->allow_file_access_from_file_urls = true;
   prefs->experimental_webgl_enabled = true;
-  prefs->allow_displaying_insecure_content = false;
   prefs->allow_running_insecure_content = false;
 
   // Custom preferences of guest page.
@@ -140,8 +181,7 @@ void AtomBrowserClient::OverrideSiteInstanceForNavigation(
     return;
   }
 
-  // Restart renderer process for all navigations except "javacript:" scheme.
-  if (url.SchemeIs(url::kJavaScriptScheme))
+  if (!ShouldCreateNewSiteInstance(browser_context, current_instance, url))
     return;
 
   scoped_refptr<content::SiteInstance> site_instance =
@@ -173,6 +213,8 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches(
   // Copy following switches to child process.
   static const char* const kCommonSwitchNames[] = {
     switches::kStandardSchemes,
+    switches::kEnableSandbox,
+    switches::kSecureSchemes
   };
   command_line->CopySwitchesFrom(
       *base::CommandLine::ForCurrentProcess(),
@@ -220,13 +262,13 @@ void AtomBrowserClient::AllowCertificateError(
     bool overridable,
     bool strict_enforcement,
     bool expired_previous_decision,
-    const base::Callback<void(bool)>& callback,
-    content::CertificateRequestResultType* request) {
+    const base::Callback<void(content::CertificateRequestResultType)>&
+        callback) {
   if (delegate_) {
     delegate_->AllowCertificateError(
         web_contents, cert_error, ssl_info, request_url,
         resource_type, overridable, strict_enforcement,
-        expired_previous_decision, callback, request);
+        expired_previous_decision, callback);
   }
 }
 
@@ -252,11 +294,13 @@ bool AtomBrowserClient::CanCreateWindow(
     const GURL& opener_top_level_frame_url,
     const GURL& source_origin,
     WindowContainerType container_type,
-    const std::string& frame_name,
     const GURL& target_url,
     const content::Referrer& referrer,
+    const std::string& frame_name,
     WindowOpenDisposition disposition,
     const blink::WebWindowFeatures& features,
+    const std::vector<std::string>& additional_features,
+    const scoped_refptr<content::ResourceRequestBodyImpl>& body,
     bool user_gesture,
     bool opener_suppressed,
     content::ResourceContext* context,
@@ -266,6 +310,11 @@ bool AtomBrowserClient::CanCreateWindow(
     bool* no_javascript_access) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
+  if (IsRendererSandboxed(render_process_id)) {
+    *no_javascript_access = false;
+    return true;
+  }
+
   if (delegate_) {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&api::App::OnCreateWindow,
@@ -273,6 +322,8 @@ bool AtomBrowserClient::CanCreateWindow(
                                     target_url,
                                     frame_name,
                                     disposition,
+                                    additional_features,
+                                    body,
                                     render_process_id,
                                     opener_render_frame_id));
   }
@@ -287,6 +338,7 @@ void AtomBrowserClient::GetAdditionalAllowedSchemesForFileSystem(
     additional_schemes->insert(additional_schemes->end(),
                                schemes_list.begin(),
                                schemes_list.end());
+  additional_schemes->push_back(content::kChromeDevToolsScheme);
 }
 
 brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
@@ -323,6 +375,7 @@ void AtomBrowserClient::RenderProcessHostDestroyed(
       break;
     }
   }
+  RemoveSandboxedRendererId(process_id);
 }
 
 }  // namespace atom

atom/browser/atom_browser_client.h

@@ -6,6 +6,7 @@
 #define ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
@@ -49,7 +50,6 @@ class AtomBrowserClient : public brightray::BrowserClient,
   void RenderProcessWillLaunch(content::RenderProcessHost* host) override;
   content::SpeechRecognitionManagerDelegate*
       CreateSpeechRecognitionManagerDelegate() override;
-  content::AccessTokenStore* CreateAccessTokenStore() override;
   void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
                            content::WebPreferences* prefs) override;
   std::string GetApplicationLocale() override;
@@ -71,29 +71,32 @@ class AtomBrowserClient : public brightray::BrowserClient,
       bool overridable,
       bool strict_enforcement,
       bool expired_previous_decision,
-      const base::Callback<void(bool)>& callback,
-      content::CertificateRequestResultType* request) override;
+      const base::Callback<void(content::CertificateRequestResultType)>&
+          callback) override;
   void SelectClientCertificate(
       content::WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
       std::unique_ptr<content::ClientCertificateDelegate> delegate) override;
   void ResourceDispatcherHostCreated() override;
-  bool CanCreateWindow(const GURL& opener_url,
-                       const GURL& opener_top_level_frame_url,
-                       const GURL& source_origin,
-                       WindowContainerType container_type,
-                       const std::string& frame_name,
-                       const GURL& target_url,
-                       const content::Referrer& referrer,
-                       WindowOpenDisposition disposition,
-                       const blink::WebWindowFeatures& features,
-                       bool user_gesture,
-                       bool opener_suppressed,
-                       content::ResourceContext* context,
-                       int render_process_id,
-                       int opener_render_view_id,
-                       int opener_render_frame_id,
-                       bool* no_javascript_access) override;
+  bool CanCreateWindow(
+      const GURL& opener_url,
+      const GURL& opener_top_level_frame_url,
+      const GURL& source_origin,
+      WindowContainerType container_type,
+      const GURL& target_url,
+      const content::Referrer& referrer,
+      const std::string& frame_name,
+      WindowOpenDisposition disposition,
+      const blink::WebWindowFeatures& features,
+      const std::vector<std::string>& additional_features,
+      const scoped_refptr<content::ResourceRequestBodyImpl>& body,
+      bool user_gesture,
+      bool opener_suppressed,
+      content::ResourceContext* context,
+      int render_process_id,
+      int opener_render_view_id,
+      int opener_render_frame_id,
+      bool* no_javascript_access) override;
   void GetAdditionalAllowedSchemesForFileSystem(
       std::vector<std::string>* schemes) override;
 
@@ -108,8 +111,19 @@ class AtomBrowserClient : public brightray::BrowserClient,
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
 
  private:
+  bool ShouldCreateNewSiteInstance(content::BrowserContext* browser_context,
+                                   content::SiteInstance* current_instance,
+                                   const GURL& dest_url);
+  // Add/remove a process id to `sandboxed_renderers_`.
+  void AddSandboxedRendererId(int process_id);
+  void RemoveSandboxedRendererId(int process_id);
+  bool IsRendererSandboxed(int process_id);
+
   // pending_render_process => current_render_process.
   std::map<int, int> pending_processes_;
+  // Set that contains the process ids of all sandboxed renderers
+  std::set<int> sandboxed_renderers_;
+  base::Lock sandboxed_renderers_lock_;
 
   std::unique_ptr<AtomResourceDispatcherHostDelegate>
       resource_dispatcher_host_delegate_;

atom/browser/atom_browser_context.cc

@@ -5,14 +5,16 @@
 #include "atom/browser/atom_browser_context.h"
 
 #include "atom/browser/api/atom_api_protocol.h"
+#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/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_ct_delegate.h"
 #include "atom/browser/net/atom_network_delegate.h"
-#include "atom/browser/net/atom_ssl_config_service.h"
 #include "atom/browser/net/atom_url_request_job_factory.h"
 #include "atom/browser/net/http_protocol_handler.h"
 #include "atom/browser/web_view_manager.h"
@@ -30,7 +32,9 @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_registry_simple.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/url_constants.h"
 #include "content/public/common/user_agent.h"
 #include "net/ftp/ftp_network_layer.h"
@@ -64,11 +68,13 @@ std::string RemoveWhitespace(const std::string& str) {
 
 }  // namespace
 
-AtomBrowserContext::AtomBrowserContext(
-    const std::string& partition, bool in_memory,
-    const base::DictionaryValue& options)
+AtomBrowserContext::AtomBrowserContext(const std::string& partition,
+                                       bool in_memory,
+                                       const base::DictionaryValue& options)
     : brightray::BrowserContext(partition, in_memory),
-      network_delegate_(new AtomNetworkDelegate) {
+      ct_delegate_(new AtomCTDelegate),
+      network_delegate_(new AtomNetworkDelegate),
+      cookie_delegate_(new AtomCookieDelegate) {
   // Construct user agent string.
   Browser* browser = Browser::Get();
   std::string name = RemoveWhitespace(browser->GetName());
@@ -104,6 +110,10 @@ net::NetworkDelegate* AtomBrowserContext::CreateNetworkDelegate() {
   return network_delegate_;
 }
 
+net::CookieMonsterDelegate* AtomBrowserContext::CreateCookieDelegate() {
+  return cookie_delegate();
+}
+
 std::string AtomBrowserContext::GetUserAgent() {
   return user_agent_;
 }
@@ -120,6 +130,8 @@ AtomBrowserContext::CreateURLRequestJobFactory(
   }
   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(
@@ -143,8 +155,7 @@ AtomBrowserContext::CreateURLRequestJobFactory(
       url_request_context_getter()->GetURLRequestContext()->host_resolver();
   job_factory->SetProtocolHandler(
       url::kFtpScheme,
-      base::WrapUnique(new net::FtpProtocolHandler(
-          new net::FtpNetworkLayer(host_resolver))));
+      net::FtpProtocolHandler::Create(host_resolver));
 
   return std::move(job_factory);
 }
@@ -182,11 +193,7 @@ content::PermissionManager* AtomBrowserContext::GetPermissionManager() {
 }
 
 std::unique_ptr<net::CertVerifier> AtomBrowserContext::CreateCertVerifier() {
-  return base::WrapUnique(new AtomCertVerifier);
-}
-
-net::SSLConfigService* AtomBrowserContext::CreateSSLConfigService() {
-  return new AtomSSLConfigService;
+  return base::WrapUnique(new AtomCertVerifier(ct_delegate_.get()));
 }
 
 std::vector<std::string> AtomBrowserContext::GetCookieableSchemes() {
@@ -197,6 +204,11 @@ std::vector<std::string> AtomBrowserContext::GetCookieableSchemes() {
   return default_schemes;
 }
 
+net::TransportSecurityState::RequireCTDelegate*
+AtomBrowserContext::GetRequireCTDelegate() {
+  return ct_delegate_.get();
+}
+
 void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
   pref_registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory,
                                       base::FilePath());
@@ -207,6 +219,19 @@ void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
   pref_registry->RegisterDictionaryPref(prefs::kDevToolsFileSystemPaths);
 }
 
+AtomBlobReader* AtomBrowserContext::GetBlobReader() {
+  if (!blob_reader_.get()) {
+    content::ChromeBlobStorageContext* blob_context =
+        content::ChromeBlobStorageContext::GetFor(this);
+    storage::FileSystemContext* file_system_context =
+        content::BrowserContext::GetStoragePartition(
+            this, nullptr)->GetFileSystemContext();
+    blob_reader_.reset(new AtomBlobReader(blob_context,
+                                          file_system_context));
+  }
+  return blob_reader_.get();
+}
+
 // static
 scoped_refptr<AtomBrowserContext> AtomBrowserContext::From(
     const std::string& partition, bool in_memory,

atom/browser/atom_browser_context.h

@@ -8,10 +8,14 @@
 #include <string>
 #include <vector>
 
+#include "atom/browser/net/atom_cookie_delegate.h"
 #include "brightray/browser/browser_context.h"
+#include "net/cookies/cookie_monster.h"
 
 namespace atom {
 
+class AtomBlobReader;
+class AtomCTDelegate;
 class AtomDownloadManagerDelegate;
 class AtomNetworkDelegate;
 class AtomPermissionManager;
@@ -30,14 +34,16 @@ class AtomBrowserContext : public brightray::BrowserContext {
 
   // brightray::URLRequestContextGetter::Delegate:
   net::NetworkDelegate* CreateNetworkDelegate() override;
+  net::CookieMonsterDelegate* CreateCookieDelegate() override;
   std::string GetUserAgent() override;
   std::unique_ptr<net::URLRequestJobFactory> CreateURLRequestJobFactory(
       content::ProtocolHandlerMap* protocol_handlers) override;
   net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
       const base::FilePath& base_path) override;
   std::unique_ptr<net::CertVerifier> CreateCertVerifier() override;
-  net::SSLConfigService* CreateSSLConfigService() override;
   std::vector<std::string> GetCookieableSchemes() override;
+  net::TransportSecurityState::RequireCTDelegate* GetRequireCTDelegate()
+      override;
 
   // content::BrowserContext:
   content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
@@ -47,7 +53,11 @@ class AtomBrowserContext : public brightray::BrowserContext {
   // brightray::BrowserContext:
   void RegisterPrefs(PrefRegistrySimple* pref_registry) override;
 
+  AtomBlobReader* GetBlobReader();
   AtomNetworkDelegate* network_delegate() const { return network_delegate_; }
+  AtomCookieDelegate* cookie_delegate() const {
+    return cookie_delegate_.get();
+  }
 
  protected:
   AtomBrowserContext(const std::string& partition, bool in_memory,
@@ -58,11 +68,14 @@ class AtomBrowserContext : public brightray::BrowserContext {
   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<AtomCTDelegate> ct_delegate_;
   std::string user_agent_;
   bool use_cache_;
 
   // Managed by brightray::BrowserContext.
   AtomNetworkDelegate* network_delegate_;
+  scoped_refptr<AtomCookieDelegate> cookie_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
 };

atom/browser/atom_browser_main_parts.cc

@@ -5,6 +5,7 @@
 #include "atom/browser/atom_browser_main_parts.h"
 
 #include "atom/browser/api/trackable_object.h"
+#include "atom/browser/atom_access_token_store.h"
 #include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/bridge_task_runner.h"
@@ -18,20 +19,39 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "content/public/browser/child_process_security_policy.h"
+#include "device/geolocation/geolocation_delegate.h"
+#include "device/geolocation/geolocation_provider.h"
 #include "v8/include/v8-debug.h"
 
 #if defined(USE_X11)
-#include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
+#include "chrome/browser/ui/libgtkui/gtk_util.h"
 #include "ui/events/devices/x11/touch_factory_x11.h"
 #endif
 
 namespace atom {
 
+namespace {
+
+// A provider of Geolocation services to override AccessTokenStore.
+class AtomGeolocationDelegate : public device::GeolocationDelegate {
+ public:
+  AtomGeolocationDelegate() = default;
+
+  scoped_refptr<device::AccessTokenStore> CreateAccessTokenStore() final {
+    return new AtomAccessTokenStore();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomGeolocationDelegate);
+};
+
 template<typename T>
 void Erase(T* container, typename T::iterator iter) {
   container->erase(iter);
 }
 
+}  // namespace
+
 // static
 AtomBrowserMainParts* AtomBrowserMainParts::self_ = nullptr;
 
@@ -115,9 +135,9 @@ void AtomBrowserMainParts::PostEarlyInitialization() {
 
   // Make sure node can get correct environment when debugging.
   if (node_debugger_->IsRunning())
-    env->AssignToContext(v8::Debug::GetDebugContext());
+    env->AssignToContext(v8::Debug::GetDebugContext(js_env_->isolate()));
 
-  // Add atom-shell extended APIs.
+  // Add Electron extended APIs.
   atom_bindings_->BindTo(js_env_->isolate(), env->process_object());
 
   // Load everything.
@@ -150,7 +170,7 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
   bridge_task_runner_ = nullptr;
 
 #if defined(USE_X11)
-  libgtk2ui::GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
+  libgtkui::GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
 #endif
 
 #if !defined(OS_MACOSX)
@@ -171,6 +191,8 @@ void AtomBrowserMainParts::PostMainMessageLoopStart() {
 #if defined(OS_POSIX)
   HandleShutdownSignals();
 #endif
+  device::GeolocationProvider::SetGeolocationDelegate(
+      new AtomGeolocationDelegate());
 }
 
 void AtomBrowserMainParts::PostMainMessageLoopRun() {

atom/browser/atom_download_manager_delegate.cc

@@ -60,7 +60,7 @@ void AtomDownloadManagerDelegate::CreateDownloadPath(
                                               std::string(),
                                               suggested_filename,
                                               mime_type,
-                                              std::string());
+                                              "download");
 
   if (!base::PathExists(default_download_path))
     base::CreateDirectory(default_download_path);
@@ -90,10 +90,11 @@ void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
   base::FilePath path;
   GetItemSavePath(item, &path);
   // Show save dialog if save path was not set already on item
-  if (path.empty() && file_dialog::ShowSaveDialog(window, item->GetURL().spec(),
-                                                  "", default_path,
-                                                  file_dialog::Filters(),
-                                                  &path)) {
+  file_dialog::DialogSettings settings;
+  settings.parent_window = window;
+  settings.title = item->GetURL().spec();
+  settings.default_path = default_path;
+  if (path.empty() && file_dialog::ShowSaveDialog(settings, &path)) {
     // Remember the last selected download directory.
     AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
         download_manager_->GetBrowserContext());

atom/browser/atom_javascript_dialog_manager.cc

@@ -5,20 +5,44 @@
 #include "atom/browser/atom_javascript_dialog_manager.h"
 
 #include <string>
+#include <vector>
 
+#include "atom/browser/native_window.h"
+#include "atom/browser/ui/message_box.h"
+#include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
+#include "ui/gfx/image/image_skia.h"
+
+using content::JavaScriptMessageType;
 
 namespace atom {
 
 void AtomJavaScriptDialogManager::RunJavaScriptDialog(
     content::WebContents* web_contents,
     const GURL& origin_url,
-    content::JavaScriptMessageType javascript_message_type,
+    JavaScriptMessageType message_type,
     const base::string16& message_text,
     const base::string16& default_prompt_text,
     const DialogClosedCallback& callback,
     bool* did_suppress_message) {
-  callback.Run(false, base::string16());
+
+  if (message_type != JavaScriptMessageType::JAVASCRIPT_MESSAGE_TYPE_ALERT &&
+      message_type != JavaScriptMessageType::JAVASCRIPT_MESSAGE_TYPE_CONFIRM) {
+    callback.Run(false, base::string16());
+    return;
+  }
+
+  std::vector<std::string> buttons = {"OK"};
+  if (message_type == JavaScriptMessageType::JAVASCRIPT_MESSAGE_TYPE_CONFIRM) {
+    buttons.push_back("Cancel");
+  }
+
+  atom::ShowMessageBox(NativeWindow::FromWebContents(web_contents),
+                       atom::MessageBoxType::MESSAGE_BOX_TYPE_NONE, buttons, -1,
+                       0, atom::MessageBoxOptions::MESSAGE_BOX_NONE, "",
+                       base::UTF16ToUTF8(message_text), "", "", false,
+                       gfx::ImageSkia(),
+                       base::Bind(&OnMessageBoxCallback, callback));
 }
 
 void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(
@@ -29,4 +53,18 @@ void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(
   callback.Run(false, base::ASCIIToUTF16("This should not be displayed"));
 }
 
+void AtomJavaScriptDialogManager::CancelDialogs(
+    content::WebContents* web_contents,
+    bool suppress_callbacks,
+    bool reset_state) {
+}
+
+// static
+void AtomJavaScriptDialogManager::OnMessageBoxCallback(
+    const DialogClosedCallback& callback,
+    int code,
+    bool checkbox_checked) {
+  callback.Run(code == 0, base::string16());
+}
+
 }  // namespace atom

atom/browser/atom_javascript_dialog_manager.h

@@ -26,9 +26,14 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
       content::WebContents* web_contents,
       bool is_reload,
       const DialogClosedCallback& callback) override;
-  void CancelActiveAndPendingDialogs(
-      content::WebContents* web_contents) override {}
-  void ResetDialogState(content::WebContents* web_contents) override {};
+  void CancelDialogs(content::WebContents* web_contents,
+                     bool suppress_callbacks,
+                     bool reset_state) override;
+
+ private:
+  static void OnMessageBoxCallback(const DialogClosedCallback& callback,
+                                   int code,
+                                   bool checkbox_checked);
 };
 
 }  // namespace atom

atom/browser/atom_permission_manager.cc

@@ -26,10 +26,52 @@ bool WebContentsDestroyed(int process_id) {
   return contents->IsBeingDestroyed();
 }
 
+void PermissionRequestResponseCallbackWrapper(
+    const AtomPermissionManager::StatusCallback& callback,
+    const std::vector<blink::mojom::PermissionStatus>& vector) {
+  callback.Run(vector[0]);
+}
+
 }  // namespace
 
-AtomPermissionManager::AtomPermissionManager()
-    : request_id_(0) {
+class AtomPermissionManager::PendingRequest {
+ public:
+  PendingRequest(content::RenderFrameHost* render_frame_host,
+                 const std::vector<content::PermissionType>& permissions,
+                 const StatusesCallback& callback)
+      : render_process_id_(render_frame_host->GetProcess()->GetID()),
+        callback_(callback),
+        results_(permissions.size(), blink::mojom::PermissionStatus::DENIED),
+        remaining_results_(permissions.size()) {}
+
+  void SetPermissionStatus(int permission_id,
+                           blink::mojom::PermissionStatus status) {
+    DCHECK(!IsComplete());
+
+    results_[permission_id] = status;
+    --remaining_results_;
+  }
+
+  int render_process_id() const {
+    return render_process_id_;
+  }
+
+  bool IsComplete() const {
+    return remaining_results_ == 0;
+  }
+
+  void RunCallback() const {
+    callback_.Run(results_);
+  }
+
+ private:
+  int render_process_id_;
+  const StatusesCallback callback_;
+  std::vector<blink::mojom::PermissionStatus> results_;
+  size_t remaining_results_;
+};
+
+AtomPermissionManager::AtomPermissionManager() {
 }
 
 AtomPermissionManager::~AtomPermissionManager() {
@@ -37,12 +79,14 @@ AtomPermissionManager::~AtomPermissionManager() {
 
 void AtomPermissionManager::SetPermissionRequestHandler(
     const RequestHandler& handler) {
-  if (handler.is_null() && !pending_requests_.empty()) {
-    for (const auto& request : pending_requests_) {
-      if (!WebContentsDestroyed(request.second.render_process_id))
-        request.second.callback.Run(blink::mojom::PermissionStatus::DENIED);
+  if (handler.is_null() && !pending_requests_.IsEmpty()) {
+    for (PendingRequestsMap::const_iterator iter(&pending_requests_);
+         !iter.IsAtEnd(); iter.Advance()) {
+      auto request = iter.GetCurrentValue();
+      if (!WebContentsDestroyed(request->render_process_id()))
+        request->RunCallback();
     }
-    pending_requests_.clear();
+    pending_requests_.Clear();
   }
   request_handler_ = handler;
 }
@@ -51,71 +95,83 @@ int AtomPermissionManager::RequestPermission(
     content::PermissionType permission,
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
-    const ResponseCallback& response_callback) {
-  int process_id = render_frame_host->GetProcess()->GetID();
-
-  if (permission == content::PermissionType::MIDI_SYSEX) {
-    content::ChildProcessSecurityPolicy::GetInstance()->
-        GrantSendMidiSysExMessage(process_id);
-  }
-
-  if (!request_handler_.is_null()) {
-    auto web_contents =
-        content::WebContents::FromRenderFrameHost(render_frame_host);
-    ++request_id_;
-    auto callback = base::Bind(&AtomPermissionManager::OnPermissionResponse,
-                               base::Unretained(this),
-                               request_id_,
-                               requesting_origin,
-                               response_callback);
-    pending_requests_[request_id_] = { process_id, callback };
-    request_handler_.Run(web_contents, permission, callback);
-    return request_id_;
-  }
-
-  response_callback.Run(blink::mojom::PermissionStatus::GRANTED);
-  return kNoPendingOperation;
+    bool user_gesture,
+    const StatusCallback& response_callback) {
+  return RequestPermissions(
+      std::vector<content::PermissionType>(1, permission),
+      render_frame_host,
+      requesting_origin,
+      user_gesture,
+      base::Bind(&PermissionRequestResponseCallbackWrapper, response_callback));
 }
 
 int AtomPermissionManager::RequestPermissions(
     const std::vector<content::PermissionType>& permissions,
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
-    const base::Callback<void(
-    const std::vector<blink::mojom::PermissionStatus>&)>& callback) {
-  // FIXME(zcbenz): Just ignore multiple permissions request for now.
-  std::vector<blink::mojom::PermissionStatus> permissionStatuses;
-  for (auto permission : permissions) {
+    bool user_gesture,
+    const StatusesCallback& response_callback) {
+  if (permissions.empty()) {
+    response_callback.Run(std::vector<blink::mojom::PermissionStatus>());
+    return kNoPendingOperation;
+  }
+
+  if (request_handler_.is_null()) {
+    std::vector<blink::mojom::PermissionStatus> statuses;
+    for (auto permission : permissions) {
+      if (permission == content::PermissionType::MIDI_SYSEX) {
+        content::ChildProcessSecurityPolicy::GetInstance()->
+            GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID());
+      }
+      statuses.push_back(blink::mojom::PermissionStatus::GRANTED);
+    }
+    response_callback.Run(statuses);
+    return kNoPendingOperation;
+  }
+
+  auto web_contents =
+      content::WebContents::FromRenderFrameHost(render_frame_host);
+  int request_id = pending_requests_.Add(new PendingRequest(
+      render_frame_host, permissions, response_callback));
+
+  for (size_t i = 0; i < permissions.size(); ++i) {
+    auto permission = permissions[i];
     if (permission == content::PermissionType::MIDI_SYSEX) {
       content::ChildProcessSecurityPolicy::GetInstance()->
           GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID());
     }
-    permissionStatuses.push_back(blink::mojom::PermissionStatus::GRANTED);
+    const auto callback =
+        base::Bind(&AtomPermissionManager::OnPermissionResponse,
+                   base::Unretained(this), request_id, i);
+    request_handler_.Run(web_contents, permission, callback);
   }
-  callback.Run(permissionStatuses);
-  return kNoPendingOperation;
+
+  return request_id;
 }
 
 void AtomPermissionManager::OnPermissionResponse(
     int request_id,
-    const GURL& origin,
-    const ResponseCallback& callback,
+    int permission_id,
     blink::mojom::PermissionStatus status) {
-  auto request = pending_requests_.find(request_id);
-  if (request != pending_requests_.end()) {
-    if (!WebContentsDestroyed(request->second.render_process_id))
-      callback.Run(status);
-    pending_requests_.erase(request);
+  auto pending_request = pending_requests_.Lookup(request_id);
+  if (!pending_request)
+    return;
+
+  pending_request->SetPermissionStatus(permission_id, status);
+  if (pending_request->IsComplete()) {
+    pending_request->RunCallback();
+    pending_requests_.Remove(request_id);
   }
 }
 
 void AtomPermissionManager::CancelPermissionRequest(int request_id) {
-  auto request = pending_requests_.find(request_id);
-  if (request != pending_requests_.end()) {
-    if (!WebContentsDestroyed(request->second.render_process_id))
-      request->second.callback.Run(blink::mojom::PermissionStatus::DENIED);
-    pending_requests_.erase(request);
-  }
+  auto pending_request = pending_requests_.Lookup(request_id);
+  if (!pending_request)
+    return;
+
+  if (!WebContentsDestroyed(pending_request->render_process_id()))
+    pending_request->RunCallback();
+  pending_requests_.Remove(request_id);
 }
 
 void AtomPermissionManager::ResetPermission(
@@ -141,7 +197,7 @@ int AtomPermissionManager::SubscribePermissionStatusChange(
     content::PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
-    const ResponseCallback& callback) {
+    const StatusCallback& callback) {
   return -1;
 }
 

atom/browser/atom_permission_manager.h

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/callback.h"
+#include "base/id_map.h"
 #include "content/public/browser/permission_manager.h"
 
 namespace content {
@@ -22,12 +23,14 @@ class AtomPermissionManager : public content::PermissionManager {
   AtomPermissionManager();
   ~AtomPermissionManager() override;
 
-  using ResponseCallback =
+  using StatusCallback =
       base::Callback<void(blink::mojom::PermissionStatus)>;
+  using StatusesCallback =
+      base::Callback<void(const std::vector<blink::mojom::PermissionStatus>&)>;
   using RequestHandler =
       base::Callback<void(content::WebContents*,
                           content::PermissionType,
-                          const ResponseCallback&)>;
+                          const StatusCallback&)>;
 
   // Handler to dispatch permission requests in JS.
   void SetPermissionRequestHandler(const RequestHandler& handler);
@@ -37,18 +40,21 @@ class AtomPermissionManager : public content::PermissionManager {
       content::PermissionType permission,
       content::RenderFrameHost* render_frame_host,
       const GURL& requesting_origin,
-      const ResponseCallback& callback) override;
+      bool user_gesture,
+      const base::Callback<void(blink::mojom::PermissionStatus)>& callback)
+      override;
   int RequestPermissions(
       const std::vector<content::PermissionType>& permissions,
       content::RenderFrameHost* render_frame_host,
       const GURL& requesting_origin,
+      bool user_gesture,
       const base::Callback<void(
-      const std::vector<blink::mojom::PermissionStatus>&)>& callback) override;
+          const std::vector<blink::mojom::PermissionStatus>&)>& callback)
+      override;
 
  protected:
   void OnPermissionResponse(int request_id,
-                            const GURL& url,
-                            const ResponseCallback& callback,
+                            int permission_id,
                             blink::mojom::PermissionStatus status);
 
   // content::PermissionManager:
@@ -72,16 +78,12 @@ class AtomPermissionManager : public content::PermissionManager {
   void UnsubscribePermissionStatusChange(int subscription_id) override;
 
  private:
-  struct RequestInfo {
-    int render_process_id;
-    ResponseCallback callback;
-  };
+  class PendingRequest;
+  using PendingRequestsMap = IDMap<PendingRequest, IDMapOwnPointer>;
 
   RequestHandler request_handler_;
 
-  std::map<int, RequestInfo> pending_requests_;
-
-  int request_id_;
+  PendingRequestsMap pending_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomPermissionManager);
 };

atom/browser/atom_resource_dispatcher_host_delegate.cc

@@ -10,8 +10,17 @@
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
+#include "net/ssl/client_cert_store.h"
 #include "url/gurl.h"
 
+#if defined(USE_NSS_CERTS)
+#include "net/ssl/client_cert_store_nss.h"
+#elif defined(OS_WIN)
+#include "net/ssl/client_cert_store_win.h"
+#elif defined(OS_MACOSX)
+#include "net/ssl/client_cert_store_mac.h"
+#endif
+
 using content::BrowserThread;
 
 namespace atom {
@@ -55,16 +64,12 @@ AtomResourceDispatcherHostDelegate::AtomResourceDispatcherHostDelegate() {
 
 bool AtomResourceDispatcherHostDelegate::HandleExternalProtocol(
     const GURL& url,
-    int child_id,
-    const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
-    bool is_main_frame,
-    ui::PageTransition transition,
-    bool has_user_gesture) {
+    content::ResourceRequestInfo* info) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&HandleExternalProtocolInUI,
                                      url,
-                                     web_contents_getter,
-                                     has_user_gesture));
+                                     info->GetWebContentsGetterForRequest(),
+                                     info->HasUserGesture()));
   return true;
 }
 
@@ -75,4 +80,19 @@ AtomResourceDispatcherHostDelegate::CreateLoginDelegate(
   return new LoginHandler(auth_info, request);
 }
 
+std::unique_ptr<net::ClientCertStore>
+AtomResourceDispatcherHostDelegate::CreateClientCertStore(
+    content::ResourceContext* resource_context) {
+  #if defined(USE_NSS_CERTS)
+    return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreNSS(
+        net::ClientCertStoreNSS::PasswordDelegateFactory()));
+  #elif defined(OS_WIN)
+    return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreWin());
+  #elif defined(OS_MACOSX)
+    return std::unique_ptr<net::ClientCertStore>(new net::ClientCertStoreMac());
+  #elif defined(USE_OPENSSL)
+    return std::unique_ptr<net::ClientCertStore>();
+  #endif
+}
+
 }  // namespace atom

atom/browser/atom_resource_dispatcher_host_delegate.h

@@ -15,16 +15,13 @@ class AtomResourceDispatcherHostDelegate
   AtomResourceDispatcherHostDelegate();
 
   // content::ResourceDispatcherHostDelegate:
-  bool HandleExternalProtocol(
-      const GURL& url,
-      int child_id,
-      const content::ResourceRequestInfo::WebContentsGetter&,
-      bool is_main_frame,
-      ui::PageTransition transition,
-      bool has_user_gesture) override;
+  bool HandleExternalProtocol(const GURL& url,
+                              content::ResourceRequestInfo* info) override;
   content::ResourceDispatcherHostLoginDelegate* CreateLoginDelegate(
       net::AuthChallengeInfo* auth_info,
       net::URLRequest* request) override;
+  std::unique_ptr<net::ClientCertStore> CreateClientCertStore(
+      content::ResourceContext* resource_context) override;
 };
 
 }  // namespace atom

atom/browser/atom_security_state_model_client.cc

@@ -1,111 +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 "atom/browser/atom_security_state_model_client.h"
-
-#include "content/public/browser/cert_store.h"
-#include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/web_contents.h"
-#include "content/public/common/origin_util.h"
-#include "content/public/common/ssl_status.h"
-#include "net/cert/x509_certificate.h"
-
-DEFINE_WEB_CONTENTS_USER_DATA_KEY(atom::AtomSecurityStateModelClient);
-
-using security_state::SecurityStateModel;
-
-namespace atom {
-
-namespace {
-
-SecurityStateModel::SecurityLevel GetSecurityLevelForSecurityStyle(
-    content::SecurityStyle style) {
-  switch (style) {
-    case content::SECURITY_STYLE_UNKNOWN:
-      return SecurityStateModel::NONE;
-    case content::SECURITY_STYLE_UNAUTHENTICATED:
-      return SecurityStateModel::NONE;
-    case content::SECURITY_STYLE_AUTHENTICATION_BROKEN:
-      return SecurityStateModel::SECURITY_ERROR;
-    case content::SECURITY_STYLE_WARNING:
-      return SecurityStateModel::SECURITY_WARNING;
-    case content::SECURITY_STYLE_AUTHENTICATED:
-      return SecurityStateModel::SECURE;
-  }
-  return SecurityStateModel::NONE;
-}
-
-}  // namespace
-
-AtomSecurityStateModelClient::AtomSecurityStateModelClient(
-    content::WebContents* web_contents)
-    : web_contents_(web_contents),
-      security_state_model_(new SecurityStateModel()) {
-  security_state_model_->SetClient(this);
-}
-
-AtomSecurityStateModelClient::~AtomSecurityStateModelClient() {
-}
-
-const SecurityStateModel::SecurityInfo&
-AtomSecurityStateModelClient::GetSecurityInfo() const {
-  return security_state_model_->GetSecurityInfo();
-}
-
-bool AtomSecurityStateModelClient::RetrieveCert(
-    scoped_refptr<net::X509Certificate>* cert) {
-  content::NavigationEntry* entry =
-      web_contents_->GetController().GetVisibleEntry();
-  if (!entry)
-    return false;
-  return content::CertStore::GetInstance()->RetrieveCert(
-      entry->GetSSL().cert_id, cert);
-}
-
-bool AtomSecurityStateModelClient::UsedPolicyInstalledCertificate() {
-  return false;
-}
-
-bool AtomSecurityStateModelClient::IsOriginSecure(const GURL& url) {
-  return content::IsOriginSecure(url);
-}
-
-void AtomSecurityStateModelClient::GetVisibleSecurityState(
-    SecurityStateModel::VisibleSecurityState* state) {
-  content::NavigationEntry* entry =
-      web_contents_->GetController().GetVisibleEntry();
-  if (!entry ||
-      entry->GetSSL().security_style == content::SECURITY_STYLE_UNKNOWN) {
-    *state = SecurityStateModel::VisibleSecurityState();
-    return;
-  }
-
-  state->initialized = true;
-  state->url = entry->GetURL();
-  const content::SSLStatus& ssl = entry->GetSSL();
-  state->initial_security_level =
-      GetSecurityLevelForSecurityStyle(ssl.security_style);
-  state->cert_id = ssl.cert_id;
-  state->cert_status = ssl.cert_status;
-  state->connection_status = ssl.connection_status;
-  state->security_bits = ssl.security_bits;
-  state->sct_verify_statuses.clear();
-  state->sct_verify_statuses.insert(state->sct_verify_statuses.end(),
-                                    ssl.num_unknown_scts,
-                                    net::ct::SCT_STATUS_LOG_UNKNOWN);
-  state->sct_verify_statuses.insert(state->sct_verify_statuses.end(),
-                                    ssl.num_invalid_scts,
-                                    net::ct::SCT_STATUS_INVALID);
-  state->sct_verify_statuses.insert(state->sct_verify_statuses.end(),
-                                    ssl.num_valid_scts, net::ct::SCT_STATUS_OK);
-  state->displayed_mixed_content =
-      (ssl.content_status & content::SSLStatus::DISPLAYED_INSECURE_CONTENT)
-          ? true
-          : false;
-  state->ran_mixed_content =
-      (ssl.content_status & content::SSLStatus::RAN_INSECURE_CONTENT) ? true
-                                                                      : false;
-}
-
-}  // namespace atom

atom/browser/atom_security_state_model_client.h

@@ -1,42 +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 ATOM_BROWSER_ATOM_SECURITY_STATE_MODEL_CLIENT_H_
-#define ATOM_BROWSER_ATOM_SECURITY_STATE_MODEL_CLIENT_H_
-
-#include "components/security_state/security_state_model.h"
-#include "components/security_state/security_state_model_client.h"
-#include "content/public/browser/web_contents_user_data.h"
-
-namespace atom {
-
-class AtomSecurityStateModelClient
-    : public security_state::SecurityStateModelClient,
-      public content::WebContentsUserData<AtomSecurityStateModelClient> {
- public:
-  ~AtomSecurityStateModelClient() override;
-
-  const security_state::SecurityStateModel::SecurityInfo&
-  GetSecurityInfo() const;
-
-  // security_state::SecurityStateModelClient:
-  void GetVisibleSecurityState(
-      security_state::SecurityStateModel::VisibleSecurityState* state) override;
-  bool RetrieveCert(scoped_refptr<net::X509Certificate>* cert) override;
-  bool UsedPolicyInstalledCertificate() override;
-  bool IsOriginSecure(const GURL& url) override;
-
- private:
-  explicit AtomSecurityStateModelClient(content::WebContents* web_contents);
-  friend class content::WebContentsUserData<AtomSecurityStateModelClient>;
-
-  content::WebContents* web_contents_;
-  std::unique_ptr<security_state::SecurityStateModel> security_state_model_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomSecurityStateModelClient);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_ATOM_SECURITY_STATE_MODEL_CLIENT_H_

atom/browser/bridge_task_runner.cc

@@ -27,7 +27,7 @@ bool BridgeTaskRunner::PostDelayedTask(
     base::TimeDelta delay) {
   auto message_loop = base::MessageLoop::current();
   if (!message_loop) {
-    tasks_.push_back(base::MakeTuple(from_here, task, delay));
+    tasks_.push_back(std::make_tuple(from_here, task, delay));
     return true;
   }
 
@@ -48,7 +48,7 @@ bool BridgeTaskRunner::PostNonNestableDelayedTask(
     base::TimeDelta delay) {
   auto message_loop = base::MessageLoop::current();
   if (!message_loop) {
-    non_nestable_tasks_.push_back(base::MakeTuple(from_here, task, delay));
+    non_nestable_tasks_.push_back(std::make_tuple(from_here, task, delay));
     return true;
   }
 

atom/browser/bridge_task_runner.h

@@ -5,6 +5,7 @@
 #ifndef ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
 #define ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
 
+#include <tuple>
 #include <vector>
 
 #include "base/single_thread_task_runner.h"
@@ -33,7 +34,7 @@ class BridgeTaskRunner : public base::SingleThreadTaskRunner {
       base::TimeDelta delay) override;
 
  private:
-  using TaskPair = base::Tuple<
+  using TaskPair = std::tuple<
       tracked_objects::Location, base::Closure, base::TimeDelta>;
   std::vector<TaskPair> tasks_;
   std::vector<TaskPair> non_nestable_tasks_;

atom/browser/browser.cc

@@ -7,11 +7,13 @@
 #include <string>
 
 #include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/browser_observer.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/window_list.h"
 #include "base/files/file_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
+#include "base/run_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "brightray/browser/brightray_paths.h"
 
 namespace atom {
@@ -82,10 +84,11 @@ void Browser::Shutdown() {
   is_shutdown_ = true;
   is_quiting_ = true;
 
-  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnQuit());
+  for (BrowserObserver& observer : observers_)
+    observer.OnQuit();
 
-  if (base::MessageLoop::current()) {
-    base::MessageLoop::current()->PostTask(
+  if (base::ThreadTaskRunnerHandle::IsSet()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   } else {
     // There is no message loop available so we are in early stage.
@@ -127,25 +130,25 @@ int Browser::GetBadgeCount() {
 
 bool Browser::OpenFile(const std::string& file_path) {
   bool prevent_default = false;
-  FOR_EACH_OBSERVER(BrowserObserver,
-                    observers_,
-                    OnOpenFile(&prevent_default, file_path));
+  for (BrowserObserver& observer : observers_)
+    observer.OnOpenFile(&prevent_default, file_path);
 
   return prevent_default;
 }
 
 void Browser::OpenURL(const std::string& url) {
-  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnOpenURL(url));
+  for (BrowserObserver& observer : observers_)
+    observer.OnOpenURL(url);
 }
 
 void Browser::Activate(bool has_visible_windows) {
-  FOR_EACH_OBSERVER(BrowserObserver,
-                    observers_,
-                    OnActivate(has_visible_windows));
+  for (BrowserObserver& observer : observers_)
+    observer.OnActivate(has_visible_windows);
 }
 
 void Browser::WillFinishLaunching() {
-  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWillFinishLaunching());
+  for (BrowserObserver& observer : observers_)
+    observer.OnWillFinishLaunching();
 }
 
 void Browser::DidFinishLaunching(const base::DictionaryValue& launch_info) {
@@ -155,22 +158,20 @@ void Browser::DidFinishLaunching(const base::DictionaryValue& launch_info) {
     base::CreateDirectoryAndGetError(user_data, nullptr);
 
   is_ready_ = true;
-  FOR_EACH_OBSERVER(BrowserObserver, observers_,
-    OnFinishLaunching(launch_info));
+  for (BrowserObserver& observer : observers_)
+    observer.OnFinishLaunching(launch_info);
 }
 
 void Browser::OnAccessibilitySupportChanged() {
-  FOR_EACH_OBSERVER(BrowserObserver,
-                    observers_,
-                    OnAccessibilitySupportChanged());
+  for (BrowserObserver& observer : observers_)
+    observer.OnAccessibilitySupportChanged();
 }
 
 void Browser::RequestLogin(
     LoginHandler* login_handler,
     std::unique_ptr<base::DictionaryValue> request_details) {
-  FOR_EACH_OBSERVER(BrowserObserver,
-                    observers_,
-                    OnLogin(login_handler, *(request_details.get())));
+  for (BrowserObserver& observer : observers_)
+    observer.OnLogin(login_handler, *(request_details.get()));
 }
 
 void Browser::NotifyAndShutdown() {
@@ -178,7 +179,8 @@ void Browser::NotifyAndShutdown() {
     return;
 
   bool prevent_default = false;
-  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWillQuit(&prevent_default));
+  for (BrowserObserver& observer : observers_)
+    observer.OnWillQuit(&prevent_default);
 
   if (prevent_default) {
     is_quiting_ = false;
@@ -190,9 +192,8 @@ void Browser::NotifyAndShutdown() {
 
 bool Browser::HandleBeforeQuit() {
   bool prevent_default = false;
-  FOR_EACH_OBSERVER(BrowserObserver,
-                    observers_,
-                    OnBeforeQuit(&prevent_default));
+  for (BrowserObserver& observer : observers_)
+    observer.OnBeforeQuit(&prevent_default);
 
   return !prevent_default;
 }
@@ -205,12 +206,14 @@ void Browser::OnWindowCloseCancelled(NativeWindow* window) {
 }
 
 void Browser::OnWindowAllClosed() {
-  if (is_exiting_)
+  if (is_exiting_) {
     Shutdown();
-  else if (is_quiting_)
+  } else if (is_quiting_) {
     NotifyAndShutdown();
-  else
-    FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWindowAllClosed());
+  } else {
+    for (BrowserObserver& observer : observers_)
+      observer.OnWindowAllClosed();
+  }
 }
 
 }  // namespace atom

atom/browser/browser.h

@@ -14,6 +14,7 @@
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
+#include "base/values.h"
 #include "native_mate/arguments.h"
 
 #if defined(OS_WIN)
@@ -21,7 +22,6 @@
 #endif
 
 namespace base {
-class DictionaryValue;
 class FilePath;
 }
 
@@ -60,7 +60,7 @@ class Browser : public WindowListObserver {
   // Overrides the application version.
   void SetVersion(const std::string& version);
 
-  // Returns the application's name, default is just Atom-Shell.
+  // Returns the application's name, default is just Electron.
   std::string GetName() const;
 
   // Overrides the application name.
@@ -98,9 +98,11 @@ class Browser : public WindowListObserver {
     bool restore_state = false;
     bool opened_at_login = false;
     bool opened_as_hidden = false;
+    base::string16 path;
+    std::vector<base::string16> args;
   };
   void SetLoginItemSettings(LoginItemSettings settings);
-  LoginItemSettings GetLoginItemSettings();
+  LoginItemSettings GetLoginItemSettings(LoginItemSettings options);
 
 #if defined(OS_MACOSX)
   // Hide the application.
@@ -146,6 +148,9 @@ class Browser : public WindowListObserver {
 
   // Set docks' icon.
   void DockSetIcon(const gfx::Image& image);
+
+  void ShowAboutPanel();
+  void SetAboutPanelOptions(const base::DictionaryValue& options);
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_WIN)
@@ -245,6 +250,10 @@ class Browser : public WindowListObserver {
   base::string16 app_user_model_id_;
 #endif
 
+#if defined(OS_MACOSX)
+  base::DictionaryValue about_panel_options_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 

atom/browser/browser_linux.cc

@@ -10,7 +10,7 @@
 #include "atom/browser/window_list.h"
 #include "atom/common/atom_version.h"
 #include "brightray/common/application_info.h"
-#include "chrome/browser/ui/libgtk2ui/unity_service.h"
+#include "chrome/browser/ui/libgtkui/unity_service.h"
 
 namespace atom {
 
@@ -63,7 +63,8 @@ bool Browser::SetBadgeCount(int count) {
 void Browser::SetLoginItemSettings(LoginItemSettings settings) {
 }
 
-Browser::LoginItemSettings Browser::GetLoginItemSettings() {
+Browser::LoginItemSettings Browser::GetLoginItemSettings(
+    LoginItemSettings options) {
   return LoginItemSettings();
 }
 

atom/browser/browser_mac.mm

@@ -146,13 +146,13 @@ std::string Browser::GetCurrentActivityType() {
 bool Browser::ContinueUserActivity(const std::string& type,
                                    const base::DictionaryValue& user_info) {
   bool prevent_default = false;
-  FOR_EACH_OBSERVER(BrowserObserver,
-                    observers_,
-                    OnContinueUserActivity(&prevent_default, type, user_info));
+  for (BrowserObserver& observer : observers_)
+    observer.OnContinueUserActivity(&prevent_default, type, user_info);
   return prevent_default;
 }
 
-Browser::LoginItemSettings Browser::GetLoginItemSettings() {
+Browser::LoginItemSettings Browser::GetLoginItemSettings(
+    LoginItemSettings options) {
   LoginItemSettings settings;
   settings.open_at_login = base::mac::CheckLoginItemStatus(
       &settings.open_as_hidden);
@@ -253,4 +253,36 @@ void Browser::DockSetIcon(const gfx::Image& image) {
       setApplicationIconImage:image.AsNSImage()];
 }
 
+void Browser::ShowAboutPanel() {
+  NSDictionary* options = DictionaryValueToNSDictionary(about_panel_options_);
+
+  // Credits must be a NSAttributedString instead of NSString
+  id credits = options[@"Credits"];
+  if (credits != nil) {
+    NSMutableDictionary* mutable_options = [options mutableCopy];
+    mutable_options[@"Credits"] = [[[NSAttributedString alloc]
+        initWithString:(NSString*)credits] autorelease];
+    options = [NSDictionary dictionaryWithDictionary:mutable_options];
+  }
+
+  [[AtomApplication sharedApplication]
+      orderFrontStandardAboutPanelWithOptions:options];
+}
+
+void Browser::SetAboutPanelOptions(const base::DictionaryValue& options) {
+  about_panel_options_.Clear();
+
+  // Upper case option keys for orderFrontStandardAboutPanelWithOptions format
+  for (base::DictionaryValue::Iterator iter(options);
+       !iter.IsAtEnd();
+       iter.Advance()) {
+    std::string key = iter.key();
+    std::string value;
+    if (!key.empty() && iter.value().GetAsString(&value)) {
+      key[0] = base::ToUpperASCII(key[0]);
+      about_panel_options_.SetString(key, value);
+    }
+  }
+}
+
 }  // namespace atom

atom/browser/browser_win.cc

@@ -43,15 +43,19 @@ BOOL CALLBACK WindowsEnumerationHandler(HWND hwnd, LPARAM param) {
   return TRUE;
 }
 
+bool GetProcessExecPath(base::string16* exe) {
+  base::FilePath path;
+  if (!PathService::Get(base::FILE_EXE, &path)) {
+    LOG(ERROR) << "Error getting app exe path";
+    return false;
+  }
+  *exe = path.value();
+  return true;
+}
+
 bool GetProtocolLaunchPath(mate::Arguments* args, base::string16* exe) {
-  // Executable Path
-  if (!args->GetNext(exe)) {
-    base::FilePath path;
-    if (!PathService::Get(base::FILE_EXE, &path)) {
-      LOG(ERROR) << "Error getting app exe path";
-      return false;
-    }
-    *exe = path.value();
+  if (!args->GetNext(exe) && !GetProcessExecPath(exe)) {
+    return false;
   }
 
   // Read in optional args arg
@@ -65,6 +69,22 @@ bool GetProtocolLaunchPath(mate::Arguments* args, base::string16* exe) {
   return true;
 }
 
+bool FormatCommandLineString(base::string16* exe,
+                             const std::vector<base::string16>& launch_args) {
+  if (exe->empty() && !GetProcessExecPath(exe)) {
+    return false;
+  }
+
+  if (!launch_args.empty()) {
+    base::string16 formatString = L"%s %s";
+    *exe = base::StringPrintf(formatString.c_str(),
+                              exe->c_str(),
+                              base::JoinString(launch_args, L" ").c_str());
+  }
+
+  return true;
+}
+
 }  // namespace
 
 void Browser::Focus() {
@@ -257,34 +277,32 @@ void Browser::SetLoginItemSettings(LoginItemSettings settings) {
   base::win::RegKey key(HKEY_CURRENT_USER, keyPath.c_str(), KEY_ALL_ACCESS);
 
   if (settings.open_at_login) {
-    base::FilePath path;
-    if (PathService::Get(base::FILE_EXE, &path)) {
-      base::string16 exePath(path.value());
-      key.WriteValue(GetAppUserModelID(), exePath.c_str());
+    base::string16 exe = settings.path;
+    if (FormatCommandLineString(&exe, settings.args)) {
+      key.WriteValue(GetAppUserModelID(), exe.c_str());
     }
   } else {
     key.DeleteValue(GetAppUserModelID());
   }
 }
 
-Browser::LoginItemSettings Browser::GetLoginItemSettings() {
+Browser::LoginItemSettings Browser::GetLoginItemSettings(
+    LoginItemSettings options) {
   LoginItemSettings settings;
   base::string16 keyPath = L"Software\\Microsoft\\Windows\\CurrentVersion\\Run";
   base::win::RegKey key(HKEY_CURRENT_USER, keyPath.c_str(), KEY_ALL_ACCESS);
   base::string16 keyVal;
 
   if (!FAILED(key.ReadValue(GetAppUserModelID(), &keyVal))) {
-    base::FilePath path;
-    if (PathService::Get(base::FILE_EXE, &path)) {
-      base::string16 exePath(path.value());
-      settings.open_at_login = keyVal == exePath;
+    base::string16 exe = options.path;
+    if (FormatCommandLineString(&exe, options.args)) {
+      settings.open_at_login = keyVal == exe;
     }
   }
 
   return settings;
 }
 
-
 PCWSTR Browser::GetAppUserModelID() {
   if (app_user_model_id_.empty()) {
     SetAppUserModelID(base::ReplaceStringPlaceholders(

atom/browser/common_web_contents_delegate.cc

@@ -10,7 +10,6 @@
 
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_javascript_dialog_manager.h"
-#include "atom/browser/atom_security_state_model_client.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/ui/file_dialog.h"
 #include "atom/browser/web_dialog_helper.h"
@@ -18,10 +17,13 @@
 #include "base/files/file_util.h"
 #include "chrome/browser/printing/print_preview_message_handler.h"
 #include "chrome/browser/printing/print_view_manager_basic.h"
+#include "chrome/browser/ssl/security_state_tab_helper.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "components/security_state/content/content_utils.h"
+#include "components/security_state/core/security_state.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
@@ -32,7 +34,6 @@
 #include "storage/browser/fileapi/isolated_context.h"
 
 using content::BrowserThread;
-using security_state::SecurityStateModel;
 
 namespace atom {
 
@@ -93,8 +94,10 @@ FileSystem CreateFileSystemStruct(
   return FileSystem(file_system_name, root_url, file_system_path);
 }
 
-base::DictionaryValue* CreateFileSystemValue(const FileSystem& file_system) {
-  auto* file_system_value = new base::DictionaryValue();
+std::unique_ptr<base::DictionaryValue> CreateFileSystemValue(
+    const FileSystem& file_system) {
+  std::unique_ptr<base::DictionaryValue> file_system_value(
+      new base::DictionaryValue());
   file_system_value->SetString("fileSystemName", file_system.file_system_name);
   file_system_value->SetString("rootURL", file_system.root_url);
   file_system_value->SetString("fileSystemPath", file_system.file_system_path);
@@ -144,24 +147,6 @@ bool IsDevToolsFileSystemAdded(
   return file_system_paths.find(file_system_path) != file_system_paths.end();
 }
 
-content::SecurityStyle SecurityLevelToSecurityStyle(
-    SecurityStateModel::SecurityLevel security_level) {
-  switch (security_level) {
-    case SecurityStateModel::NONE:
-      return content::SECURITY_STYLE_UNAUTHENTICATED;
-    case SecurityStateModel::SECURITY_WARNING:
-    case SecurityStateModel::SECURITY_POLICY_WARNING:
-      return content::SECURITY_STYLE_WARNING;
-    case SecurityStateModel::EV_SECURE:
-    case SecurityStateModel::SECURE:
-      return content::SECURITY_STYLE_AUTHENTICATED;
-    case SecurityStateModel::SECURITY_ERROR:
-      return content::SECURITY_STYLE_AUTHENTICATION_BROKEN;
-  }
-
-  return content::SECURITY_STYLE_UNKNOWN;
-}
-
 }  // namespace
 
 CommonWebContentsDelegate::CommonWebContentsDelegate()
@@ -252,11 +237,11 @@ content::ColorChooser* CommonWebContentsDelegate::OpenColorChooser(
 }
 
 void CommonWebContentsDelegate::RunFileChooser(
-    content::WebContents* guest,
+    content::RenderFrameHost* render_frame_host,
     const content::FileChooserParams& params) {
   if (!web_dialog_helper_)
     web_dialog_helper_.reset(new WebDialogHelper(owner_window()));
-  web_dialog_helper_->RunFileChooser(guest, params);
+  web_dialog_helper_->RunFileChooser(render_frame_host, params);
 }
 
 void CommonWebContentsDelegate::EnumerateDirectory(content::WebContents* guest,
@@ -290,88 +275,16 @@ bool CommonWebContentsDelegate::IsFullscreenForTabOrPending(
   return html_fullscreen_;
 }
 
-content::SecurityStyle CommonWebContentsDelegate::GetSecurityStyle(
+blink::WebSecurityStyle CommonWebContentsDelegate::GetSecurityStyle(
     content::WebContents* web_contents,
-    content::SecurityStyleExplanations* explanations) {
-  auto model_client =
-      AtomSecurityStateModelClient::FromWebContents(web_contents);
-
-  const SecurityStateModel::SecurityInfo& security_info =
-      model_client->GetSecurityInfo();
-
-  const content::SecurityStyle security_style =
-      SecurityLevelToSecurityStyle(security_info.security_level);
-
-  explanations->ran_insecure_content_style =
-      SecurityLevelToSecurityStyle(
-          SecurityStateModel::kRanInsecureContentLevel);
-  explanations->displayed_insecure_content_style =
-      SecurityLevelToSecurityStyle(
-          SecurityStateModel::kDisplayedInsecureContentLevel);
-
-  explanations->scheme_is_cryptographic = security_info.scheme_is_cryptographic;
-  if (!security_info.scheme_is_cryptographic)
-    return security_style;
-
-  if (security_info.sha1_deprecation_status ==
-      SecurityStateModel::DEPRECATED_SHA1_MAJOR) {
-    explanations->broken_explanations.push_back(
-        content::SecurityStyleExplanation(
-            kSHA1Certificate,
-            kSHA1MajorDescription,
-            security_info.cert_id));
-  } else if (security_info.sha1_deprecation_status ==
-                SecurityStateModel::DEPRECATED_SHA1_MINOR) {
-    explanations->unauthenticated_explanations.push_back(
-        content::SecurityStyleExplanation(
-            kSHA1Certificate,
-            kSHA1MinorDescription,
-            security_info.cert_id));
-  }
-
-  explanations->ran_insecure_content =
-      security_info.mixed_content_status ==
-          SecurityStateModel::RAN_MIXED_CONTENT ||
-      security_info.mixed_content_status ==
-          SecurityStateModel::RAN_AND_DISPLAYED_MIXED_CONTENT;
-  explanations->displayed_insecure_content =
-      security_info.mixed_content_status ==
-          SecurityStateModel::DISPLAYED_MIXED_CONTENT ||
-      security_info.mixed_content_status ==
-          SecurityStateModel::RAN_AND_DISPLAYED_MIXED_CONTENT;
-
-  if (net::IsCertStatusError(security_info.cert_status)) {
-    std::string error_string = net::ErrorToString(
-        net::MapCertStatusToNetError(security_info.cert_status));
-
-    content::SecurityStyleExplanation explanation(
-        kCertificateError,
-        "There are issues with the site's certificate chain " + error_string,
-        security_info.cert_id);
-
-    if (net::IsCertStatusMinorError(security_info.cert_status))
-      explanations->unauthenticated_explanations.push_back(explanation);
-    else
-      explanations->broken_explanations.push_back(explanation);
-  } else {
-    if (security_info.sha1_deprecation_status ==
-        SecurityStateModel::NO_DEPRECATED_SHA1) {
-      explanations->secure_explanations.push_back(
-          content::SecurityStyleExplanation(
-              kValidCertificate,
-              kValidCertificateDescription,
-              security_info.cert_id));
-    }
-  }
-
-  if (security_info.is_secure_protocol_and_ciphersuite) {
-    explanations->secure_explanations.push_back(
-        content::SecurityStyleExplanation(
-            kSecureProtocol,
-            kSecureProtocolDescription));
-  }
-
-  return security_style;
+    content::SecurityStyleExplanations* security_style_explanations) {
+  SecurityStateTabHelper* helper =
+      SecurityStateTabHelper::FromWebContents(web_contents);
+  DCHECK(helper);
+  security_state::SecurityInfo security_info;
+  helper->GetSecurityInfo(&security_info);
+  return security_state::GetSecurityStyle(security_info,
+                                          security_style_explanations);
 }
 
 void CommonWebContentsDelegate::DevToolsSaveToFile(
@@ -381,10 +294,11 @@ void CommonWebContentsDelegate::DevToolsSaveToFile(
   if (it != saved_files_.end() && !save_as) {
     path = it->second;
   } else {
-    file_dialog::Filters filters;
-    base::FilePath default_path(base::FilePath::FromUTF8Unsafe(url));
-    if (!file_dialog::ShowSaveDialog(owner_window(), url, "", default_path,
-                                     filters, &path)) {
+    file_dialog::DialogSettings settings;
+    settings.parent_window = owner_window();
+    settings.title = url;
+    settings.default_path = base::FilePath::FromUTF8Unsafe(url);
+    if (!file_dialog::ShowSaveDialog(settings, &path)) {
       base::StringValue url_value(url);
       web_contents_->CallClientFunction(
           "DevToolsAPI.canceledSaveURL", &url_value, nullptr, nullptr);
@@ -445,12 +359,11 @@ void CommonWebContentsDelegate::DevToolsAddFileSystem(
     const base::FilePath& file_system_path) {
   base::FilePath path = file_system_path;
   if (path.empty()) {
-    file_dialog::Filters filters;
-    base::FilePath default_path;
     std::vector<base::FilePath> paths;
-    int flag = file_dialog::FILE_DIALOG_OPEN_DIRECTORY;
-    if (!file_dialog::ShowOpenDialog(owner_window(), "", "", default_path,
-                                     filters, flag, &paths))
+    file_dialog::DialogSettings settings;
+    settings.parent_window = owner_window();
+    settings.properties = file_dialog::FILE_DIALOG_OPEN_DIRECTORY;
+    if (!file_dialog::ShowOpenDialog(settings, &paths))
       return;
 
     path = paths[0];

atom/browser/common_web_contents_delegate.h

@@ -71,7 +71,7 @@ class CommonWebContentsDelegate
       content::WebContents* web_contents,
       SkColor color,
       const std::vector<content::ColorSuggestion>& suggestions) override;
-  void RunFileChooser(content::WebContents* web_contents,
+  void RunFileChooser(content::RenderFrameHost* render_frame_host,
                       const content::FileChooserParams& params) override;
   void EnumerateDirectory(content::WebContents* web_contents,
                           int request_id,
@@ -81,7 +81,7 @@ class CommonWebContentsDelegate
   void ExitFullscreenModeForTab(content::WebContents* source) override;
   bool IsFullscreenForTabOrPending(
       const content::WebContents* source) const override;
-  content::SecurityStyle GetSecurityStyle(
+  blink::WebSecurityStyle GetSecurityStyle(
       content::WebContents* web_contents,
       content::SecurityStyleExplanations* explanations) override;
   void HandleKeyboardEvent(

atom/browser/lib/bluetooth_chooser.cc

@@ -89,8 +89,12 @@ void BluetoothChooser::ShowDiscoveryState(DiscoveryState state) {
   }
 }
 
-void BluetoothChooser::AddDevice(const std::string& device_id,
-                                 const base::string16& device_name) {
+void BluetoothChooser::AddOrUpdateDevice(const std::string& device_id,
+                                         bool should_update_name,
+                                         const base::string16& device_name,
+                                         bool is_gatt_connected,
+                                         bool is_paired,
+                                         int signal_strength_level) {
   DeviceInfo info = {device_id, device_name};
   device_list_.push_back(info);
 }

atom/browser/lib/bluetooth_chooser.h

@@ -27,8 +27,12 @@ class BluetoothChooser : public content::BluetoothChooser {
   // content::BluetoothChooser:
   void SetAdapterPresence(AdapterPresence presence) override;
   void ShowDiscoveryState(DiscoveryState state) override;
-  void AddDevice(const std::string& device_id,
-                 const base::string16& device_name) override;
+  void AddOrUpdateDevice(const std::string& device_id,
+                         bool should_update_name,
+                         const base::string16& device_name,
+                         bool is_gatt_connected,
+                         bool is_paired,
+                         int signal_strength_level) override;
   void RemoveDevice(const std::string& device_id) override;
 
  private:

atom/browser/mac/atom_application.mm

@@ -87,4 +87,8 @@
   atom::Browser::Get()->OnAccessibilitySupportChanged();
 }
 
+- (void)orderFrontStandardAboutPanel:(id)sender {
+  atom::Browser::Get()->ShowAboutPanel();
+}
+
 @end

atom/browser/mac/atom_application_delegate.mm

@@ -10,6 +10,10 @@
 #include "base/strings/sys_string_conversions.h"
 #include "base/values.h"
 
+@interface NSWindow (SierraSDK)
+@property(class) BOOL allowsAutomaticWindowTabbing;
+@end
+
 @implementation AtomApplicationDelegate
 
 - (void)setApplicationDockMenu:(atom::AtomMenuModel*)model {
@@ -21,6 +25,10 @@
   // Don't add the "Enter Full Screen" menu item automatically.
   [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"NSFullScreenMenuItemEverywhere"];
 
+  // Don't add the "Show Tab Bar" menu item.
+  if ([NSWindow respondsToSelector:@selector(allowsAutomaticWindowTabbing)])
+    NSWindow.allowsAutomaticWindowTabbing = NO;
+
   atom::Browser::Get()->WillFinishLaunching();
 }
 

atom/browser/mac/dict_util.h

@@ -16,13 +16,15 @@ class DictionaryValue;
 
 namespace atom {
 
+NSArray* ListValueToNSArray(const base::ListValue& value);
+
+std::unique_ptr<base::ListValue> NSArrayToListValue(NSArray* arr);
+
 NSDictionary* DictionaryValueToNSDictionary(const base::DictionaryValue& value);
 
 std::unique_ptr<base::DictionaryValue> NSDictionaryToDictionaryValue(
     NSDictionary* dict);
 
-std::unique_ptr<base::ListValue> NSArrayToListValue(NSArray* arr);
-
 }  // namespace atom
 
 #endif  // ATOM_BROWSER_MAC_DICT_UTIL_H_

atom/browser/mac/dict_util.mm

@@ -10,6 +10,18 @@
 
 namespace atom {
 
+NSArray* ListValueToNSArray(const base::ListValue& value) {
+  std::string json;
+  if (!base::JSONWriter::Write(value, &json))
+    return nil;
+  NSData* jsonData = [NSData dataWithBytes:json.c_str() length:json.length()];
+  id obj =
+      [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:nil];
+  if (![obj isKindOfClass:[NSArray class]])
+    return nil;
+  return obj;
+}
+
 std::unique_ptr<base::ListValue> NSArrayToListValue(NSArray* arr) {
   if (!arr)
     return nullptr;

atom/browser/native_window.cc

@@ -20,6 +20,7 @@
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "brightray/browser/inspectable_web_contents.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
 #include "components/prefs/pref_service.h"
@@ -33,6 +34,7 @@
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_message_macros.h"
 #include "native_mate/dictionary.h"
+#include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
@@ -332,6 +334,12 @@ void NativeWindow::SetParentWindow(NativeWindow* parent) {
   parent_ = parent;
 }
 
+void NativeWindow::SetAutoHideCursor(bool auto_hide) {
+}
+
+void NativeWindow::SetVibrancy(const std::string& filename) {
+}
+
 void NativeWindow::FocusOnWebView() {
   web_contents()->GetRenderViewHost()->GetWidget()->Focus();
 }
@@ -373,11 +381,17 @@ void NativeWindow::SetAspectRatio(double aspect_ratio,
   aspect_ratio_extraSize_ = extra_size;
 }
 
+void NativeWindow::PreviewFile(const std::string& path,
+                               const std::string& display_name) {
+}
+
+void NativeWindow::CloseFilePreview() {
+}
+
 void NativeWindow::RequestToClosePage() {
   bool prevent_default = false;
-  FOR_EACH_OBSERVER(NativeWindowObserver,
-                    observers_,
-                    WillCloseWindow(&prevent_default));
+  for (NativeWindowObserver& observer : observers_)
+    observer.WillCloseWindow(&prevent_default);
   if (prevent_default) {
     WindowList::WindowCloseCancelled(this);
     return;
@@ -390,6 +404,10 @@ void NativeWindow::RequestToClosePage() {
   if (window_unresposive_closure_.IsCancelled())
     ScheduleUnresponsiveEvent(5000);
 
+  if (!web_contents())
+    // Already closed by renderer
+    return;
+
   if (web_contents()->NeedToFireBeforeUnload())
     web_contents()->DispatchBeforeUnload();
   else
@@ -404,8 +422,8 @@ void NativeWindow::CloseContents(content::WebContents* source) {
   inspectable_web_contents_ = nullptr;
   Observe(nullptr);
 
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    WillDestroyNativeObject());
+  for (NativeWindowObserver& observer : observers_)
+    observer.WillDestroyNativeObject();
 
   // When the web contents is gone, close the window immediately, but the
   // memory will not be freed until you call delete.
@@ -431,7 +449,8 @@ void NativeWindow::RendererUnresponsive(content::WebContents* source) {
 
 void NativeWindow::RendererResponsive(content::WebContents* source) {
   window_unresposive_closure_.Cancel();
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererResponsive());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnRendererResponsive();
 }
 
 void NativeWindow::NotifyWindowClosed() {
@@ -441,99 +460,116 @@ void NativeWindow::NotifyWindowClosed() {
   WindowList::RemoveWindow(this);
 
   is_closed_ = true;
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowClosed());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowClosed();
 }
 
 void NativeWindow::NotifyWindowBlur() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowBlur());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowBlur();
 }
 
 void NativeWindow::NotifyWindowFocus() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowFocus());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowFocus();
 }
 
 void NativeWindow::NotifyWindowShow() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowShow());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowShow();
 }
 
 void NativeWindow::NotifyWindowHide() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowHide());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowHide();
 }
 
 void NativeWindow::NotifyWindowMaximize() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowMaximize());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowMaximize();
 }
 
 void NativeWindow::NotifyWindowUnmaximize() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowUnmaximize());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowUnmaximize();
 }
 
 void NativeWindow::NotifyWindowMinimize() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowMinimize());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowMinimize();
 }
 
 void NativeWindow::NotifyWindowRestore() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowRestore());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowRestore();
 }
 
 void NativeWindow::NotifyWindowResize() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowResize());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowResize();
 }
 
 void NativeWindow::NotifyWindowMove() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowMove());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowMove();
 }
 
 void NativeWindow::NotifyWindowMoved() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowMoved());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowMoved();
 }
 
 void NativeWindow::NotifyWindowEnterFullScreen() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnWindowEnterFullScreen());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowEnterFullScreen();
 }
 
 void NativeWindow::NotifyWindowScrollTouchBegin() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnWindowScrollTouchBegin());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowScrollTouchBegin();
 }
 
 void NativeWindow::NotifyWindowScrollTouchEnd() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnWindowScrollTouchEnd());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowScrollTouchEnd();
+}
+
+void NativeWindow::NotifyWindowScrollTouchEdge() {
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowScrollTouchEdge();
 }
 
 void NativeWindow::NotifyWindowSwipe(const std::string& direction) {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnWindowSwipe(direction));
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowSwipe(direction);
 }
 
 void NativeWindow::NotifyWindowLeaveFullScreen() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnWindowLeaveFullScreen());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowLeaveFullScreen();
 }
 
 void NativeWindow::NotifyWindowEnterHtmlFullScreen() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnWindowEnterHtmlFullScreen());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowEnterHtmlFullScreen();
 }
 
 void NativeWindow::NotifyWindowLeaveHtmlFullScreen() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnWindowLeaveHtmlFullScreen());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowLeaveHtmlFullScreen();
 }
 
 void NativeWindow::NotifyWindowExecuteWindowsCommand(
     const std::string& command) {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnExecuteWindowsCommand(command));
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnExecuteWindowsCommand(command);
 }
 
 #if defined(OS_WIN)
 void NativeWindow::NotifyWindowMessage(
     UINT message, WPARAM w_param, LPARAM l_param) {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnWindowMessage(message, w_param, l_param));
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnWindowMessage(message, w_param, l_param);
 }
 #endif
 
@@ -581,7 +617,7 @@ void NativeWindow::DidFirstVisuallyNonEmptyPaint() {
   view->SetSize(GetContentSize());
 
   // Emit the ReadyToShow event in next tick in case of pending drawing work.
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&NativeWindow::NotifyReadyToShow, GetWeakPtr()));
 }
@@ -612,7 +648,7 @@ void NativeWindow::ScheduleUnresponsiveEvent(int ms) {
   window_unresposive_closure_.Reset(
       base::Bind(&NativeWindow::NotifyWindowUnresponsive,
                  weak_factory_.GetWeakPtr()));
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       window_unresposive_closure_.callback(),
       base::TimeDelta::FromMilliseconds(ms));
@@ -621,14 +657,15 @@ void NativeWindow::ScheduleUnresponsiveEvent(int ms) {
 void NativeWindow::NotifyWindowUnresponsive() {
   window_unresposive_closure_.Cancel();
 
-  if (!is_closed_ && !IsUnresponsiveEventSuppressed() && IsEnabled())
-    FOR_EACH_OBSERVER(NativeWindowObserver,
-                      observers_,
-                      OnRendererUnresponsive());
+  if (!is_closed_ && !IsUnresponsiveEventSuppressed() && IsEnabled()) {
+    for (NativeWindowObserver& observer : observers_)
+      observer.OnRendererUnresponsive();
+  }
 }
 
 void NativeWindow::NotifyReadyToShow() {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnReadyToShow());
+  for (NativeWindowObserver& observer : observers_)
+    observer.OnReadyToShow();
 }
 
 }  // namespace atom

atom/browser/native_window.h

@@ -118,9 +118,13 @@ class NativeWindow : public base::SupportsUserData,
   virtual bool IsFullScreenable() = 0;
   virtual void SetClosable(bool closable) = 0;
   virtual bool IsClosable() = 0;
-  virtual void SetAlwaysOnTop(bool top) = 0;
+  virtual void SetAlwaysOnTop(bool top,
+                              const std::string& level = "floating",
+                              int relativeLevel = 0,
+                              std::string* error = nullptr) = 0;
   virtual bool IsAlwaysOnTop() = 0;
   virtual void Center() = 0;
+  virtual void Invalidate() = 0;
   virtual void SetTitle(const std::string& title) = 0;
   virtual std::string GetTitle() = 0;
   virtual void FlashFrame(bool flash) = 0;
@@ -160,6 +164,11 @@ class NativeWindow : public base::SupportsUserData,
   virtual void SetVisibleOnAllWorkspaces(bool visible) = 0;
   virtual bool IsVisibleOnAllWorkspaces() = 0;
 
+  virtual void SetAutoHideCursor(bool auto_hide);
+
+  // Vibrancy API
+  virtual void SetVibrancy(const std::string& type);
+
   // Webview APIs.
   virtual void FocusOnWebView();
   virtual void BlurWebView();
@@ -176,6 +185,11 @@ class NativeWindow : public base::SupportsUserData,
   gfx::Size GetAspectRatioExtraSize();
   virtual void SetAspectRatio(double aspect_ratio, const gfx::Size& extra_size);
 
+  // File preview APIs.
+  virtual void PreviewFile(const std::string& path,
+                           const std::string& display_name);
+  virtual void CloseFilePreview();
+
   base::WeakPtr<NativeWindow> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
@@ -207,6 +221,7 @@ class NativeWindow : public base::SupportsUserData,
   void NotifyWindowMoved();
   void NotifyWindowScrollTouchBegin();
   void NotifyWindowScrollTouchEnd();
+  void NotifyWindowScrollTouchEdge();
   void NotifyWindowSwipe(const std::string& direction);
   void NotifyWindowEnterFullScreen();
   void NotifyWindowLeaveFullScreen();

atom/browser/native_window_mac.h

@@ -55,6 +55,9 @@ class NativeWindowMac : public NativeWindow,
   void SetMovable(bool movable) override;
   void SetAspectRatio(double aspect_ratio, const gfx::Size& extra_size)
     override;
+  void PreviewFile(const std::string& path, const std::string& display_name)
+    override;
+  void CloseFilePreview() override;
   bool IsMovable() override;
   void SetMinimizable(bool minimizable) override;
   bool IsMinimizable() override;
@@ -64,9 +67,11 @@ class NativeWindowMac : public NativeWindow,
   bool IsFullScreenable() override;
   void SetClosable(bool closable) override;
   bool IsClosable() override;
-  void SetAlwaysOnTop(bool top) override;
+  void SetAlwaysOnTop(bool top, const std::string& level,
+                      int relativeLevel, std::string* error) override;
   bool IsAlwaysOnTop() override;
   void Center() override;
+  void Invalidate() override;
   void SetTitle(const std::string& title) override;
   std::string GetTitle() override;
   void FlashFrame(bool flash) override;
@@ -88,9 +93,14 @@ class NativeWindowMac : public NativeWindow,
   void SetProgressBar(double progress, const ProgressState state) override;
   void SetOverlayIcon(const gfx::Image& overlay,
                       const std::string& description) override;
+
   void SetVisibleOnAllWorkspaces(bool visible) override;
   bool IsVisibleOnAllWorkspaces() override;
 
+  void SetAutoHideCursor(bool auto_hide) override;
+
+  void SetVibrancy(const std::string& type) override;
+
   // content::RenderWidgetHost::InputEventObserver:
   void OnInputEvent(const blink::WebInputEvent& event) override;
 
@@ -114,6 +124,8 @@ class NativeWindowMac : public NativeWindow,
   };
   TitleBarStyle title_bar_style() const { return title_bar_style_; }
 
+  bool zoom_to_page_width() const { return zoom_to_page_width_; }
+
  protected:
   // Return a vector of non-draggable regions that fill a window of size
   // |width| by |height|, but leave gaps where the window should be draggable.
@@ -152,6 +164,10 @@ class NativeWindowMac : public NativeWindow,
 
   bool is_kiosk_;
 
+  bool was_fullscreen_;
+
+  bool zoom_to_page_width_;
+
   NSInteger attention_request_id_;  // identifier from requestUserAttention
 
   // The presentation options before entering kiosk mode.
@@ -160,9 +176,6 @@ class NativeWindowMac : public NativeWindow,
   // The "titleBarStyle" option.
   TitleBarStyle title_bar_style_;
 
-  // Whether user has scrolled the page to edge.
-  bool is_edge_;
-
   DISALLOW_COPY_AND_ASSIGN(NativeWindowMac);
 };
 

atom/browser/native_window_mac.mm

@@ -4,6 +4,7 @@
 
 #include "atom/browser/native_window_mac.h"
 
+#include <Quartz/Quartz.h>
 #include <string>
 
 #include "atom/browser/window_list.h"
@@ -22,6 +23,7 @@
 #include "content/public/browser/render_widget_host_view.h"
 #include "native_mate/dictionary.h"
 #include "skia/ext/skia_utils_mac.h"
+#include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/skia_util.h"
 
 namespace {
@@ -100,6 +102,41 @@ bool ScopedDisableResize::disable_resize_ = false;
    }
 }
 
+// Called when the user clicks the zoom button or selects it from the Window
+// menu to determine the "standard size" of the window.
+- (NSRect)windowWillUseStandardFrame:(NSWindow*)window
+                        defaultFrame:(NSRect)frame {
+  if (!shell_->zoom_to_page_width())
+    return frame;
+
+  // If the shift key is down, maximize.
+  if ([[NSApp currentEvent] modifierFlags] & NSShiftKeyMask)
+    return frame;
+
+  content::WebContents* web_contents = shell_->web_contents();
+  if (!web_contents)
+    return frame;
+
+  CGFloat page_width = static_cast<CGFloat>(
+      web_contents->GetPreferredSize().width());
+  NSRect window_frame = [window frame];
+
+  // Never shrink from the current size on zoom.
+  CGFloat zoomed_width = std::max(page_width, NSWidth(window_frame));
+
+  // |frame| determines our maximum extents. We need to set the origin of the
+  // frame -- and only move it left if necessary.
+  if (window_frame.origin.x + zoomed_width > NSMaxX(frame))
+    frame.origin.x = NSMaxX(frame) - zoomed_width;
+  else
+    frame.origin.x = window_frame.origin.x;
+
+  // Set the width. Don't touch y or height.
+  frame.size.width = zoomed_width;
+
+  return frame;
+}
+
 - (void)windowDidBecomeMain:(NSNotification*)notification {
   content::WebContents* web_contents = shell_->web_contents();
   if (!web_contents)
@@ -191,7 +228,7 @@ bool ScopedDisableResize::disable_resize_ = false;
 - (void)windowWillEnterFullScreen:(NSNotification*)notification {
   // Hide the native toolbar before entering fullscreen, so there is no visual
   // artifacts.
-  if (base::mac::IsOSYosemiteOrLater() &&
+  if (base::mac::IsAtLeastOS10_10() &&
       shell_->title_bar_style() == atom::NativeWindowMac::HIDDEN_INSET) {
     NSWindow* window = shell_->GetNativeWindow();
     [window setToolbar:nil];
@@ -206,7 +243,7 @@ bool ScopedDisableResize::disable_resize_ = false;
   // have to set one, because title bar is visible here.
   NSWindow* window = shell_->GetNativeWindow();
   if ((shell_->transparent() || !shell_->has_frame()) &&
-      base::mac::IsOSYosemiteOrLater() &&
+      base::mac::IsAtLeastOS10_10() &&
       // FIXME(zcbenz): Showing titlebar for hiddenInset window is weird under
       // fullscreen mode.
       shell_->title_bar_style() != atom::NativeWindowMac::HIDDEN_INSET) {
@@ -215,7 +252,7 @@ bool ScopedDisableResize::disable_resize_ = false;
 
   // Restore the native toolbar immediately after entering fullscreen, if we do
   // this before leaving fullscreen, traffic light buttons will be jumping.
-  if (base::mac::IsOSYosemiteOrLater() &&
+  if (base::mac::IsAtLeastOS10_10() &&
       shell_->title_bar_style() == atom::NativeWindowMac::HIDDEN_INSET) {
     base::scoped_nsobject<NSToolbar> toolbar(
         [[NSToolbar alloc] initWithIdentifier:@"titlebarStylingToolbar"]);
@@ -232,13 +269,13 @@ bool ScopedDisableResize::disable_resize_ = false;
   // Restore the titlebar visibility.
   NSWindow* window = shell_->GetNativeWindow();
   if ((shell_->transparent() || !shell_->has_frame()) &&
-      base::mac::IsOSYosemiteOrLater() &&
+      base::mac::IsAtLeastOS10_10() &&
       shell_->title_bar_style() != atom::NativeWindowMac::HIDDEN_INSET) {
     [window setTitleVisibility:NSWindowTitleHidden];
   }
 
   // Turn off the style for toolbar.
-  if (base::mac::IsOSYosemiteOrLater() &&
+  if (base::mac::IsAtLeastOS10_10() &&
       shell_->title_bar_style() == atom::NativeWindowMac::HIDDEN_INSET) {
     shell_->SetStyleMask(false, NSFullSizeContentViewWindowMask);
   }
@@ -276,7 +313,29 @@ bool ScopedDisableResize::disable_resize_ = false;
 
 @end
 
-@interface AtomNSWindow : EventDispatchingWindow {
+@interface AtomPreviewItem : NSObject <QLPreviewItem>
+
+@property (nonatomic, retain) NSURL* previewItemURL;
+@property (nonatomic, retain) NSString* previewItemTitle;
+
+- (id)initWithURL:(NSURL*)url title:(NSString*)title;
+
+@end
+
+@implementation AtomPreviewItem
+
+- (id)initWithURL:(NSURL*)url title:(NSString*)title {
+  self = [super init];
+  if (self) {
+    self.previewItemURL = url;
+    self.previewItemTitle = title;
+  }
+  return self;
+}
+
+@end
+
+@interface AtomNSWindow : EventDispatchingWindow<QLPreviewPanelDataSource, QLPreviewPanelDelegate> {
  @private
   atom::NativeWindowMac* shell_;
   bool enable_larger_than_screen_;
@@ -286,6 +345,8 @@ bool ScopedDisableResize::disable_resize_ = false;
 @property BOOL disableAutoHideCursor;
 @property BOOL disableKeyOrMainWindow;
 @property NSPoint windowButtonsOffset;
+@property (nonatomic, retain) AtomPreviewItem* quickLookItem;
+@property (nonatomic, retain) NSView* vibrantView;
 
 - (void)setShell:(atom::NativeWindowMac*)shell;
 - (void)setEnableLargerThanScreen:(bool)enable;
@@ -443,6 +504,36 @@ bool ScopedDisableResize::disable_resize_ = false;
   return [[self contentView] superview];
 }
 
+// Quicklook methods
+
+- (BOOL)acceptsPreviewPanelControl:(QLPreviewPanel*)panel {
+  return YES;
+}
+
+- (void)beginPreviewPanelControl:(QLPreviewPanel*)panel {
+  panel.delegate = self;
+  panel.dataSource = self;
+}
+
+- (void)endPreviewPanelControl:(QLPreviewPanel*)panel {
+  panel.delegate = nil;
+  panel.dataSource = nil;
+}
+
+- (NSInteger)numberOfPreviewItemsInPreviewPanel:(QLPreviewPanel*)panel {
+  return 1;
+}
+
+- (id <QLPreviewItem>)previewPanel:(QLPreviewPanel*)panel previewItemAtIndex:(NSInteger)index {
+  return [self quickLookItem];
+}
+
+- (void)previewFileAtPath:(NSString*)path  withName:(NSString*) fileName {
+  NSURL* url = [[[NSURL alloc] initFileURLWithPath:path] autorelease];
+  [self setQuickLookItem:[[[AtomPreviewItem alloc] initWithURL:url title:fileName] autorelease]];
+  [[QLPreviewPanel sharedPreviewPanel] makeKeyAndOrderFront:nil];
+}
+
 @end
 
 @interface ControlRegionView : NSView
@@ -528,14 +619,15 @@ NativeWindowMac::NativeWindowMac(
     NativeWindow* parent)
     : NativeWindow(web_contents, options, parent),
       is_kiosk_(false),
+      was_fullscreen_(false),
+      zoom_to_page_width_(false),
       attention_request_id_(0),
-      title_bar_style_(NORMAL),
-      is_edge_(false) {
+      title_bar_style_(NORMAL) {
   int width = 800, height = 600;
   options.Get(options::kWidth, &width);
   options.Get(options::kHeight, &height);
 
-  NSRect main_screen_rect = [[[NSScreen screens] objectAtIndex:0] frame];
+  NSRect main_screen_rect = [[[NSScreen screens] firstObject] frame];
   NSRect cocoa_bounds = NSMakeRect(
       round((NSWidth(main_screen_rect) - width) / 2) ,
       round((NSHeight(main_screen_rect) - height) / 2),
@@ -620,7 +712,7 @@ NativeWindowMac::NativeWindowMac(
     [window_ setDisableKeyOrMainWindow:YES];
 
   if (transparent() || !has_frame()) {
-    if (base::mac::IsOSYosemiteOrLater()) {
+    if (base::mac::IsAtLeastOS10_10()) {
       // Don't show title bar.
       [window_ setTitleVisibility:NSWindowTitleHidden];
     }
@@ -633,7 +725,7 @@ NativeWindowMac::NativeWindowMac(
 
   // Hide the title bar.
   if (title_bar_style_ == HIDDEN_INSET) {
-    if (base::mac::IsOSYosemiteOrLater()) {
+    if (base::mac::IsAtLeastOS10_10()) {
       [window_ setTitlebarAppearsTransparent:YES];
       base::scoped_nsobject<NSToolbar> toolbar(
           [[NSToolbar alloc] initWithIdentifier:@"titlebarStylingToolbar"]);
@@ -651,6 +743,8 @@ NativeWindowMac::NativeWindowMac(
   if (!has_frame() || !use_content_size)
     SetSize(gfx::Size(width, height));
 
+  options.Get(options::kZoomToPageWidth, &zoom_to_page_width_);
+
   // Enable the NSView to accept first mouse event.
   bool acceptsFirstMouse = false;
   options.Get(options::kAcceptFirstMouse, &acceptsFirstMouse);
@@ -675,22 +769,25 @@ NativeWindowMac::NativeWindowMac(
       if (!web_contents)
         return event;
 
-      if (!began && is_edge_ && (([event phase] == NSEventPhaseMayBegin) ||
+      if (!began && (([event phase] == NSEventPhaseMayBegin) ||
                                  ([event phase] == NSEventPhaseBegan))) {
         this->NotifyWindowScrollTouchBegin();
         began = YES;
-        is_edge_ = false;
       } else if (began && (([event phase] == NSEventPhaseEnded) ||
                            ([event phase] == NSEventPhaseCancelled))) {
         this->NotifyWindowScrollTouchEnd();
         began = NO;
-        is_edge_ = false;
       }
       return event;
   }];
 
   InstallView();
 
+  std::string type;
+  if (options.Get(options::kVibrancyType, &type)) {
+    SetVibrancy(type);
+  }
+
   // Set maximizable state last to ensure zoom button does not get reset
   // by calls to other APIs.
   SetMaximizable(maximizable);
@@ -742,8 +839,9 @@ bool NativeWindowMac::IsFocused() {
 
 void NativeWindowMac::Show() {
   if (is_modal() && parent()) {
-    [parent()->GetNativeWindow() beginSheet:window_
-                          completionHandler:^(NSModalResponse) {}];
+    if ([window_ sheetParent] == nil)
+      [parent()->GetNativeWindow() beginSheet:window_
+                            completionHandler:^(NSModalResponse) {}];
     return;
   }
 
@@ -840,7 +938,7 @@ void NativeWindowMac::SetBounds(const gfx::Rect& bounds, bool animate) {
 
   NSRect cocoa_bounds = NSMakeRect(bounds.x(), 0, size.width(), size.height());
   // Flip coordinates based on the primary screen.
-  NSScreen* screen = [[NSScreen screens] objectAtIndex:0];
+  NSScreen* screen = [[NSScreen screens] firstObject];
   cocoa_bounds.origin.y =
       NSHeight([screen frame]) - size.height() - bounds.y();
 
@@ -850,7 +948,7 @@ void NativeWindowMac::SetBounds(const gfx::Rect& bounds, bool animate) {
 gfx::Rect NativeWindowMac::GetBounds() {
   NSRect frame = [window_ frame];
   gfx::Rect bounds(frame.origin.x, 0, NSWidth(frame), NSHeight(frame));
-  NSScreen* screen = [[NSScreen screens] objectAtIndex:0];
+  NSScreen* screen = [[NSScreen screens] firstObject];
   bounds.set_y(NSHeight([screen frame]) - NSMaxY(frame));
   return bounds;
 }
@@ -900,6 +998,19 @@ void NativeWindowMac::SetAspectRatio(double aspect_ratio,
     [window_ setResizeIncrements:NSMakeSize(1.0, 1.0)];
 }
 
+void NativeWindowMac::PreviewFile(const std::string& path,
+                                  const std::string& display_name) {
+  NSString* path_ns = [NSString stringWithUTF8String:path.c_str()];
+  NSString* name_ns = [NSString stringWithUTF8String:display_name.c_str()];
+  [window_ previewFileAtPath:path_ns withName:name_ns];
+}
+
+void NativeWindowMac::CloseFilePreview() {
+  if ([QLPreviewPanel sharedPreviewPanelExists]) {
+    [[QLPreviewPanel sharedPreviewPanel] close];
+  }
+}
+
 void NativeWindowMac::SetMovable(bool movable) {
   [window_ setMovable:movable];
 }
@@ -945,22 +1056,60 @@ bool NativeWindowMac::IsClosable() {
   return [window_ styleMask] & NSClosableWindowMask;
 }
 
-void NativeWindowMac::SetAlwaysOnTop(bool top) {
-  [window_ setLevel:(top ? NSFloatingWindowLevel : NSNormalWindowLevel)];
+void NativeWindowMac::SetAlwaysOnTop(bool top, const std::string& level,
+                                     int relativeLevel, std::string* error) {
+  int windowLevel = NSNormalWindowLevel;
+  CGWindowLevel maxWindowLevel = CGWindowLevelForKey(kCGMaximumWindowLevelKey);
+  CGWindowLevel minWindowLevel = CGWindowLevelForKey(kCGMinimumWindowLevelKey);
+
+  if (top) {
+    if (level == "floating") {
+      windowLevel = NSFloatingWindowLevel;
+    } else if (level == "torn-off-menu") {
+      windowLevel = NSTornOffMenuWindowLevel;
+    } else if (level == "modal-panel") {
+      windowLevel = NSModalPanelWindowLevel;
+    } else if (level == "main-menu") {
+      windowLevel = NSMainMenuWindowLevel;
+    } else if (level == "status") {
+      windowLevel = NSStatusWindowLevel;
+    } else if (level == "pop-up-menu") {
+      windowLevel = NSPopUpMenuWindowLevel;
+    } else if (level == "screen-saver") {
+      windowLevel = NSScreenSaverWindowLevel;
+    } else if (level == "dock") {
+      // Deprecated by macOS, but kept for backwards compatibility
+      windowLevel = NSDockWindowLevel;
+    }
+  }
+
+  NSInteger newLevel = windowLevel + relativeLevel;
+  if (newLevel >= minWindowLevel && newLevel <= maxWindowLevel) {
+    [window_ setLevel:newLevel];
+  } else {
+    *error = std::string([[NSString stringWithFormat:
+      @"relativeLevel must be between %d and %d", minWindowLevel,
+      maxWindowLevel] UTF8String]);
+  }
 }
 
 bool NativeWindowMac::IsAlwaysOnTop() {
-  return [window_ level] == NSFloatingWindowLevel;
+  return [window_ level] != NSNormalWindowLevel;
 }
 
 void NativeWindowMac::Center() {
   [window_ center];
 }
 
+void NativeWindowMac::Invalidate() {
+  [window_ flushWindow];
+  [[window_ contentView] setNeedsDisplay:YES];
+}
+
 void NativeWindowMac::SetTitle(const std::string& title) {
   // For macOS <= 10.9, the setTitleVisibility API is not available, we have
   // to avoid calling setTitle for frameless window.
-  if (!base::mac::IsOSYosemiteOrLater() && (transparent() || !has_frame()))
+  if (!base::mac::IsAtLeastOS10_10() && (transparent() || !has_frame()))
     return;
 
   [window_ setTitle:base::SysUTF8ToNSString(title)];
@@ -995,10 +1144,11 @@ void NativeWindowMac::SetKiosk(bool kiosk) {
         NSApplicationPresentationDisableHideApplication;
     [NSApp setPresentationOptions:options];
     is_kiosk_ = true;
-    SetFullScreen(true);
+    was_fullscreen_ = IsFullscreen();
+    if (!was_fullscreen_) SetFullScreen(true);
   } else if (!kiosk && is_kiosk_) {
     is_kiosk_ = false;
-    SetFullScreen(false);
+    if (!was_fullscreen_) SetFullScreen(false);
     [NSApp setPresentationOptions:kiosk_options_];
   }
 }
@@ -1009,8 +1159,8 @@ bool NativeWindowMac::IsKiosk() {
 
 void NativeWindowMac::SetBackgroundColor(const std::string& color_name) {
   SkColor color = ParseHexColor(color_name);
-  base::ScopedCFTypeRef<CGColorRef> cgcolor =
-      skia::CGColorCreateFromSkColor(color);
+  base::ScopedCFTypeRef<CGColorRef> cgcolor(
+      skia::CGColorCreateFromSkColor(color));
   [[[window_ contentView] layer] setBackgroundColor:cgcolor];
 
   const auto view = web_contents()->GetRenderWidgetHostView();
@@ -1125,12 +1275,83 @@ bool NativeWindowMac::IsVisibleOnAllWorkspaces() {
   return collectionBehavior & NSWindowCollectionBehaviorCanJoinAllSpaces;
 }
 
+void NativeWindowMac::SetAutoHideCursor(bool auto_hide) {
+  [window_ setDisableAutoHideCursor:!auto_hide];
+}
+
+void NativeWindowMac::SetVibrancy(const std::string& type) {
+  if (!base::mac::IsAtLeastOS10_10()) return;
+
+  NSView* vibrant_view = [window_ vibrantView];
+
+  if (type.empty()) {
+    if (vibrant_view == nil) return;
+
+    [vibrant_view removeFromSuperview];
+    [window_ setVibrantView:nil];
+
+    return;
+  }
+
+  NSVisualEffectView* effect_view = (NSVisualEffectView*)vibrant_view;
+  if (effect_view == nil) {
+    effect_view = [[[NSVisualEffectView alloc]
+        initWithFrame: [[window_ contentView] bounds]] autorelease];
+    [window_ setVibrantView:(NSView*)effect_view];
+
+    [effect_view setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
+    [effect_view setBlendingMode:NSVisualEffectBlendingModeBehindWindow];
+    [effect_view setState:NSVisualEffectStateActive];
+    [[window_ contentView] addSubview:effect_view
+                           positioned:NSWindowBelow
+                           relativeTo:nil];
+  }
+
+  NSVisualEffectMaterial vibrancyType = NSVisualEffectMaterialLight;
+
+  if (type == "appearance-based") {
+    vibrancyType = NSVisualEffectMaterialAppearanceBased;
+  } else if (type == "light") {
+    vibrancyType = NSVisualEffectMaterialLight;
+  } else if (type == "dark") {
+    vibrancyType = NSVisualEffectMaterialDark;
+  } else if (type == "titlebar") {
+    vibrancyType = NSVisualEffectMaterialTitlebar;
+  }
+
+  if (base::mac::IsAtLeastOS10_11()) {
+    // TODO(kevinsawicki): Use NSVisualEffectMaterial* constants directly once
+    // they are available in the minimum SDK version
+    if (type == "selection") {
+      // NSVisualEffectMaterialSelection
+      vibrancyType = (NSVisualEffectMaterial) 4;
+    } else if (type == "menu") {
+      // NSVisualEffectMaterialMenu
+      vibrancyType = (NSVisualEffectMaterial) 5;
+    } else if (type == "popover") {
+      // NSVisualEffectMaterialPopover
+      vibrancyType = (NSVisualEffectMaterial) 6;
+    } else if (type == "sidebar") {
+      // NSVisualEffectMaterialSidebar
+      vibrancyType = (NSVisualEffectMaterial) 7;
+    } else if (type == "medium-light") {
+      // NSVisualEffectMaterialMediumLight
+      vibrancyType = (NSVisualEffectMaterial) 8;
+    } else if (type == "ultra-dark") {
+      // NSVisualEffectMaterialUltraDark
+      vibrancyType = (NSVisualEffectMaterial) 9;
+    }
+  }
+
+  [effect_view setMaterial:vibrancyType];
+}
+
 void NativeWindowMac::OnInputEvent(const blink::WebInputEvent& event) {
   switch (event.type) {
     case blink::WebInputEvent::GestureScrollBegin:
     case blink::WebInputEvent::GestureScrollUpdate:
     case blink::WebInputEvent::GestureScrollEnd:
-      is_edge_ = true;
+        this->NotifyWindowScrollTouchEdge();
       break;
     default:
       break;
@@ -1200,10 +1421,10 @@ void NativeWindowMac::ShowWindowButton(NSWindowButton button) {
 }
 
 void NativeWindowMac::InstallView() {
-  // Make sure the bottom corner is rounded: http://crbug.com/396264.
+  // Make sure the bottom corner is rounded for non-modal windows: http://crbug.com/396264.
   // But do not enable it on OS X 10.9 for transparent window, otherwise a
   // semi-transparent frame would show.
-  if (!(transparent() && base::mac::IsOSMavericks()))
+  if (!(transparent() && base::mac::IsOS10_9()) && !is_modal())
     [[window_ contentView] setWantsLayer:YES];
 
   NSView* view = inspectable_web_contents()->GetView()->GetNativeView();
@@ -1228,7 +1449,7 @@ void NativeWindowMac::InstallView() {
     [[window_ standardWindowButton:NSWindowFullScreenButton] setHidden:YES];
 
     if (title_bar_style_ != NORMAL) {
-      if (base::mac::IsOSMavericks()) {
+      if (base::mac::IsOS10_9()) {
         ShowWindowButton(NSWindowZoomButton);
         ShowWindowButton(NSWindowMiniaturizeButton);
         ShowWindowButton(NSWindowCloseButton);

atom/browser/native_window_observer.h

@@ -64,6 +64,7 @@ class NativeWindowObserver {
   virtual void OnWindowMoved() {}
   virtual void OnWindowScrollTouchBegin() {}
   virtual void OnWindowScrollTouchEnd() {}
+  virtual void OnWindowScrollTouchEdge() {}
   virtual void OnWindowSwipe(const std::string& direction) {}
   virtual void OnWindowEnterFullScreen() {}
   virtual void OnWindowLeaveFullScreen() {}

atom/browser/native_window_views.cc

@@ -41,13 +41,14 @@
 #include "atom/browser/ui/x/window_state_watcher.h"
 #include "atom/browser/ui/x/x_window_utils.h"
 #include "base/strings/string_util.h"
-#include "chrome/browser/ui/libgtk2ui/unity_service.h"
+#include "chrome/browser/ui/libgtkui/unity_service.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 #include "ui/views/window/native_frame_view.h"
 #elif defined(OS_WIN)
 #include "atom/browser/ui/views/win_frame_view.h"
+#include "atom/browser/ui/win/atom_desktop_native_widget_aura.h"
 #include "atom/browser/ui/win/atom_desktop_window_tree_host_win.h"
 #include "skia/ext/skia_utils_win.h"
 #include "ui/base/win/shell.h"
@@ -138,7 +139,7 @@ NativeWindowViews::NativeWindowViews(
       menu_bar_visible_(false),
       menu_bar_alt_pressed_(false),
 #if defined(OS_WIN)
-      enabled_a11y_support_(false),
+      checked_for_a11y_support_(false),
       thick_frame_(true),
 #endif
       keyboard_event_handler_(new views::UnhandledKeyboardEventHandler),
@@ -204,8 +205,7 @@ NativeWindowViews::NativeWindowViews(
   if (parent)
     params.parent = parent->GetNativeWindow();
 
-  params.native_widget =
-      new views::DesktopNativeWidgetAura(window_.get());
+  params.native_widget = new AtomDesktopNativeWidgetAura(window_.get());
   atom_desktop_window_tree_host_win_ = new AtomDesktopWindowTreeHostWin(
       this,
       window_.get(),
@@ -426,7 +426,7 @@ bool NativeWindowViews::IsEnabled() {
 void NativeWindowViews::Maximize() {
 #if defined(OS_WIN)
   // For window without WS_THICKFRAME style, we can not call Maximize().
-  if (!thick_frame_) {
+  if (!(::GetWindowLong(GetAcceleratedWidget(), GWL_STYLE) & WS_THICKFRAME)) {
     restore_bounds_ = GetBounds();
     auto display =
         display::Screen::GetScreen()->GetDisplayNearestPoint(GetPosition());
@@ -444,7 +444,7 @@ void NativeWindowViews::Maximize() {
 
 void NativeWindowViews::Unmaximize() {
 #if defined(OS_WIN)
-  if (!thick_frame_) {
+  if (!(::GetWindowLong(GetAcceleratedWidget(), GWL_STYLE) & WS_THICKFRAME)) {
     SetBounds(restore_bounds_, false);
     return;
   }
@@ -488,6 +488,7 @@ void NativeWindowViews::SetFullScreen(bool fullscreen) {
   }
 
   // For window without WS_THICKFRAME style, we can not call SetFullscreen().
+  // This path will be used for transparent windows as well.
   if (!thick_frame_) {
     if (fullscreen) {
       restore_bounds_ = GetBounds();
@@ -572,7 +573,7 @@ void NativeWindowViews::SetContentSizeConstraints(
 
 void NativeWindowViews::SetResizable(bool resizable) {
 #if defined(OS_WIN)
-  if (thick_frame_)
+  if (has_frame())
     FlipWindowStyle(GetAcceleratedWidget(), resizable, WS_THICKFRAME);
 #elif defined(USE_X11)
   if (resizable != resizable_) {
@@ -595,11 +596,10 @@ void NativeWindowViews::SetResizable(bool resizable) {
 
 bool NativeWindowViews::IsResizable() {
 #if defined(OS_WIN)
-  if (thick_frame_) {
+  if (has_frame())
     return ::GetWindowLong(GetAcceleratedWidget(), GWL_STYLE) & WS_THICKFRAME;
-  } else {
+  else
     return CanResize();
-  }
 #else
   return CanResize();
 #endif
@@ -682,7 +682,8 @@ bool NativeWindowViews::IsClosable() {
 #endif
 }
 
-void NativeWindowViews::SetAlwaysOnTop(bool top) {
+void NativeWindowViews::SetAlwaysOnTop(bool top, const std::string& level,
+                                       int relativeLevel, std::string* error) {
   window_->SetAlwaysOnTop(top);
 }
 
@@ -694,6 +695,10 @@ void NativeWindowViews::Center() {
   window_->CenterWindow(GetSize());
 }
 
+void NativeWindowViews::Invalidate() {
+  window_->SchedulePaintInRect(gfx::Rect(GetBounds().size()));
+}
+
 void NativeWindowViews::SetTitle(const std::string& title) {
   title_ = title;
   window_->UpdateWindowTitle();
@@ -846,7 +851,7 @@ void NativeWindowViews::SetMenu(AtomMenuModel* menu_model) {
 
   if (!menu_bar_) {
     gfx::Size content_size = GetContentSize();
-    menu_bar_.reset(new MenuBar);
+    menu_bar_.reset(new MenuBar(this));
     menu_bar_->set_owned_by_client();
 
     if (!menu_bar_autohide_) {

atom/browser/native_window_views.h

@@ -18,6 +18,8 @@
 #include "atom/browser/ui/win/message_handler_delegate.h"
 #include "atom/browser/ui/win/taskbar_host.h"
 #include "base/win/scoped_gdi_object.h"
+#include "ui/base/win/accessibility_misc_utils.h"
+#include <UIAutomationCoreApi.h>
 #endif
 
 namespace views {
@@ -84,9 +86,11 @@ class NativeWindowViews : public NativeWindow,
   bool IsFullScreenable() override;
   void SetClosable(bool closable) override;
   bool IsClosable() override;
-  void SetAlwaysOnTop(bool top) override;
+  void SetAlwaysOnTop(bool top, const std::string& level,
+                      int relativeLevel, std::string* error) override;
   bool IsAlwaysOnTop() override;
   void Center() override;
+  void Invalidate() override;
   void SetTitle(const std::string& title) override;
   std::string GetTitle() override;
   void FlashFrame(bool flash) override;
@@ -214,6 +218,7 @@ class NativeWindowViews : public NativeWindow,
   // size of the window while in the normal state (not maximized, minimized or
   // fullscreen), so we restore it correctly.
   gfx::Rect last_normal_bounds_;
+  gfx::Rect last_normal_bounds_before_move_;
 
   // last_normal_bounds_ may or may not require update on WM_MOVE. When a
   // window is maximized, it is moved (WM_MOVE) to maximum size first and then
@@ -228,8 +233,8 @@ class NativeWindowViews : public NativeWindow,
   // In charge of running taskbar related APIs.
   TaskbarHost taskbar_host_;
 
-  // If true we have enabled a11y
-  bool enabled_a11y_support_;
+  // Memoized version of a11y check
+  bool checked_for_a11y_support_;
 
   // Whether to show the WS_THICKFRAME style.
   bool thick_frame_;

atom/browser/native_window_views_win.cc

@@ -72,6 +72,12 @@ const char* AppCommandToString(int command_id) {
   }
 }
 
+bool IsScreenReaderActive() {
+  UINT screenReader = 0;
+  SystemParametersInfo(SPI_GETSCREENREADER, 0, &screenReader, 0);
+  return screenReader && UiaClientsAreListening();
+}
+
 }  // namespace
 
 bool NativeWindowViews::ExecuteWindowsCommand(int command_id) {
@@ -91,16 +97,24 @@ bool NativeWindowViews::PreHandleMSG(
     // because we still want Chromium to handle returning the actual
     // accessibility object.
     case WM_GETOBJECT: {
-      const DWORD obj_id = static_cast<DWORD>(l_param);
-      if (enabled_a11y_support_) return false;
+      if (checked_for_a11y_support_) return false;
 
-      if (obj_id == OBJID_CLIENT) {
-        const auto axState = content::BrowserAccessibilityState::GetInstance();
-        if (axState && !axState->IsAccessibleBrowser()) {
-          axState->OnScreenReaderDetected();
-          enabled_a11y_support_ = true;
-          Browser::Get()->OnAccessibilitySupportChanged();
-        }
+      const DWORD obj_id = static_cast<DWORD>(l_param);
+
+      if (obj_id != OBJID_CLIENT) {
+        return false;
+      }
+
+      if (!IsScreenReaderActive()) {
+        return false;
+      }
+
+      checked_for_a11y_support_ = true;
+
+      const auto axState = content::BrowserAccessibilityState::GetInstance();
+      if (axState && !axState->IsAccessibleBrowser()) {
+        axState->OnScreenReaderDetected();
+        Browser::Get()->OnAccessibilitySupportChanged();
       }
 
       return false;
@@ -111,9 +125,12 @@ bool NativeWindowViews::PreHandleMSG(
         return taskbar_host_.HandleThumbarButtonEvent(LOWORD(w_param));
       return false;
     case WM_SIZE: {
-      consecutive_moves_ = false;
       // Handle window state change.
       HandleSizeEvent(w_param, l_param);
+
+      consecutive_moves_ = false;
+      last_normal_bounds_before_move_ = last_normal_bounds_;
+
       return false;
     }
     case WM_MOVING: {
@@ -141,6 +158,9 @@ void NativeWindowViews::HandleSizeEvent(WPARAM w_param, LPARAM l_param) {
   switch (w_param) {
     case SIZE_MAXIMIZED:
       last_window_state_ = ui::SHOW_STATE_MAXIMIZED;
+      if (consecutive_moves_) {
+        last_normal_bounds_ = last_normal_bounds_before_move_;
+      }
       NotifyWindowMaximize();
       break;
     case SIZE_MINIMIZED:
@@ -151,14 +171,14 @@ void NativeWindowViews::HandleSizeEvent(WPARAM w_param, LPARAM l_param) {
       if (last_window_state_ == ui::SHOW_STATE_NORMAL) {
         // Window was resized so we save it's new size.
         last_normal_bounds_ = GetBounds();
+        last_normal_bounds_before_move_ = last_normal_bounds_;
       } else {
         switch (last_window_state_) {
           case ui::SHOW_STATE_MAXIMIZED:
             last_window_state_ = ui::SHOW_STATE_NORMAL;
 
-            // When the window is restored we resize it to the previous known
-            // normal size.
-            SetBounds(last_normal_bounds_, false);
+            // Don't force out last known bounds onto the window as Windows
+            // actually gets these correct
 
             NotifyWindowUnmaximize();
             break;

atom/browser/net/about_protocol_handler.cc

@@ -0,0 +1,25 @@
+// 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 "atom/browser/net/about_protocol_handler.h"
+
+#include "atom/browser/net/url_request_about_job.h"
+
+namespace atom {
+
+AboutProtocolHandler::AboutProtocolHandler() {}
+
+AboutProtocolHandler::~AboutProtocolHandler() {}
+
+net::URLRequestJob* AboutProtocolHandler::MaybeCreateJob(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  return new URLRequestAboutJob(request, network_delegate);
+}
+
+bool AboutProtocolHandler::IsSafeRedirectTarget(const GURL& location) const {
+  return false;
+}
+
+}  // namespace atom

atom/browser/net/about_protocol_handler.h

@@ -0,0 +1,29 @@
+// 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 ATOM_BROWSER_NET_ABOUT_PROTOCOL_HANDLER_H_
+#define ATOM_BROWSER_NET_ABOUT_PROTOCOL_HANDLER_H_
+
+#include "net/url_request/url_request_job_factory.h"
+
+namespace atom {
+
+class AboutProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  AboutProtocolHandler();
+  ~AboutProtocolHandler() override;
+
+  // net::URLRequestJobFactory::ProtocolHandler:
+  net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override;
+  bool IsSafeRedirectTarget(const GURL& location) const override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AboutProtocolHandler);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NET_ABOUT_PROTOCOL_HANDLER_H_

atom/browser/net/asar/url_request_asar_job.cc

@@ -21,7 +21,7 @@
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
-#include "net/filter/filter.h"
+#include "net/filter/gzip_source_stream.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request_status.h"
 
@@ -179,10 +179,14 @@ bool URLRequestAsarJob::IsRedirectResponse(GURL* location,
 #endif
 }
 
-std::unique_ptr<net::Filter> URLRequestAsarJob::SetupFilter() const {
+std::unique_ptr<net::SourceStream> URLRequestAsarJob::SetUpSourceStream() {
+  std::unique_ptr<net::SourceStream> source =
+      net::URLRequestJob::SetUpSourceStream();
   // Bug 9936 - .svgz files needs to be decompressed.
   return base::LowerCaseEqualsASCII(file_path_.Extension(), ".svgz")
-      ? net::Filter::GZipFactory() : nullptr;
+      ? net::GzipSourceStream::Create(std::move(source),
+                                      net::SourceStream::TYPE_GZIP)
+      : std::move(source);
 }
 
 bool URLRequestAsarJob::GetMimeType(std::string* mime_type) const {

atom/browser/net/asar/url_request_asar_job.h

@@ -56,7 +56,7 @@ class URLRequestAsarJob : public net::URLRequestJob {
   void Kill() override;
   int ReadRawData(net::IOBuffer* buf, int buf_size) override;
   bool IsRedirectResponse(GURL* location, int* http_status_code) override;
-  std::unique_ptr<net::Filter> SetupFilter() const override;
+  std::unique_ptr<net::SourceStream> SetUpSourceStream() override;
   bool GetMimeType(std::string* mime_type) const override;
   void SetExtraRequestHeaders(const net::HttpRequestHeaders& headers) override;
   int GetResponseCode() const override;

atom/browser/net/atom_cert_verifier.cc

@@ -5,9 +5,14 @@
 #include "atom/browser/net/atom_cert_verifier.h"
 
 #include "atom/browser/browser.h"
+#include "atom/browser/net/atom_ct_delegate.h"
 #include "atom/common/native_mate_converters/net_converter.h"
+#include "base/containers/linked_list.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/weak_ptr.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
+#include "net/cert/cert_verify_result.h"
 #include "net/cert/crl_set.h"
 #include "net/cert/x509_certificate.h"
 
@@ -17,54 +22,188 @@ namespace atom {
 
 namespace {
 
-void OnResult(
-    net::CertVerifyResult* verify_result,
-    const net::CompletionCallback& callback,
-    bool result) {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(callback, result ? net::OK : net::ERR_FAILED));
-}
+class Response : public base::LinkNode<Response> {
+ public:
+  Response(net::CertVerifyResult* verify_result,
+           const net::CompletionCallback& callback)
+      : verify_result_(verify_result), callback_(callback) {}
+  net::CertVerifyResult* verify_result() { return verify_result_; }
+  net::CompletionCallback callback() { return callback_; }
+
+ private:
+  net::CertVerifyResult* verify_result_;
+  net::CompletionCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(Response);
+};
 
 }  // namespace
 
-AtomCertVerifier::AtomCertVerifier()
-    : default_cert_verifier_(net::CertVerifier::CreateDefault()) {
-}
+class CertVerifierRequest : public AtomCertVerifier::Request {
+ public:
+  CertVerifierRequest(const AtomCertVerifier::RequestParams& params,
+                      AtomCertVerifier* cert_verifier)
+      : params_(params),
+        cert_verifier_(cert_verifier),
+        error_(net::ERR_IO_PENDING),
+        custom_response_(net::ERR_IO_PENDING),
+        first_response_(true),
+        weak_ptr_factory_(this) {}
 
-AtomCertVerifier::~AtomCertVerifier() {
-}
+  ~CertVerifierRequest() {
+    cert_verifier_->RemoveRequest(params_);
+    default_verifier_request_.reset();
+    while (!response_list_.empty() && !first_response_) {
+      base::LinkNode<Response>* response_node = response_list_.head();
+      response_node->RemoveFromList();
+      Response* response = response_node->value();
+      RunResponse(response);
+    }
+    cert_verifier_ = nullptr;
+    weak_ptr_factory_.InvalidateWeakPtrs();
+  }
+
+  void RunResponse(Response* response) {
+    if (custom_response_ == net::ERR_ABORTED) {
+      *(response->verify_result()) = result_;
+      response->callback().Run(error_);
+    } else {
+      response->verify_result()->Reset();
+      response->verify_result()->verified_cert = params_.certificate();
+      cert_verifier_->ct_delegate()->AddCTExcludedHost(params_.hostname());
+      response->callback().Run(custom_response_);
+    }
+    delete response;
+  }
+
+  void Start(net::CRLSet* crl_set,
+             const net::NetLogWithSource& net_log) {
+    int error = cert_verifier_->default_verifier()->Verify(
+        params_, crl_set, &result_,
+        base::Bind(&CertVerifierRequest::OnDefaultVerificationDone,
+                   weak_ptr_factory_.GetWeakPtr()),
+        &default_verifier_request_, net_log);
+    if (error != net::ERR_IO_PENDING)
+      OnDefaultVerificationDone(error);
+  }
+
+  void OnDefaultVerificationDone(int error) {
+    error_ = error;
+    std::unique_ptr<VerifyRequestParams> request(new VerifyRequestParams());
+    request->hostname = params_.hostname();
+    request->default_result = net::ErrorToString(error);
+    request->certificate = params_.certificate();
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&CertVerifierRequest::OnVerifyRequestInUI,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   cert_verifier_->verify_proc(),
+                   base::Passed(&request)));
+  }
+
+  void OnVerifyRequestInUI(const AtomCertVerifier::VerifyProc& verify_proc,
+                           std::unique_ptr<VerifyRequestParams> request) {
+    verify_proc.Run(*(request.get()),
+                    base::Bind(&CertVerifierRequest::OnResponseInUI,
+                               weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  void OnResponseInUI(int result) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(&CertVerifierRequest::NotifyResponseInIO,
+                                       weak_ptr_factory_.GetWeakPtr(), result));
+  }
+
+  void NotifyResponseInIO(int result) {
+    custom_response_ = result;
+    first_response_ = false;
+    // Responding to first request in the list will initiate destruction of
+    // the class, respond to others in the list inside destructor.
+    base::LinkNode<Response>* response_node = response_list_.head();
+    response_node->RemoveFromList();
+    Response* response = response_node->value();
+    RunResponse(response);
+  }
+
+  void AddResponseListener(net::CertVerifyResult* verify_result,
+                           const net::CompletionCallback& callback) {
+    response_list_.Append(new Response(verify_result, callback));
+  }
+
+  const AtomCertVerifier::RequestParams& params() const { return params_; }
+
+ private:
+  using ResponseList = base::LinkedList<Response>;
+
+  const AtomCertVerifier::RequestParams params_;
+  AtomCertVerifier* cert_verifier_;
+  int error_;
+  int custom_response_;
+  bool first_response_;
+  ResponseList response_list_;
+  net::CertVerifyResult result_;
+  std::unique_ptr<AtomCertVerifier::Request> default_verifier_request_;
+  base::WeakPtrFactory<CertVerifierRequest> weak_ptr_factory_;
+};
+
+AtomCertVerifier::AtomCertVerifier(AtomCTDelegate* ct_delegate)
+    : default_cert_verifier_(net::CertVerifier::CreateDefault()),
+      ct_delegate_(ct_delegate) {}
+
+AtomCertVerifier::~AtomCertVerifier() {}
 
 void AtomCertVerifier::SetVerifyProc(const VerifyProc& proc) {
   verify_proc_ = proc;
 }
 
 int AtomCertVerifier::Verify(
-    net::X509Certificate* cert,
-    const std::string& hostname,
-    const std::string& ocsp_response,
-    int flags,
+    const RequestParams& params,
     net::CRLSet* crl_set,
     net::CertVerifyResult* verify_result,
     const net::CompletionCallback& callback,
     std::unique_ptr<Request>* out_req,
-    const net::BoundNetLog& net_log) {
+    const net::NetLogWithSource& net_log) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  if (verify_proc_.is_null())
-    return default_cert_verifier_->Verify(
-        cert, hostname, ocsp_response, flags, crl_set, verify_result, callback,
-        out_req, net_log);
+  if (verify_proc_.is_null()) {
+    ct_delegate_->ClearCTExcludedHostsList();
+    return default_cert_verifier_->Verify(params, crl_set, verify_result,
+                                          callback, out_req, net_log);
+  } else {
+    CertVerifierRequest* request = FindRequest(params);
+    if (!request) {
+      out_req->reset();
+      std::unique_ptr<CertVerifierRequest> new_request =
+          base::MakeUnique<CertVerifierRequest>(params, this);
+      new_request->Start(crl_set, net_log);
+      request = new_request.get();
+      *out_req = std::move(new_request);
+      inflight_requests_[params] = request;
+    }
+    request->AddResponseListener(verify_result, callback);
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(verify_proc_, hostname, make_scoped_refptr(cert),
-                 base::Bind(OnResult, verify_result, callback)));
-  return net::ERR_IO_PENDING;
+    return net::ERR_IO_PENDING;
+  }
 }
 
 bool AtomCertVerifier::SupportsOCSPStapling() {
-  return true;
+  if (verify_proc_.is_null())
+    return default_cert_verifier_->SupportsOCSPStapling();
+  return false;
+}
+
+void AtomCertVerifier::RemoveRequest(const RequestParams& params) {
+  auto it = inflight_requests_.find(params);
+  if (it != inflight_requests_.end())
+    inflight_requests_.erase(it);
+}
+
+CertVerifierRequest* AtomCertVerifier::FindRequest(
+    const RequestParams& params) {
+  auto it = inflight_requests_.find(params);
+  if (it != inflight_requests_.end())
+    return it->second;
+  return nullptr;
 }
 
 }  // namespace atom

atom/browser/net/atom_cert_verifier.h

@@ -5,6 +5,7 @@
 #ifndef ATOM_BROWSER_NET_ATOM_CERT_VERIFIER_H_
 #define ATOM_BROWSER_NET_ATOM_CERT_VERIFIER_H_
 
+#include <map>
 #include <memory>
 #include <string>
 
@@ -12,34 +13,51 @@
 
 namespace atom {
 
+class AtomCTDelegate;
+class CertVerifierRequest;
+
+struct VerifyRequestParams {
+  std::string hostname;
+  std::string default_result;
+  scoped_refptr<net::X509Certificate> certificate;
+};
+
 class AtomCertVerifier : public net::CertVerifier {
  public:
-  AtomCertVerifier();
+  explicit AtomCertVerifier(AtomCTDelegate* ct_delegate);
   virtual ~AtomCertVerifier();
 
-  using VerifyProc =
-      base::Callback<void(const std::string& hostname,
-                          scoped_refptr<net::X509Certificate>,
-                          const base::Callback<void(bool)>&)>;
+  using VerifyProc = base::Callback<void(const VerifyRequestParams& request,
+                                         const net::CompletionCallback&)>;
 
   void SetVerifyProc(const VerifyProc& proc);
 
+  const VerifyProc verify_proc() const { return verify_proc_; }
+  AtomCTDelegate* ct_delegate() const { return ct_delegate_; }
+  net::CertVerifier* default_verifier() const {
+    return default_cert_verifier_.get();
+  }
+
  protected:
   // net::CertVerifier:
-  int Verify(net::X509Certificate* cert,
-             const std::string& hostname,
-             const std::string& ocsp_response,
-             int flags,
+  int Verify(const RequestParams& params,
              net::CRLSet* crl_set,
              net::CertVerifyResult* verify_result,
              const net::CompletionCallback& callback,
              std::unique_ptr<Request>* out_req,
-             const net::BoundNetLog& net_log) override;
+             const net::NetLogWithSource& net_log) override;
   bool SupportsOCSPStapling() override;
 
  private:
+  friend class CertVerifierRequest;
+
+  void RemoveRequest(const RequestParams& params);
+  CertVerifierRequest* FindRequest(const RequestParams& params);
+
+  std::map<RequestParams, CertVerifierRequest*> inflight_requests_;
   VerifyProc verify_proc_;
   std::unique_ptr<net::CertVerifier> default_cert_verifier_;
+  AtomCTDelegate* ct_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomCertVerifier);
 };

atom/browser/net/atom_cookie_delegate.cc

@@ -0,0 +1,44 @@
+// 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 "atom/browser/net/atom_cookie_delegate.h"
+
+#include "content/public/browser/browser_thread.h"
+
+namespace atom {
+
+AtomCookieDelegate::AtomCookieDelegate() {
+}
+
+AtomCookieDelegate::~AtomCookieDelegate() {
+}
+
+void AtomCookieDelegate::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void AtomCookieDelegate::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void AtomCookieDelegate::NotifyObservers(
+    const net::CanonicalCookie& cookie,
+    bool removed,
+    net::CookieStore::ChangeCause cause) {
+  for (Observer& observer : observers_)
+    observer.OnCookieChanged(cookie, removed, cause);
+}
+
+void AtomCookieDelegate::OnCookieChanged(
+    const net::CanonicalCookie& cookie,
+    bool removed,
+    net::CookieStore::ChangeCause cause) {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&AtomCookieDelegate::NotifyObservers,
+                 this, cookie, removed, cause));
+}
+
+}  // namespace atom

atom/browser/net/atom_cookie_delegate.h

@@ -0,0 +1,48 @@
+// 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 ATOM_BROWSER_NET_ATOM_COOKIE_DELEGATE_H_
+#define ATOM_BROWSER_NET_ATOM_COOKIE_DELEGATE_H_
+
+#include "base/observer_list.h"
+#include "net/cookies/cookie_monster.h"
+
+namespace atom {
+
+class AtomCookieDelegate : public net::CookieMonsterDelegate {
+ public:
+  AtomCookieDelegate();
+  ~AtomCookieDelegate() override;
+
+  class Observer {
+   public:
+    virtual void OnCookieChanged(const net::CanonicalCookie& cookie,
+                                 bool removed,
+                                 net::CookieStore::ChangeCause cause) {}
+   protected:
+    virtual ~Observer() {}
+  };
+
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
+  // net::CookieMonsterDelegate:
+  void OnCookieChanged(const net::CanonicalCookie& cookie,
+                       bool removed,
+                       net::CookieStore::ChangeCause cause) override;
+
+
+ private:
+  base::ObserverList<Observer> observers_;
+
+  void NotifyObservers(const net::CanonicalCookie& cookie,
+                       bool removed,
+                       net::CookieStore::ChangeCause cause);
+
+  DISALLOW_COPY_AND_ASSIGN(AtomCookieDelegate);
+};
+
+}   // namespace atom
+
+#endif  // ATOM_BROWSER_NET_ATOM_COOKIE_DELEGATE_H_

atom/browser/net/atom_ct_delegate.cc

@@ -0,0 +1,34 @@
+// 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 "atom/browser/net/atom_ct_delegate.h"
+
+#include "content/public/browser/browser_thread.h"
+
+namespace atom {
+
+AtomCTDelegate::AtomCTDelegate() {}
+
+AtomCTDelegate::~AtomCTDelegate() {}
+
+void AtomCTDelegate::AddCTExcludedHost(const std::string& host) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  ct_excluded_hosts_.insert(host);
+}
+
+void AtomCTDelegate::ClearCTExcludedHostsList() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  ct_excluded_hosts_.clear();
+}
+
+AtomCTDelegate::CTRequirementLevel AtomCTDelegate::IsCTRequiredForHost(
+    const std::string& host) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  if (!ct_excluded_hosts_.empty() &&
+      (ct_excluded_hosts_.find(host) != ct_excluded_hosts_.end()))
+    return CTRequirementLevel::NOT_REQUIRED;
+  return CTRequirementLevel::DEFAULT;
+}
+
+}  // namespace atom

atom/browser/net/atom_ct_delegate.h

@@ -0,0 +1,33 @@
+// 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 ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_
+#define ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_
+
+#include <set>
+#include <string>
+
+#include "net/http/transport_security_state.h"
+
+namespace atom {
+
+class AtomCTDelegate : public net::TransportSecurityState::RequireCTDelegate {
+ public:
+  AtomCTDelegate();
+  ~AtomCTDelegate() override;
+
+  void AddCTExcludedHost(const std::string& host);
+  void ClearCTExcludedHostsList();
+
+  // net::TransportSecurityState::RequireCTDelegate:
+  CTRequirementLevel IsCTRequiredForHost(const std::string& host) override;
+
+ private:
+  std::set<std::string> ct_excluded_hosts_;
+  DISALLOW_COPY_AND_ASSIGN(AtomCTDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NET_ATOM_CT_DELEGATE_H_