Bump v0.35.1

Support the "desktop" window type on Mac OS X

.gitignore

@@ -1,4 +1,5 @@
 .DS_Store
+/.idea/
 /build/
 /dist/
 /external_binaries/

.travis.yml

@@ -10,6 +10,7 @@ os:
   - osx
 env:
   - TARGET_ARCH=x64
+osx_image: xcode7
 
 matrix:
   include:

CONTRIBUTING.md

@@ -29,7 +29,8 @@ possible with your report. If you can, please include:
 * Include screenshots and animated GIFs in your pull request whenever possible.
 * Follow the CoffeeScript, JavaScript, C++ and Python [coding style defined in docs](/docs/development/coding-style.md).
 * Write documentation in [Markdown](https://daringfireball.net/projects/markdown).
-* Use short, present tense commit messages. See [Commit Message Styleguide](#git-commit-messages-styleguide).
+  See the [Documentation Styleguide](/docs/styleguide.md).
+* Use short, present tense commit messages. See [Commit Message Styleguide](#git-commit-messages).
 
 ## Styleguides
 

README-ko.md

@@ -1,4 +1,4 @@
-[![Electron Logo](http://electron.atom.io/images/electron-logo.svg)](http://electron.atom.io/)
+[![Electron Logo](http://electron.atom.io/images/electron-logo.svg)](http://electron.atom.io/)
 
 [![Build Status](https://travis-ci.org/atom/electron.svg?branch=master)](https://travis-ci.org/atom/electron)
 [![devDependency Status](https://david-dm.org/atom/electron/dev-status.svg)](https://david-dm.org/atom/electron#info=devDependencies)
@@ -6,25 +6,34 @@
 
 ### [Electron](https://github.com/atom/electron/) 한국어 참조문서
 
-:zap: *이전까지 Atom Shell로 알려져 있었습니다* :zap:
+:zap: *프레임워크 이름이 Atom Shell에서 Electron으로 변경되었습니다* :zap:
 
+Electron 프레임워크는 JavaScript, HTML 그리고 CSS를 사용하여
+Cross-Platform 데스크톱 어플리케이션을 개발할 수 있도록 해주는 프레임워크입니다.
+[Node.js](https://nodejs.org/)와 [Chromium](http://www.chromium.org)을 기반으로
+만들어졌으며 [Atom Editor](https://github.com/atom/atom)에 사용되고 있습니다.
 
-Electron은 JavaScript, HTML 그리고 CSS를 이용하여 Cross-Platform 데스크톱 어플리케이션을 개발할 수 있도록 해주는 프레임워크입니다. 이 프레임워크는 [io.js](http://iojs.org) 와
-[Chromium](http://www.chromium.org) 을 기반으로 만들어 졌으며 [Atom Editor](https://github.com/atom/atom) 에 사용되고 있습니다.
+Electron에 대한 중요한 알림을 받고 싶다면 Twitter에서
+[@ElectronJS](https://twitter.com/electronjs)를 팔로우 하세요.
 
-Electron에 대한 중요한 알림을 받으려면 Twitter에서 [@ElectronJS](https://twitter.com/electronjs)를 Follow하세요.
+이 프로젝트는 [기여자 규약 1.2](http://contributor-covenant.org/version/1/2/0/)을
+준수합니다. 따라서 이 프로젝트의 개발에 참여하려면 이 계약을 지켜야 합니다. 받아들일 수
+없는 행위를 발견했을 경우 atom@github.com로 보고 하십시오.
 
 ## 다운로드
 
-Linux, Windows, Mac용으로 미리 빌드된 Electron 바이너리와 디버그 심볼이 준비되어 있습니다. [releases](https://github.com/atom/electron/releases) 페이지에서 받아 볼 수 있습니다.
+Linux, Windows, OS X 용으로 미리 빌드된 Electron 바이너리와 디버그 심볼이 준비되어
+있습니다. [releases](https://github.com/atom/electron/releases) 페이지에서 받아 볼
+수 있습니다.
 
-또한 [`npm`](https://docs.npmjs.com/)을 이용하여 미리 빌드된 Electron 바이너리를 받을 수 있습니다:
+또한 [`npm`](https://docs.npmjs.com/)을 통해 미리 빌드된 Electron 바이너리를 설치할
+수도 있습니다:
 
 ```sh
-# $PATH에 `electron`을 등록하고 전역에 설치합니다.
+# $PATH에 `electron` 커맨드를 등록하고 전역에 설치합니다.
 npm install electron-prebuilt -g
 
-# 개발용 dependency로 설치합니다.
+# 개발 의존성 모듈 형태로 설치합니다.
 npm install electron-prebuilt --save-dev
 ```
 
@@ -32,13 +41,34 @@ npm install electron-prebuilt --save-dev
 
 - [China](https://npm.taobao.org/mirrors/electron)
 
-## 참조문서
+## 참조 문서
 
-[docs](https://github.com/atom/electron/tree/master/docs/README-ko.md) 에 프레임워크 사용 가이드와 API 레퍼런스가 있습니다.
-추가적으로 Electron을 빌드 하는 방법과 프로젝트에 기여하는 방법이 문서에 포함되어 있으니 참고하시기 바랍니다.
+[Docs](https://github.com/atom/electron/tree/master/docs/README.md)에 개발 지침과
+API 레퍼런스가 있습니다. Electron을 빌드 하는 방법과 프로젝트에 기여하는법 또한 문서에
+포함되어 있으니 참고하시기 바랍니다.
+
+## 참조 문서 (번역)
+
+- [브라질 포르투칼어](https://github.com/atom/electron/tree/master/docs-translations/pt-BR)
+- [한국어](https://github.com/atom/electron/tree/master/docs-translations/ko-KR)
+- [일본어](https://github.com/atom/electron/tree/master/docs-translations/jp)
+- [스페인어](https://github.com/atom/electron/tree/master/docs-translations/es)
+- [중국어 간체](https://github.com/atom/electron/tree/master/docs-translations/zh-CN)
+- [중국어 번체](https://github.com/atom/electron/tree/master/docs-translations/zh-TW)
+
+## 시작하기
+
+[`atom/electron-quick-start`](https://github.com/atom/electron-quick-start)
+저장소를 클론하여 Electron을 간단히 접해볼 수 있습니다.
 
 ## 커뮤니티
 
-[Atom 포럼내의 `electron` 카테고리](http://discuss.atom.io/category/electron) 와 Freenode `#atom-shell` 채팅채널이 있습니다.
+다음 링크를 통해 커뮤니티에 질문을 올리거나 토론을 나눌 수 있습니다:
 
-[awesome-electron](https://github.com/sindresorhus/awesome-electron) 에 커뮤니티가 운영중인 유용한 예제 앱과 툴, 리소스가 있으니 한번 탐색해 보시기 바랍니다.
+- Atom 포럼의 [`electron`](http://discuss.atom.io/c/electron) 카테고리
+- Freenode 채팅의 `#atom-shell` 채널
+- Slack의 [`Atom`](http://atom-slack.herokuapp.com/) 채널
+
+[awesome-electron](https://github.com/sindresorhus/awesome-electron) 프로젝트에
+커뮤니티가 운영중인 유용한 예제 어플리케이션과 도구, 리소스가 있으니 한번 참고해 보시기
+바랍니다.

README.md

@@ -4,22 +4,23 @@
 [![devDependency Status](https://david-dm.org/atom/electron/dev-status.svg)](https://david-dm.org/atom/electron#info=devDependencies)
 [![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
 
-:zap: *formerly known as Atom Shell* :zap:
+:zap: *Formerly known as Atom Shell* :zap:
 
 The Electron framework lets you write cross-platform desktop applications
-using JavaScript, HTML and CSS. It is based on [io.js](http://iojs.org) and
+using JavaScript, HTML and CSS. It is based on [Node.js](https://nodejs.org/) and
 [Chromium](http://www.chromium.org) and is used in the [Atom
 editor](https://github.com/atom/atom).
 
 Follow [@ElectronJS](https://twitter.com/electronjs) on Twitter for important
 announcements.
 
-This project adheres to the [Contributor Covenant 1.2](http://contributor-covenant.org/version/1/2/0).
-By participating, you are expected to uphold this code. Please report unacceptable behavior to atom@github.com.
+This project adheres to the [Contributor Covenant 1.2](http://contributor-covenant.org/version/1/2/0/).
+By participating, you are expected to uphold this code. Please report
+unacceptable behavior to atom@github.com.
 
 ## Downloads
 
-Prebuilt binaries and debug symbols of Electron for Linux, Windows and Mac can
+Prebuilt binaries and debug symbols of Electron for Linux, Windows and OS X can
 be found on the [releases](https://github.com/atom/electron/releases) page.
 
 You can also use [`npm`](https://docs.npmjs.com/) to install prebuilt electron
@@ -43,9 +44,28 @@ Guides and the API reference are located in the
 [docs](https://github.com/atom/electron/tree/master/docs) directory. It also
 contains documents describing how to build and contribute to Electron.
 
+## Documentation Translations
+
+- [Brazilian Portuguese](https://github.com/atom/electron/tree/master/docs-translations/pt-BR)
+- [Korean](https://github.com/atom/electron/tree/master/docs-translations/ko-KR)
+- [Japanese](https://github.com/atom/electron/tree/master/docs-translations/jp)
+- [Spanish](https://github.com/atom/electron/tree/master/docs-translations/es)
+- [Simplified Chinese](https://github.com/atom/electron/tree/master/docs-translations/zh-CN)
+- [Traditional Chinese](https://github.com/atom/electron/tree/master/docs-translations/zh-TW)
+
+## Quick Start
+
+Clone and run the [`atom/electron-quick-start`](https://github.com/atom/electron-quick-start)
+repository to see a minimal Electron app in action.
+
 ## Community
 
-There is an [`electron` category on the Atom forums](http://discuss.atom.io/category/electron)
-as well as an `#atom-shell` channel on Freenode.
+You can ask questions and interact with the community in the following
+locations:
+- [`electron`](http://discuss.atom.io/c/electron) category on the Atom
+forums
+- `#atom-shell` channel on Freenode
+- [`Atom`](http://atom-slack.herokuapp.com/) channel on Slack
 
-Check out [awesome-electron](https://github.com/sindresorhus/awesome-electron) for a community maintained list of useful example apps, tools and resources.
+Check out [awesome-electron](https://github.com/sindresorhus/awesome-electron)
+for a community maintained list of useful example apps, tools and resources.

atom.gyp

@@ -4,7 +4,7 @@
     'product_name%': 'Electron',
     'company_name%': 'GitHub, Inc',
     'company_abbr%': 'github',
-    'version%': '0.30.6',
+    'version%': '0.35.1',
   },
   'includes': [
     'filenames.gypi',
@@ -64,9 +64,6 @@
               'files': [
                 '<(PRODUCT_DIR)/<(product_name) Helper.app',
                 '<(PRODUCT_DIR)/<(product_name) Framework.framework',
-                'external_binaries/Squirrel.framework',
-                'external_binaries/ReactiveCocoa.framework',
-                'external_binaries/Mantle.framework',
               ],
             },
             {
@@ -109,7 +106,21 @@
                 '<@(locale_dirs)',
               ],
             },
-          ]
+          ],
+          'conditions': [
+            ['mas_build==0', {
+              'copies': [
+                {
+                  'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Frameworks',
+                  'files': [
+                    'external_binaries/Squirrel.framework',
+                    'external_binaries/ReactiveCocoa.framework',
+                    'external_binaries/Mantle.framework',
+                  ],
+                },
+              ],
+            }],
+          ],
         }, {  # OS=="mac"
           'dependencies': [
             'make_locale_paks',
@@ -144,7 +155,6 @@
               'destination': '<(PRODUCT_DIR)',
               'files': [
                 '<@(copied_libraries)',
-                '<(libchromiumcontent_dir)/ffmpegsumo.dll',
                 '<(libchromiumcontent_dir)/libEGL.dll',
                 '<(libchromiumcontent_dir)/libGLESv2.dll',
                 '<(libchromiumcontent_dir)/icudtl.dat',
@@ -193,7 +203,6 @@
               'destination': '<(PRODUCT_DIR)',
               'files': [
                 '<@(copied_libraries)',
-                '<(libchromiumcontent_dir)/libffmpegsumo.so',
                 '<(libchromiumcontent_dir)/icudtl.dat',
                 '<(libchromiumcontent_dir)/content_shell.pak',
                 '<(libchromiumcontent_dir)/natives_blob.bin',
@@ -226,8 +235,6 @@
         # Defined in Chromium but not exposed in its gyp file.
         'V8_USE_EXTERNAL_STARTUP_DATA',
         'ENABLE_PLUGINS',
-        # Needed by Node.
-        'NODE_WANT_INTERNALS=1',
       ],
       'sources': [
         '<@(lib_sources)',
@@ -289,12 +296,28 @@
             'vendor/breakpad/breakpad.gyp:breakpad_sender',
           ],
         }],  # OS=="win"
-        ['OS=="mac"', {
+        ['OS=="mac" and mas_build==0', {
           'dependencies': [
             'vendor/crashpad/client/client.gyp:crashpad_client',
             'vendor/crashpad/handler/handler.gyp:crashpad_handler',
           ],
-        }],  # OS=="mac"
+          'link_settings': {
+            # Do not link with QTKit for mas build.
+            'libraries': [
+              '$(SDKROOT)/System/Library/Frameworks/QTKit.framework',
+            ],
+          },
+        }],  # OS=="mac" and mas_build==0
+        ['OS=="mac" and mas_build==1', {
+          'defines': [
+            'MAS_BUILD',
+          ],
+          'sources!': [
+            'atom/browser/auto_updater_mac.mm',
+            'atom/common/crash_reporter/crash_reporter_mac.h',
+            'atom/common/crash_reporter/crash_reporter_mac.mm',
+          ],
+        }],  # OS=="mac" and mas_build==1
         ['OS=="linux"', {
           'link_settings': {
             'ldflags': [
@@ -397,9 +420,6 @@
             'libraries': [
               '$(SDKROOT)/System/Library/Frameworks/Carbon.framework',
               '$(SDKROOT)/System/Library/Frameworks/QuartzCore.framework',
-              'external_binaries/Squirrel.framework',
-              'external_binaries/ReactiveCocoa.framework',
-              'external_binaries/Mantle.framework',
             ],
           },
           'mac_bundle': 1,
@@ -441,13 +461,6 @@
               'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Libraries',
               'files': [
                 '<@(copied_libraries)',
-                '<(libchromiumcontent_dir)/ffmpegsumo.so',
-              ],
-            },
-            {
-              'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Resources',
-              'files': [
-                '<(PRODUCT_DIR)/crashpad_handler',
               ],
             },
           ],
@@ -462,6 +475,16 @@
                 '${BUILT_PRODUCTS_DIR}/<(product_name) Framework.framework/Versions/A/<(product_name) Framework',
               ],
             },
+            {
+              'postbuild_name': 'Fix path of ffmpeg',
+              'action': [
+                'install_name_tool',
+                '-change',
+                '@loader_path/libffmpeg.dylib',
+                '@rpath/libffmpeg.dylib',
+                '${BUILT_PRODUCTS_DIR}/<(product_name) Framework.framework/Versions/A/<(product_name) Framework',
+              ],
+            },
             {
               'postbuild_name': 'Add symlinks for framework subdirectories',
               'action': [
@@ -471,6 +494,25 @@
               ],
             },
           ],
+          'conditions': [
+            ['mas_build==0', {
+              'link_settings': {
+                'libraries': [
+                  'external_binaries/Squirrel.framework',
+                  'external_binaries/ReactiveCocoa.framework',
+                  'external_binaries/Mantle.framework',
+                ],
+              },
+              'copies': [
+                {
+                  'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Resources',
+                  'files': [
+                    '<(PRODUCT_DIR)/crashpad_handler',
+                  ],
+                },
+              ],
+            }],
+          ],
         },  # target framework
         {
           'target_name': '<(project_name)_helper',

atom/app/atom_content_client.cc

@@ -7,6 +7,7 @@
 #include <string>
 #include <vector>
 
+#include "atom/common/atom_version.h"
 #include "atom/common/chrome_version.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
@@ -14,6 +15,7 @@
 #include "base/strings/string_util.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/pepper_plugin_info.h"
+#include "content/public/common/user_agent.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
 
 namespace atom {
@@ -72,6 +74,12 @@ std::string AtomContentClient::GetProduct() const {
   return "Chrome/" CHROME_VERSION_STRING;
 }
 
+std::string AtomContentClient::GetUserAgent() const {
+  return content::BuildUserAgentFromProduct(
+      "Chrome/" CHROME_VERSION_STRING " "
+      ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING);
+}
+
 void AtomContentClient::AddAdditionalSchemes(
     std::vector<std::string>* standard_schemes,
     std::vector<std::string>* savable_schemes) {
@@ -91,7 +99,7 @@ void AtomContentClient::AddAdditionalSchemes(
 void AtomContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
   auto command_line = base::CommandLine::ForCurrentProcess();
-  auto flash_path = command_line->GetSwitchValueNative(
+  auto flash_path = command_line->GetSwitchValuePath(
       switches::kPpapiFlashPath);
   if (flash_path.empty())
     return;
@@ -100,7 +108,7 @@ void AtomContentClient::AddPepperPlugins(
       switches::kPpapiFlashVersion);
 
   plugins->push_back(
-      CreatePepperFlashInfo(base::FilePath(flash_path), flash_version));
+      CreatePepperFlashInfo(flash_path, flash_version));
 }
 
 }  // namespace atom

atom/app/atom_content_client.h

@@ -20,6 +20,7 @@ class AtomContentClient : public brightray::ContentClient {
  protected:
   // content::ContentClient:
   std::string GetProduct() const override;
+  std::string GetUserAgent() const override;
   void AddAdditionalSchemes(
       std::vector<std::string>* standard_schemes,
       std::vector<std::string>* savable_schemes) override;

atom/app/atom_library_main.mm

@@ -10,6 +10,7 @@
 #include "base/at_exit.h"
 #include "base/i18n/icu_util.h"
 #include "base/mac/bundle_locations.h"
+#include "base/mac/scoped_nsautorelease_pool.h"
 #include "brightray/common/mac/main_application_bundle.h"
 #include "content/public/app/content_main.h"
 
@@ -25,6 +26,7 @@ int AtomMain(int argc, const char* argv[]) {
 
 int AtomInitializeICUandStartNode(int argc, char *argv[]) {
   base::AtExitManager atexit_manager;
+  base::mac::ScopedNSAutoreleasePool pool;
   base::mac::SetOverrideFrameworkBundlePath(
       brightray::MainApplicationBundlePath()
           .Append("Contents")

atom/app/atom_main.cc

@@ -33,6 +33,7 @@
 
 #include "atom/app/node_main.h"
 #include "atom/common/atom_command_line.h"
+#include "base/at_exit.h"
 #include "base/i18n/icu_util.h"
 
 #if defined(OS_WIN)
@@ -134,6 +135,7 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   if (env->GetVar("ATOM_SHELL_INTERNAL_RUN_AS_NODE", &node_indicator) &&
       node_indicator == "1") {
     // Now that argv conversion is done, we can finally start.
+    base::AtExitManager atexit_manager;
     base::i18n::InitializeICU();
     return atom::NodeMain(argc, argv);
   } else if (env->GetVar("ATOM_SHELL_INTERNAL_CRASH_SERVICE",
@@ -165,6 +167,7 @@ int main(int argc, const char* argv[]) {
   char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
   if (node_indicator != NULL && strcmp(node_indicator, "1") == 0) {
     base::i18n::InitializeICU();
+    base::AtExitManager atexit_manager;
     return atom::NodeMain(argc, const_cast<char**>(argv));
   }
 

atom/app/atom_main_delegate.cc

@@ -5,6 +5,7 @@
 #include "atom/app/atom_main_delegate.h"
 
 #include <string>
+#include <iostream>
 
 #include "atom/app/atom_content_client.h"
 #include "atom/browser/atom_browser_client.h"
@@ -15,11 +16,21 @@
 #include "base/debug/stack_trace.h"
 #include "base/environment.h"
 #include "base/logging.h"
+#include "chrome/common/chrome_paths.h"
 #include "content/public/common/content_switches.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace atom {
 
+namespace {
+
+bool IsBrowserProcess(base::CommandLine* cmd) {
+  std::string process_type = cmd->GetSwitchValueASCII(switches::kProcessType);
+  return process_type.empty();
+}
+
+}  // namespace
+
 AtomMainDelegate::AtomMainDelegate() {
 }
 
@@ -27,10 +38,16 @@ AtomMainDelegate::~AtomMainDelegate() {
 }
 
 bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
-  // Disable logging out to debug.log on Windows
+  auto command_line = base::CommandLine::ForCurrentProcess();
+
   logging::LoggingSettings settings;
 #if defined(OS_WIN)
+  // On Windows the terminal returns immediately, so we add a new line to
+  // prevent output in the same line as the prompt.
+  if (IsBrowserProcess(command_line))
+    std::wcout << std::endl;
 #if defined(DEBUG)
+  // Print logging to debug.log on Windows
   settings.logging_dest = logging::LOG_TO_ALL;
   settings.log_file = L"debug.log";
   settings.lock_log = logging::LOCK_LOG_FILE;
@@ -38,16 +55,32 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 #else
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 #endif  // defined(DEBUG)
-#endif  // defined(OS_WIN)
+#else  // defined(OS_WIN)
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+#endif  // !defined(OS_WIN)
+
+  // Only enable logging when --enable-logging is specified.
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  if (!command_line->HasSwitch(switches::kEnableLogging) &&
+      !env->HasVar("ELECTRON_ENABLE_LOGGING")) {
+    settings.logging_dest = logging::LOG_NONE;
+    logging::SetMinLogLevel(logging::LOG_NUM_SEVERITIES);
+  }
+
   logging::InitLogging(settings);
 
   // Logging with pid and timestamp.
   logging::SetLogItems(true, false, true, false);
 
-#if defined(DEBUG) && defined(OS_LINUX)
   // Enable convient stack printing.
-  base::debug::EnableInProcessStackDumping();
+  bool enable_stack_dumping = env->HasVar("ELECTRON_ENABLE_STACK_DUMPING");
+#if defined(DEBUG) && defined(OS_LINUX)
+  enable_stack_dumping = true;
 #endif
+  if (enable_stack_dumping)
+    base::debug::EnableInProcessStackDumping();
+
+  chrome::RegisterPathProvider();
 
   return brightray::MainDelegate::BasicStartupComplete(exit_code);
 }
@@ -69,16 +102,9 @@ void AtomMainDelegate::PreSandboxStartup() {
   }
 
   // Only append arguments for browser process.
-  if (!process_type.empty())
+  if (!IsBrowserProcess(command_line))
     return;
 
-#if defined(OS_WIN)
-  // Disable the LegacyRenderWidgetHostHWND, it made frameless windows unable
-  // to move and resize. We may consider enabling it again after upgraded to
-  // Chrome 38, which should have fixed the problem.
-  command_line->AppendSwitch(switches::kDisableLegacyIntermediateWindow);
-#endif
-
   // Disable renderer sandbox for most of node's functions.
   command_line->AppendSwitch(switches::kNoSandbox);
 

atom/app/node_main.cc

@@ -4,42 +4,48 @@
 
 #include "atom/app/node_main.h"
 
+#include "atom/app/uv_task_runner.h"
 #include "atom/browser/javascript_environment.h"
+#include "atom/browser/node_debugger.h"
+#include "base/command_line.h"
 #include "atom/common/node_includes.h"
+#include "base/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
+#include "gin/v8_initializer.h"
 
 namespace atom {
 
 int NodeMain(int argc, char *argv[]) {
-  argv = uv_setup_args(argc, argv);
-  int exec_argc;
-  const char** exec_argv;
-  node::Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv);
+  base::CommandLine::Init(argc, argv);
 
   int exit_code = 1;
   {
-    gin::IsolateHolder::LoadV8Snapshot();
-    gin::IsolateHolder::Initialize(
-        gin::IsolateHolder::kNonStrictMode,
-        gin::ArrayBufferAllocator::SharedInstance());
+    // Feed gin::PerIsolateData with a task runner.
+    argv = uv_setup_args(argc, argv);
+    uv_loop_t* loop = uv_default_loop();
+    scoped_refptr<UvTaskRunner> uv_task_runner(new UvTaskRunner(loop));
+    base::ThreadTaskRunnerHandle handle(uv_task_runner);
 
+    gin::V8Initializer::LoadV8Snapshot();
+    gin::V8Initializer::LoadV8Natives();
     JavascriptEnvironment gin_env;
+
+    int exec_argc;
+    const char** exec_argv;
+    node::Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv);
+
     node::Environment* env = node::CreateEnvironment(
-        gin_env.isolate(), uv_default_loop(), gin_env.context(), argc, argv,
+        gin_env.isolate(), loop, gin_env.context(), argc, argv,
         exec_argc, exec_argv);
 
-    // Start debugger.
-    node::node_isolate = gin_env.isolate();
-    if (node::use_debug_agent)
-      node::StartDebug(env, node::debug_wait_connect);
+    // Start our custom debugger implementation.
+    NodeDebugger node_debugger(gin_env.isolate());
+    if (node_debugger.IsRunning())
+      env->AssignToContext(v8::Debug::GetDebugContext());
 
     node::LoadEnvironment(env);
 
-    // Enable debugger.
-    if (node::use_debug_agent)
-      node::EnableDebug(env);
-
     bool more;
     do {
       more = uv_run(env->event_loop(), UV_RUN_ONCE);

atom/app/uv_task_runner.cc

@@ -0,0 +1,60 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/app/uv_task_runner.h"
+
+#include "base/stl_util.h"
+
+namespace atom {
+
+UvTaskRunner::UvTaskRunner(uv_loop_t* loop) : loop_(loop) {
+}
+
+UvTaskRunner::~UvTaskRunner() {
+  for (auto& iter : tasks_) {
+    uv_unref(reinterpret_cast<uv_handle_t*>(iter.first));
+    delete iter.first;
+  }
+}
+
+bool UvTaskRunner::PostDelayedTask(const tracked_objects::Location& from_here,
+                                   const base::Closure& task,
+                                   base::TimeDelta delay) {
+  uv_timer_t* timer = new uv_timer_t;
+  timer->data = this;
+  uv_timer_init(loop_, timer);
+  uv_timer_start(timer, UvTaskRunner::OnTimeout, delay.InMilliseconds(), 0);
+  tasks_[timer] = task;
+  return true;
+}
+
+bool UvTaskRunner::RunsTasksOnCurrentThread() const {
+  return true;
+}
+
+bool UvTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  return PostDelayedTask(from_here, task, delay);;
+}
+
+// static
+void UvTaskRunner::OnTimeout(uv_timer_t* timer) {
+  UvTaskRunner* self = static_cast<UvTaskRunner*>(timer->data);
+  if (!ContainsKey(self->tasks_, timer))
+    return;
+
+  self->tasks_[timer].Run();
+  self->tasks_.erase(timer);
+  uv_timer_stop(timer);
+  uv_close(reinterpret_cast<uv_handle_t*>(timer), UvTaskRunner::OnClose);
+}
+
+// static
+void UvTaskRunner::OnClose(uv_handle_t* handle) {
+  delete reinterpret_cast<uv_timer_t*>(handle);
+}
+
+}  // namespace atom

atom/app/uv_task_runner.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_UV_TASK_RUNNER_H_
+#define ATOM_APP_UV_TASK_RUNNER_H_
+
+#include <map>
+
+#include "base/callback.h"
+#include "base/single_thread_task_runner.h"
+#include "vendor/node/deps/uv/include/uv.h"
+
+namespace atom {
+
+// TaskRunner implementation that posts tasks into libuv's default loop.
+class UvTaskRunner : public base::SingleThreadTaskRunner {
+ public:
+  explicit UvTaskRunner(uv_loop_t* loop);
+  ~UvTaskRunner() override;
+
+  // base::SingleThreadTaskRunner:
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override;
+  bool RunsTasksOnCurrentThread() const override;
+  bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      base::TimeDelta delay) override;
+
+ private:
+  static void OnTimeout(uv_timer_t* timer);
+  static void OnClose(uv_handle_t* handle);
+
+  uv_loop_t* loop_;
+
+  std::map<uv_timer_t*, base::Closure> tasks_;
+
+  DISALLOW_COPY_AND_ASSIGN(UvTaskRunner);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_APP_UV_TASK_RUNNER_H_

atom/browser/api/atom_api_app.cc

@@ -7,35 +7,38 @@
 #include <string>
 #include <vector>
 
-#if defined(OS_WIN)
-#include <shlobj.h>
-#endif
-
 #include "atom/browser/api/atom_api_menu.h"
 #include "atom/browser/api/atom_api_session.h"
+#include "atom/browser/api/atom_api_web_contents.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/browser.h"
-#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/login_handler.h"
 #include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/net_converter.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 "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "brightray/browser/brightray_paths.h"
+#include "chrome/common/chrome_paths.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 "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 #include "net/ssl/ssl_cert_request_info.h"
+#include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_WIN)
 #include "base/strings/utf_string_conversions.h"
 #endif
 
-#include "atom/common/node_includes.h"
-
 using atom::Browser;
 
 namespace mate {
@@ -61,21 +64,6 @@ struct Converter<Browser::UserTask> {
 };
 #endif
 
-template<>
-struct Converter<scoped_refptr<net::X509Certificate>> {
-  static v8::Local<v8::Value> ToV8(
-      v8::Isolate* isolate,
-      const scoped_refptr<net::X509Certificate>& val) {
-    mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    std::string encoded_data;
-    net::X509Certificate::GetPEMEncoded(
-        val->os_cert_handle(), &encoded_data);
-    dict.Set("data", encoded_data);
-    dict.Set("issuerName", val->issuer().GetDisplayName());
-    return dict.GetHandle();
-  }
-};
-
 }  // namespace mate
 
 
@@ -99,22 +87,47 @@ int GetPathConstant(const std::string& name) {
     return base::DIR_HOME;
   else if (name == "temp")
     return base::DIR_TEMP;
-  else if (name == "userDesktop")
+  else if (name == "userDesktop" || name == "desktop")
     return base::DIR_USER_DESKTOP;
   else if (name == "exe")
     return base::FILE_EXE;
   else if (name == "module")
     return base::FILE_MODULE;
+  else if (name == "documents")
+    return chrome::DIR_USER_DOCUMENTS;
+  else if (name == "downloads")
+    return chrome::DIR_DEFAULT_DOWNLOADS;
+  else if (name == "music")
+    return chrome::DIR_USER_MUSIC;
+  else if (name == "pictures")
+    return chrome::DIR_USER_PICTURES;
+  else if (name == "videos")
+    return chrome::DIR_USER_VIDEOS;
   else
     return -1;
 }
 
+bool NotificationCallbackWrapper(
+    const ProcessSingleton::NotificationCallback& callback,
+    const base::CommandLine::StringVector& cmd,
+    const base::FilePath& cwd) {
+  // Make sure the callback is called after app gets ready.
+  if (Browser::Get()->is_ready()) {
+    callback.Run(cmd, cwd);
+  } else {
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner(
+        base::ThreadTaskRunnerHandle::Get());
+    task_runner->PostTask(
+        FROM_HERE, base::Bind(base::IgnoreResult(callback), cmd, cwd));
+  }
+  // ProcessSingleton needs to know whether current process is quiting.
+  return !Browser::Get()->is_shutting_down();
+}
+
 void OnClientCertificateSelected(
     v8::Isolate* isolate,
     std::shared_ptr<content::ClientCertificateDelegate> delegate,
     mate::Arguments* args) {
-  v8::Locker locker(isolate);
-  v8::HandleScope handle_scope(isolate);
   mate::Dictionary cert_data;
   if (!(args->Length() == 1 && args->GetNext(&cert_data))) {
     args->ThrowError();
@@ -128,18 +141,29 @@ void OnClientCertificateSelected(
       net::X509Certificate::CreateCertificateListFromBytes(
           encoded_data.data(), encoded_data.size(),
           net::X509Certificate::FORMAT_AUTO);
-
   delegate->ContinueWithCertificate(certs[0].get());
 }
 
+void PassLoginInformation(scoped_refptr<LoginHandler> login_handler,
+                          mate::Arguments* args) {
+  base::string16 username, password;
+  if (args->GetNext(&username) && args->GetNext(&password))
+    login_handler->Login(username, password);
+  else
+    login_handler->CancelAuth();
+}
+
 }  // namespace
 
 App::App() {
+  static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())->set_delegate(this);
   Browser::Get()->AddObserver(this);
   content::GpuDataManager::GetInstance()->AddObserver(this);
 }
 
 App::~App() {
+  static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())->set_delegate(
+      nullptr);
   Browser::Get()->RemoveObserver(this);
   content::GpuDataManager::GetInstance()->RemoveObserver(this);
 }
@@ -158,6 +182,11 @@ void App::OnWindowAllClosed() {
 
 void App::OnQuit() {
   Emit("quit");
+
+  if (process_singleton_.get()) {
+    process_singleton_->Cleanup();
+    process_singleton_.reset();
+  }
 }
 
 void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
@@ -168,8 +197,8 @@ void App::OnOpenURL(const std::string& url) {
   Emit("open-url", url);
 }
 
-void App::OnActivateWithNoOpenWindows() {
-  Emit("activate-with-no-open-windows");
+void App::OnActivate(bool has_visible_windows) {
+  Emit("activate", has_visible_windows);
 }
 
 void App::OnWillFinishLaunching() {
@@ -177,26 +206,62 @@ void App::OnWillFinishLaunching() {
 }
 
 void App::OnFinishLaunching() {
-  // Create the defaultSession.
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  auto browser_context = static_cast<AtomBrowserContext*>(
-      AtomBrowserMainParts::Get()->browser_context());
-  auto handle = Session::CreateFrom(isolate(), browser_context);
-  default_session_.Reset(isolate(), handle.ToV8());
-
   Emit("ready");
 }
 
-void App::OnSelectCertificate(
+void App::OnLogin(LoginHandler* login_handler) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  bool prevent_default = Emit(
+      "login",
+      WebContents::CreateFrom(isolate(), login_handler->GetWebContents()),
+      login_handler->request(),
+      login_handler->auth_info(),
+      base::Bind(&PassLoginInformation, make_scoped_refptr(login_handler)));
+
+  // Default behavior is to always cancel the auth.
+  if (!prevent_default)
+    login_handler->CancelAuth();
+}
+
+void App::AllowCertificateError(
+    int pid,
+    int fid,
+    int cert_error,
+    const net::SSLInfo& ssl_info,
+    const GURL& request_url,
+    content::ResourceType resource_type,
+    bool overridable,
+    bool strict_enforcement,
+    bool expired_previous_decision,
+    const base::Callback<void(bool)>& callback,
+    content::CertificateRequestResultType* request) {
+  auto rfh = content::RenderFrameHost::FromID(pid, fid);
+  auto web_contents = content::WebContents::FromRenderFrameHost(rfh);
+
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  bool prevent_default = Emit("certificate-error",
+                              WebContents::CreateFrom(isolate(), web_contents),
+                              request_url,
+                              net::ErrorToString(cert_error),
+                              ssl_info.cert,
+                              callback);
+
+  // Deny the certificate by default.
+  if (!prevent_default)
+    *request = content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY;
+}
+
+void App::SelectClientCertificate(
     content::WebContents* web_contents,
     net::SSLCertRequestInfo* cert_request_info,
     scoped_ptr<content::ClientCertificateDelegate> delegate) {
   std::shared_ptr<content::ClientCertificateDelegate>
       shared_delegate(delegate.release());
   bool prevent_default =
-      Emit("select-certificate",
-           api::WebContents::CreateFrom(isolate(), web_contents),
+      Emit("select-client-certificate",
+           WebContents::CreateFrom(isolate(), web_contents),
            cert_request_info->host_and_port.ToString(),
            cert_request_info->client_certs,
            base::Bind(&OnClientCertificateSelected,
@@ -242,18 +307,36 @@ void App::SetDesktopName(const std::string& desktop_name) {
 #endif
 }
 
-void App::SetAppUserModelId(const std::string& app_id) {
-#if defined(OS_WIN)
-  base::string16 app_id_utf16 = base::UTF8ToUTF16(app_id);
-  SetCurrentProcessExplicitAppUserModelID(app_id_utf16.c_str());
-#endif
+void App::AllowNTLMCredentialsForAllDomains(bool should_allow) {
+  auto browser_context = static_cast<AtomBrowserContext*>(
+        AtomBrowserMainParts::Get()->browser_context());
+  browser_context->AllowNTLMCredentialsForAllDomains(should_allow);
 }
 
-v8::Local<v8::Value> App::DefaultSession(v8::Isolate* isolate) {
-  if (default_session_.IsEmpty())
-    return v8::Null(isolate);
-  else
-    return v8::Local<v8::Value>::New(isolate, default_session_);
+std::string App::GetLocale() {
+  return l10n_util::GetApplicationLocale("");
+}
+
+bool App::MakeSingleInstance(
+    const ProcessSingleton::NotificationCallback& callback) {
+  if (process_singleton_.get())
+    return false;
+
+  base::FilePath user_dir;
+  PathService::Get(brightray::DIR_USER_DATA, &user_dir);
+  process_singleton_.reset(new ProcessSingleton(
+      user_dir, base::Bind(NotificationCallbackWrapper, callback)));
+
+  switch (process_singleton_->NotifyOtherProcessOrCreate()) {
+    case ProcessSingleton::NotifyResult::LOCK_ERROR:
+    case ProcessSingleton::NotifyResult::PROFILE_IN_USE:
+    case ProcessSingleton::NotifyResult::PROCESS_NOTIFIED:
+      process_singleton_.reset();
+      return true;
+    case ProcessSingleton::NotifyResult::PROCESS_NONE:
+    default:  // Shouldn't be needed, but VS warns if it is not there.
+      return false;
+  }
 }
 
 mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
@@ -261,6 +344,7 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
   auto browser = base::Unretained(Browser::Get());
   return mate::ObjectTemplateBuilder(isolate)
       .SetMethod("quit", base::Bind(&Browser::Quit, browser))
+      .SetMethod("exit", base::Bind(&Browser::Exit, browser))
       .SetMethod("focus", base::Bind(&Browser::Focus, browser))
       .SetMethod("getVersion", base::Bind(&Browser::GetVersion, browser))
       .SetMethod("setVersion", base::Bind(&Browser::SetVersion, browser))
@@ -271,6 +355,8 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
                  base::Bind(&Browser::AddRecentDocument, browser))
       .SetMethod("clearRecentDocuments",
                  base::Bind(&Browser::ClearRecentDocuments, browser))
+      .SetMethod("setAppUserModelId",
+                 base::Bind(&Browser::SetAppUserModelID, browser))
 #if defined(OS_WIN)
       .SetMethod("setUserTasks",
                  base::Bind(&Browser::SetUserTasks, browser))
@@ -278,8 +364,10 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
       .SetMethod("setPath", &App::SetPath)
       .SetMethod("getPath", &App::GetPath)
       .SetMethod("setDesktopName", &App::SetDesktopName)
-      .SetMethod("setAppUserModelId", &App::SetAppUserModelId)
-      .SetProperty("defaultSession", &App::DefaultSession);
+      .SetMethod("allowNTLMCredentialsForAllDomains",
+                 &App::AllowNTLMCredentialsForAllDomains)
+      .SetMethod("getLocale", &App::GetLocale)
+      .SetMethod("makeSingleInstance", &App::MakeSingleInstance);
 }
 
 // static
@@ -296,6 +384,16 @@ namespace {
 
 void AppendSwitch(const std::string& switch_string, mate::Arguments* args) {
   auto command_line = base::CommandLine::ForCurrentProcess();
+
+  if (switch_string == atom::switches::kPpapiFlashPath ||
+      switch_string == atom::switches::kClientCertificate ||
+      switch_string == switches::kLogNetLog) {
+    base::FilePath path;
+    args->GetNext(&path);
+    command_line->AppendSwitchPath(switch_string, path);
+    return;
+  }
+
   std::string value;
   if (args->GetNext(&value))
     command_line->AppendSwitchASCII(switch_string, value);

atom/browser/api/atom_api_app.h

@@ -8,7 +8,10 @@
 #include <string>
 
 #include "atom/browser/api/event_emitter.h"
+#include "atom/browser/atom_browser_client.h"
 #include "atom/browser/browser_observer.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "chrome/browser/process_singleton.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "native_mate/handle.h"
 
@@ -24,7 +27,8 @@ namespace atom {
 
 namespace api {
 
-class App : public mate::EventEmitter,
+class App : public AtomBrowserClient::Delegate,
+            public mate::EventEmitter,
             public BrowserObserver,
             public content::GpuDataManagerObserver {
  public:
@@ -41,10 +45,25 @@ class App : public mate::EventEmitter,
   void OnQuit() override;
   void OnOpenFile(bool* prevent_default, const std::string& file_path) override;
   void OnOpenURL(const std::string& url) override;
-  void OnActivateWithNoOpenWindows() override;
+  void OnActivate(bool has_visible_windows) override;
   void OnWillFinishLaunching() override;
   void OnFinishLaunching() override;
-  void OnSelectCertificate(
+  void OnLogin(LoginHandler* login_handler) override;
+
+  // content::ContentBrowserClient:
+  void AllowCertificateError(
+      int render_process_id,
+      int render_frame_id,
+      int cert_error,
+      const net::SSLInfo& ssl_info,
+      const GURL& request_url,
+      content::ResourceType resource_type,
+      bool overridable,
+      bool strict_enforcement,
+      bool expired_previous_decision,
+      const base::Callback<void(bool)>& callback,
+      content::CertificateRequestResultType* request) override;
+  void SelectClientCertificate(
       content::WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
       scoped_ptr<content::ClientCertificateDelegate> delegate) override;
@@ -64,10 +83,12 @@ class App : public mate::EventEmitter,
                const base::FilePath& path);
 
   void SetDesktopName(const std::string& desktop_name);
-  void SetAppUserModelId(const std::string& app_id);
-  v8::Local<v8::Value> DefaultSession(v8::Isolate* isolate);
+  void AllowNTLMCredentialsForAllDomains(bool should_allow);
+  bool MakeSingleInstance(
+      const ProcessSingleton::NotificationCallback& callback);
+  std::string GetLocale();
 
-  v8::Global<v8::Value> default_session_;
+  scoped_ptr<ProcessSingleton> process_singleton_;
 
   DISALLOW_COPY_AND_ASSIGN(App);
 };

atom/browser/api/atom_api_auto_updater.cc

@@ -5,12 +5,30 @@
 #include "atom/browser/api/atom_api_auto_updater.h"
 
 #include "base/time/time.h"
-#include "atom/browser/auto_updater.h"
 #include "atom/browser/browser.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/window_list.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/node_includes.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 
-#include "atom/common/node_includes.h"
+namespace mate {
+
+template<>
+struct Converter<base::Time> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const base::Time& val) {
+    v8::MaybeLocal<v8::Value> date = v8::Date::New(
+        isolate->GetCurrentContext(), val.ToJsTime());
+    if (date.IsEmpty())
+      return v8::Null(isolate);
+    else
+      return date.ToLocalChecked();
+  }
+};
+
+}  // namespace mate
 
 namespace atom {
 
@@ -21,11 +39,18 @@ AutoUpdater::AutoUpdater() {
 }
 
 AutoUpdater::~AutoUpdater() {
-  auto_updater::AutoUpdater::SetDelegate(NULL);
+  auto_updater::AutoUpdater::SetDelegate(nullptr);
 }
 
-void AutoUpdater::OnError(const std::string& error) {
-  Emit("error", error);
+void AutoUpdater::OnError(const std::string& message) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  auto error = v8::Exception::Error(mate::StringToV8(isolate(), message));
+  EmitCustomEvent(
+      "error",
+      error->ToObject(isolate()->GetCurrentContext()).ToLocalChecked(),
+      // Message is also emitted to keep compatibility with old code.
+      message);
 }
 
 void AutoUpdater::OnCheckingForUpdate() {
@@ -43,26 +68,36 @@ void AutoUpdater::OnUpdateNotAvailable() {
 void AutoUpdater::OnUpdateDownloaded(const std::string& release_notes,
                                      const std::string& release_name,
                                      const base::Time& release_date,
-                                     const std::string& update_url,
-                                     const base::Closure& quit_and_install) {
-  quit_and_install_ = quit_and_install;
-  Emit("update-downloaded-raw", release_notes, release_name,
-       release_date.ToJsTime(), update_url);
+                                     const std::string& url) {
+  Emit("update-downloaded", release_notes, release_name, release_date, url,
+       // Keep compatibility with old APIs.
+       base::Bind(&AutoUpdater::QuitAndInstall, base::Unretained(this)));
+}
+
+void AutoUpdater::OnWindowAllClosed() {
+  QuitAndInstall();
 }
 
 mate::ObjectTemplateBuilder AutoUpdater::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return mate::ObjectTemplateBuilder(isolate)
-      .SetMethod("setFeedUrl", &auto_updater::AutoUpdater::SetFeedURL)
+      .SetMethod("setFeedURL", &auto_updater::AutoUpdater::SetFeedURL)
       .SetMethod("checkForUpdates", &auto_updater::AutoUpdater::CheckForUpdates)
-      .SetMethod("_quitAndInstall", &AutoUpdater::QuitAndInstall);
+      .SetMethod("quitAndInstall", &AutoUpdater::QuitAndInstall);
 }
 
 void AutoUpdater::QuitAndInstall() {
-  if (quit_and_install_.is_null())
-    Browser::Get()->Shutdown();
-  else
-    quit_and_install_.Run();
+  // If we don't have any window then quitAndInstall immediately.
+  WindowList* window_list = WindowList::GetInstance();
+  if (window_list->size() == 0) {
+    auto_updater::AutoUpdater::QuitAndInstall();
+    return;
+  }
+
+  // Otherwise do the restart after all windows have been closed.
+  window_list->AddObserver(this);
+  for (NativeWindow* window : *window_list)
+    window->Close();
 }
 
 // static

atom/browser/api/atom_api_auto_updater.h

@@ -7,9 +7,9 @@
 
 #include <string>
 
-#include "base/callback.h"
 #include "atom/browser/api/event_emitter.h"
-#include "atom/browser/auto_updater_delegate.h"
+#include "atom/browser/auto_updater.h"
+#include "atom/browser/window_list_observer.h"
 #include "native_mate/handle.h"
 
 namespace atom {
@@ -17,7 +17,8 @@ namespace atom {
 namespace api {
 
 class AutoUpdater : public mate::EventEmitter,
-                    public auto_updater::AutoUpdaterDelegate {
+                    public auto_updater::Delegate,
+                    public WindowListObserver {
  public:
   static mate::Handle<AutoUpdater> Create(v8::Isolate* isolate);
 
@@ -25,17 +26,18 @@ class AutoUpdater : public mate::EventEmitter,
   AutoUpdater();
   virtual ~AutoUpdater();
 
-  // AutoUpdaterDelegate implementations.
+  // Delegate implementations.
   void OnError(const std::string& error) override;
   void OnCheckingForUpdate() override;
   void OnUpdateAvailable() override;
   void OnUpdateNotAvailable() override;
-  void OnUpdateDownloaded(
-      const std::string& release_notes,
-      const std::string& release_name,
-      const base::Time& release_date,
-      const std::string& update_url,
-      const base::Closure& quit_and_install) override;
+  void OnUpdateDownloaded(const std::string& release_notes,
+                          const std::string& release_name,
+                          const base::Time& release_date,
+                          const std::string& update_url) override;
+
+  // WindowListObserver:
+  void OnWindowAllClosed() override;
 
   // mate::Wrappable implementations:
   mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
@@ -44,8 +46,6 @@ class AutoUpdater : public mate::EventEmitter,
  private:
   void QuitAndInstall();
 
-  base::Closure quit_and_install_;
-
   DISALLOW_COPY_AND_ASSIGN(AutoUpdater);
 };
 

atom/browser/api/atom_api_content_tracing.cc

@@ -7,39 +7,30 @@
 
 #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 {
 
 template<>
-struct Converter<base::trace_event::CategoryFilter> {
+struct Converter<base::trace_event::TraceConfig> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
-                     base::trace_event::CategoryFilter* out) {
-    std::string filter;
-    if (!ConvertFromV8(isolate, val, &filter))
-      return false;
-    *out = base::trace_event::CategoryFilter(filter);
-    return true;
-  }
-};
-
-template<>
-struct Converter<base::trace_event::TraceOptions> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     base::trace_event::TraceOptions* out) {
-    std::string options;
+                     base::trace_event::TraceConfig* out) {
+    Dictionary options;
     if (!ConvertFromV8(isolate, val, &options))
       return false;
-    return out->SetFromString(options);
+    std::string category_filter, trace_options;
+    if (!options.Get("categoryFilter", &category_filter) ||
+        !options.Get("traceOptions", &trace_options))
+      return false;
+    *out = base::trace_event::TraceConfig(category_filter, trace_options);
+    return true;
   }
 };
 

atom/browser/api/atom_api_cookies.cc

@@ -20,8 +20,6 @@
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
-#include "atom/common/node_includes.h"
-
 using atom::api::Cookies;
 using content::BrowserThread;
 
@@ -206,7 +204,7 @@ void Cookies::GetCookiesOnIOThread(scoped_ptr<base::DictionaryValue> filter,
               Passed(&filter), callback))) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&RunGetCookiesCallbackOnUIThread, isolate(),
-                   "Url is not valid", net::CookieList(), callback));
+                   "URL is not valid", net::CookieList(), callback));
   }
 }
 
@@ -231,7 +229,7 @@ void Cookies::Remove(const mate::Dictionary& details,
     error_message = "Details(url, name) of removing cookie are required.";
   }
   if (error_message.empty() && !url.is_valid()) {
-    error_message = "Url is not valid.";
+    error_message = "URL is not valid.";
   }
   if (!error_message.empty()) {
      RunRemoveCookiesCallbackOnUIThread(isolate(), error_message, callback);
@@ -263,7 +261,7 @@ void Cookies::Set(const base::DictionaryValue& options,
 
   GURL gurl(url);
   if (error_message.empty() && !gurl.is_valid()) {
-    error_message = "Url is not valid.";
+    error_message = "URL is not valid.";
   }
 
   if (!error_message.empty()) {

atom/browser/api/atom_api_cookies.h

@@ -78,7 +78,7 @@ class Cookies : public mate::Wrappable {
   // Must be called on IO thread.
   net::CookieStore* GetCookieStore();
 
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+  net::URLRequestContextGetter* request_context_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(Cookies);
 };

atom/browser/api/atom_api_download_item.cc

@@ -0,0 +1,205 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_download_item.h"
+
+#include <map>
+
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/node_includes.h"
+#include "base/memory/linked_ptr.h"
+#include "base/strings/utf_string_conversions.h"
+#include "native_mate/dictionary.h"
+#include "net/base/filename_util.h"
+
+namespace mate {
+
+template<>
+struct Converter<content::DownloadItem::DownloadState> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   content::DownloadItem::DownloadState state) {
+    std::string download_state;
+    switch (state) {
+      case content::DownloadItem::COMPLETE:
+        download_state = "completed";
+        break;
+      case content::DownloadItem::CANCELLED:
+        download_state = "cancelled";
+        break;
+      case content::DownloadItem::INTERRUPTED:
+        download_state = "interrupted";
+        break;
+      default:
+        break;
+    }
+    return ConvertToV8(isolate, download_state);
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+
+namespace api {
+
+namespace {
+// The wrapDownloadItem funtion which is implemented in JavaScript
+using WrapDownloadItemCallback = base::Callback<void(v8::Local<v8::Value>)>;
+WrapDownloadItemCallback g_wrap_download_item;
+
+char kDownloadItemSavePathKey[] = "DownloadItemSavePathKey";
+
+std::map<uint32, linked_ptr<v8::Global<v8::Value>>> g_download_item_objects;
+}  // namespace
+
+DownloadItem::SavePathData::SavePathData(const base::FilePath& path) :
+  path_(path) {
+}
+
+const base::FilePath& DownloadItem::SavePathData::path() {
+  return path_;
+}
+
+DownloadItem::DownloadItem(content::DownloadItem* download_item) :
+    download_item_(download_item) {
+  download_item_->AddObserver(this);
+}
+
+DownloadItem::~DownloadItem() {
+  Destroy();
+}
+
+void DownloadItem::Destroy() {
+  if (download_item_) {
+    download_item_->RemoveObserver(this);
+    auto iter = g_download_item_objects.find(download_item_->GetId());
+    if (iter != g_download_item_objects.end())
+      g_download_item_objects.erase(iter);
+    download_item_ = nullptr;
+  }
+}
+
+bool DownloadItem::IsDestroyed() const {
+  return download_item_ == nullptr;
+}
+
+void DownloadItem::OnDownloadUpdated(content::DownloadItem* item) {
+  download_item_->IsDone() ? Emit("done", item->GetState()) : Emit("updated");
+}
+
+void DownloadItem::OnDownloadDestroyed(content::DownloadItem* download) {
+  Destroy();
+}
+
+int64 DownloadItem::GetReceivedBytes() {
+  return download_item_->GetReceivedBytes();
+}
+
+int64 DownloadItem::GetTotalBytes() {
+  return download_item_->GetTotalBytes();
+}
+
+const GURL& DownloadItem::GetURL() {
+  return download_item_->GetURL();
+}
+
+std::string DownloadItem::GetMimeType() {
+  return download_item_->GetMimeType();
+}
+
+bool DownloadItem::HasUserGesture() {
+  return download_item_->HasUserGesture();
+}
+
+std::string DownloadItem::GetFilename() {
+  return base::UTF16ToUTF8(net::GenerateFileName(GetURL(),
+                           GetContentDisposition(),
+                           std::string(),
+                           download_item_->GetSuggestedFilename(),
+                           GetMimeType(),
+                           std::string()).LossyDisplayName());
+}
+
+std::string DownloadItem::GetContentDisposition() {
+  return download_item_->GetContentDisposition();
+}
+
+void DownloadItem::SetSavePath(const base::FilePath& path) {
+  download_item_->SetUserData(UserDataKey(), new SavePathData(path));
+}
+
+void DownloadItem::Pause() {
+  download_item_->Pause();
+}
+
+void DownloadItem::Resume() {
+  download_item_->Resume();
+}
+
+void DownloadItem::Cancel() {
+  download_item_->Cancel(true);
+}
+
+mate::ObjectTemplateBuilder DownloadItem::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("pause", &DownloadItem::Pause)
+      .SetMethod("resume", &DownloadItem::Resume)
+      .SetMethod("cancel", &DownloadItem::Cancel)
+      .SetMethod("getReceivedBytes", &DownloadItem::GetReceivedBytes)
+      .SetMethod("getTotalBytes", &DownloadItem::GetTotalBytes)
+      .SetMethod("getURL", &DownloadItem::GetURL)
+      .SetMethod("getMimeType", &DownloadItem::GetMimeType)
+      .SetMethod("hasUserGesture", &DownloadItem::HasUserGesture)
+      .SetMethod("getFilename", &DownloadItem::GetFilename)
+      .SetMethod("getContentDisposition", &DownloadItem::GetContentDisposition)
+      .SetMethod("setSavePath", &DownloadItem::SetSavePath);
+}
+
+// static
+mate::Handle<DownloadItem> DownloadItem::Create(
+    v8::Isolate* isolate, content::DownloadItem* item) {
+  auto handle = mate::CreateHandle(isolate, new DownloadItem(item));
+  g_wrap_download_item.Run(handle.ToV8());
+  g_download_item_objects[item->GetId()] = make_linked_ptr(
+      new v8::Global<v8::Value>(isolate, handle.ToV8()));
+  return handle;
+}
+
+// static
+void* DownloadItem::UserDataKey() {
+  return &kDownloadItemSavePathKey;
+}
+
+void ClearWrapDownloadItem() {
+  g_wrap_download_item.Reset();
+}
+
+void SetWrapDownloadItem(const WrapDownloadItemCallback& callback) {
+  g_wrap_download_item = callback;
+
+  // Cleanup the wrapper on exit.
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(
+      base::Bind(ClearWrapDownloadItem));
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.SetMethod("_setWrapDownloadItem", &atom::api::SetWrapDownloadItem);
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_download_item, Initialize);

atom/browser/api/atom_api_download_item.h

@@ -0,0 +1,72 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_DOWNLOAD_ITEM_H_
+#define ATOM_BROWSER_API_ATOM_API_DOWNLOAD_ITEM_H_
+
+#include <string>
+
+#include "atom/browser/api/trackable_object.h"
+#include "base/files/file_path.h"
+#include "content/public/browser/download_item.h"
+#include "native_mate/handle.h"
+#include "url/gurl.h"
+
+namespace atom {
+
+namespace api {
+
+class DownloadItem : public mate::EventEmitter,
+                     public content::DownloadItem::Observer {
+ public:
+  class SavePathData : public base::SupportsUserData::Data {
+   public:
+    explicit SavePathData(const base::FilePath& path);
+    const base::FilePath& path();
+   private:
+    base::FilePath path_;
+  };
+
+  static mate::Handle<DownloadItem> Create(v8::Isolate* isolate,
+                                           content::DownloadItem* item);
+  static void* UserDataKey();
+
+ protected:
+  explicit DownloadItem(content::DownloadItem* download_item);
+  ~DownloadItem();
+
+  // Override content::DownloadItem::Observer methods
+  void OnDownloadUpdated(content::DownloadItem* download) override;
+  void OnDownloadDestroyed(content::DownloadItem* download) override;
+
+  void Pause();
+  void Resume();
+  void Cancel();
+  int64 GetReceivedBytes();
+  int64 GetTotalBytes();
+  std::string GetMimeType();
+  bool HasUserGesture();
+  std::string GetFilename();
+  std::string GetContentDisposition();
+  const GURL& GetURL();
+  void SetSavePath(const base::FilePath& path);
+
+ private:
+  // mate::Wrappable:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+  bool IsDestroyed() const override;
+
+  void Destroy();
+
+  content::DownloadItem* download_item_;
+
+  DISALLOW_COPY_AND_ASSIGN(DownloadItem);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_DOWNLOAD_ITEM_H_

atom/browser/api/atom_api_global_shortcut.cc

@@ -23,6 +23,9 @@ GlobalShortcut::GlobalShortcut() {
 }
 
 GlobalShortcut::~GlobalShortcut() {
+}
+
+void GlobalShortcut::Destroy() {
   UnregisterAll();
 }
 

atom/browser/api/atom_api_global_shortcut.h

@@ -8,9 +8,9 @@
 #include <map>
 #include <string>
 
+#include "atom/browser/api/trackable_object.h"
 #include "base/callback.h"
 #include "chrome/browser/extensions/global_shortcut_listener.h"
-#include "native_mate/wrappable.h"
 #include "native_mate/handle.h"
 #include "ui/base/accelerators/accelerator.h"
 
@@ -19,13 +19,16 @@ namespace atom {
 namespace api {
 
 class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
-                       public mate::Wrappable {
+                       public mate::TrackableObject<GlobalShortcut> {
  public:
   static mate::Handle<GlobalShortcut> Create(v8::Isolate* isolate);
 
  protected:
   GlobalShortcut();
-  virtual ~GlobalShortcut();
+  ~GlobalShortcut() override;
+
+  // mate::TrackableObject:
+  void Destroy() override;
 
   // mate::Wrappable implementations:
   mate::ObjectTemplateBuilder GetObjectTemplateBuilder(

atom/browser/api/atom_api_menu.cc

@@ -27,6 +27,14 @@ Menu::Menu()
 Menu::~Menu() {
 }
 
+void Menu::Destroy() {
+  model_.reset();
+}
+
+bool Menu::IsDestroyed() const {
+  return !model_;
+}
+
 void Menu::AfterInit(v8::Isolate* isolate) {
   mate::Dictionary wrappable(isolate, GetWrapper(isolate));
   mate::Dictionary delegate;
@@ -107,6 +115,10 @@ void Menu::SetSublabel(int index, const base::string16& sublabel) {
   model_->SetSublabel(index, sublabel);
 }
 
+void Menu::SetRole(int index, const base::string16& role) {
+  model_->SetRole(index, role);
+}
+
 void Menu::Clear() {
   model_->Clear();
 }
@@ -154,6 +166,7 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("insertSubMenu", &Menu::InsertSubMenuAt)
       .SetMethod("setIcon", &Menu::SetIcon)
       .SetMethod("setSublabel", &Menu::SetSublabel)
+      .SetMethod("setRole", &Menu::SetRole)
       .SetMethod("clear", &Menu::Clear)
       .SetMethod("getIndexOfCommandId", &Menu::GetIndexOfCommandId)
       .SetMethod("getItemCount", &Menu::GetItemCount)

atom/browser/api/atom_api_menu.h

@@ -8,16 +8,16 @@
 #include <string>
 
 #include "atom/browser/api/atom_api_window.h"
+#include "atom/browser/api/trackable_object.h"
 #include "atom/browser/ui/atom_menu_model.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
-#include "native_mate/wrappable.h"
 
 namespace atom {
 
 namespace api {
 
-class Menu : public mate::Wrappable,
+class Menu : public mate::TrackableObject<Menu>,
              public AtomMenuModel::Delegate {
  public:
   static mate::Wrappable* Create();
@@ -37,9 +37,13 @@ class Menu : public mate::Wrappable,
 
  protected:
   Menu();
-  virtual ~Menu();
+  ~Menu() override;
+
+  // mate::TrackableObject:
+  void Destroy() override;
 
   // mate::Wrappable:
+  bool IsDestroyed() const override;
   void AfterInit(v8::Isolate* isolate) override;
 
   // ui::SimpleMenuModel::Delegate:
@@ -73,6 +77,7 @@ class Menu : public mate::Wrappable,
                        Menu* menu);
   void SetIcon(int index, const gfx::Image& image);
   void SetSublabel(int index, const base::string16& sublabel);
+  void SetRole(int index, const base::string16& role);
   void Clear();
   int GetIndexOfCommandId(int command_id);
   int GetItemCount() const;

atom/browser/api/atom_api_menu_mac.h

@@ -19,6 +19,7 @@ class MenuMac : public Menu {
  protected:
   MenuMac();
 
+  void Destroy() override;
   void Popup(Window* window) override;
   void PopupAt(Window* window, int x, int y) override;
 

atom/browser/api/atom_api_menu_mac.mm

@@ -18,6 +18,11 @@ namespace api {
 MenuMac::MenuMac() {
 }
 
+void MenuMac::Destroy() {
+  menu_controller_.reset();
+  Menu::Destroy();
+}
+
 void MenuMac::Popup(Window* window) {
   NativeWindow* native_window = window->window();
   if (!native_window)

atom/browser/api/atom_api_power_monitor.cc

@@ -5,12 +5,11 @@
 #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 {
@@ -20,6 +19,9 @@ PowerMonitor::PowerMonitor() {
 }
 
 PowerMonitor::~PowerMonitor() {
+}
+
+void PowerMonitor::Destroy() {
   base::PowerMonitor::Get()->RemoveObserver(this);
 }
 
@@ -41,9 +43,9 @@ void PowerMonitor::OnResume() {
 // static
 v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
-    node::ThrowError(
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
         isolate,
-        "Cannot initialize \"power-monitor\" module before app is ready");
+        "Cannot initialize \"power-monitor\" module before app is ready")));
     return v8::Null(isolate);
   }
 

atom/browser/api/atom_api_power_monitor.h

@@ -5,7 +5,7 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
 #define ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
 
-#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/api/trackable_object.h"
 #include "base/compiler_specific.h"
 #include "base/power_monitor/power_observer.h"
 #include "native_mate/handle.h"
@@ -14,14 +14,17 @@ namespace atom {
 
 namespace api {
 
-class PowerMonitor : public mate::EventEmitter,
+class PowerMonitor : public mate::TrackableObject<PowerMonitor>,
                      public base::PowerObserver {
  public:
   static v8::Local<v8::Value> Create(v8::Isolate* isolate);
 
  protected:
   PowerMonitor();
-  virtual ~PowerMonitor();
+  ~PowerMonitor() override;
+
+  // mate::TrackableObject:
+  void Destroy() override;
 
   // base::PowerObserver implementations:
   void OnPowerStateChange(bool on_battery_power) override;

atom/browser/api/atom_api_power_save_blocker.cc

@@ -6,9 +6,9 @@
 
 #include <string>
 
+#include "atom/common/node_includes.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "native_mate/dictionary.h"
-#include "atom/common/node_includes.h"
 
 namespace mate {
 
@@ -45,6 +45,11 @@ PowerSaveBlocker::PowerSaveBlocker()
 PowerSaveBlocker::~PowerSaveBlocker() {
 }
 
+void PowerSaveBlocker::Destroy() {
+  power_save_blocker_types_.clear();
+  power_save_blocker_.reset();
+}
+
 void PowerSaveBlocker::UpdatePowerSaveBlocker() {
   if (power_save_blocker_types_.empty()) {
     power_save_blocker_.reset();

atom/browser/api/atom_api_power_save_blocker.h

@@ -7,10 +7,10 @@
 
 #include <map>
 
+#include "atom/browser/api/trackable_object.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "native_mate/handle.h"
-#include "native_mate/wrappable.h"
 
 namespace mate {
 class Dictionary;
@@ -20,13 +20,16 @@ namespace atom {
 
 namespace api {
 
-class PowerSaveBlocker : public mate::Wrappable {
+class PowerSaveBlocker : public mate::TrackableObject<PowerSaveBlocker> {
  public:
   static mate::Handle<PowerSaveBlocker> Create(v8::Isolate* isolate);
 
  protected:
   PowerSaveBlocker();
-  virtual ~PowerSaveBlocker();
+  ~PowerSaveBlocker() override;
+
+  // mate::TrackableObject:
+  void Destroy() override;
 
   // mate::Wrappable implementations:
   mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
@@ -48,7 +51,6 @@ class PowerSaveBlocker : public mate::Wrappable {
       std::map<int, content::PowerSaveBlocker::PowerSaveBlockerType>;
   PowerSaveBlockerTypeMap power_save_blocker_types_;
 
-
   DISALLOW_COPY_AND_ASSIGN(PowerSaveBlocker);
 };
 

atom/browser/api/atom_api_protocol.cc

@@ -7,264 +7,50 @@
 #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/api/atom_api_session.h"
-#include "atom/browser/net/adapter_request_job.h"
-#include "atom/browser/net/atom_url_request_job_factory.h"
+#include "atom/browser/net/url_request_async_asar_job.h"
+#include "atom/browser/net/url_request_buffer_job.h"
+#include "atom/browser/net/url_request_fetch_job.h"
+#include "atom/browser/net/url_request_string_job.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/gurl_converter.h"
-#include "content/public/browser/browser_thread.h"
-#include "native_mate/dictionary.h"
-#include "net/url_request/url_request_context.h"
-
+#include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/node_includes.h"
+#include "native_mate/dictionary.h"
 
 using content::BrowserThread;
 
-namespace mate {
-
-template<>
-struct Converter<const net::URLRequest*> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const net::URLRequest* val) {
-    return mate::ObjectTemplateBuilder(isolate)
-        .SetValue("method", val->method())
-        .SetValue("url", val->url().spec())
-        .SetValue("referrer", val->referrer())
-        .Build()->NewInstance();
-  }
-};
-
-}  // namespace mate
-
 namespace atom {
 
 namespace api {
 
-namespace {
-
-typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
-
-scoped_refptr<base::RefCountedBytes> BufferToRefCountedBytes(
-    v8::Local<v8::Value> buf) {
-  scoped_refptr<base::RefCountedBytes> data(new base::RefCountedBytes);
-  auto start = reinterpret_cast<const unsigned char*>(node::Buffer::Data(buf));
-  data->data().assign(start, start + node::Buffer::Length(buf));
-  return data;
-}
-
-class CustomProtocolRequestJob : public AdapterRequestJob {
- public:
-  CustomProtocolRequestJob(Protocol* registry,
-                           ProtocolHandler* protocol_handler,
-                           net::URLRequest* request,
-                           net::NetworkDelegate* network_delegate)
-      : AdapterRequestJob(protocol_handler, request, network_delegate),
-        registry_(registry) {
-  }
-
-  void GetJobTypeInUI(const Protocol::JsProtocolHandler& callback) {
-    DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-    v8::Locker locker(registry_->isolate());
-    v8::HandleScope handle_scope(registry_->isolate());
-
-    // Call the JS handler.
-    v8::Local<v8::Value> result = callback.Run(request());
-
-    // Determine the type of the job we are going to create.
-    if (result->IsString()) {
-      std::string data = mate::V8ToString(result);
-      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-          base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
-                     GetWeakPtr(), "text/plain", "UTF-8", data));
-      return;
-    } else if (result->IsObject()) {
-      v8::Local<v8::Object> obj = result->ToObject();
-      mate::Dictionary dict(registry_->isolate(), obj);
-      std::string name = mate::V8ToString(obj->GetConstructorName());
-      if (name == "RequestStringJob") {
-        std::string mime_type, charset, data;
-        dict.Get("mimeType", &mime_type);
-        dict.Get("charset", &charset);
-        dict.Get("data", &data);
-
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-            base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
-                       GetWeakPtr(), mime_type, charset, data));
-        return;
-      } else if (name == "RequestBufferJob") {
-        std::string mime_type, encoding;
-        v8::Local<v8::Value> buffer;
-        dict.Get("mimeType", &mime_type);
-        dict.Get("encoding", &encoding);
-        dict.Get("data", &buffer);
-
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-            base::Bind(&AdapterRequestJob::CreateBufferJobAndStart,
-                       GetWeakPtr(), mime_type, encoding,
-                       BufferToRefCountedBytes(buffer)));
-        return;
-      } else if (name == "RequestFileJob") {
-        base::FilePath path;
-        dict.Get("path", &path);
-
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-            base::Bind(&AdapterRequestJob::CreateFileJobAndStart,
-                       GetWeakPtr(), path));
-        return;
-      } else if (name == "RequestErrorJob") {
-        int error = net::ERR_NOT_IMPLEMENTED;
-        dict.Get("error", &error);
-
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-            base::Bind(&AdapterRequestJob::CreateErrorJobAndStart,
-                       GetWeakPtr(), error));
-        return;
-      } else if (name == "RequestHttpJob") {
-        GURL url;
-        std::string method, referrer;
-        dict.Get("url", &url);
-        dict.Get("method", &method);
-        dict.Get("referrer", &referrer);
-
-        v8::Local<v8::Value> value;
-        mate::Handle<Session> session;
-        scoped_refptr<net::URLRequestContextGetter> request_context_getter;
-        // "session" null -> pass nullptr;
-        // "session" a Session object -> use passed session.
-        // "session" undefined -> use current session;
-        if (dict.Get("session", &session))
-          request_context_getter =
-              session->browser_context()->GetRequestContext();
-        else if (dict.Get("session", &value) && value->IsNull())
-          request_context_getter = nullptr;
-        else
-          request_context_getter = registry_->request_context_getter();
-
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-            base::Bind(&AdapterRequestJob::CreateHttpJobAndStart, GetWeakPtr(),
-                       request_context_getter, url, method, referrer));
-        return;
-      }
-    }
-
-    // Try the default protocol handler if we have.
-    if (default_protocol_handler()) {
-      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-          base::Bind(&AdapterRequestJob::CreateJobFromProtocolHandlerAndStart,
-                     GetWeakPtr()));
-      return;
-    }
-
-    // Fallback to the not implemented error.
-    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-        base::Bind(&AdapterRequestJob::CreateErrorJobAndStart,
-                   GetWeakPtr(), net::ERR_NOT_IMPLEMENTED));
-  }
-
-  // AdapterRequestJob:
-  void GetJobType() override {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&CustomProtocolRequestJob::GetJobTypeInUI,
-                   base::Unretained(this),
-                   registry_->GetProtocolHandler(request()->url().scheme())));
-  }
-
- private:
-  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
-};
-
-// Always return the same CustomProtocolRequestJob for all requests, because
-// the content API needs the ProtocolHandler to return a job immediately, and
-// getting the real job from the JS requires asynchronous calls, so we have
-// to create an adapter job first.
-// Users can also pass an extra ProtocolHandler as the fallback one when
-// registered handler doesn't want to deal with the request.
-class CustomProtocolHandler : public ProtocolHandler {
- public:
-  CustomProtocolHandler(api::Protocol* registry,
-                        ProtocolHandler* protocol_handler = NULL)
-      : registry_(registry), protocol_handler_(protocol_handler) {
-  }
-
-  net::URLRequestJob* MaybeCreateJob(
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const override {
-    return new CustomProtocolRequestJob(registry_, protocol_handler_.get(),
-                                        request, network_delegate);
-  }
-
-  ProtocolHandler* ReleaseDefaultProtocolHandler() {
-    return protocol_handler_.release();
-  }
-
-  ProtocolHandler* original_handler() { return protocol_handler_.get(); }
-
- private:
-  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
-  scoped_ptr<ProtocolHandler> protocol_handler_;
-
-  DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
-};
-
-std::string ConvertErrorCode(int error_code) {
-  switch (error_code) {
-    case Protocol::ERR_SCHEME_REGISTERED:
-      return "The Scheme is already registered";
-    case Protocol::ERR_SCHEME_UNREGISTERED:
-      return "The Scheme has not been registered";
-    case Protocol::ERR_SCHEME_INTERCEPTED:
-      return "There is no protocol handler to intercept";
-    case Protocol::ERR_SCHEME_UNINTERCEPTED:
-      return "The protocol is not intercepted";
-    case Protocol::ERR_NO_SCHEME:
-      return "The Scheme does not exist.";
-    case Protocol::ERR_SCHEME:
-      return "Cannot intercept custom protocols";
-    default:
-      NOTREACHED();
-      return std::string();
-  }
-}
-
-}  // namespace
-
 Protocol::Protocol(AtomBrowserContext* browser_context)
     : request_context_getter_(browser_context->GetRequestContext()),
       job_factory_(browser_context->job_factory()) {
   CHECK(job_factory_);
 }
 
-Protocol::JsProtocolHandler Protocol::GetProtocolHandler(
-    const std::string& scheme) {
-  return protocol_handlers_[scheme];
-}
-
-void Protocol::OnIOActionCompleted(const JsCompletionCallback& callback,
-                                   int error) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-
-  if (error) {
-    callback.Run(v8::Exception::Error(
-        mate::StringToV8(isolate(), ConvertErrorCode(error))));
-    return;
-  }
-
-  callback.Run(v8::Null(isolate()));
-}
-
 mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return mate::ObjectTemplateBuilder(isolate)
       .SetMethod("registerStandardSchemes", &Protocol::RegisterStandardSchemes)
-      .SetMethod("isHandledProtocol", &Protocol::IsHandledProtocol)
-      .SetMethod("_registerProtocol", &Protocol::RegisterProtocol)
-      .SetMethod("_unregisterProtocol", &Protocol::UnregisterProtocol)
-      .SetMethod("_interceptProtocol", &Protocol::InterceptProtocol)
-      .SetMethod("_uninterceptProtocol", &Protocol::UninterceptProtocol);
+      .SetMethod("registerStringProtocol",
+                 &Protocol::RegisterProtocol<URLRequestStringJob>)
+      .SetMethod("registerBufferProtocol",
+                 &Protocol::RegisterProtocol<URLRequestBufferJob>)
+      .SetMethod("registerFileProtocol",
+                 &Protocol::RegisterProtocol<URLRequestAsyncAsarJob>)
+      .SetMethod("registerHttpProtocol",
+                 &Protocol::RegisterProtocol<URLRequestFetchJob>)
+      .SetMethod("unregisterProtocol", &Protocol::UnregisterProtocol)
+      .SetMethod("isProtocolHandled", &Protocol::IsProtocolHandled)
+      .SetMethod("interceptStringProtocol",
+                 &Protocol::InterceptProtocol<URLRequestStringJob>)
+      .SetMethod("interceptBufferProtocol",
+                 &Protocol::InterceptProtocol<URLRequestBufferJob>)
+      .SetMethod("interceptFileProtocol",
+                 &Protocol::InterceptProtocol<URLRequestAsyncAsarJob>)
+      .SetMethod("interceptHttpProtocol",
+                 &Protocol::InterceptProtocol<URLRequestFetchJob>)
+      .SetMethod("uninterceptProtocol", &Protocol::UninterceptProtocol);
 }
 
 void Protocol::RegisterStandardSchemes(
@@ -272,131 +58,86 @@ void Protocol::RegisterStandardSchemes(
   atom::AtomBrowserClient::SetCustomSchemes(schemes);
 }
 
-void Protocol::IsHandledProtocol(const std::string& scheme,
-                                 const net::CompletionCallback& callback) {
-  BrowserThread::PostTaskAndReplyWithResult(BrowserThread::IO, FROM_HERE,
-      base::Bind(&AtomURLRequestJobFactory::IsHandledProtocol,
-                 base::Unretained(job_factory_), scheme),
+void Protocol::UnregisterProtocol(
+    const std::string& scheme, mate::Arguments* args) {
+  CompletionCallback callback;
+  args->GetNext(&callback);
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&Protocol::UnregisterProtocolInIO,
+                 base::Unretained(this), scheme),
+      base::Bind(&Protocol::OnIOCompleted,
+                 base::Unretained(this), callback));
+}
+
+Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
+    const std::string& scheme) {
+  if (!job_factory_->HasProtocolHandler(scheme))
+    return PROTOCOL_NOT_REGISTERED;
+  job_factory_->SetProtocolHandler(scheme, nullptr);
+  return PROTOCOL_OK;
+}
+
+void Protocol::IsProtocolHandled(const std::string& scheme,
+                                    const BooleanCallback& callback) {
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&Protocol::IsProtocolHandledInIO,
+                 base::Unretained(this), scheme),
       callback);
 }
 
-void Protocol::RegisterProtocol(v8::Isolate* isolate,
-                                const std::string& scheme,
-                                const JsProtocolHandler& handler,
-                                const JsCompletionCallback& callback) {
-  BrowserThread::PostTaskAndReplyWithResult(BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::RegisterProtocolInIO,
-                 base::Unretained(this), scheme, handler),
-      base::Bind(&Protocol::OnIOActionCompleted,
-                 base::Unretained(this), callback));
+bool Protocol::IsProtocolHandledInIO(const std::string& scheme) {
+  return job_factory_->IsHandledProtocol(scheme);
 }
 
-void Protocol::UnregisterProtocol(v8::Isolate* isolate,
-                                  const std::string& scheme,
-                                  const JsCompletionCallback& callback) {
-  BrowserThread::PostTaskAndReplyWithResult(BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::UnregisterProtocolInIO,
-                 base::Unretained(this), scheme),
-      base::Bind(&Protocol::OnIOActionCompleted,
-                 base::Unretained(this), callback));
-}
-
-void Protocol::InterceptProtocol(v8::Isolate* isolate,
-                                 const std::string& scheme,
-                                 const JsProtocolHandler& handler,
-                                 const JsCompletionCallback& callback) {
-  BrowserThread::PostTaskAndReplyWithResult(BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::InterceptProtocolInIO,
-                 base::Unretained(this), scheme, handler),
-      base::Bind(&Protocol::OnIOActionCompleted,
-                 base::Unretained(this), callback));
-}
-
-void Protocol::UninterceptProtocol(v8::Isolate* isolate,
-                                   const std::string& scheme,
-                                   const JsCompletionCallback& callback) {
-  BrowserThread::PostTaskAndReplyWithResult(BrowserThread::IO, FROM_HERE,
+void Protocol::UninterceptProtocol(
+    const std::string& scheme, mate::Arguments* args) {
+  CompletionCallback callback;
+  args->GetNext(&callback);
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
       base::Bind(&Protocol::UninterceptProtocolInIO,
                  base::Unretained(this), scheme),
-      base::Bind(&Protocol::OnIOActionCompleted,
+      base::Bind(&Protocol::OnIOCompleted,
                  base::Unretained(this), callback));
 }
 
-int Protocol::RegisterProtocolInIO(const std::string& scheme,
-                                   const JsProtocolHandler& handler) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (ContainsKey(protocol_handlers_, scheme) ||
-      job_factory_->IsHandledProtocol(scheme)) {
-    return ERR_SCHEME_REGISTERED;
-  }
-
-  protocol_handlers_[scheme] = handler;
-  job_factory_->SetProtocolHandler(scheme, new CustomProtocolHandler(this));
-
-  return OK;
+Protocol::ProtocolError Protocol::UninterceptProtocolInIO(
+    const std::string& scheme) {
+  if (!original_protocols_.contains(scheme))
+    return PROTOCOL_NOT_INTERCEPTED;
+  job_factory_->ReplaceProtocol(scheme,
+                                original_protocols_.take_and_erase(scheme));
+  return PROTOCOL_OK;
 }
 
-int Protocol::UnregisterProtocolInIO(const std::string& scheme) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+void Protocol::OnIOCompleted(
+    const CompletionCallback& callback, ProtocolError error) {
+  // The completion callback is optional.
+  if (callback.is_null())
+    return;
 
-  ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
-  if (it == protocol_handlers_.end()) {
-    return ERR_SCHEME_UNREGISTERED;
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+
+  if (error == PROTOCOL_OK) {
+    callback.Run(v8::Null(isolate()));
+  } else {
+    std::string str = ErrorCodeToString(error);
+    callback.Run(v8::Exception::Error(mate::StringToV8(isolate(), str)));
   }
-
-  protocol_handlers_.erase(it);
-  job_factory_->SetProtocolHandler(scheme, NULL);
-
-  return OK;
 }
 
-int Protocol::InterceptProtocolInIO(const std::string& scheme,
-                                    const JsProtocolHandler& handler) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  // Force the request context to initialize, otherwise we might have nothing
-  // to intercept.
-  request_context_getter_->GetURLRequestContext();
-
-  if (!job_factory_->HasProtocolHandler(scheme))
-    return ERR_NO_SCHEME;
-
-  if (ContainsKey(protocol_handlers_, scheme))
-    return ERR_SCHEME;
-
-  protocol_handlers_[scheme] = handler;
-  ProtocolHandler* original_handler = job_factory_->GetProtocolHandler(scheme);
-  if (original_handler == nullptr) {
-    return ERR_SCHEME_INTERCEPTED;
+std::string Protocol::ErrorCodeToString(ProtocolError error) {
+  switch (error) {
+    case PROTOCOL_FAIL: return "Failed to manipulate protocol factory";
+    case PROTOCOL_REGISTERED: return "The scheme has been registred";
+    case PROTOCOL_NOT_REGISTERED: return "The scheme has not been registred";
+    case PROTOCOL_INTERCEPTED: return "The scheme has been intercepted";
+    case PROTOCOL_NOT_INTERCEPTED: return "The scheme has not been intercepted";
+    default: return "Unexpected error";
   }
-
-  job_factory_->ReplaceProtocol(
-      scheme, new CustomProtocolHandler(this, original_handler));
-
-  return OK;
-}
-
-int Protocol::UninterceptProtocolInIO(const std::string& scheme) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
-  if (it == protocol_handlers_.end())
-    return ERR_SCHEME_UNREGISTERED;
-
-  protocol_handlers_.erase(it);
-  CustomProtocolHandler* handler = static_cast<CustomProtocolHandler*>(
-      job_factory_->GetProtocolHandler(scheme));
-  if (handler->original_handler() == nullptr) {
-    return ERR_SCHEME_UNINTERCEPTED;
-  }
-
-  // Reset the protocol handler to the orignal one and delete current protocol
-  // handler.
-  ProtocolHandler* original_handler = handler->ReleaseDefaultProtocolHandler();
-  delete job_factory_->ReplaceProtocol(scheme, original_handler);
-
-  return OK;
 }
 
 // static

atom/browser/api/atom_api_protocol.h

@@ -9,10 +9,14 @@
 #include <map>
 #include <vector>
 
-#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/net/atom_url_request_job_factory.h"
 #include "base/callback.h"
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "content/public/browser/browser_thread.h"
+#include "native_mate/arguments.h"
+#include "native_mate/dictionary.h"
 #include "native_mate/handle.h"
-#include "net/base/completion_callback.h"
+#include "native_mate/wrappable.h"
 
 namespace net {
 class URLRequest;
@@ -26,31 +30,16 @@ class AtomURLRequestJobFactory;
 
 namespace api {
 
-class Protocol : public mate::EventEmitter {
+class Protocol : public mate::Wrappable {
  public:
-  using JsProtocolHandler =
-      base::Callback<v8::Local<v8::Value>(const net::URLRequest*)>;
-  using JsCompletionCallback = base::Callback<void(v8::Local<v8::Value>)>;
-
-  enum {
-    OK = 0,
-    ERR_SCHEME_REGISTERED,
-    ERR_SCHEME_UNREGISTERED,
-    ERR_SCHEME_INTERCEPTED,
-    ERR_SCHEME_UNINTERCEPTED,
-    ERR_NO_SCHEME,
-    ERR_SCHEME
-  };
+  using Handler =
+      base::Callback<void(const net::URLRequest*, v8::Local<v8::Value>)>;
+  using CompletionCallback = base::Callback<void(v8::Local<v8::Value>)>;
+  using BooleanCallback = base::Callback<void(bool)>;
 
   static mate::Handle<Protocol> Create(
       v8::Isolate* isolate, AtomBrowserContext* browser_context);
 
-  JsProtocolHandler GetProtocolHandler(const std::string& scheme);
-
-  net::URLRequestContextGetter* request_context_getter() {
-    return request_context_getter_.get();
-  }
-
  protected:
   explicit Protocol(AtomBrowserContext* browser_context);
 
@@ -59,48 +48,139 @@ class Protocol : public mate::EventEmitter {
       v8::Isolate* isolate);
 
  private:
-  typedef std::map<std::string, JsProtocolHandler> ProtocolHandlersMap;
+  // Possible errors.
+  enum ProtocolError {
+    PROTOCOL_OK,  // no error
+    PROTOCOL_FAIL,  // operation failed, should never occur
+    PROTOCOL_REGISTERED,
+    PROTOCOL_NOT_REGISTERED,
+    PROTOCOL_INTERCEPTED,
+    PROTOCOL_NOT_INTERCEPTED,
+  };
 
-  // Callback called after performing action on IO thread.
-  void OnIOActionCompleted(const JsCompletionCallback& callback,
-                           int error);
+  // The protocol handler that will create a protocol handler for certain
+  // request job.
+  template<typename RequestJob>
+  class CustomProtocolHandler
+      : public net::URLRequestJobFactory::ProtocolHandler {
+   public:
+    CustomProtocolHandler(
+        v8::Isolate* isolate,
+        net::URLRequestContextGetter* request_context,
+        const Handler& handler)
+        : isolate_(isolate),
+          request_context_(request_context),
+          handler_(handler) {}
+    ~CustomProtocolHandler() override {}
+
+    net::URLRequestJob* MaybeCreateJob(
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const override {
+      RequestJob* request_job = new RequestJob(request, network_delegate);
+      request_job->SetHandlerInfo(isolate_, request_context_, handler_);
+      return request_job;
+    }
+
+   private:
+    v8::Isolate* isolate_;
+    net::URLRequestContextGetter* request_context_;
+    Protocol::Handler handler_;
+
+    DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
+  };
 
   // Register schemes to standard scheme list.
   void RegisterStandardSchemes(const std::vector<std::string>& schemes);
 
-  // Returns whether a scheme has been registered.
-  void IsHandledProtocol(const std::string& scheme,
-                         const net::CompletionCallback& callback);
+  // Register the protocol with certain request job.
+  template<typename RequestJob>
+  void RegisterProtocol(const std::string& scheme,
+                        const Handler& handler,
+                        mate::Arguments* args) {
+    CompletionCallback callback;
+    args->GetNext(&callback);
+    content::BrowserThread::PostTaskAndReplyWithResult(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&Protocol::RegisterProtocolInIO<RequestJob>,
+                   base::Unretained(this), scheme, handler),
+        base::Bind(&Protocol::OnIOCompleted,
+                   base::Unretained(this), callback));
+  }
+  template<typename RequestJob>
+  ProtocolError RegisterProtocolInIO(const std::string& scheme,
+                                     const Handler& handler) {
+    if (job_factory_->IsHandledProtocol(scheme))
+      return PROTOCOL_REGISTERED;
+    scoped_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
+        new CustomProtocolHandler<RequestJob>(
+            isolate(), request_context_getter_, handler));
+    if (job_factory_->SetProtocolHandler(scheme, protocol_handler.Pass()))
+      return PROTOCOL_OK;
+    else
+      return PROTOCOL_FAIL;
+  }
 
-  // Register/unregister an networking |scheme| which would be handled by
-  // |callback|.
-  void RegisterProtocol(v8::Isolate* isolate,
-                        const std::string& scheme,
-                        const JsProtocolHandler& handler,
-                        const JsCompletionCallback& callback);
-  void UnregisterProtocol(v8::Isolate* isolate, const std::string& scheme,
-                          const JsCompletionCallback& callback);
+  // Unregister the protocol handler that handles |scheme|.
+  void UnregisterProtocol(const std::string& scheme, mate::Arguments* args);
+  ProtocolError UnregisterProtocolInIO(const std::string& scheme);
 
-  // Intercept/unintercept an existing protocol handler.
-  void InterceptProtocol(v8::Isolate* isolate,
-                         const std::string& scheme,
-                         const JsProtocolHandler& handler,
-                         const JsCompletionCallback& callback);
-  void UninterceptProtocol(v8::Isolate* isolate, const std::string& scheme,
-                           const JsCompletionCallback& callback);
+  // Whether the protocol has handler registered.
+  void IsProtocolHandled(const std::string& scheme,
+                         const BooleanCallback& callback);
+  bool IsProtocolHandledInIO(const std::string& scheme);
 
-  // The networking related operations have to be done in IO thread.
-  int RegisterProtocolInIO(const std::string& scheme,
-                           const JsProtocolHandler& handler);
-  int UnregisterProtocolInIO(const std::string& scheme);
-  int InterceptProtocolInIO(const std::string& scheme,
-                            const JsProtocolHandler& handler);
-  int UninterceptProtocolInIO(const std::string& scheme);
+  // Replace the protocol handler with a new one.
+  template<typename RequestJob>
+  void InterceptProtocol(const std::string& scheme,
+                         const Handler& handler,
+                         mate::Arguments* args) {
+    CompletionCallback callback;
+    args->GetNext(&callback);
+    content::BrowserThread::PostTaskAndReplyWithResult(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&Protocol::InterceptProtocolInIO<RequestJob>,
+                   base::Unretained(this), scheme, handler),
+        base::Bind(&Protocol::OnIOCompleted,
+                   base::Unretained(this), callback));
+  }
+  template<typename RequestJob>
+  ProtocolError InterceptProtocolInIO(const std::string& scheme,
+                                      const Handler& handler) {
+    if (!job_factory_->IsHandledProtocol(scheme))
+      return PROTOCOL_NOT_REGISTERED;
+    // It is possible a protocol is handled but can not be intercepted.
+    if (!job_factory_->HasProtocolHandler(scheme))
+      return PROTOCOL_FAIL;
+    if (ContainsKey(original_protocols_, scheme))
+      return PROTOCOL_INTERCEPTED;
+    scoped_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
+        new CustomProtocolHandler<RequestJob>(
+            isolate(), request_context_getter_, handler));
+    original_protocols_.set(
+        scheme,
+        job_factory_->ReplaceProtocol(scheme, protocol_handler.Pass()));
+    return PROTOCOL_OK;
+  }
 
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
+  // Restore the |scheme| to its original protocol handler.
+  void UninterceptProtocol(const std::string& scheme, mate::Arguments* args);
+  ProtocolError UninterceptProtocolInIO(const std::string& scheme);
 
-  AtomURLRequestJobFactory* job_factory_;
-  ProtocolHandlersMap protocol_handlers_;
+  // Convert error code to JS exception and call the callback.
+  void OnIOCompleted(const CompletionCallback& callback, ProtocolError error);
+
+  // Convert error code to string.
+  std::string ErrorCodeToString(ProtocolError error);
+
+  net::URLRequestContextGetter* request_context_getter_;
+
+  // Map that stores the original protocols of schemes.
+  using OriginalProtocolsMap = base::ScopedPtrHashMap<
+      std::string,
+      scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>>;
+  OriginalProtocolsMap original_protocols_;
+
+  AtomURLRequestJobFactory* job_factory_;  // weak ref
 
   DISALLOW_COPY_AND_ASSIGN(Protocol);
 };

atom/browser/api/atom_api_screen.cc

@@ -113,14 +113,16 @@ mate::ObjectTemplateBuilder Screen::GetObjectTemplateBuilder(
 // static
 v8::Local<v8::Value> Screen::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
-    node::ThrowError(isolate,
-                     "Cannot initialize \"screen\" module before app is ready");
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate,
+        "Cannot initialize \"screen\" module before app is ready")));
     return v8::Null(isolate);
   }
 
   gfx::Screen* screen = gfx::Screen::GetNativeScreen();
   if (!screen) {
-    node::ThrowError(isolate, "Failed to get screen information");
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Failed to get screen information")));
     return v8::Null(isolate);
   }
 

atom/browser/api/atom_api_session.cc

@@ -8,14 +8,23 @@
 #include <vector>
 
 #include "atom/browser/api/atom_api_cookies.h"
+#include "atom/browser/api/atom_api_download_item.h"
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/api/save_page_handler.h"
 #include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/net/atom_cert_verifier.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/net_converter.h"
+#include "atom/common/node_includes.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
+#include "brightray/browser/net/devtools_network_conditions.h"
+#include "brightray/browser/net/devtools_network_controller.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
@@ -28,8 +37,6 @@
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
-#include "atom/common/node_includes.h"
-
 using content::BrowserThread;
 using content::StoragePartition;
 
@@ -101,6 +108,24 @@ struct Converter<ClearStorageDataOptions> {
   }
 };
 
+template<>
+struct Converter<net::ProxyConfig> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     net::ProxyConfig* out) {
+    std::string proxy;
+    if (!ConvertFromV8(isolate, val, &proxy))
+      return false;
+    auto pac_url = GURL(proxy);
+    if (pac_url.is_valid()) {
+      out->set_pac_url(pac_url);
+    } else {
+      out->proxy_rules().ParseFromString(proxy);
+    }
+    return true;
+  }
+};
+
 }  // namespace mate
 
 namespace atom {
@@ -109,6 +134,10 @@ namespace api {
 
 namespace {
 
+// The wrapSession funtion which is implemented in JavaScript
+using WrapSessionCallback = base::Callback<void(v8::Local<v8::Value>)>;
+WrapSessionCallback g_wrap_session;
+
 class ResolveProxyHelper {
  public:
   ResolveProxyHelper(AtomBrowserContext* browser_context,
@@ -201,12 +230,12 @@ void ClearHttpCacheInIO(
 }
 
 void SetProxyInIO(net::URLRequestContextGetter* getter,
-                  const std::string& proxy,
+                  const net::ProxyConfig& config,
                   const base::Closure& callback) {
-  net::ProxyConfig config;
-  config.proxy_rules().ParseFromString(proxy);
   auto proxy_service = getter->GetURLRequestContext()->proxy_service();
   proxy_service->ResetConfigService(new net::ProxyConfigServiceFixed(config));
+  // Refetches and applies the new pac script if provided.
+  proxy_service->ForceReloadProxyConfig();
   RunCallbackInUI(callback);
 }
 
@@ -215,13 +244,43 @@ void SetProxyInIO(net::URLRequestContextGetter* getter,
 Session::Session(AtomBrowserContext* browser_context)
     : browser_context_(browser_context) {
   AttachAsUserData(browser_context);
+
+  // Observe DownloadManger to get download notifications.
+  content::BrowserContext::GetDownloadManager(browser_context)->
+      AddObserver(this);
 }
 
 Session::~Session() {
+  content::BrowserContext::GetDownloadManager(browser_context())->
+      RemoveObserver(this);
+  Destroy();
+}
+
+void Session::OnDownloadCreated(content::DownloadManager* manager,
+                                content::DownloadItem* item) {
+  auto web_contents = item->GetWebContents();
+  if (SavePageHandler::IsSavePageTypes(item->GetMimeType()))
+    return;
+  bool prevent_default = Emit(
+      "will-download",
+      DownloadItem::Create(isolate(), item),
+      api::WebContents::CreateFrom(isolate(), web_contents));
+  if (prevent_default) {
+    item->Cancel(true);
+    item->Remove();
+  }
+}
+
+bool Session::IsDestroyed() const {
+  return !browser_context_;
+}
+
+void Session::Destroy() {
+  browser_context_ = nullptr;
 }
 
 void Session::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
-  new ResolveProxyHelper(browser_context_, url, callback);
+  new ResolveProxyHelper(browser_context(), url, callback);
 }
 
 void Session::ClearCache(const net::CompletionCallback& callback) {
@@ -242,18 +301,18 @@ void Session::ClearStorageData(mate::Arguments* args) {
   }
 
   auto storage_partition =
-      content::BrowserContext::GetStoragePartition(browser_context_, nullptr);
+      content::BrowserContext::GetStoragePartition(browser_context(), nullptr);
   storage_partition->ClearData(
       options.storage_types, options.quota_types, options.origin,
       content::StoragePartition::OriginMatcherFunction(),
       base::Time(), base::Time::Max(), callback);
 }
 
-void Session::SetProxy(const std::string& proxy,
+void Session::SetProxy(const net::ProxyConfig& config,
                        const base::Closure& callback) {
   auto getter = browser_context_->GetRequestContext();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&SetProxyInIO, base::Unretained(getter), proxy, callback));
+      base::Bind(&SetProxyInIO, base::Unretained(getter), config, callback));
 }
 
 void Session::SetDownloadPath(const base::FilePath& path) {
@@ -261,9 +320,57 @@ void Session::SetDownloadPath(const base::FilePath& path) {
       prefs::kDownloadDefaultDirectory, path);
 }
 
+void Session::EnableNetworkEmulation(const mate::Dictionary& options) {
+  scoped_ptr<brightray::DevToolsNetworkConditions> conditions;
+  bool offline = false;
+  double latency, download_throughput, upload_throughput;
+  if (options.Get("offline", &offline) && offline) {
+    conditions.reset(new brightray::DevToolsNetworkConditions(offline));
+  } else {
+    options.Get("latency", &latency);
+    options.Get("downloadThroughput", &download_throughput);
+    options.Get("uploadThroughput", &upload_throughput);
+    conditions.reset(
+        new brightray::DevToolsNetworkConditions(false,
+                                                 latency,
+                                                 download_throughput,
+                                                 upload_throughput));
+  }
+  auto controller = browser_context_->GetDevToolsNetworkController();
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&brightray::DevToolsNetworkController::SetNetworkState,
+                 base::Unretained(controller),
+                 std::string(),
+                 base::Passed(&conditions)));
+}
+
+void Session::DisableNetworkEmulation() {
+  scoped_ptr<brightray::DevToolsNetworkConditions> conditions(
+      new brightray::DevToolsNetworkConditions(false));
+  auto controller = browser_context_->GetDevToolsNetworkController();
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&brightray::DevToolsNetworkController::SetNetworkState,
+                 base::Unretained(controller),
+                 std::string(),
+                 base::Passed(&conditions)));
+}
+
+void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
+                                mate::Arguments* args) {
+  AtomCertVerifier::VerifyProc proc;
+  if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &proc))) {
+    args->ThrowError("Must pass null or function");
+    return;
+  }
+
+  browser_context_->cert_verifier()->SetVerifyProc(proc);
+}
+
 v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
   if (cookies_.IsEmpty()) {
-    auto handle = atom::api::Cookies::Create(isolate, browser_context_);
+    auto handle = atom::api::Cookies::Create(isolate, browser_context());
     cookies_.Reset(isolate, handle.ToV8());
   }
   return v8::Local<v8::Value>::New(isolate, cookies_);
@@ -277,20 +384,58 @@ mate::ObjectTemplateBuilder Session::GetObjectTemplateBuilder(
       .SetMethod("clearStorageData", &Session::ClearStorageData)
       .SetMethod("setProxy", &Session::SetProxy)
       .SetMethod("setDownloadPath", &Session::SetDownloadPath)
+      .SetMethod("enableNetworkEmulation", &Session::EnableNetworkEmulation)
+      .SetMethod("disableNetworkEmulation", &Session::DisableNetworkEmulation)
+      .SetMethod("setCertificateVerifyProc", &Session::SetCertVerifyProc)
       .SetProperty("cookies", &Session::Cookies);
 }
 
 // static
 mate::Handle<Session> Session::CreateFrom(
-    v8::Isolate* isolate,
-    AtomBrowserContext* browser_context) {
+    v8::Isolate* isolate, AtomBrowserContext* browser_context) {
   auto existing = TrackableObject::FromWrappedClass(isolate, browser_context);
   if (existing)
     return mate::CreateHandle(isolate, static_cast<Session*>(existing));
 
-  return mate::CreateHandle(isolate, new Session(browser_context));
+  auto handle = mate::CreateHandle(isolate, new Session(browser_context));
+  g_wrap_session.Run(handle.ToV8());
+  return handle;
+}
+
+// static
+mate::Handle<Session> Session::FromPartition(
+    v8::Isolate* isolate, const std::string& partition, bool in_memory) {
+  auto browser_context = brightray::BrowserContext::From(partition, in_memory);
+  return CreateFrom(isolate,
+                    static_cast<AtomBrowserContext*>(browser_context.get()));
+}
+
+void ClearWrapSession() {
+  g_wrap_session.Reset();
+}
+
+void SetWrapSession(const WrapSessionCallback& callback) {
+  g_wrap_session = callback;
+
+  // Cleanup the wrapper on exit.
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(
+      base::Bind(ClearWrapSession));
 }
 
 }  // namespace api
 
 }  // namespace atom
+
+namespace {
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.SetMethod("fromPartition", &atom::api::Session::FromPartition);
+  dict.SetMethod("_setWrapSession", &atom::api::SetWrapSession);
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_session, Initialize)

atom/browser/api/atom_api_session.h

@@ -8,6 +8,7 @@
 #include <string>
 
 #include "atom/browser/api/trackable_object.h"
+#include "content/public/browser/download_manager.h"
 #include "native_mate/handle.h"
 #include "net/base/completion_callback.h"
 
@@ -19,6 +20,11 @@ class FilePath;
 
 namespace mate {
 class Arguments;
+class Dictionary;
+}
+
+namespace net {
+class ProxyConfig;
 }
 
 namespace atom {
@@ -27,7 +33,8 @@ class AtomBrowserContext;
 
 namespace api {
 
-class Session: public mate::TrackableObject<Session> {
+class Session: public mate::TrackableObject<Session>,
+               public content::DownloadManager::Observer {
  public:
   using ResolveProxyCallback = base::Callback<void(std::string)>;
 
@@ -35,27 +42,43 @@ class Session: public mate::TrackableObject<Session> {
   static mate::Handle<Session> CreateFrom(
       v8::Isolate* isolate, AtomBrowserContext* browser_context);
 
-  AtomBrowserContext* browser_context() const { return browser_context_; }
+  // Gets the Session of |partition| and |in_memory|.
+  static mate::Handle<Session> FromPartition(
+      v8::Isolate* isolate, const std::string& partition, bool in_memory);
+
+  AtomBrowserContext* browser_context() const { return browser_context_.get(); }
 
  protected:
   explicit Session(AtomBrowserContext* browser_context);
   ~Session();
 
-  // mate::Wrappable implementations:
+  // content::DownloadManager::Observer:
+  void OnDownloadCreated(content::DownloadManager* manager,
+                         content::DownloadItem* item) override;
+
+  // mate::Wrappable:
   mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override;
+  bool IsDestroyed() const override;
 
  private:
+  // mate::TrackableObject:
+  void Destroy() override;
+
   void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
   void ClearCache(const net::CompletionCallback& callback);
   void ClearStorageData(mate::Arguments* args);
-  void SetProxy(const std::string& proxy, const base::Closure& callback);
+  void SetProxy(const net::ProxyConfig& config, const base::Closure& callback);
   void SetDownloadPath(const base::FilePath& path);
+  void EnableNetworkEmulation(const mate::Dictionary& options);
+  void DisableNetworkEmulation();
+  void SetCertVerifyProc(v8::Local<v8::Value> proc, mate::Arguments* args);
   v8::Local<v8::Value> Cookies(v8::Isolate* isolate);
 
+  // Cached object for cookies API.
   v8::Global<v8::Value> cookies_;
 
-  AtomBrowserContext* browser_context_;  // weak ref
+  scoped_refptr<AtomBrowserContext> browser_context_;
 
   DISALLOW_COPY_AND_ASSIGN(Session);
 };

atom/browser/api/atom_api_tray.cc

@@ -12,13 +12,12 @@
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_includes.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/image/image.h"
 
-#include "atom/common/node_includes.h"
-
 namespace atom {
 
 namespace api {
@@ -35,7 +34,8 @@ Tray::~Tray() {
 // static
 mate::Wrappable* Tray::New(v8::Isolate* isolate, const gfx::Image& image) {
   if (!Browser::Get()->is_ready()) {
-    node::ThrowError(isolate, "Cannot create Tray before app is ready");
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Cannot create Tray before app is ready")));
     return nullptr;
   }
   return new Tray(image);
@@ -44,21 +44,21 @@ mate::Wrappable* Tray::New(v8::Isolate* isolate, const gfx::Image& image) {
 void Tray::OnClicked(const gfx::Rect& bounds, int modifiers) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  EmitCustomEvent("clicked",
+  EmitCustomEvent("click",
                   ModifiersToObject(isolate(), modifiers), bounds);
 }
 
 void Tray::OnDoubleClicked(const gfx::Rect& bounds, int modifiers) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  EmitCustomEvent("double-clicked",
+  EmitCustomEvent("double-click",
                   ModifiersToObject(isolate(), modifiers), bounds);
 }
 
 void Tray::OnRightClicked(const gfx::Rect& bounds, int modifiers) {
   v8::Locker locker(isolate());
   v8::HandleScope handle_scope(isolate());
-  EmitCustomEvent("right-clicked",
+  EmitCustomEvent("right-click",
                   ModifiersToObject(isolate(), modifiers), bounds);
 }
 
@@ -67,17 +67,33 @@ void Tray::OnBalloonShow() {
 }
 
 void Tray::OnBalloonClicked() {
-  Emit("balloon-clicked");
+  Emit("balloon-click");
 }
 
 void Tray::OnBalloonClosed() {
   Emit("balloon-closed");
 }
 
+void Tray::OnDrop() {
+  Emit("drop");
+}
+
 void Tray::OnDropFiles(const std::vector<std::string>& files) {
   Emit("drop-files", files);
 }
 
+void Tray::OnDragEntered() {
+  Emit("drag-enter");
+}
+
+void Tray::OnDragExited() {
+  Emit("drag-leave");
+}
+
+void Tray::OnDragEnded() {
+  Emit("drag-end");
+}
+
 bool Tray::IsDestroyed() const {
   return !tray_icon_;
 }
@@ -145,6 +161,7 @@ void Tray::BuildPrototype(v8::Isolate* isolate,
                           v8::Local<v8::ObjectTemplate> prototype) {
   mate::ObjectTemplateBuilder(isolate, prototype)
       .SetMethod("destroy", &Tray::Destroy, true)
+      .SetMethod("isDestroyed", &Tray::IsDestroyed, true)
       .SetMethod("setImage", &Tray::SetImage)
       .SetMethod("setPressedImage", &Tray::SetPressedImage)
       .SetMethod("setToolTip", &Tray::SetToolTip)

atom/browser/api/atom_api_tray.h

@@ -8,7 +8,7 @@
 #include <string>
 #include <vector>
 
-#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/api/trackable_object.h"
 #include "atom/browser/ui/tray_icon_observer.h"
 #include "base/memory/scoped_ptr.h"
 
@@ -29,7 +29,7 @@ namespace api {
 
 class Menu;
 
-class Tray : public mate::EventEmitter,
+class Tray : public mate::TrackableObject<Tray>,
              public TrayIconObserver {
  public:
   static mate::Wrappable* New(v8::Isolate* isolate, const gfx::Image& image);
@@ -39,7 +39,7 @@ class Tray : public mate::EventEmitter,
 
  protected:
   explicit Tray(const gfx::Image& image);
-  virtual ~Tray();
+  ~Tray() override;
 
   // TrayIconObserver:
   void OnClicked(const gfx::Rect& bounds, int modifiers) override;
@@ -48,12 +48,18 @@ class Tray : public mate::EventEmitter,
   void OnBalloonShow() override;
   void OnBalloonClicked() override;
   void OnBalloonClosed() override;
+  void OnDrop() override;
   void OnDropFiles(const std::vector<std::string>& files) override;
+  void OnDragEntered() override;
+  void OnDragExited() override;
+  void OnDragEnded() override;
 
   // mate::Wrappable:
   bool IsDestroyed() const override;
 
-  void Destroy();
+  // mate::TrackableObject:
+  void Destroy() override;
+
   void SetImage(mate::Arguments* args, const gfx::Image& image);
   void SetPressedImage(mate::Arguments* args, const gfx::Image& image);
   void SetToolTip(mate::Arguments* args, const std::string& tool_tip);

atom/browser/api/atom_api_web_contents.cc

@@ -7,14 +7,18 @@
 #include <set>
 
 #include "atom/browser/api/atom_api_session.h"
+#include "atom/browser/api/atom_api_window.h"
 #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/native_window.h"
+#include "atom/browser/web_contents_preferences.h"
 #include "atom/browser/web_view_guest_delegate.h"
 #include "atom/common/api/api_messages.h"
 #include "atom/common/api/event_emitter_caller.h"
+#include "atom/common/native_mate_converters/blink_converter.h"
 #include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/content_converter.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"
@@ -24,25 +28,33 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "brightray/browser/inspectable_web_contents.h"
+#include "brightray/browser/inspectable_web_contents_view.h"
 #include "chrome/browser/printing/print_view_manager_basic.h"
 #include "chrome/browser/printing/print_preview_message_handler.h"
+#include "content/common/view_messages.h"
+#include "content/public/browser/browser_plugin_guest_manager.h"
 #include "content/public/browser/favicon_status.h"
+#include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
+#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/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
+#include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "ui/base/l10n/l10n_util.h"
 
 #include "atom/common/node_includes.h"
 
@@ -54,9 +66,21 @@ struct PrintSettings {
 };
 
 void SetUserAgentInIO(scoped_refptr<net::URLRequestContextGetter> getter,
+                      std::string accept_lang,
                       std::string user_agent) {
   getter->GetURLRequestContext()->set_http_user_agent_settings(
-      new net::StaticHttpUserAgentSettings("en-us,en", user_agent));
+      new net::StaticHttpUserAgentSettings(
+          net::HttpUtil::GenerateAcceptLanguageHeader(accept_lang),
+          user_agent));
+}
+
+bool NotifyZoomLevelChanged(
+    double level, content::WebContents* guest_web_contents) {
+  guest_web_contents->SendToAllFrames(
+      new AtomViewMsg_SetZoomLevel(MSG_ROUTING_NONE, level));
+
+  // Return false to iterate over all guests.
+  return false;
 }
 
 }  // namespace
@@ -114,6 +138,53 @@ struct Converter<WindowOpenDisposition> {
   }
 };
 
+template<>
+struct Converter<net::HttpResponseHeaders*> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   net::HttpResponseHeaders* headers) {
+    base::DictionaryValue response_headers;
+    if (headers) {
+      void* iter = nullptr;
+      std::string key;
+      std::string value;
+      while (headers->EnumerateHeaderLines(&iter, &key, &value)) {
+        key = base::StringToLowerASCII(key);
+        if (response_headers.HasKey(key)) {
+          base::ListValue* values = nullptr;
+          if (response_headers.GetList(key, &values))
+            values->AppendString(value);
+        } else {
+          scoped_ptr<base::ListValue> values(new base::ListValue());
+          values->AppendString(value);
+          response_headers.Set(key, values.Pass());
+        }
+      }
+    }
+    return ConvertToV8(isolate, response_headers);
+  }
+};
+
+template<>
+struct Converter<content::SavePageType> {
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
+                     content::SavePageType* out) {
+    std::string save_type;
+    if (!ConvertFromV8(isolate, val, &save_type))
+      return false;
+    save_type = base::StringToLowerASCII(save_type);
+    if (save_type == "htmlonly") {
+      *out = content::SAVE_PAGE_TYPE_AS_ONLY_HTML;
+    } else if (save_type == "htmlcomplete") {
+      *out = content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML;
+    } else if (save_type == "mhtml") {
+      *out = content::SAVE_PAGE_TYPE_AS_MHTML;
+    } else {
+      return false;
+    }
+    return true;
+  }
+};
+
 }  // namespace mate
 
 
@@ -125,7 +196,7 @@ namespace {
 
 v8::Persistent<v8::ObjectTemplate> template_;
 
-// The wrapWebContents funtion which is implemented in JavaScript
+// The wrapWebContents function which is implemented in JavaScript
 using WrapWebContentsCallback = base::Callback<void(v8::Local<v8::Value>)>;
 WrapWebContentsCallback g_wrap_web_contents;
 
@@ -153,23 +224,41 @@ WebContents::WebContents(content::WebContents* web_contents)
   web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());
 }
 
-WebContents::WebContents(const mate::Dictionary& options) {
+WebContents::WebContents(v8::Isolate* isolate,
+                         const mate::Dictionary& options) {
+  // Whether it is a guest WebContents.
   bool is_guest = false;
   options.Get("isGuest", &is_guest);
-
   type_ = is_guest ? WEB_VIEW : BROWSER_WINDOW;
 
-  auto browser_context = AtomBrowserMainParts::Get()->browser_context();
+  // Obtain the session.
+  std::string partition;
+  mate::Handle<api::Session> session;
+  if (options.Get("session", &session)) {
+  } else if (options.Get("partition", &partition) && !partition.empty()) {
+    bool in_memory = true;
+    if (base::StartsWith(partition, "persist:", base::CompareCase::SENSITIVE)) {
+      in_memory = false;
+      partition = partition.substr(8);
+    }
+    session = Session::FromPartition(isolate, partition, in_memory);
+  } else {
+    // Use the default session if not specified.
+    session = Session::FromPartition(isolate, "", false);
+  }
+  session_.Reset(isolate, session.ToV8());
+
   content::WebContents* web_contents;
   if (is_guest) {
     content::SiteInstance* site_instance = content::SiteInstance::CreateForURL(
-        browser_context, GURL("chrome-guest://fake-host"));
-    content::WebContents::CreateParams params(browser_context, site_instance);
+        session->browser_context(), GURL("chrome-guest://fake-host"));
+    content::WebContents::CreateParams params(
+        session->browser_context(), site_instance);
     guest_delegate_.reset(new WebViewGuestDelegate);
     params.guest_delegate = guest_delegate_.get();
     web_contents = content::WebContents::Create(params);
   } else {
-    content::WebContents::CreateParams params(browser_context);
+    content::WebContents::CreateParams params(session->browser_context());
     web_contents = content::WebContents::Create(params);
   }
 
@@ -177,6 +266,11 @@ WebContents::WebContents(const mate::Dictionary& options) {
   AttachAsUserData(web_contents);
   InitWithWebContents(web_contents);
 
+  managed_web_contents()->GetView()->SetDelegate(this);
+
+  // Save the preferences in C++.
+  new WebContentsPreferences(web_contents, options);
+
   web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());
 
   if (is_guest) {
@@ -217,7 +311,7 @@ bool WebContents::ShouldCreateWebContents(
     int route_id,
     int main_frame_route_id,
     WindowContainerType window_container_type,
-    const base::string16& frame_name,
+    const std::string& frame_name,
     const GURL& target_url,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace) {
@@ -277,7 +371,10 @@ bool WebContents::IsPopupOrPanel(const content::WebContents* source) const {
 void WebContents::HandleKeyboardEvent(
     content::WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
-  if (type_ == BROWSER_WINDOW) {
+  if (event.windowsKeyCode == ui::VKEY_ESCAPE && is_html_fullscreen()) {
+    // Escape exits tabbed fullscreen mode.
+    ExitFullscreenModeForTab(source);
+  } else if (type_ == BROWSER_WINDOW) {
     owner_window()->HandleKeyboardEvent(source, event);
   } else if (type_ == WEB_VIEW && guest_delegate_) {
     // Send the unhandled keyboard events back to the embedder.
@@ -308,6 +405,15 @@ void WebContents::RendererResponsive(content::WebContents* source) {
     owner_window()->RendererResponsive(source);
 }
 
+bool WebContents::HandleContextMenu(const content::ContextMenuParams& params) {
+  if (!params.custom_context.is_pepper_menu)
+    return false;
+
+  Emit("pepper-context-menu", std::make_pair(params, web_contents()));
+  web_contents()->NotifyContextMenuClosed(params.custom_context);
+  return true;
+}
+
 void WebContents::BeforeUnloadFired(const base::TimeTicks& proceed_time) {
   // Do nothing, we override this method just to avoid compilation error since
   // there are two virtual functions named BeforeUnloadFired.
@@ -359,15 +465,17 @@ void WebContents::DidFailProvisionalLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     int error_code,
-    const base::string16& error_description) {
-  Emit("did-fail-load", error_code, error_description);
+    const base::string16& error_description,
+    bool was_ignored_by_handler) {
+  Emit("did-fail-load", error_code, error_description, validated_url);
 }
 
 void WebContents::DidFailLoad(content::RenderFrameHost* render_frame_host,
                               const GURL& validated_url,
                               int error_code,
-                              const base::string16& error_description) {
-  Emit("did-fail-load", error_code, error_description);
+                              const base::string16& error_description,
+                              bool was_ignored_by_handler) {
+  Emit("did-fail-load", error_code, error_description, validated_url);
 }
 
 void WebContents::DidStartLoading() {
@@ -380,30 +488,6 @@ void WebContents::DidStopLoading() {
 
 void WebContents::DidGetResourceResponseStart(
     const content::ResourceRequestDetails& details) {
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  base::DictionaryValue response_headers;
-
-  net::HttpResponseHeaders* headers = details.headers.get();
-  if (!headers)
-    return;
-  void* iter = nullptr;
-  std::string key;
-  std::string value;
-  while (headers->EnumerateHeaderLines(&iter, &key, &value)) {
-    key = base::StringToLowerASCII(key);
-    value = base::StringToLowerASCII(value);
-    if (response_headers.HasKey(key)) {
-      base::ListValue* values = nullptr;
-      if (response_headers.GetList(key, &values))
-        values->AppendString(value);
-    } else {
-      scoped_ptr<base::ListValue> values(new base::ListValue());
-      values->AppendString(value);
-      response_headers.Set(key, values.Pass());
-    }
-  }
-
   Emit("did-get-response-details",
        details.socket_address.IsEmpty(),
        details.url,
@@ -411,7 +495,7 @@ void WebContents::DidGetResourceResponseStart(
        details.http_response_code,
        details.method,
        details.referrer,
-       response_headers);
+       details.headers.get());
 }
 
 void WebContents::DidGetRedirectForResourceRequest(
@@ -420,7 +504,11 @@ void WebContents::DidGetRedirectForResourceRequest(
   Emit("did-get-redirect-request",
        details.url,
        details.new_url,
-       (details.resource_type == content::RESOURCE_TYPE_MAIN_FRAME));
+       (details.resource_type == content::RESOURCE_TYPE_MAIN_FRAME),
+       details.http_response_code,
+       details.method,
+       details.referrer,
+       details.headers.get());
 }
 
 void WebContents::DidNavigateMainFrame(
@@ -450,12 +538,40 @@ void WebContents::DidUpdateFaviconURL(
   Emit("page-favicon-updated", unique_urls);
 }
 
+void WebContents::DevToolsFocused() {
+  Emit("devtools-focused");
+}
+
+void WebContents::DevToolsOpened() {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  auto handle = WebContents::CreateFrom(
+      isolate(), managed_web_contents()->GetDevToolsWebContents());
+  devtools_web_contents_.Reset(isolate(), handle.ToV8());
+
+  // Inherit owner window in devtools.
+  if (owner_window())
+    handle->SetOwnerWindow(managed_web_contents()->GetDevToolsWebContents(),
+                           owner_window());
+
+  Emit("devtools-opened");
+}
+
+void WebContents::DevToolsClosed() {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  devtools_web_contents_.Reset();
+
+  Emit("devtools-closed");
+}
+
 bool WebContents::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebContents, message)
     IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
                                     OnRendererMessageSync)
+    IPC_MESSAGE_HANDLER(AtomViewHostMsg_ZoomLevelChanged, OnZoomLevelChanged)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
@@ -476,6 +592,7 @@ void WebContents::NavigationEntryCommitted(
 }
 
 void WebContents::Destroy() {
+  session_.Reset();
   if (type_ == WEB_VIEW && managed_web_contents()) {
     // When force destroying the "destroyed" event is not emitted.
     WebContentsDestroyed();
@@ -487,10 +604,6 @@ void WebContents::Destroy() {
   }
 }
 
-bool WebContents::IsAlive() const {
-  return web_contents() != NULL;
-}
-
 int WebContents::GetID() const {
   return web_contents()->GetRenderProcessHost()->GetID();
 }
@@ -511,12 +624,20 @@ void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
   if (options.Get("userAgent", &user_agent))
     SetUserAgent(user_agent);
 
+  std::string extra_headers;
+  if (options.Get("extraHeaders", &extra_headers))
+    params.extra_headers = extra_headers;
+
   params.transition_type = ui::PAGE_TRANSITION_TYPED;
   params.should_clear_history_list = true;
   params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
   web_contents()->GetController().LoadURLWithParams(params);
 }
 
+GURL WebContents::GetURL() const {
+  return web_contents()->GetURL();
+}
+
 base::string16 WebContents::GetTitle() const {
   return web_contents()->GetTitle();
 }
@@ -533,10 +654,6 @@ void WebContents::Stop() {
   web_contents()->Stop();
 }
 
-void WebContents::ReloadIgnoringCache() {
-  web_contents()->GetController().ReloadIgnoringCache(false);
-}
-
 void WebContents::GoBack() {
   atom::AtomBrowserClient::SuppressRendererProcessRestartForOnce();
   web_contents()->GetController().GoBack();
@@ -560,8 +677,10 @@ void WebContents::SetUserAgent(const std::string& user_agent) {
   web_contents()->SetUserAgentOverride(user_agent);
   scoped_refptr<net::URLRequestContextGetter> getter =
       web_contents()->GetBrowserContext()->GetRequestContext();
+
+  auto accept_lang = l10n_util::GetApplicationLocale("");
   getter->GetNetworkTaskRunner()->PostTask(FROM_HERE,
-      base::Bind(&SetUserAgentInIO, getter, user_agent));
+      base::Bind(&SetUserAgentInIO, getter, accept_lang, user_agent));
 }
 
 std::string WebContents::GetUserAgent() {
@@ -572,6 +691,13 @@ 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) {
+  auto handler = new SavePageHandler(web_contents(), callback);
+  return handler->Handle(full_file_path, save_type);
+}
+
 void WebContents::ExecuteJavaScript(const base::string16& code,
                                     bool has_user_gesture) {
   Send(new AtomViewMsg_ExecuteJavaScript(routing_id(), code, has_user_gesture));
@@ -606,6 +732,21 @@ bool WebContents::IsDevToolsOpened() {
   return managed_web_contents()->IsDevToolsViewShowing();
 }
 
+void WebContents::EnableDeviceEmulation(
+    const blink::WebDeviceEmulationParams& params) {
+  if (type_ == REMOTE)
+    return;
+
+  Send(new ViewMsg_EnableDeviceEmulation(routing_id(), params));
+}
+
+void WebContents::DisableDeviceEmulation() {
+  if (type_ == REMOTE)
+    return;
+
+  Send(new ViewMsg_DisableDeviceEmulation(routing_id()));
+}
+
 void WebContents::ToggleDevTools() {
   if (IsDevToolsOpened())
     CloseDevTools();
@@ -637,14 +778,6 @@ void WebContents::InspectServiceWorker() {
   }
 }
 
-v8::Local<v8::Value> WebContents::Session(v8::Isolate* isolate) {
-  if (session_.IsEmpty()) {
-    auto handle = Session::CreateFrom(isolate, GetBrowserContext());
-    session_.Reset(isolate, handle.ToV8());
-  }
-  return v8::Local<v8::Value>::New(isolate, session_);
-}
-
 void WebContents::HasServiceWorker(
     const base::Callback<void(bool)>& callback) {
   auto context = GetServiceWorkerContext(web_contents());
@@ -691,17 +824,19 @@ void WebContents::PrintToPDF(const base::DictionaryValue& setting,
       PrintToPDF(setting, callback);
 }
 
-void WebContents::AddWorkSpace(const base::FilePath& path) {
+void WebContents::AddWorkSpace(mate::Arguments* args,
+                               const base::FilePath& path) {
   if (path.empty()) {
-    node::ThrowError(isolate(), "path cannot be empty");
+    args->ThrowError("path cannot be empty");
     return;
   }
   DevToolsAddFileSystem(path);
 }
 
-void WebContents::RemoveWorkSpace(const base::FilePath& path) {
+void WebContents::RemoveWorkSpace(mate::Arguments* args,
+                                  const base::FilePath& path) {
   if (path.empty()) {
-    node::ThrowError(isolate(), "path cannot be empty");
+    args->ThrowError("path cannot be empty");
     return;
   }
   DevToolsRemoveFileSystem(path);
@@ -764,6 +899,56 @@ bool WebContents::SendIPCMessage(const base::string16& channel,
   return Send(new AtomViewMsg_Message(routing_id(), channel, args));
 }
 
+void WebContents::SendInputEvent(v8::Isolate* isolate,
+                                 v8::Local<v8::Value> input_event) {
+  const auto view = web_contents()->GetRenderWidgetHostView();
+  if (!view)
+    return;
+  const auto host = view->GetRenderWidgetHost();
+  if (!host)
+    return;
+
+  int type = mate::GetWebInputEventType(isolate, input_event);
+  if (blink::WebInputEvent::isMouseEventType(type)) {
+    blink::WebMouseEvent mouse_event;
+    if (mate::ConvertFromV8(isolate, input_event, &mouse_event)) {
+      host->ForwardMouseEvent(mouse_event);
+      return;
+    }
+  } else if (blink::WebInputEvent::isKeyboardEventType(type)) {
+    content::NativeWebKeyboardEvent keyboard_event;;
+    if (mate::ConvertFromV8(isolate, input_event, &keyboard_event)) {
+      host->ForwardKeyboardEvent(keyboard_event);
+      return;
+    }
+  } else if (type == blink::WebInputEvent::MouseWheel) {
+    blink::WebMouseWheelEvent mouse_wheel_event;
+    if (mate::ConvertFromV8(isolate, input_event, &mouse_wheel_event)) {
+      host->ForwardWheelEvent(mouse_wheel_event);
+      return;
+    }
+  }
+
+  isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+      isolate, "Invalid event object")));
+}
+
+void WebContents::BeginFrameSubscription(
+    const FrameSubscriber::FrameCaptureCallback& callback) {
+  const auto view = web_contents()->GetRenderWidgetHostView();
+  if (view) {
+    scoped_ptr<FrameSubscriber> frame_subscriber(new FrameSubscriber(
+        isolate(), view->GetVisibleViewportSize(), callback));
+    view->BeginFrameSubscription(frame_subscriber.Pass());
+  }
+}
+
+void WebContents::EndFrameSubscription() {
+  const auto view = web_contents()->GetRenderWidgetHostView();
+  if (view)
+    view->EndFrameSubscription();
+}
+
 void WebContents::SetSize(const SetSizeParams& params) {
   if (guest_delegate_)
     guest_delegate_->SetSize(params);
@@ -778,20 +963,44 @@ bool WebContents::IsGuest() const {
   return type_ == WEB_VIEW;
 }
 
+v8::Local<v8::Value> WebContents::GetWebPreferences(v8::Isolate* isolate) {
+  WebContentsPreferences* web_preferences =
+      WebContentsPreferences::FromWebContents(web_contents());
+  return mate::ConvertToV8(isolate, *web_preferences->web_preferences());
+}
+
+v8::Local<v8::Value> WebContents::GetOwnerBrowserWindow() {
+  if (owner_window())
+    return Window::From(isolate(), owner_window());
+  else
+    return v8::Null(isolate());
+}
+
+v8::Local<v8::Value> WebContents::Session(v8::Isolate* isolate) {
+  return v8::Local<v8::Value>::New(isolate, session_);
+}
+
+v8::Local<v8::Value> WebContents::DevToolsWebContents(v8::Isolate* isolate) {
+  if (devtools_web_contents_.IsEmpty())
+    return v8::Null(isolate);
+  else
+    return v8::Local<v8::Value>::New(isolate, devtools_web_contents_);
+}
+
 mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   if (template_.IsEmpty())
     template_.Reset(isolate, mate::ObjectTemplateBuilder(isolate)
         .SetMethod("destroy", &WebContents::Destroy, true)
-        .SetMethod("isAlive", &WebContents::IsAlive, true)
+        .SetMethod("isDestroyed", &WebContents::IsDestroyed, true)
         .SetMethod("getId", &WebContents::GetID)
         .SetMethod("equal", &WebContents::Equal)
-        .SetMethod("_loadUrl", &WebContents::LoadURL)
+        .SetMethod("_loadURL", &WebContents::LoadURL)
+        .SetMethod("_getURL", &WebContents::GetURL)
         .SetMethod("getTitle", &WebContents::GetTitle)
         .SetMethod("isLoading", &WebContents::IsLoading)
         .SetMethod("isWaitingForResponse", &WebContents::IsWaitingForResponse)
         .SetMethod("_stop", &WebContents::Stop)
-        .SetMethod("_reloadIgnoringCache", &WebContents::ReloadIgnoringCache)
         .SetMethod("_goBack", &WebContents::GoBack)
         .SetMethod("_goForward", &WebContents::GoForward)
         .SetMethod("_goToOffset", &WebContents::GoToOffset)
@@ -799,10 +1008,15 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
         .SetMethod("setUserAgent", &WebContents::SetUserAgent)
         .SetMethod("getUserAgent", &WebContents::GetUserAgent)
         .SetMethod("insertCSS", &WebContents::InsertCSS)
+        .SetMethod("savePage", &WebContents::SavePage)
         .SetMethod("_executeJavaScript", &WebContents::ExecuteJavaScript)
         .SetMethod("openDevTools", &WebContents::OpenDevTools)
         .SetMethod("closeDevTools", &WebContents::CloseDevTools)
         .SetMethod("isDevToolsOpened", &WebContents::IsDevToolsOpened)
+        .SetMethod("enableDeviceEmulation",
+                   &WebContents::EnableDeviceEmulation)
+        .SetMethod("disableDeviceEmulation",
+                   &WebContents::DisableDeviceEmulation)
         .SetMethod("toggleDevTools", &WebContents::ToggleDevTools)
         .SetMethod("inspectElement", &WebContents::InspectElement)
         .SetMethod("setAudioMuted", &WebContents::SetAudioMuted)
@@ -821,9 +1035,15 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
         .SetMethod("focus", &WebContents::Focus)
         .SetMethod("tabTraverse", &WebContents::TabTraverse)
         .SetMethod("_send", &WebContents::SendIPCMessage, true)
+        .SetMethod("sendInputEvent", &WebContents::SendInputEvent)
+        .SetMethod("beginFrameSubscription",
+                   &WebContents::BeginFrameSubscription)
+        .SetMethod("endFrameSubscription", &WebContents::EndFrameSubscription)
         .SetMethod("setSize", &WebContents::SetSize)
         .SetMethod("setAllowTransparency", &WebContents::SetAllowTransparency)
         .SetMethod("isGuest", &WebContents::IsGuest)
+        .SetMethod("getWebPreferences", &WebContents::GetWebPreferences)
+        .SetMethod("getOwnerBrowserWindow", &WebContents::GetOwnerBrowserWindow)
         .SetMethod("hasServiceWorker", &WebContents::HasServiceWorker)
         .SetMethod("unregisterServiceWorker",
                    &WebContents::UnregisterServiceWorker)
@@ -832,7 +1052,9 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
         .SetMethod("_printToPDF", &WebContents::PrintToPDF)
         .SetMethod("addWorkSpace", &WebContents::AddWorkSpace)
         .SetMethod("removeWorkSpace", &WebContents::RemoveWorkSpace)
-        .SetProperty("session", &WebContents::Session)
+        .SetProperty("session", &WebContents::Session, true)
+        .SetProperty("devToolsWebContents",
+                     &WebContents::DevToolsWebContents, true)
         .Build());
 
   return mate::ObjectTemplateBuilder(
@@ -840,7 +1062,7 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
 }
 
 bool WebContents::IsDestroyed() const {
-  return !IsAlive();
+  return !web_contents();
 }
 
 AtomBrowserContext* WebContents::GetBrowserContext() const {
@@ -860,6 +1082,15 @@ void WebContents::OnRendererMessageSync(const base::string16& channel,
   EmitWithSender(base::UTF16ToUTF8(channel), web_contents(), message, args);
 }
 
+void WebContents::OnZoomLevelChanged(double level) {
+  auto manager = web_contents()->GetBrowserContext()->GetGuestManager();
+  if (!manager)
+    return;
+  manager->ForEachGuest(web_contents(),
+                        base::Bind(&NotifyZoomLevelChanged,
+                                   level));
+}
+
 // static
 mate::Handle<WebContents> WebContents::CreateFrom(
     v8::Isolate* isolate, content::WebContents* web_contents) {
@@ -877,19 +1108,23 @@ mate::Handle<WebContents> WebContents::CreateFrom(
 // static
 mate::Handle<WebContents> WebContents::Create(
     v8::Isolate* isolate, const mate::Dictionary& options) {
-  auto handle =  mate::CreateHandle(isolate, new WebContents(options));
+  auto handle = mate::CreateHandle(isolate, new WebContents(isolate, options));
   g_wrap_web_contents.Run(handle.ToV8());
   return handle;
 }
 
-void SetWrapWebContents(const WrapWebContentsCallback& callback) {
-  g_wrap_web_contents = callback;
-}
-
 void ClearWrapWebContents() {
   g_wrap_web_contents.Reset();
 }
 
+void SetWrapWebContents(const WrapWebContentsCallback& callback) {
+  g_wrap_web_contents = callback;
+
+  // Cleanup the wrapper on exit.
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(
+      base::Bind(ClearWrapWebContents));
+}
+
 }  // namespace api
 
 }  // namespace atom
@@ -903,7 +1138,6 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
   mate::Dictionary dict(isolate, exports);
   dict.SetMethod("create", &atom::api::WebContents::Create);
   dict.SetMethod("_setWrapWebContents", &atom::api::SetWrapWebContents);
-  dict.SetMethod("_clearWrapWebContents", &atom::api::ClearWrapWebContents);
 }
 
 }  // namespace

atom/browser/api/atom_api_web_contents.h

@@ -8,13 +8,19 @@
 #include <string>
 #include <vector>
 
+#include "atom/browser/api/frame_subscriber.h"
+#include "atom/browser/api/save_page_handler.h"
 #include "atom/browser/api/trackable_object.h"
 #include "atom/browser/common_web_contents_delegate.h"
-#include "content/public/common/favicon_url.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/common/favicon_url.h"
 #include "native_mate/handle.h"
 #include "ui/gfx/image/image.h"
 
+namespace blink {
+struct WebDeviceEmulationParams;
+}
+
 namespace brightray {
 class InspectableWebContents;
 }
@@ -48,11 +54,13 @@ class WebContents : public mate::TrackableObject<WebContents>,
   static mate::Handle<WebContents> Create(
       v8::Isolate* isolate, const mate::Dictionary& options);
 
-  void Destroy();
-  bool IsAlive() const;
+  // mate::TrackableObject:
+  void Destroy() override;
+
   int GetID() const;
   bool Equal(const WebContents* web_contents) const;
   void LoadURL(const GURL& url, const mate::Dictionary& options);
+  GURL GetURL() const;
   base::string16 GetTitle() const;
   bool IsLoading() const;
   bool IsWaitingForResponse() const;
@@ -65,15 +73,19 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void SetUserAgent(const std::string& user_agent);
   std::string GetUserAgent();
   void InsertCSS(const std::string& css);
+  bool SavePage(const base::FilePath& full_file_path,
+                const content::SavePageType& save_type,
+                const SavePageHandler::SavePageCallback& callback);
   void ExecuteJavaScript(const base::string16& code,
                          bool has_user_gesture);
   void OpenDevTools(mate::Arguments* args);
   void CloseDevTools();
   bool IsDevToolsOpened();
   void ToggleDevTools();
+  void EnableDeviceEmulation(const blink::WebDeviceEmulationParams& params);
+  void DisableDeviceEmulation();
   void InspectElement(int x, int y);
   void InspectServiceWorker();
-  v8::Local<v8::Value> Session(v8::Isolate* isolate);
   void HasServiceWorker(const base::Callback<void(bool)>&);
   void UnregisterServiceWorker(const base::Callback<void(bool)>&);
   void SetAudioMuted(bool muted);
@@ -85,8 +97,8 @@ class WebContents : public mate::TrackableObject<WebContents>,
                   const PrintToPDFCallback& callback);
 
   // DevTools workspace api.
-  void AddWorkSpace(const base::FilePath& path);
-  void RemoveWorkSpace(const base::FilePath& path);
+  void AddWorkSpace(mate::Arguments* args, const base::FilePath& path);
+  void RemoveWorkSpace(mate::Arguments* args, const base::FilePath& path);
 
   // Editing commands.
   void Undo();
@@ -105,18 +117,36 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void Focus();
   void TabTraverse(bool reverse);
 
-  // Sending messages to browser.
+  // Send messages to browser.
   bool SendIPCMessage(const base::string16& channel,
                       const base::ListValue& args);
 
+  // Send WebInputEvent to the page.
+  void SendInputEvent(v8::Isolate* isolate, v8::Local<v8::Value> input_event);
+
+  // Subscribe to the frame updates.
+  void BeginFrameSubscription(
+      const FrameSubscriber::FrameCaptureCallback& callback);
+  void EndFrameSubscription();
+
   // Methods for creating <webview>.
   void SetSize(const SetSizeParams& params);
   void SetAllowTransparency(bool allow);
   bool IsGuest() const;
 
+  // Returns the web preferences of current WebContents.
+  v8::Local<v8::Value> GetWebPreferences(v8::Isolate* isolate);
+
+  // Returns the owner window.
+  v8::Local<v8::Value> GetOwnerBrowserWindow();
+
+  // Properties.
+  v8::Local<v8::Value> Session(v8::Isolate* isolate);
+  v8::Local<v8::Value> DevToolsWebContents(v8::Isolate* isolate);
+
  protected:
   explicit WebContents(content::WebContents* web_contents);
-  explicit WebContents(const mate::Dictionary& options);
+  WebContents(v8::Isolate* isolate, const mate::Dictionary& options);
   ~WebContents();
 
   // mate::Wrappable:
@@ -135,7 +165,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
       int route_id,
       int main_frame_route_id,
       WindowContainerType window_container_type,
-      const base::string16& frame_name,
+      const std::string& frame_name,
       const GURL& target_url,
       const std::string& partition_id,
       content::SessionStorageNamespace* session_storage_namespace) override;
@@ -158,6 +188,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void ExitFullscreenModeForTab(content::WebContents* source) override;
   void RendererUnresponsive(content::WebContents* source) override;
   void RendererResponsive(content::WebContents* source) override;
+  bool HandleContextMenu(const content::ContextMenuParams& params) override;
 
   // content::WebContentsObserver:
   void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
@@ -170,11 +201,13 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void DidFailLoad(content::RenderFrameHost* render_frame_host,
                    const GURL& validated_url,
                    int error_code,
-                   const base::string16& error_description) override;
+                   const base::string16& error_description,
+                   bool was_ignored_by_handler) override;
   void DidFailProvisionalLoad(content::RenderFrameHost* render_frame_host,
                               const GURL& validated_url,
                               int error_code,
-                              const base::string16& error_description) override;
+                              const base::string16& error_description,
+                              bool was_ignored_by_handler) override;
   void DidStartLoading() override;
   void DidStopLoading() override;
   void DidGetResourceResponseStart(
@@ -195,6 +228,11 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void PluginCrashed(const base::FilePath& plugin_path,
                      base::ProcessId plugin_pid) override;
 
+  // brightray::InspectableWebContentsViewDelegate:
+  void DevToolsFocused() override;
+  void DevToolsOpened() override;
+  void DevToolsClosed() override;
+
  private:
   enum Type {
     BROWSER_WINDOW,  // Used by BrowserWindow.
@@ -213,7 +251,12 @@ class WebContents : public mate::TrackableObject<WebContents>,
                              const base::ListValue& args,
                              IPC::Message* message);
 
+  // Called when guests need to be notified of
+  // embedders' zoom level change.
+  void OnZoomLevelChanged(double level);
+
   v8::Global<v8::Value> session_;
+  v8::Global<v8::Value> devtools_web_contents_;
 
   scoped_ptr<WebViewGuestDelegate> guest_delegate_;
 

atom/browser/api/atom_api_web_view_manager.cc

@@ -3,13 +3,14 @@
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/web_contents_preferences.h"
 #include "atom/browser/web_view_manager.h"
-#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
 #include "content/public/browser/browser_context.h"
 #include "native_mate/dictionary.h"
-#include "net/base/filename_util.h"
 
-#include "atom/common/node_includes.h"
+using atom::WebContentsPreferences;
 
 namespace mate {
 
@@ -25,28 +26,6 @@ struct Converter<content::WebContents*> {
   }
 };
 
-template<>
-struct Converter<atom::WebViewManager::WebViewInfo> {
-  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
-                     atom::WebViewManager::WebViewInfo* out) {
-    Dictionary options;
-    if (!ConvertFromV8(isolate, val, &options))
-      return false;
-
-    GURL preload_url;
-    if (!options.Get("preloadUrl", &preload_url))
-      return false;
-
-    if (!preload_url.is_empty() &&
-        !net::FileURLToFilePath(preload_url, &(out->preload_script)))
-      return false;
-
-    return options.Get("nodeIntegration", &(out->node_integration)) &&
-           options.Get("plugins", &(out->plugins)) &&
-           options.Get("disableWebSecurity", &(out->disable_web_security));
-  }
-};
-
 }  // namespace mate
 
 namespace {
@@ -65,14 +44,13 @@ void AddGuest(int guest_instance_id,
               int element_instance_id,
               content::WebContents* embedder,
               content::WebContents* guest_web_contents,
-              atom::WebViewManager::WebViewInfo info) {
+              const base::DictionaryValue& options) {
   auto manager = GetWebViewManager(embedder);
-  if (manager) {
-    info.guest_instance_id = guest_instance_id;
-    info.embedder = embedder;
+  if (manager)
     manager->AddGuest(guest_instance_id, element_instance_id, embedder,
-                      guest_web_contents, info);
-  }
+                      guest_web_contents);
+
+  WebContentsPreferences::FromWebContents(guest_web_contents)->Merge(options);
 }
 
 void RemoveGuest(content::WebContents* embedder, int guest_instance_id) {

atom/browser/api/atom_api_window.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_window.h"
+#include "atom/common/native_mate_converters/value_converter.h"
 
 #include "atom/browser/api/atom_api_menu.h"
 #include "atom/browser/api/atom_api_web_contents.h"
@@ -13,6 +14,8 @@
 #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 "content/public/browser/render_process_host.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
@@ -23,8 +26,6 @@
 #include "atom/browser/ui/win/taskbar_host.h"
 #endif
 
-#include "atom/common/node_includes.h"
-
 #if defined(OS_WIN)
 namespace mate {
 
@@ -60,22 +61,99 @@ void OnCapturePageDone(
   callback.Run(gfx::Image::CreateFrom1xBitmap(bitmap));
 }
 
+// Converts min-width to minWidth, returns false if no conversion is needed.
+bool TranslateOldKey(const std::string& key, std::string* new_key) {
+  if (key.find('-') == std::string::npos)
+    return false;
+  new_key->reserve(key.size());
+  bool next_upper_case = false;
+  for (char c : key) {
+    if (c == '-') {
+      next_upper_case = true;
+    } else if (next_upper_case) {
+      new_key->push_back(base::ToUpperASCII(c));
+      next_upper_case = false;
+    } else {
+      new_key->push_back(c);
+    }
+  }
+  return true;
+}
+
+// Converts min-width to minWidth recursively in the dictionary.
+void TranslateOldOptions(v8::Isolate* isolate, v8::Local<v8::Object> options) {
+  auto context = isolate->GetCurrentContext();
+  auto maybe_keys = options->GetOwnPropertyNames(context);
+  if (maybe_keys.IsEmpty())
+    return;
+  std::vector<std::string> keys;
+  if (!mate::ConvertFromV8(isolate, maybe_keys.ToLocalChecked(), &keys))
+    return;
+  mate::Dictionary dict(isolate, options);
+  for (const auto& key : keys) {
+    v8::Local<v8::Value> value;
+    if (!dict.Get(key, &value))  // Shouldn't happen, but guard it anyway.
+      continue;
+    // Go recursively.
+    v8::Local<v8::Object> sub_options;
+    if (mate::ConvertFromV8(isolate, value, &sub_options))
+      TranslateOldOptions(isolate, sub_options);
+    // Translate key.
+    std::string new_key;
+    if (TranslateOldKey(key, &new_key)) {
+      dict.Set(new_key, value);
+      dict.Delete(key);
+    }
+  }
+}
+
+#if defined(OS_WIN)
+// Converts binary data to Buffer.
+v8::Local<v8::Value> ToBuffer(v8::Isolate* isolate, void* val, int size) {
+  auto buffer = node::Buffer::New(isolate, static_cast<char*>(val), size);
+  if (buffer.IsEmpty())
+    return v8::Null(isolate);
+  else
+    return buffer.ToLocalChecked();
+}
+#endif
+
 }  // namespace
 
 
 Window::Window(v8::Isolate* isolate, const mate::Dictionary& options) {
+  // Be compatible with old style field names like min-width.
+  TranslateOldOptions(isolate, options.GetHandle());
+
+  // Use options.webPreferences to create WebContents.
+  mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
+  options.Get(options::kWebPreferences, &web_preferences);
+
+  // Be compatible with old options which are now in web_preferences.
+  v8::Local<v8::Value> value;
+  if (options.Get(options::kNodeIntegration, &value))
+    web_preferences.Set(options::kNodeIntegration, value);
+  if (options.Get(options::kPreloadScript, &value))
+    web_preferences.Set(options::kPreloadScript, value);
+  if (options.Get(options::kZoomFactor, &value))
+    web_preferences.Set(options::kZoomFactor, value);
+
   // Creates the WebContents used by BrowserWindow.
-  mate::Dictionary web_contents_options(isolate, v8::Object::New(isolate));
-  auto web_contents = WebContents::Create(isolate, web_contents_options);
+  auto web_contents = WebContents::Create(isolate, web_preferences);
   web_contents_.Reset(isolate, web_contents.ToV8());
   api_web_contents_ = web_contents.get();
 
+  // Keep a copy of the options for later use.
+  mate::Dictionary(isolate, web_contents->GetWrapper(isolate)).Set(
+      "browserWindowOptions", options);
+
   // Creates BrowserWindow.
   window_.reset(NativeWindow::Create(web_contents->managed_web_contents(),
                                      options));
   web_contents->SetOwnerWindow(window_.get());
   window_->InitFromOptions(options);
   window_->AddObserver(this);
+  AttachAsUserData(window_.get());
 }
 
 Window::~Window() {
@@ -103,6 +181,9 @@ void Window::OnWindowClosed() {
   window_->RemoveObserver(this);
 
   Emit("closed");
+
+  // Clean up the resources after window has been closed.
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, window_.release());
 }
 
 void Window::OnWindowBlur() {
@@ -165,38 +246,26 @@ void Window::OnRendererResponsive() {
   Emit("responsive");
 }
 
-void Window::OnDevToolsFocus() {
-  Emit("devtools-focused");
-}
-
-void Window::OnDevToolsOpened() {
-  Emit("devtools-opened");
-
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  auto handle = WebContents::CreateFrom(
-      isolate(), api_web_contents_->GetDevToolsWebContents());
-  devtools_web_contents_.Reset(isolate(), handle.ToV8());
-}
-
-void Window::OnDevToolsClosed() {
-  Emit("devtools-closed");
-
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  devtools_web_contents_.Reset();
-}
-
 void Window::OnExecuteWindowsCommand(const std::string& command_name) {
   Emit("app-command", command_name);
 }
 
+#if defined(OS_WIN)
+void Window::OnWindowMessage(UINT message, WPARAM w_param, LPARAM l_param) {
+  if (IsWindowMessageHooked(message)) {
+    messages_callback_map_[message].Run(
+        ToBuffer(isolate(), static_cast<void*>(&w_param), sizeof(WPARAM)),
+        ToBuffer(isolate(), static_cast<void*>(&l_param), sizeof(LPARAM)));
+  }
+}
+#endif
+
 // static
 mate::Wrappable* Window::New(v8::Isolate* isolate,
                              const mate::Dictionary& options) {
   if (!Browser::Get()->is_ready()) {
-    node::ThrowError(isolate,
-                     "Cannot create BrowserWindow before app is ready");
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Cannot create BrowserWindow before app is ready")));
     return nullptr;
   }
   return new Window(isolate, options);
@@ -207,17 +276,14 @@ bool Window::IsDestroyed() const {
 }
 
 void Window::Destroy() {
-  window_->CloseContents(nullptr);
+  if (window_)
+    window_->CloseContents(nullptr);
 }
 
 void Window::Close() {
   window_->Close();
 }
 
-bool Window::IsClosed() {
-  return window_->IsClosed();
-}
-
 void Window::Focus() {
   window_->Focus(true);
 }
@@ -386,6 +452,10 @@ bool Window::IsKiosk() {
   return window_->IsKiosk();
 }
 
+void Window::SetBackgroundColor(const std::string& color_name) {
+  window_->SetBackgroundColor(color_name);
+}
+
 void Window::FocusOnWebView() {
   window_->FocusOnWebView();
 }
@@ -398,6 +468,10 @@ bool Window::IsWebViewFocused() {
   return window_->IsWebViewFocused();
 }
 
+bool Window::IsDevToolsFocused() {
+  return window_->IsDevToolsFocused();
+}
+
 void Window::SetRepresentedFilename(const std::string& filename) {
   window_->SetRepresentedFilename(filename);
 }
@@ -485,6 +559,29 @@ bool Window::IsMenuBarVisible() {
   return window_->IsMenuBarVisible();
 }
 
+#if defined(OS_WIN)
+bool Window::HookWindowMessage(UINT message,
+                               const MessageCallback& callback) {
+  messages_callback_map_[message] = callback;
+  return true;
+}
+
+void Window::UnhookWindowMessage(UINT message) {
+  if (!ContainsKey(messages_callback_map_, message))
+    return;
+
+  messages_callback_map_.erase(message);
+}
+
+bool Window::IsWindowMessageHooked(UINT message) {
+  return ContainsKey(messages_callback_map_, message);
+}
+
+void Window::UnhookAllWindowMessages() {
+  messages_callback_map_.clear();
+}
+#endif
+
 #if defined(OS_MACOSX)
 void Window::ShowDefinitionForSelection() {
   window_->ShowDefinitionForSelection();
@@ -516,20 +613,13 @@ v8::Local<v8::Value> Window::WebContents(v8::Isolate* isolate) {
     return v8::Local<v8::Value>::New(isolate, web_contents_);
 }
 
-v8::Local<v8::Value> Window::DevToolsWebContents(v8::Isolate* isolate) {
-  if (devtools_web_contents_.IsEmpty())
-    return v8::Null(isolate);
-  else
-    return v8::Local<v8::Value>::New(isolate, devtools_web_contents_);
-}
-
 // static
 void Window::BuildPrototype(v8::Isolate* isolate,
                             v8::Local<v8::ObjectTemplate> prototype) {
   mate::ObjectTemplateBuilder(isolate, prototype)
       .SetMethod("destroy", &Window::Destroy, true)
+      .SetMethod("isDestroyed", &Window::IsDestroyed, true)
       .SetMethod("close", &Window::Close)
-      .SetMethod("isClosed", &Window::IsClosed)
       .SetMethod("focus", &Window::Focus)
       .SetMethod("isFocused", &Window::IsFocused)
       .SetMethod("show", &Window::Show)
@@ -568,6 +658,7 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setSkipTaskbar", &Window::SetSkipTaskbar)
       .SetMethod("setKiosk", &Window::SetKiosk)
       .SetMethod("isKiosk", &Window::IsKiosk)
+      .SetMethod("setBackgroundColor", &Window::SetBackgroundColor)
       .SetMethod("setRepresentedFilename", &Window::SetRepresentedFilename)
       .SetMethod("getRepresentedFilename", &Window::GetRepresentedFilename)
       .SetMethod("setDocumentEdited", &Window::SetDocumentEdited)
@@ -575,6 +666,7 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("focusOnWebView", &Window::FocusOnWebView)
       .SetMethod("blurWebView", &Window::BlurWebView)
       .SetMethod("isWebViewFocused", &Window::IsWebViewFocused)
+      .SetMethod("isDevToolsFocused", &Window::IsDevToolsFocused)
       .SetMethod("capturePage", &Window::CapturePage)
       .SetMethod("setProgressBar", &Window::SetProgressBar)
       .SetMethod("setOverlayIcon", &Window::SetOverlayIcon)
@@ -588,13 +680,28 @@ void Window::BuildPrototype(v8::Isolate* isolate,
                  &Window::SetVisibleOnAllWorkspaces)
       .SetMethod("isVisibleOnAllWorkspaces",
                  &Window::IsVisibleOnAllWorkspaces)
+#if defined(OS_WIN)
+      .SetMethod("hookWindowMessage", &Window::HookWindowMessage)
+      .SetMethod("isWindowMessageHooked", &Window::IsWindowMessageHooked)
+      .SetMethod("unhookWindowMessage", &Window::UnhookWindowMessage)
+      .SetMethod("unhookAllWindowMessages", &Window::UnhookAllWindowMessages)
+#endif
 #if defined(OS_MACOSX)
       .SetMethod("showDefinitionForSelection",
                  &Window::ShowDefinitionForSelection)
 #endif
       .SetProperty("id", &Window::ID, true)
-      .SetProperty("webContents", &Window::WebContents, true)
-      .SetProperty("devToolsWebContents", &Window::DevToolsWebContents, true);
+      .SetProperty("webContents", &Window::WebContents, true);
+}
+
+// static
+v8::Local<v8::Value> Window::From(v8::Isolate* isolate,
+                                  NativeWindow* native_window) {
+  auto existing = TrackableObject::FromWrappedClass(isolate, native_window);
+  if (existing)
+    return existing->GetWrapper(isolate);
+  else
+    return v8::Null(isolate);
 }
 
 }  // namespace api

atom/browser/api/atom_api_window.h

@@ -5,6 +5,7 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_WINDOW_H_
 #define ATOM_BROWSER_API_ATOM_API_WINDOW_H_
 
+#include <map>
 #include <string>
 #include <vector>
 
@@ -43,6 +44,10 @@ class Window : public mate::TrackableObject<Window>,
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::ObjectTemplate> prototype);
 
+  // Returns the BrowserWindow object from |native_window|.
+  static v8::Local<v8::Value> From(v8::Isolate* isolate,
+                                   NativeWindow* native_window);
+
   NativeWindow* window() const { return window_.get(); }
 
  protected:
@@ -69,19 +74,21 @@ class Window : public mate::TrackableObject<Window>,
   void OnWindowLeaveHtmlFullScreen() override;
   void OnRendererUnresponsive() override;
   void OnRendererResponsive() override;
-  void OnDevToolsFocus() override;
-  void OnDevToolsOpened() override;
-  void OnDevToolsClosed() override;
   void OnExecuteWindowsCommand(const std::string& command_name) override;
 
+  #if defined(OS_WIN)
+  void OnWindowMessage(UINT message, WPARAM w_param, LPARAM l_param) override;
+  #endif
+
   // mate::Wrappable:
   bool IsDestroyed() const override;
 
  private:
+  // mate::TrackableObject:
+  void Destroy() override;
+
   // APIs for NativeWindow.
-  void Destroy();
   void Close();
-  bool IsClosed();
   void Focus();
   bool IsFocused();
   void Show();
@@ -119,9 +126,11 @@ class Window : public mate::TrackableObject<Window>,
   void SetSkipTaskbar(bool skip);
   void SetKiosk(bool kiosk);
   bool IsKiosk();
+  void SetBackgroundColor(const std::string& color_name);
   void FocusOnWebView();
   void BlurWebView();
   bool IsWebViewFocused();
+  bool IsDevToolsFocused();
   void SetRepresentedFilename(const std::string& filename);
   std::string GetRepresentedFilename();
   void SetDocumentEdited(bool edited);
@@ -138,6 +147,16 @@ class Window : public mate::TrackableObject<Window>,
   bool IsMenuBarVisible();
   void SetAspectRatio(double aspect_ratio, mate::Arguments* args);
 
+#if defined(OS_WIN)
+  typedef base::Callback<void(v8::Local<v8::Value>,
+                              v8::Local<v8::Value>)> MessageCallback;
+
+  bool HookWindowMessage(UINT message, const MessageCallback& callback);
+  bool IsWindowMessageHooked(UINT message);
+  void UnhookWindowMessage(UINT message);
+  void UnhookAllWindowMessages();
+#endif
+
 #if defined(OS_MACOSX)
   void ShowDefinitionForSelection();
 #endif
@@ -147,10 +166,13 @@ class Window : public mate::TrackableObject<Window>,
 
   int32_t ID() const;
   v8::Local<v8::Value> WebContents(v8::Isolate* isolate);
-  v8::Local<v8::Value> DevToolsWebContents(v8::Isolate* isolate);
+
+#if defined(OS_WIN)
+  typedef std::map<UINT, MessageCallback> MessageCallbackMap;
+  MessageCallbackMap messages_callback_map_;
+#endif
 
   v8::Global<v8::Value> web_contents_;
-  v8::Global<v8::Value> devtools_web_contents_;
   v8::Global<v8::Value> menu_;
 
   api::WebContents* api_web_contents_;

atom/browser/api/event_emitter.cc

@@ -56,7 +56,7 @@ v8::Local<v8::Object> EventEmitter::CreateJSEvent(
 v8::Local<v8::Object> EventEmitter::CreateCustomEvent(
     v8::Isolate* isolate, v8::Local<v8::Object> custom_event) {
   v8::Local<v8::Object> event = CreateEventObject(isolate);
-  event->SetPrototype(custom_event->CreationContext(), custom_event);
+  (void)event->SetPrototype(custom_event->CreationContext(), custom_event);
   mate::Dictionary(isolate, event).Set("sender", GetWrapper(isolate));
   return event;
 }

atom/browser/api/event_emitter.h

@@ -45,6 +45,8 @@ class EventEmitter : public Wrappable {
                       content::WebContents* sender,
                       IPC::Message* message,
                       const Args&... args) {
+    v8::Locker locker(isolate());
+    v8::HandleScope handle_scope(isolate());
     v8::Local<v8::Object> event = CreateJSEvent(isolate(), sender, message);
     return EmitWithEvent(name, event, args...);
   }

atom/browser/api/frame_subscriber.cc

@@ -0,0 +1,67 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/frame_subscriber.h"
+
+#include "atom/common/node_includes.h"
+#include "base/bind.h"
+#include "media/base/video_frame.h"
+#include "media/base/yuv_convert.h"
+
+namespace atom {
+
+namespace api {
+
+FrameSubscriber::FrameSubscriber(v8::Isolate* isolate,
+                                 const gfx::Size& size,
+                                 const FrameCaptureCallback& callback)
+    : isolate_(isolate), size_(size), callback_(callback) {
+}
+
+bool FrameSubscriber::ShouldCaptureFrame(
+    const gfx::Rect& damage_rect,
+    base::TimeTicks present_time,
+    scoped_refptr<media::VideoFrame>* storage,
+    DeliverFrameCallback* callback) {
+  *storage = media::VideoFrame::CreateFrame(media::VideoFrame::YV12, size_,
+                                            gfx::Rect(size_), size_,
+                                            base::TimeDelta());
+  *callback = base::Bind(&FrameSubscriber::OnFrameDelivered,
+                         base::Unretained(this),
+                         *storage);
+  return true;
+}
+
+void FrameSubscriber::OnFrameDelivered(
+    scoped_refptr<media::VideoFrame> frame, base::TimeTicks, bool result) {
+  if (!result)
+    return;
+
+  v8::Locker locker(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+
+  gfx::Rect rect = frame->visible_rect();
+  size_t rgb_arr_size = rect.width() * rect.height() * 4;
+  v8::MaybeLocal<v8::Object> buffer = node::Buffer::New(isolate_, rgb_arr_size);
+  if (buffer.IsEmpty())
+    return;
+
+  // Convert a frame of YUV to 32 bit ARGB.
+  media::ConvertYUVToRGB32(frame->data(media::VideoFrame::kYPlane),
+                           frame->data(media::VideoFrame::kUPlane),
+                           frame->data(media::VideoFrame::kVPlane),
+                           reinterpret_cast<uint8*>(
+                              node::Buffer::Data(buffer.ToLocalChecked())),
+                           rect.width(), rect.height(),
+                           frame->stride(media::VideoFrame::kYPlane),
+                           frame->stride(media::VideoFrame::kUVPlane),
+                           rect.width() * 4,
+                           media::YV12);
+
+  callback_.Run(buffer.ToLocalChecked());
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/frame_subscriber.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_FRAME_SUBSCRIBER_H_
+#define ATOM_BROWSER_API_FRAME_SUBSCRIBER_H_
+
+#include "base/callback.h"
+#include "content/public/browser/render_widget_host_view_frame_subscriber.h"
+#include "ui/gfx/geometry/size.h"
+#include "v8/include/v8.h"
+
+namespace atom {
+
+namespace api {
+
+class FrameSubscriber : public content::RenderWidgetHostViewFrameSubscriber {
+ public:
+  using FrameCaptureCallback = base::Callback<void(v8::Local<v8::Value>)>;
+
+  FrameSubscriber(v8::Isolate* isolate,
+                  const gfx::Size& size,
+                  const FrameCaptureCallback& callback);
+
+  bool ShouldCaptureFrame(const gfx::Rect& damage_rect,
+                          base::TimeTicks present_time,
+                          scoped_refptr<media::VideoFrame>* storage,
+                          DeliverFrameCallback* callback) override;
+
+ private:
+  void OnFrameDelivered(
+      scoped_refptr<media::VideoFrame> frame, base::TimeTicks, bool);
+
+  v8::Isolate* isolate_;
+  gfx::Size size_;
+  FrameCaptureCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(FrameSubscriber);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_FRAME_SUBSCRIBER_H_

atom/browser/api/lib/app.coffee

@@ -1,15 +1,17 @@
-EventEmitter = require('events').EventEmitter
+{deprecate, session, Menu} = require 'electron'
+{EventEmitter} = require 'events'
 
 bindings = process.atomBinding 'app'
+downloadItemBindings = process.atomBinding 'download_item'
 
 app = bindings.app
 app.__proto__ = EventEmitter.prototype
 
 app.setApplicationMenu = (menu) ->
-  require('menu').setApplicationMenu menu
+  Menu.setApplicationMenu menu
 
 app.getApplicationMenu = ->
-  require('menu').getApplicationMenu()
+  Menu.getApplicationMenu()
 
 app.commandLine =
   appendSwitch: bindings.appendSwitch,
@@ -32,14 +34,40 @@ app.setAppPath = (path) ->
 app.getAppPath = ->
   appPath
 
-# Be compatible with old API.
-app.once 'ready', -> @emit 'finish-launching'
-app.terminate = app.quit
-app.exit = process.exit
-app.getHomeDir = -> @getPath 'home'
-app.getDataPath = -> @getPath 'userData'
-app.setDataPath = (path) -> @setPath 'userData', path
-app.resolveProxy = -> @defaultSession.resolveProxy.apply @defaultSession, arguments
+# Routes the events to webContents.
+for name in ['login', 'certificate-error', 'select-client-certificate']
+  do (name) ->
+    app.on name, (event, webContents, args...) ->
+      webContents.emit name, event, args...
+
+# Deprecated.
+app.getHomeDir = deprecate 'app.getHomeDir', 'app.getPath', ->
+  @getPath 'home'
+app.getDataPath = deprecate 'app.getDataPath', 'app.getPath', ->
+  @getPath 'userData'
+app.setDataPath = deprecate 'app.setDataPath', 'app.setPath', (path) ->
+  @setPath 'userData', path
+app.resolveProxy = deprecate 'app.resolveProxy', 'session.defaultSession.resolveProxy', (url, callback) ->
+  session.defaultSession.resolveProxy url, callback
+deprecate.rename app, 'terminate', 'quit'
+deprecate.event app, 'finish-launching', 'ready', ->
+  setImmediate => # give default app a chance to setup default menu.
+    @emit 'finish-launching'
+deprecate.event app, 'activate-with-no-open-windows', 'activate', (event, hasVisibleWindows) ->
+  @emit 'activate-with-no-open-windows' if not hasVisibleWindows
+deprecate.event app, 'select-certificate', 'select-client-certificate'
+
+# Wrappers for native classes.
+wrapDownloadItem = (downloadItem) ->
+  # downloadItem is an EventEmitter.
+  downloadItem.__proto__ = EventEmitter.prototype
+  # Deprecated.
+  deprecate.property downloadItem, 'url', 'getURL'
+  deprecate.property downloadItem, 'filename', 'getFilename'
+  deprecate.property downloadItem, 'mimeType', 'getMimeType'
+  deprecate.property downloadItem, 'hasUserGesture', 'hasUserGesture'
+  deprecate.rename downloadItem, 'getUrl', 'getURL'
+downloadItemBindings._setWrapDownloadItem wrapDownloadItem
 
 # Only one App object pemitted.
 module.exports = app

atom/browser/api/lib/atom-delegate.coffee

@@ -1,6 +0,0 @@
-module.exports =
-  browserMainParts:
-    preMainMessageLoopRun: ->
-
-setImmediate ->
-  module.exports.browserMainParts.preMainMessageLoopRun()

atom/browser/api/lib/auto-updater.coffee

@@ -1,24 +1,12 @@
-autoUpdater = process.atomBinding('auto_updater').autoUpdater
-EventEmitter = require('events').EventEmitter
+{deprecate} = require 'electron'
 
-autoUpdater.__proto__ = EventEmitter.prototype
+autoUpdater =
+  if process.platform is 'win32'
+    require './auto-updater/auto-updater-win'
+  else
+    require './auto-updater/auto-updater-native'
 
-autoUpdater.on 'update-downloaded-raw', (args...) ->
-  args[3] = new Date(args[3])  # releaseDate
-  @emit 'update-downloaded', args..., => @quitAndInstall()
-
-autoUpdater.quitAndInstall = ->
-  # If we don't have any window then quitAndInstall immediately.
-  BrowserWindow = require 'browser-window'
-  windows = BrowserWindow.getAllWindows()
-  if windows.length is 0
-    @_quitAndInstall()
-    return
-
-  # Do the restart after all windows have been closed.
-  app = require 'app'
-  app.removeAllListeners 'window-all-closed'
-  app.once 'window-all-closed', @_quitAndInstall.bind(this)
-  win.close() for win in windows
+# Deprecated.
+deprecate.rename autoUpdater, 'setFeedUrl', 'setFeedURL'
 
 module.exports = autoUpdater

atom/browser/api/lib/auto-updater/auto-updater-native.coffee

@@ -0,0 +1,6 @@
+{EventEmitter} = require 'events'
+{autoUpdater} = process.atomBinding 'auto_updater'
+
+autoUpdater.__proto__ = EventEmitter.prototype
+
+module.exports = autoUpdater

atom/browser/api/lib/auto-updater/auto-updater-win.coffee

@@ -0,0 +1,42 @@
+{app} = require 'electron'
+{EventEmitter} = require 'events'
+url = require 'url'
+
+squirrelUpdate = require './squirrel-update-win'
+
+class AutoUpdater extends EventEmitter
+  quitAndInstall: ->
+    squirrelUpdate.processStart()
+    app.quit()
+
+  setFeedURL: (updateURL) ->
+    @updateURL = updateURL
+
+  checkForUpdates: ->
+    return @emitError 'Update URL is not set' unless @updateURL
+    return @emitError 'Can not find Squirrel' unless squirrelUpdate.supported()
+
+    @emit 'checking-for-update'
+
+    squirrelUpdate.download @updateURL, (error, update) =>
+      return @emitError error if error?
+      return @emit 'update-not-available' unless update?
+
+      @emit 'update-available'
+
+      squirrelUpdate.update @updateURL, (error) =>
+        return @emitError error if error?
+
+        {releaseNotes, version} = update
+        # Following information is not available on Windows, so fake them.
+        date = new Date
+        url = @updateURL
+
+        @emit 'update-downloaded', {}, releaseNotes, version, date, url, => @quitAndInstall()
+
+  # Private: Emit both error object and message, this is to keep compatibility
+  # with Old APIs.
+  emitError: (message) ->
+    @emit 'error', new Error(message), message
+
+module.exports = new AutoUpdater

atom/browser/api/lib/auto-updater/squirrel-update-win.coffee

@@ -0,0 +1,67 @@
+fs      = require 'fs'
+path    = require 'path'
+{spawn} = require 'child_process'
+
+appFolder = path.dirname process.execPath # i.e. my-app/app-0.1.13/
+updateExe = path.resolve appFolder, '..', 'Update.exe' # i.e. my-app/Update.exe
+exeName   = path.basename process.execPath
+
+# Spawn a command and invoke the callback when it completes with an error
+# and the output from standard out.
+spawnUpdate = (args, detached, callback) ->
+  try
+    spawnedProcess = spawn updateExe, args, {detached}
+  catch error
+    # Shouldn't happen, but still guard it.
+    process.nextTick -> callback error
+    return
+
+  stdout = ''
+  stderr = ''
+  spawnedProcess.stdout.on 'data', (data) -> stdout += data
+  spawnedProcess.stderr.on 'data', (data) -> stderr += data
+
+  errorEmitted = false
+  spawnedProcess.on 'error', (error) ->
+    errorEmitted = true
+    callback error
+  spawnedProcess.on 'exit', (code, signal) ->
+    # We may have already emitted an error.
+    return if errorEmitted
+
+    # Process terminated with error.
+    if code isnt 0
+      return callback "Command failed: #{signal ? code}\n#{stderr}"
+
+    # Success.
+    callback null, stdout
+
+# Start an instance of the installed app.
+exports.processStart = (callback) ->
+  spawnUpdate ['--processStart', exeName], true, ->
+
+# Download the releases specified by the URL and write new results to stdout.
+exports.download = (updateURL, callback) ->
+  spawnUpdate ['--download', updateURL], false, (error, stdout) ->
+    return callback(error) if error?
+
+    try
+      # Last line of output is the JSON details about the releases
+      json = stdout.trim().split('\n').pop()
+      update = JSON.parse(json)?.releasesToApply?.pop?()
+    catch
+      return callback "Invalid result:\n#{stdout}"
+
+    callback null, update
+
+# Update the application to the latest remote version specified by URL.
+exports.update = (updateURL, callback) ->
+  spawnUpdate ['--update', updateURL], false, callback
+
+# Is the Update.exe installed with the current application?
+exports.supported = ->
+  try
+    fs.accessSync updateExe, fs.R_OK
+    return true
+  catch
+    return false

atom/browser/api/lib/browser-window.coffee

@@ -1,11 +1,12 @@
-EventEmitter = require('events').EventEmitter
-app = require 'app'
-ipc = require 'ipc'
+{ipcMain, deprecate} = require 'electron'
+{EventEmitter} = require 'events'
 
-BrowserWindow = process.atomBinding('window').BrowserWindow
+{BrowserWindow} = process.atomBinding 'window'
 BrowserWindow::__proto__ = EventEmitter.prototype
 
 BrowserWindow::_init = ->
+  {app} = require 'electron'  # avoid recursive require.
+
   # Simulate the application menu on platforms other than OS X.
   if process.platform isnt 'darwin'
     menu = app.getApplicationMenu()
@@ -14,7 +15,7 @@ BrowserWindow::_init = ->
   # Make new windows requested by links behave like "window.open"
   @webContents.on '-new-window', (event, url, frameName) ->
     options = show: true, width: 800, height: 600
-    ipc.emit 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', event, url, frameName, options
+    ipcMain.emit 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', event, url, frameName, options
 
   # window.resizeTo(...)
   # window.moveTo(...)
@@ -45,6 +46,18 @@ BrowserWindow::_init = ->
   @on 'focus', (event) =>
     app.emit 'browser-window-focus', event, this
 
+  # Notify the creation of the window.
+  app.emit 'browser-window-created', {}, this
+
+  # Be compatible with old APIs.
+  @webContents.on 'devtools-focused', => @emit 'devtools-focused'
+  @webContents.on 'devtools-opened', => @emit 'devtools-opened'
+  @webContents.on 'devtools-closed', => @emit 'devtools-closed'
+  Object.defineProperty this, 'devToolsWebContents',
+    enumerable: true,
+    configurable: false,
+    get: -> @webContents.devToolsWebContents
+
 BrowserWindow.getFocusedWindow = ->
   windows = BrowserWindow.getAllWindows()
   return window for window in windows when window.isFocused()
@@ -58,27 +71,35 @@ BrowserWindow.fromDevToolsWebContents = (webContents) ->
   return window for window in windows when window.devToolsWebContents?.equal webContents
 
 # Helpers.
-BrowserWindow::loadUrl = -> @webContents.loadUrl.apply @webContents, arguments
-BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
-
-# Be compatible with old API.
-BrowserWindow::restart = -> @webContents.reload()
-BrowserWindow::getUrl = -> @webContents.getUrl()
+BrowserWindow::loadURL = -> @webContents.loadURL.apply @webContents, arguments
+BrowserWindow::getURL = -> @webContents.getURL()
 BrowserWindow::reload = -> @webContents.reload.apply @webContents, arguments
-BrowserWindow::reloadIgnoringCache = -> @webContents.reloadIgnoringCache.apply @webContents, arguments
-BrowserWindow::getPageTitle = -> @webContents.getTitle()
-BrowserWindow::isLoading = -> @webContents.isLoading()
-BrowserWindow::isWaitingForResponse = -> @webContents.isWaitingForResponse()
-BrowserWindow::stop = -> @webContents.stop()
-BrowserWindow::isCrashed = -> @webContents.isCrashed()
-BrowserWindow::executeJavaScriptInDevTools = (code) -> @devToolsWebContents?.executeJavaScript code
+BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
 BrowserWindow::openDevTools = -> @webContents.openDevTools.apply @webContents, arguments
 BrowserWindow::closeDevTools = -> @webContents.closeDevTools()
 BrowserWindow::isDevToolsOpened = -> @webContents.isDevToolsOpened()
 BrowserWindow::toggleDevTools = -> @webContents.toggleDevTools()
 BrowserWindow::inspectElement = -> @webContents.inspectElement.apply @webContents, arguments
 BrowserWindow::inspectServiceWorker = -> @webContents.inspectServiceWorker()
-BrowserWindow::print = -> @webContents.print.apply @webContents, arguments
-BrowserWindow::printToPDF = -> @webContents.printToPDF.apply @webContents, arguments
+
+# Deprecated.
+deprecate.member BrowserWindow, 'undo', 'webContents'
+deprecate.member BrowserWindow, 'redo', 'webContents'
+deprecate.member BrowserWindow, 'cut', 'webContents'
+deprecate.member BrowserWindow, 'copy', 'webContents'
+deprecate.member BrowserWindow, 'paste', 'webContents'
+deprecate.member BrowserWindow, 'selectAll', 'webContents'
+deprecate.member BrowserWindow, 'reloadIgnoringCache', 'webContents'
+deprecate.member BrowserWindow, 'getPageTitle', 'webContents'
+deprecate.member BrowserWindow, 'isLoading', 'webContents'
+deprecate.member BrowserWindow, 'isWaitingForResponse', 'webContents'
+deprecate.member BrowserWindow, 'stop', 'webContents'
+deprecate.member BrowserWindow, 'isCrashed', 'webContents'
+deprecate.member BrowserWindow, 'executeJavaScriptInDevTools', 'webContents'
+deprecate.member BrowserWindow, 'print', 'webContents'
+deprecate.member BrowserWindow, 'printToPDF', 'webContents'
+deprecate.rename BrowserWindow, 'restart', 'reload'
+deprecate.rename BrowserWindow, 'loadUrl', 'loadURL'
+deprecate.rename BrowserWindow, 'getUrl', 'getURL'
 
 module.exports = BrowserWindow

atom/browser/api/lib/dialog.coffee

@@ -1,7 +1,7 @@
+{app, BrowserWindow} = require 'electron'
+
 binding = process.atomBinding 'dialog'
 v8Util = process.atomBinding 'v8_util'
-app = require 'app'
-BrowserWindow = require 'browser-window'
 
 fileDialogProperties =
   openFile:        1 << 0

atom/browser/api/lib/exports/electron.coffee

@@ -0,0 +1,55 @@
+# Import common modules.
+module.exports = require '../../../../common/api/lib/exports/electron'
+
+Object.defineProperties module.exports,
+  # Browser side modules, please sort with alphabet order.
+  app:
+    enumerable: true
+    get: -> require '../app'
+  autoUpdater:
+    enumerable: true
+    get: -> require '../auto-updater'
+  BrowserWindow:
+    enumerable: true
+    get: -> require '../browser-window'
+  contentTracing:
+    enumerable: true
+    get: -> require '../content-tracing'
+  dialog:
+    enumerable: true
+    get: -> require '../dialog'
+  ipcMain:
+    enumerable: true
+    get: -> require '../ipc-main'
+  globalShortcut:
+    enumerable: true
+    get: -> require '../global-shortcut'
+  Menu:
+    enumerable: true
+    get: -> require '../menu'
+  MenuItem:
+    enumerable: true
+    get: -> require '../menu-item'
+  powerMonitor:
+    enumerable: true
+    get: -> require '../power-monitor'
+  powerSaveBlocker:
+    enumerable: true
+    get: -> require '../power-save-blocker'
+  protocol:
+    enumerable: true
+    get: -> require '../protocol'
+  screen:
+    enumerable: true
+    get: -> require '../screen'
+  session:
+    enumerable: true
+    get: -> require '../session'
+  Tray:
+    enumerable: true
+    get: -> require '../tray'
+  # The internal modules, invisible unless you know their names.
+  NavigationController:
+    get: -> require '../navigation-controller'
+  webContents:
+    get: -> require '../web-contents'

atom/browser/api/lib/global-shortcut.coffee

@@ -1,5 +1,3 @@
-bindings = process.atomBinding 'global_shortcut'
-
-globalShortcut = bindings.globalShortcut
+{globalShortcut} = process.atomBinding 'global_shortcut'
 
 module.exports = globalShortcut

atom/browser/api/lib/ipc-main.coffee

@@ -0,0 +1,3 @@
+{EventEmitter} = require 'events'
+
+module.exports = new EventEmitter

atom/browser/api/lib/ipc.coffee

@@ -1,3 +1,6 @@
-EventEmitter = require('events').EventEmitter
+{deprecate, ipcMain} = require 'electron'
 
-module.exports = new EventEmitter
+# This module is deprecated, we mirror everything from ipcMain.
+deprecate.warn 'ipc module', 'ipcMain module'
+
+module.exports = ipcMain

atom/browser/api/lib/menu-item.coffee

@@ -1,20 +1,31 @@
-BrowserWindow = require 'browser-window'
 v8Util = process.atomBinding 'v8_util'
 
 nextCommandId = 0
 
+# Maps role to methods of webContents
+rolesMap =
+  undo: 'undo'
+  redo: 'redo'
+  cut: 'cut'
+  copy: 'copy'
+  paste: 'paste'
+  selectall: 'selectAll'
+  minimize: 'minimize'
+  close: 'close'
+
 class MenuItem
   @types = ['normal', 'separator', 'submenu', 'checkbox', 'radio']
 
   constructor: (options) ->
-    Menu = require 'menu'
+    {Menu} = require 'electron'
 
-    {click, @selector, @type, @label, @sublabel, @accelerator, @icon, @enabled, @visible, @checked, @submenu} = options
+    {click, @selector, @type, @role, @label, @sublabel, @accelerator, @icon, @enabled, @visible, @checked, @submenu} = options
 
     @type = 'submenu' if not @type? and @submenu?
     throw new Error('Invalid submenu') if @type is 'submenu' and @submenu?.constructor isnt Menu
 
     @overrideReadOnlyProperty 'type', 'normal'
+    @overrideReadOnlyProperty 'role'
     @overrideReadOnlyProperty 'accelerator'
     @overrideReadOnlyProperty 'icon'
     @overrideReadOnlyProperty 'submenu'
@@ -27,12 +38,14 @@ class MenuItem
     throw new Error("Unknown menu type #{@type}") if MenuItem.types.indexOf(@type) is -1
 
     @commandId = ++nextCommandId
-    @click = =>
+    @click = (focusedWindow) =>
       # Manually flip the checked flags when clicked.
       @checked = !@checked if @type in ['checkbox', 'radio']
 
-      if typeof click is 'function'
-        click this, BrowserWindow.getFocusedWindow()
+      if @role and rolesMap[@role] and process.platform isnt 'darwin'
+        focusedWindow?[rolesMap[@role]]()
+      else if typeof click is 'function'
+        click this, focusedWindow
       else if typeof @selector is 'string'
         Menu.sendActionToFirstResponder @selector
 

atom/browser/api/lib/menu.coffee

@@ -1,8 +1,7 @@
-BrowserWindow = require 'browser-window'
-EventEmitter = require('events').EventEmitter
-MenuItem = require 'menu-item'
-v8Util = process.atomBinding 'v8_util'
+{BrowserWindow, MenuItem} = require 'electron'
+{EventEmitter} = require 'events'
 
+v8Util = process.atomBinding 'v8_util'
 bindings = process.atomBinding 'menu'
 
 # Automatically generated radio menu item's group id.
@@ -67,7 +66,8 @@ Menu::_init = ->
     isCommandIdVisible: (commandId) => @commandsMap[commandId]?.visible
     getAcceleratorForCommandId: (commandId) => @commandsMap[commandId]?.accelerator
     getIconForCommandId: (commandId) => @commandsMap[commandId]?.icon
-    executeCommand: (commandId) => @commandsMap[commandId]?.click()
+    executeCommand: (commandId) =>
+      @commandsMap[commandId]?.click BrowserWindow.getFocusedWindow()
     menuWillShow: =>
       # Make sure radio groups have at least one menu item seleted.
       for id, group of @groupsMap
@@ -78,7 +78,11 @@ Menu::_init = ->
         v8Util.setHiddenValue group[0], 'checked', true unless checked
 
 Menu::popup = (window, x, y) ->
-  throw new TypeError('Invalid window') unless window?.constructor is BrowserWindow
+  unless window?.constructor is BrowserWindow
+    # Shift.
+    y = x
+    x = window
+    window = BrowserWindow.getFocusedWindow()
   if x? and y?
     @_popupAt(window, x, y)
   else
@@ -115,6 +119,7 @@ Menu::insert = (pos, item) ->
 
   @setSublabel pos, item.sublabel if item.sublabel?
   @setIcon pos, item.icon if item.icon?
+  @setRole pos, item.role if item.role?
 
   # Make menu accessable to items.
   item.overrideReadOnlyProperty 'menu', this

atom/browser/api/lib/navigation-controller.coffee

@@ -1,21 +1,26 @@
-ipc = require 'ipc'
+{ipcMain} = require 'electron'
 
 # The history operation in renderer is redirected to browser.
-ipc.on 'ATOM_SHELL_NAVIGATION_CONTROLLER', (event, method, args...) ->
+ipcMain.on 'ATOM_SHELL_NAVIGATION_CONTROLLER', (event, method, args...) ->
   event.sender[method] args...
 
-ipc.on 'ATOM_SHELL_SYNC_NAVIGATION_CONTROLLER', (event, method, args...) ->
+ipcMain.on 'ATOM_SHELL_SYNC_NAVIGATION_CONTROLLER', (event, method, args...) ->
   event.returnValue = event.sender[method] args...
 
 # JavaScript implementation of Chromium's NavigationController.
 # Instead of relying on Chromium for history control, we compeletely do history
-# control on user land, and only rely on WebContents.loadUrl for navigation.
+# control on user land, and only rely on WebContents.loadURL for navigation.
 # This helps us avoid Chromium's various optimizations so we can ensure renderer
 # process is restarted everytime.
 class NavigationController
   constructor: (@webContents) ->
     @clearHistory()
 
+    # webContents may have already navigated to a page.
+    if @webContents._getURL()
+      @currentIndex++
+      @history.push @webContents._getURL()
+
     @webContents.on 'navigation-entry-commited', (event, url, inPage, replaceEntry) =>
       if @inPageIndex > -1 and not inPage
         # Navigated to a new page, clear in-page mark.
@@ -37,12 +42,12 @@ class NavigationController
           @currentIndex++
           @history.push url
 
-  loadUrl: (url, options={}) ->
+  loadURL: (url, options={}) ->
     @pendingIndex = -1
-    @webContents._loadUrl url, options
+    @webContents._loadURL url, options
     @webContents.emit 'load-url', url, options
 
-  getUrl: ->
+  getURL: ->
     if @currentIndex is -1
       ''
     else
@@ -54,11 +59,11 @@ class NavigationController
 
   reload: ->
     @pendingIndex = @currentIndex
-    @webContents._loadUrl @getUrl(), {}
+    @webContents._loadURL @getURL(), {}
 
   reloadIgnoringCache: ->
-    @webContents._reloadIgnoringCache()  # Rely on WebContents to clear cache.
-    @reload()
+    @pendingIndex = @currentIndex
+    @webContents._loadURL @getURL(), {extraHeaders: "pragma: no-cache\n"}
 
   canGoBack: ->
     @getActiveIndex() > 0
@@ -84,7 +89,7 @@ class NavigationController
     if @inPageIndex > -1 and @pendingIndex >= @inPageIndex
       @webContents._goBack()
     else
-      @webContents._loadUrl @history[@pendingIndex], {}
+      @webContents._loadURL @history[@pendingIndex], {}
 
   goForward: ->
     return unless @canGoForward()
@@ -92,12 +97,12 @@ class NavigationController
     if @inPageIndex > -1 and @pendingIndex >= @inPageIndex
       @webContents._goForward()
     else
-      @webContents._loadUrl @history[@pendingIndex], {}
+      @webContents._loadURL @history[@pendingIndex], {}
 
   goToIndex: (index) ->
     return unless @canGoToIndex index
     @pendingIndex = index
-    @webContents._loadUrl @history[@pendingIndex], {}
+    @webContents._loadURL @history[@pendingIndex], {}
 
   goToOffset: (offset) ->
     return unless @canGoToOffset offset

atom/browser/api/lib/power-monitor.coffee

@@ -1,5 +1,6 @@
-powerMonitor = process.atomBinding('power_monitor').powerMonitor
-EventEmitter = require('events').EventEmitter
+{EventEmitter} = require 'events'
+
+{powerMonitor} = process.atomBinding 'power_monitor'
 
 powerMonitor.__proto__ = EventEmitter.prototype
 

atom/browser/api/lib/power-save-blocker.coffee

@@ -1,3 +1,3 @@
-bindings = process.atomBinding 'power_save_blocker'
+{powerSaveBlocker} = process.atomBinding 'power_save_blocker'
 
-module.exports = bindings.powerSaveBlocker
+module.exports = powerSaveBlocker

atom/browser/api/lib/protocol.coffee

@@ -1,64 +1,25 @@
-app = require 'app'
+{app} = require 'electron'
+
 throw new Error('Can not initialize protocol module before app is ready') unless app.isReady()
 
-protocol = process.atomBinding('protocol').protocol
-EventEmitter = require('events').EventEmitter
+{protocol} = process.atomBinding 'protocol'
 
-protocol.__proto__ = EventEmitter.prototype
-
-GetWrappedCallback = (scheme, callback, notification) ->
-  wrappedCallback = (error) ->
-    if not callback?
-      if error
-        throw error
-      else
-        protocol.emit notification, scheme
-    else
-      callback error, scheme
-
-# Compatibility with old api.
+# Warn about removed APIs.
+logAndThrow = (callback, message) ->
+  console.error message
+  if callback then callback(new Error(message)) else throw new Error(message)
 protocol.registerProtocol = (scheme, handler, callback) ->
-  protocol._registerProtocol scheme, handler, GetWrappedCallback(scheme, callback, 'registered')
-
-protocol.unregisterProtocol = (scheme, callback) ->
-  protocol._unregisterProtocol scheme, GetWrappedCallback(scheme, callback, 'unregistered')
-
+  logAndThrow callback,
+              'registerProtocol API has been replaced by the
+               register[File/Http/Buffer/String]Protocol API family, please
+               switch to the new APIs.'
+protocol.isHandledProtocol = (scheme, callback) ->
+  logAndThrow callback,
+              'isHandledProtocol API has been replaced by isProtocolHandled.'
 protocol.interceptProtocol = (scheme, handler, callback) ->
-  protocol._interceptProtocol scheme, handler, GetWrappedCallback(scheme, callback, 'intercepted')
-
-protocol.uninterceptProtocol = (scheme, callback) ->
-  protocol._uninterceptProtocol scheme, GetWrappedCallback(scheme, callback, 'unintercepted')
-
-protocol.RequestStringJob =
-class RequestStringJob
-  constructor: ({mimeType, charset, data}) ->
-    if typeof data isnt 'string' and not data instanceof Buffer
-      throw new TypeError('Data should be string or Buffer')
-
-    @mimeType = mimeType ? 'text/plain'
-    @charset = charset ? 'UTF-8'
-    @data = String data
-
-protocol.RequestBufferJob =
-class RequestBufferJob
-  constructor: ({mimeType, encoding, data}) ->
-    if not data instanceof Buffer
-      throw new TypeError('Data should be Buffer')
-
-    @mimeType = mimeType ? 'application/octet-stream'
-    @encoding = encoding ? 'utf8'
-    @data = new Buffer(data)
-
-protocol.RequestFileJob =
-class RequestFileJob
-  constructor: (@path) ->
-
-protocol.RequestErrorJob =
-class RequestErrorJob
-  constructor: (@error) ->
-
-protocol.RequestHttpJob =
-class RequestHttpJob
-  constructor: ({@session, @url, @method, @referrer}) ->
+  logAndThrow callback,
+              'interceptProtocol API has been replaced by the
+               intercept[File/Http/Buffer/String]Protocol API family, please
+               switch to the new APIs.'
 
 module.exports = protocol

atom/browser/api/lib/screen.coffee

@@ -1,6 +1,6 @@
-EventEmitter = require('events').EventEmitter
+{EventEmitter} = require 'events'
+{screen} = process.atomBinding 'screen'
 
-screen = process.atomBinding('screen').screen
 screen.__proto__ = EventEmitter.prototype
 
 module.exports = screen

atom/browser/api/lib/session.coffee

@@ -0,0 +1,23 @@
+{EventEmitter} = require 'events'
+
+bindings = process.atomBinding 'session'
+
+PERSIST_PERFIX = 'persist:'
+
+# Returns the Session from |partition| string.
+exports.fromPartition = (partition='') ->
+  if partition.startsWith PERSIST_PERFIX
+    bindings.fromPartition partition.substr(PERSIST_PERFIX.length), false
+  else
+    bindings.fromPartition partition, true
+
+# Returns the default session.
+Object.defineProperty exports, 'defaultSession',
+  enumerable: true
+  get: -> exports.fromPartition ''
+
+wrapSession = (session) ->
+  # session is an EventEmitter.
+  session.__proto__ = EventEmitter.prototype
+
+bindings._setWrapSession wrapSession

atom/browser/api/lib/tray.coffee

@@ -1,14 +1,19 @@
-EventEmitter = require('events').EventEmitter
-bindings = process.atomBinding 'tray'
+{deprecate} = require 'electron'
+{EventEmitter} = require 'events'
 
-Tray = bindings.Tray
+{Tray} = process.atomBinding 'tray'
 Tray::__proto__ = EventEmitter.prototype
 
+Tray::_init = ->
+  # Deprecated.
+  deprecate.rename this, 'popContextMenu', 'popUpContextMenu'
+  deprecate.event this, 'clicked', 'click'
+  deprecate.event this, 'double-clicked', 'double-click'
+  deprecate.event this, 'right-clicked', 'right-click'
+  deprecate.event this, 'balloon-clicked', 'balloon-click'
+
 Tray::setContextMenu = (menu) ->
   @_setContextMenu menu
   @menu = menu  # Keep a strong reference of menu.
 
-# Keep compatibility with old APIs.
-Tray::popContextMenu = Tray::popUpContextMenu
-
 module.exports = Tray

atom/browser/api/lib/web-contents.coffee

@@ -1,7 +1,7 @@
-EventEmitter = require('events').EventEmitter
-NavigationController = require './navigation-controller'
+{EventEmitter} = require 'events'
+{deprecate, ipcMain, session, NavigationController, Menu} = require 'electron'
+
 binding = process.atomBinding 'web_contents'
-ipc = require 'ipc'
 
 nextId = 0
 getNextId = -> ++nextId
@@ -44,10 +44,8 @@ wrapWebContents = (webContents) ->
 
   # Make sure webContents.executeJavaScript would run the code only when the
   # web contents has been loaded.
-  webContents.loaded = false
-  webContents.once 'did-finish-load', -> @loaded = true
   webContents.executeJavaScript = (code, hasUserGesture=false) ->
-    if @loaded
+    if @getURL() and not @isLoading()
       @_executeJavaScript code, hasUserGesture
     else
       webContents.once 'did-finish-load', @_executeJavaScript.bind(this, code, hasUserGesture)
@@ -61,11 +59,20 @@ wrapWebContents = (webContents) ->
   # Dispatch IPC messages to the ipc module.
   webContents.on 'ipc-message', (event, packed) ->
     [channel, args...] = packed
-    ipc.emit channel, event, args...
+    ipcMain.emit channel, event, args...
   webContents.on 'ipc-message-sync', (event, packed) ->
     [channel, args...] = packed
     Object.defineProperty event, 'returnValue', set: (value) -> event.sendReply JSON.stringify(value)
-    ipc.emit channel, event, args...
+    ipcMain.emit channel, event, args...
+
+  # Handle context menu action request from pepper plugin.
+  webContents.on 'pepper-context-menu', (event, params) ->
+    menu = Menu.buildFromTemplate params.menu
+    menu.popup params.x, params.y
+
+  # Deprecated.
+  deprecate.rename webContents, 'loadUrl', 'loadURL'
+  deprecate.rename webContents, 'getUrl', 'getURL'
 
   webContents.printToPDF = (options, callback) ->
     printingSetting =
@@ -108,7 +115,6 @@ wrapWebContents = (webContents) ->
     @_printToPDF printingSetting, callback
 
 binding._setWrapWebContents wrapWebContents
-process.once 'exit', binding._clearWrapWebContents
 
 module.exports.create = (options={}) ->
   binding.create(options)

atom/browser/api/save_page_handler.cc

@@ -0,0 +1,83 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/save_page_handler.h"
+
+#include <string>
+
+#include "atom/browser/atom_browser_context.h"
+#include "base/callback.h"
+#include "base/files/file_path.h"
+#include "content/public/browser/web_contents.h"
+
+namespace atom {
+
+namespace api {
+
+SavePageHandler::SavePageHandler(content::WebContents* web_contents,
+                                 const SavePageCallback& callback)
+    : web_contents_(web_contents),
+      callback_(callback) {
+}
+
+SavePageHandler::~SavePageHandler() {
+}
+
+void SavePageHandler::OnDownloadCreated(content::DownloadManager* manager,
+                                        content::DownloadItem* item) {
+  // OnDownloadCreated is invoked during WebContents::SavePage, so the |item|
+  // here is the one stated by WebContents::SavePage.
+  item->AddObserver(this);
+}
+
+bool SavePageHandler::Handle(const base::FilePath& full_path,
+                             const content::SavePageType& save_type) {
+  auto download_manager = content::BrowserContext::GetDownloadManager(
+      web_contents_->GetBrowserContext());
+  download_manager->AddObserver(this);
+  // Chromium will create a 'foo_files' directory under the directory of saving
+  // page 'foo.html' for holding other resource files of 'foo.html'.
+  base::FilePath saved_main_directory_path = full_path.DirName().Append(
+      full_path.RemoveExtension().BaseName().value() +
+      FILE_PATH_LITERAL("_files"));
+  bool result = web_contents_->SavePage(full_path,
+                                        saved_main_directory_path,
+                                        save_type);
+  download_manager->RemoveObserver(this);
+  // If initialization fails which means fail to create |DownloadItem|, we need
+  // to delete the |SavePageHandler| instance to avoid memory-leak.
+  if (!result)
+    delete this;
+  return result;
+}
+
+void SavePageHandler::OnDownloadUpdated(content::DownloadItem* item) {
+  if (item->IsDone()) {
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);
+    if (item->GetState() == content::DownloadItem::COMPLETE) {
+      callback_.Run(v8::Null(isolate));
+    } else {
+      v8::Local<v8::String> error_message = v8::String::NewFromUtf8(
+          isolate, "Fail to save page");
+      callback_.Run(v8::Exception::Error(error_message));
+    }
+    Destroy(item);
+  }
+}
+
+void SavePageHandler::Destroy(content::DownloadItem* item) {
+  item->RemoveObserver(this);
+  delete this;
+}
+
+// static
+bool SavePageHandler::IsSavePageTypes(const std::string& type) {
+  return type == "multipart/related" || type == "text/html";
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/save_page_handler.h

@@ -0,0 +1,60 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_SAVE_PAGE_HANDLER_H_
+#define ATOM_BROWSER_API_SAVE_PAGE_HANDLER_H_
+
+#include <string>
+
+#include "content/public/browser/download_item.h"
+#include "content/public/browser/download_manager.h"
+#include "content/public/browser/save_page_type.h"
+#include "v8/include/v8.h"
+
+namespace base {
+class FilePath;
+}
+
+namespace content {
+class WebContents;
+}
+
+namespace atom {
+
+namespace api {
+
+// A self-destroyed class for handling save page request.
+class SavePageHandler : public content::DownloadManager::Observer,
+                        public content::DownloadItem::Observer {
+ public:
+  using SavePageCallback = base::Callback<void(v8::Local<v8::Value>)>;
+
+  SavePageHandler(content::WebContents* web_contents,
+                  const SavePageCallback& callback);
+  ~SavePageHandler();
+
+  bool Handle(const base::FilePath& full_path,
+              const content::SavePageType& save_type);
+
+  static bool IsSavePageTypes(const std::string& type);
+
+ private:
+  void Destroy(content::DownloadItem* item);
+
+  // content::DownloadManager::Observer:
+  void OnDownloadCreated(content::DownloadManager* manager,
+                         content::DownloadItem* item) override;
+
+  // content::DownloadItem::Observer:
+  void OnDownloadUpdated(content::DownloadItem* item) override;
+
+  content::WebContents* web_contents_;  // weak
+  SavePageCallback callback_;
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_SAVE_PAGE_HANDLER_H_

atom/browser/api/trackable_object.cc

@@ -29,7 +29,9 @@ class IDUserData : public base::SupportsUserData::Data {
 }  // namespace
 
 TrackableObjectBase::TrackableObjectBase()
-    : weak_map_id_(0), wrapped_(nullptr) {
+    : weak_map_id_(0), wrapped_(nullptr), weak_factory_(this) {
+  RegisterDestructionCallback(
+      base::Bind(&TrackableObjectBase::Destroy, weak_factory_.GetWeakPtr()));
 }
 
 TrackableObjectBase::~TrackableObjectBase() {
@@ -61,8 +63,9 @@ int32_t TrackableObjectBase::GetIDFromWrappedClass(base::SupportsUserData* w) {
 }
 
 // static
-void TrackableObjectBase::RegisterDestructionCallback(void (*c)()) {
-  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(base::Bind(c));
+void TrackableObjectBase::RegisterDestructionCallback(
+    const base::Closure& closure) {
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(closure);
 }
 
 }  // namespace mate

atom/browser/api/trackable_object.h

@@ -9,7 +9,9 @@
 
 #include "atom/browser/api/event_emitter.h"
 #include "atom/common/id_weak_map.h"
+#include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 
 namespace base {
 class SupportsUserData;
@@ -28,6 +30,9 @@ class TrackableObjectBase : public mate::EventEmitter {
   // Wrap TrackableObject into a class that SupportsUserData.
   void AttachAsUserData(base::SupportsUserData* wrapped);
 
+  // Subclasses should implement this to destroy their native types.
+  virtual void Destroy() = 0;
+
  protected:
   ~TrackableObjectBase() override;
 
@@ -39,12 +44,14 @@ class TrackableObjectBase : public mate::EventEmitter {
 
   // Register a callback that should be destroyed before JavaScript environment
   // gets destroyed.
-  static void RegisterDestructionCallback(void (*callback)());
+  static void RegisterDestructionCallback(const base::Closure& closure);
 
   int32_t weak_map_id_;
   base::SupportsUserData* wrapped_;
 
  private:
+  base::WeakPtrFactory<TrackableObjectBase> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(TrackableObjectBase);
 };
 
@@ -85,7 +92,8 @@ class TrackableObject : public TrackableObjectBase {
   }
 
   TrackableObject() {
-    RegisterDestructionCallback(&TrackableObject<T>::ReleaseAllWeakReferences);
+    RegisterDestructionCallback(
+        base::Bind(&TrackableObject<T>::ReleaseAllWeakReferences));
   }
 
   // Removes this instance from the weak map.

atom/browser/atom_access_token_store.cc

@@ -9,6 +9,7 @@
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/common/google_api_key.h"
+#include "content/public/browser/geolocation_provider.h"
 
 namespace atom {
 
@@ -17,13 +18,14 @@ namespace {
 // 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 =
+const char* kGeolocationProviderURL =
     "https://www.googleapis.com/geolocation/v1/geolocate?key="
     GOOGLEAPIS_API_KEY;
 
 }  // namespace
 
 AtomAccessTokenStore::AtomAccessTokenStore() {
+  content::GeolocationProvider::GetInstance()->UserDidOptIntoLocationServices();
 }
 
 AtomAccessTokenStore::~AtomAccessTokenStore() {
@@ -33,11 +35,11 @@ void AtomAccessTokenStore::LoadAccessTokens(
     const LoadAccessTokensCallbackType& callback) {
   AccessTokenSet access_token_set;
 
-  // Equivelent to access_token_set[kGeolocationProviderUrl].
+  // Equivelent to access_token_set[kGeolocationProviderURL].
   // Somehow base::string16 is causing compilation errors when used in a pair
   // of std::map on Linux, this can work around it.
   std::pair<GURL, base::string16> token_pair;
-  token_pair.first = GURL(kGeolocationProviderUrl);
+  token_pair.first = GURL(kGeolocationProviderURL);
   access_token_set.insert(token_pair);
 
   auto browser_context = AtomBrowserMainParts::Get()->browser_context();

atom/browser/atom_browser_client.cc

@@ -12,14 +12,15 @@
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_quota_permission_context.h"
+#include "atom/browser/atom_resource_dispatcher_host_delegate.h"
 #include "atom/browser/atom_speech_recognition_manager_delegate.h"
-#include "atom/browser/browser.h"
 #include "atom/browser/native_window.h"
-#include "atom/browser/web_view_manager.h"
+#include "atom/browser/web_contents_preferences.h"
 #include "atom/browser/window_list.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
+#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/printing/printing_message_filter.h"
@@ -29,6 +30,7 @@
 #include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#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/web_preferences.h"
@@ -36,6 +38,7 @@
 #include "net/ssl/ssl_cert_request_info.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "v8/include/v8.h"
 
 namespace atom {
 
@@ -52,34 +55,6 @@ bool g_suppress_renderer_process_restart = false;
 // Custom schemes to be registered to standard.
 std::string g_custom_schemes = "";
 
-// Find out the owner of the child process according to |process_id|.
-enum ProcessOwner {
-  OWNER_NATIVE_WINDOW,
-  OWNER_GUEST_WEB_CONTENTS,
-  OWNER_NONE,  // it might be devtools though.
-};
-ProcessOwner GetProcessOwner(int process_id,
-                             NativeWindow** window,
-                             WebViewManager::WebViewInfo* info) {
-  auto web_contents = content::WebContents::FromRenderViewHost(
-      content::RenderViewHost::FromID(process_id, kDefaultRoutingID));
-  if (!web_contents)
-    return OWNER_NONE;
-
-  // First search for NativeWindow.
-  for (auto native_window : *WindowList::GetInstance())
-    if (web_contents == native_window->web_contents()) {
-      *window = native_window;
-      return OWNER_NATIVE_WINDOW;
-    }
-
-  // Then search for guest WebContents.
-  if (WebViewManager::GetInfoForWebContents(web_contents, info))
-    return OWNER_GUEST_WEB_CONTENTS;
-
-  return OWNER_NONE;
-}
-
 scoped_refptr<net::X509Certificate> ImportCertFromFile(
     const base::FilePath& path) {
   if (path.empty())
@@ -112,7 +87,7 @@ void AtomBrowserClient::SetCustomSchemes(
   g_custom_schemes = JoinString(schemes, ',');
 }
 
-AtomBrowserClient::AtomBrowserClient() {
+AtomBrowserClient::AtomBrowserClient() : delegate_(nullptr) {
 }
 
 AtomBrowserClient::~AtomBrowserClient() {
@@ -155,15 +130,7 @@ void AtomBrowserClient::OverrideWebkitPrefs(
 
   // Custom preferences of guest page.
   auto web_contents = content::WebContents::FromRenderViewHost(host);
-  WebViewManager::WebViewInfo info;
-  if (WebViewManager::GetInfoForWebContents(web_contents, &info)) {
-    prefs->web_security_enabled = !info.disable_web_security;
-    return;
-  }
-
-  NativeWindow* window = NativeWindow::FromWebContents(web_contents);
-  if (window)
-    window->OverrideWebkitPrefs(prefs);
+  WebContentsPreferences::OverrideWebkitPrefs(web_contents, prefs);
 }
 
 std::string AtomBrowserClient::GetApplicationLocale() {
@@ -185,6 +152,13 @@ void AtomBrowserClient::OverrideSiteInstanceForNavigation(
     return;
 
   *new_instance = content::SiteInstance::CreateForURL(browser_context, url);
+
+  // Remember the original renderer process of the pending renderer process.
+  auto current_process = current_instance->GetProcess();
+  auto pending_process = (*new_instance)->GetProcess();
+  pending_processes_[pending_process->GetID()] = current_process->GetID();
+  // Clear the entry in map when process ends.
+  current_process->AddObserver(this);
 }
 
 void AtomBrowserClient::AppendExtraCommandLineSwitches(
@@ -208,23 +182,18 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches(
   }
 #endif
 
-  NativeWindow* window;
-  WebViewManager::WebViewInfo info;
-  ProcessOwner owner = GetProcessOwner(process_id, &window, &info);
+  // If the process is a pending process, we should use the old one.
+  if (ContainsKey(pending_processes_, process_id))
+    process_id = pending_processes_[process_id];
 
-  if (owner == OWNER_NATIVE_WINDOW) {
-    window->AppendExtraCommandLineSwitches(command_line);
-  } else if (owner == OWNER_GUEST_WEB_CONTENTS) {
-    command_line->AppendSwitchASCII(
-        switches::kGuestInstanceID, base::IntToString(info.guest_instance_id));
-    command_line->AppendSwitchASCII(
-        switches::kNodeIntegration, info.node_integration ? "true" : "false");
-    if (info.plugins)
-      command_line->AppendSwitch(switches::kEnablePlugins);
-    if (!info.preload_script.empty())
-      command_line->AppendSwitchPath(
-          switches::kPreloadScript, info.preload_script);
-  }
+  // Get the WebContents of the render process.
+  content::WebContents* web_contents = content::WebContents::FromRenderViewHost(
+      content::RenderViewHost::FromID(process_id, kDefaultRoutingID));
+  if (!web_contents)
+    return;
+
+  WebContentsPreferences::AppendExtraCommandLineSwitches(
+      web_contents, command_line);
 }
 
 void AtomBrowserClient::DidCreatePpapiPlugin(
@@ -238,6 +207,26 @@ content::QuotaPermissionContext*
   return new AtomQuotaPermissionContext;
 }
 
+void AtomBrowserClient::AllowCertificateError(
+    int render_process_id,
+    int render_frame_id,
+    int cert_error,
+    const net::SSLInfo& ssl_info,
+    const GURL& request_url,
+    content::ResourceType resource_type,
+    bool overridable,
+    bool strict_enforcement,
+    bool expired_previous_decision,
+    const base::Callback<void(bool)>& callback,
+    content::CertificateRequestResultType* request) {
+  if (delegate_) {
+    delegate_->AllowCertificateError(
+        render_process_id, render_frame_id, cert_error, ssl_info, request_url,
+        resource_type, overridable, strict_enforcement,
+        expired_previous_decision, callback, request);
+  }
+}
+
 void AtomBrowserClient::SelectClientCertificate(
     content::WebContents* web_contents,
     net::SSLCertRequestInfo* cert_request_info,
@@ -252,10 +241,17 @@ void AtomBrowserClient::SelectClientCertificate(
     return;
   }
 
-  if (!cert_request_info->client_certs.empty())
-    Browser::Get()->ClientCertificateSelector(web_contents,
-                                              cert_request_info,
-                                              delegate.Pass());
+  if (!cert_request_info->client_certs.empty() && delegate_) {
+    delegate_->SelectClientCertificate(
+        web_contents, cert_request_info, delegate.Pass());
+  }
+}
+
+void AtomBrowserClient::ResourceDispatcherHostCreated() {
+  resource_dispatcher_host_delegate_.reset(
+      new AtomResourceDispatcherHostDelegate);
+  content::ResourceDispatcherHost::Get()->SetDelegate(
+      resource_dispatcher_host_delegate_.get());
 }
 
 brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
@@ -264,4 +260,15 @@ brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
   return new AtomBrowserMainParts;
 }
 
+void AtomBrowserClient::RenderProcessHostDestroyed(
+    content::RenderProcessHost* host) {
+  int process_id = host->GetID();
+  for (const auto& entry : pending_processes_) {
+    if (entry.first == process_id || entry.second == process_id) {
+      pending_processes_.erase(entry.first);
+      break;
+    }
+  }
+}
+
 }  // namespace atom

atom/browser/atom_browser_client.h

@@ -5,10 +5,12 @@
 #ifndef ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 #define ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "brightray/browser/browser_client.h"
+#include "content/public/browser/render_process_host_observer.h"
 
 namespace content {
 class QuotaPermissionContext;
@@ -21,11 +23,17 @@ class SSLCertRequestInfo;
 
 namespace atom {
 
-class AtomBrowserClient : public brightray::BrowserClient {
+class AtomResourceDispatcherHostDelegate;
+
+class AtomBrowserClient : public brightray::BrowserClient,
+                          public content::RenderProcessHostObserver {
  public:
   AtomBrowserClient();
   virtual ~AtomBrowserClient();
 
+  using Delegate = content::ContentBrowserClient;
+  void set_delegate(Delegate* delegate) { delegate_ = delegate; }
+
   // Don't force renderer process to restart for once.
   static void SuppressRendererProcessRestartForOnce();
   // Custom schemes to be registered to standard.
@@ -49,15 +57,40 @@ class AtomBrowserClient : public brightray::BrowserClient {
                                       int child_process_id) override;
   void DidCreatePpapiPlugin(content::BrowserPpapiHost* browser_host) override;
   content::QuotaPermissionContext* CreateQuotaPermissionContext() override;
+  void AllowCertificateError(
+      int render_process_id,
+      int render_frame_id,
+      int cert_error,
+      const net::SSLInfo& ssl_info,
+      const GURL& request_url,
+      content::ResourceType resource_type,
+      bool overridable,
+      bool strict_enforcement,
+      bool expired_previous_decision,
+      const base::Callback<void(bool)>& callback,
+      content::CertificateRequestResultType* request) override;
   void SelectClientCertificate(
       content::WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
       scoped_ptr<content::ClientCertificateDelegate> delegate) override;
+  void ResourceDispatcherHostCreated() override;
 
- private:
+  // brightray::BrowserClient:
   brightray::BrowserMainParts* OverrideCreateBrowserMainParts(
       const content::MainFunctionParams&) override;
 
+  // content::RenderProcessHostObserver:
+  void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
+
+ private:
+  // pending_render_process => current_render_process.
+  std::map<int, int> pending_processes_;
+
+  scoped_ptr<AtomResourceDispatcherHostDelegate>
+      resource_dispatcher_host_delegate_;
+
+  Delegate* delegate_;
+
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
 };
 

atom/browser/atom_browser_context.cc

@@ -7,6 +7,8 @@
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_download_manager_delegate.h"
 #include "atom/browser/browser.h"
+#include "atom/browser/net/atom_cert_verifier.h"
+#include "atom/browser/net/atom_ssl_config_service.h"
 #include "atom/browser/net/atom_url_request_job_factory.h"
 #include "atom/browser/net/asar/asar_protocol_handler.h"
 #include "atom/browser/net/http_protocol_handler.h"
@@ -56,8 +58,12 @@ std::string RemoveWhitespace(const std::string& str) {
 
 }  // namespace
 
-AtomBrowserContext::AtomBrowserContext()
-    : job_factory_(new AtomURLRequestJobFactory) {
+AtomBrowserContext::AtomBrowserContext(const std::string& partition,
+                                       bool in_memory)
+    : brightray::BrowserContext(partition, in_memory),
+      cert_verifier_(new AtomCertVerifier),
+      job_factory_(new AtomURLRequestJobFactory),
+      allow_ntlm_everywhere_(false) {
 }
 
 AtomBrowserContext::~AtomBrowserContext() {
@@ -85,32 +91,37 @@ net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
     content::URLRequestInterceptorScopedVector* interceptors) {
   scoped_ptr<AtomURLRequestJobFactory> job_factory(job_factory_);
 
-  for (content::ProtocolHandlerMap::iterator it = handlers->begin();
-       it != handlers->end(); ++it)
-    job_factory->SetProtocolHandler(it->first, it->second.release());
+  for (auto& it : *handlers) {
+    job_factory->SetProtocolHandler(it.first,
+                                    make_scoped_ptr(it.second.release()));
+  }
   handlers->clear();
 
   job_factory->SetProtocolHandler(
-      url::kDataScheme, new net::DataProtocolHandler);
+      url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler));
   job_factory->SetProtocolHandler(
-      url::kFileScheme, new asar::AsarProtocolHandler(
+      url::kFileScheme, make_scoped_ptr(new asar::AsarProtocolHandler(
           BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
   job_factory->SetProtocolHandler(
-      url::kHttpScheme, new HttpProtocolHandler(url::kHttpScheme));
+      url::kHttpScheme,
+      make_scoped_ptr(new HttpProtocolHandler(url::kHttpScheme)));
   job_factory->SetProtocolHandler(
-      url::kHttpsScheme, new HttpProtocolHandler(url::kHttpsScheme));
+      url::kHttpsScheme,
+      make_scoped_ptr(new HttpProtocolHandler(url::kHttpsScheme)));
   job_factory->SetProtocolHandler(
-      url::kWsScheme, new HttpProtocolHandler(url::kWsScheme));
+      url::kWsScheme,
+      make_scoped_ptr(new HttpProtocolHandler(url::kWsScheme)));
   job_factory->SetProtocolHandler(
-      url::kWssScheme, new HttpProtocolHandler(url::kWssScheme));
+      url::kWssScheme,
+      make_scoped_ptr(new HttpProtocolHandler(url::kWssScheme)));
 
-  auto host_resolver = url_request_context_getter()
-                          ->GetURLRequestContext()
-                          ->host_resolver();
+  auto host_resolver =
+      url_request_context_getter()->GetURLRequestContext()->host_resolver();
   job_factory->SetProtocolHandler(
-      url::kFtpScheme, new net::FtpProtocolHandler(
-          new net::FtpNetworkLayer(host_resolver)));
+      url::kFtpScheme,
+      make_scoped_ptr(new net::FtpProtocolHandler(
+          new net::FtpNetworkLayer(host_resolver))));
 
   // Set up interceptors in the reverse order.
   scoped_ptr<net::URLRequestJobFactory> top_job_factory = job_factory.Pass();
@@ -145,10 +156,18 @@ AtomBrowserContext::GetDownloadManagerDelegate() {
 
 content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
   if (!guest_manager_)
-    guest_manager_.reset(new WebViewManager(this));
+    guest_manager_.reset(new WebViewManager);
   return guest_manager_.get();
 }
 
+net::CertVerifier* AtomBrowserContext::CreateCertVerifier() {
+  return cert_verifier_;
+}
+
+net::SSLConfigService* AtomBrowserContext::CreateSSLConfigService() {
+  return new AtomSSLConfigService;
+}
+
 void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
   pref_registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory,
                                       base::FilePath());
@@ -156,4 +175,24 @@ void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
                                       base::FilePath());
 }
 
+bool AtomBrowserContext::AllowNTLMCredentialsForDomain(const GURL& origin) {
+  if (allow_ntlm_everywhere_)
+    return true;
+  return Delegate::AllowNTLMCredentialsForDomain(origin);
+}
+
+void AtomBrowserContext::AllowNTLMCredentialsForAllDomains(bool should_allow) {
+  allow_ntlm_everywhere_ = should_allow;
+}
+
 }  // namespace atom
+
+namespace brightray {
+
+// static
+scoped_refptr<BrowserContext> BrowserContext::Create(
+    const std::string& partition, bool in_memory) {
+  return make_scoped_refptr(new atom::AtomBrowserContext(partition, in_memory));
+}
+
+}  // namespace brightray

atom/browser/atom_browser_context.h

@@ -12,13 +12,14 @@
 namespace atom {
 
 class AtomDownloadManagerDelegate;
+class AtomCertVerifier;
 class AtomURLRequestJobFactory;
 class WebViewManager;
 
 class AtomBrowserContext : public brightray::BrowserContext {
  public:
-  AtomBrowserContext();
-  virtual ~AtomBrowserContext();
+  AtomBrowserContext(const std::string& partition, bool in_memory);
+  ~AtomBrowserContext() override;
 
   // brightray::URLRequestContextGetter::Delegate:
   std::string GetUserAgent() override;
@@ -27,6 +28,9 @@ class AtomBrowserContext : public brightray::BrowserContext {
       content::URLRequestInterceptorScopedVector* interceptors) override;
   net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
       const base::FilePath& base_path) override;
+  net::CertVerifier* CreateCertVerifier() override;
+  net::SSLConfigService* CreateSSLConfigService() override;
+  bool AllowNTLMCredentialsForDomain(const GURL& auth_origin) override;
 
   // content::BrowserContext:
   content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
@@ -35,13 +39,21 @@ class AtomBrowserContext : public brightray::BrowserContext {
   // brightray::BrowserContext:
   void RegisterPrefs(PrefRegistrySimple* pref_registry) override;
 
+  void AllowNTLMCredentialsForAllDomains(bool should_allow);
+
+  AtomCertVerifier* cert_verifier() const { return cert_verifier_; }
+
   AtomURLRequestJobFactory* job_factory() const { return job_factory_; }
 
  private:
   scoped_ptr<AtomDownloadManagerDelegate> download_manager_delegate_;
   scoped_ptr<WebViewManager> guest_manager_;
 
-  AtomURLRequestJobFactory* job_factory_;  // Weak reference.
+  // Managed by brightray::BrowserContext.
+  AtomCertVerifier* cert_verifier_;
+  AtomURLRequestJobFactory* job_factory_;
+
+  bool allow_ntlm_everywhere_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
 };

atom/browser/atom_browser_main_parts.cc

@@ -7,11 +7,15 @@
 #include "atom/browser/api/trackable_object.h"
 #include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_context.h"
+#include "atom/browser/bridge_task_runner.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/javascript_environment.h"
+#include "atom/browser/node_debugger.h"
 #include "atom/common/api/atom_bindings.h"
 #include "atom/common/node_bindings.h"
+#include "atom/common/node_includes.h"
 #include "base/command_line.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "v8/include/v8-debug.h"
 
@@ -19,8 +23,6 @@
 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
 #endif
 
-#include "atom/common/node_includes.h"
-
 namespace atom {
 
 // static
@@ -28,6 +30,7 @@ AtomBrowserMainParts* AtomBrowserMainParts::self_ = NULL;
 
 AtomBrowserMainParts::AtomBrowserMainParts()
     : fake_browser_process_(new BrowserProcess),
+      exit_code_(nullptr),
       browser_(new Browser),
       node_bindings_(NodeBindings::Create(true)),
       atom_bindings_(new AtomBindings),
@@ -37,8 +40,6 @@ AtomBrowserMainParts::AtomBrowserMainParts()
 }
 
 AtomBrowserMainParts::~AtomBrowserMainParts() {
-  for (const auto& callback : destruction_callbacks_)
-    callback.Run();
 }
 
 // static
@@ -47,31 +48,51 @@ AtomBrowserMainParts* AtomBrowserMainParts::Get() {
   return self_;
 }
 
+bool AtomBrowserMainParts::SetExitCode(int code) {
+  if (!exit_code_)
+    return false;
+
+  *exit_code_ = code;
+  return true;
+}
+
 void AtomBrowserMainParts::RegisterDestructionCallback(
     const base::Closure& callback) {
   destruction_callbacks_.push_back(callback);
 }
 
-brightray::BrowserContext* AtomBrowserMainParts::CreateBrowserContext() {
-  return new AtomBrowserContext();
+void AtomBrowserMainParts::PreEarlyInitialization() {
+  brightray::BrowserMainParts::PreEarlyInitialization();
+#if defined(OS_POSIX)
+  HandleSIGCHLD();
+#endif
 }
 
 void AtomBrowserMainParts::PostEarlyInitialization() {
   brightray::BrowserMainParts::PostEarlyInitialization();
 
-#if defined(USE_X11)
-  SetDPIFromGSettings();
-#endif
+  // Temporary set the bridge_task_runner_ as current thread's task runner,
+  // so we can fool gin::PerIsolateData to use it as its task runner, instead
+  // of getting current message loop's task runner, which is null for now.
+  bridge_task_runner_ = new BridgeTaskRunner;
+  base::ThreadTaskRunnerHandle handle(bridge_task_runner_);
 
-  // The ProxyResolverV8 has setup a complete V8 environment, in order to avoid
-  // conflicts we only initialize our V8 environment after that.
+  // The ProxyResolverV8 has setup a complete V8 environment, in order to
+  // avoid conflicts we only initialize our V8 environment after that.
   js_env_.reset(new JavascriptEnvironment);
 
   node_bindings_->Initialize();
 
+  // Support the "--debug" switch.
+  node_debugger_.reset(new NodeDebugger(js_env_->isolate()));
+
   // Create the global environment.
   global_env = node_bindings_->CreateEnvironment(js_env_->context());
 
+  // Make sure node can get correct environment when debugging.
+  if (node_debugger_->IsRunning())
+    global_env->AssignToContext(v8::Debug::GetDebugContext());
+
   // Add atom-shell extended APIs.
   atom_bindings_->BindTo(js_env_->isolate(), global_env->process_object());
 
@@ -93,6 +114,7 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
                  1000));
 
   brightray::BrowserMainParts::PreMainMessageLoopRun();
+  BridgeTaskRunner::MessageLoopIsReady();
 
 #if defined(USE_X11)
   libgtk2ui::GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
@@ -105,4 +127,38 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
 #endif
 }
 
+bool AtomBrowserMainParts::MainMessageLoopRun(int* result_code) {
+  exit_code_ = result_code;
+  return brightray::BrowserMainParts::MainMessageLoopRun(result_code);
+}
+
+void AtomBrowserMainParts::PostMainMessageLoopStart() {
+  brightray::BrowserMainParts::PostMainMessageLoopStart();
+#if defined(OS_POSIX)
+  HandleShutdownSignals();
+#endif
+}
+
+void AtomBrowserMainParts::PostMainMessageLoopRun() {
+  brightray::BrowserMainParts::PostMainMessageLoopRun();
+
+#if defined(OS_MACOSX)
+  FreeAppDelegate();
+#endif
+
+  // Make sure destruction callbacks are called before message loop is
+  // destroyed, otherwise some objects that need to be deleted on IO thread
+  // won't be freed.
+  for (const auto& callback : destruction_callbacks_)
+    callback.Run();
+
+  // Destroy JavaScript environment immediately after running destruction
+  // callbacks.
+  gc_timer_.Stop();
+  node_debugger_.reset();
+  atom_bindings_.reset();
+  node_bindings_.reset();
+  js_env_.reset();
+}
+
 }  // namespace atom

atom/browser/atom_browser_main_parts.h

@@ -6,10 +6,12 @@
 #define ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
 
 #include <list>
+#include <string>
 
 #include "base/callback.h"
 #include "base/timer/timer.h"
 #include "brightray/browser/browser_main_parts.h"
+#include "content/public/browser/browser_context.h"
 
 class BrowserProcess;
 
@@ -19,6 +21,8 @@ class AtomBindings;
 class Browser;
 class JavascriptEnvironment;
 class NodeBindings;
+class NodeDebugger;
+class BridgeTaskRunner;
 
 class AtomBrowserMainParts : public brightray::BrowserMainParts {
  public:
@@ -27,6 +31,9 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 
   static AtomBrowserMainParts* Get();
 
+  // Sets the exit code, will fail if the the message loop is not ready.
+  bool SetExitCode(int code);
+
   // Register a callback that should be destroyed before JavaScript environment
   // gets destroyed.
   void RegisterDestructionCallback(const base::Closure& callback);
@@ -34,29 +41,43 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   Browser* browser() { return browser_.get(); }
 
  protected:
-  // Implementations of brightray::BrowserMainParts.
-  brightray::BrowserContext* CreateBrowserContext() override;
-
-  // Implementations of content::BrowserMainParts.
+  // content::BrowserMainParts:
+  void PreEarlyInitialization() override;
   void PostEarlyInitialization() override;
   void PreMainMessageLoopRun() override;
+  bool MainMessageLoopRun(int* result_code) override;
+  void PostMainMessageLoopStart() override;
+  void PostMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
   void PreMainMessageLoopStart() override;
-  void PostDestroyThreads() override;
 #endif
 
  private:
-#if defined(USE_X11)
-  void SetDPIFromGSettings();
+#if defined(OS_POSIX)
+  // Set signal handlers.
+  void HandleSIGCHLD();
+  void HandleShutdownSignals();
+#endif
+
+#if defined(OS_MACOSX)
+  void FreeAppDelegate();
 #endif
 
   // A fake BrowserProcess object that used to feed the source code from chrome.
   scoped_ptr<BrowserProcess> fake_browser_process_;
 
+  // The gin::PerIsolateData requires a task runner to create, so we feed it
+  // with a task runner that will post all work to main loop.
+  scoped_refptr<BridgeTaskRunner> bridge_task_runner_;
+
+  // Pointer to exit code.
+  int* exit_code_;
+
   scoped_ptr<Browser> browser_;
   scoped_ptr<JavascriptEnvironment> js_env_;
   scoped_ptr<NodeBindings> node_bindings_;
   scoped_ptr<AtomBindings> atom_bindings_;
+  scoped_ptr<NodeDebugger> node_debugger_;
 
   base::Timer gc_timer_;
 

atom/browser/atom_browser_main_parts_linux.cc

@@ -1,73 +0,0 @@
-// Copyright (c) 2014 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/atom_browser_main_parts.h"
-
-#include <gio/gio.h>
-
-#include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
-#include "ui/gfx/switches.h"
-
-namespace atom {
-
-namespace {
-
-const char* kInterfaceSchema = "org.gnome.desktop.interface";
-const char* kScaleFactor = "scaling-factor";
-
-bool SchemaExists(const char* schema_name) {
-  const gchar* const* schemas = g_settings_list_schemas();
-  while (*schemas) {
-    if (strcmp(schema_name, static_cast<const char*>(*schemas)) == 0)
-      return true;
-    schemas++;
-  }
-  return false;
-}
-
-bool KeyExists(GSettings* client, const char* key) {
-  gchar** keys = g_settings_list_keys(client);
-  if (!keys)
-    return false;
-
-  gchar** iter = keys;
-  while (*iter) {
-    if (strcmp(*iter, key) == 0)
-      break;
-    iter++;
-  }
-
-  bool exists = *iter != NULL;
-  g_strfreev(keys);
-  return exists;
-}
-
-void GetDPIFromGSettings(guint* scale_factor) {
-  GSettings* client = nullptr;
-  if (!SchemaExists(kInterfaceSchema) ||
-      !(client = g_settings_new(kInterfaceSchema))) {
-    VLOG(1) << "Cannot create gsettings client.";
-    return;
-  }
-
-  if (KeyExists(client, kScaleFactor))
-    *scale_factor = g_settings_get_uint(client, kScaleFactor);
-
-  g_object_unref(client);
-}
-
-}  // namespace
-
-void AtomBrowserMainParts::SetDPIFromGSettings() {
-  guint scale_factor = 1;
-  GetDPIFromGSettings(&scale_factor);
-  if (scale_factor == 0)
-    scale_factor = 1;
-
-  base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-      switches::kForceDeviceScaleFactor, base::UintToString(scale_factor));
-}
-
-}  // namespace atom

atom/browser/atom_browser_main_parts_mac.mm

@@ -34,7 +34,7 @@ void AtomBrowserMainParts::PreMainMessageLoopStart() {
       setObject:@"NO" forKey:@"NSTreatUnknownArgumentsAsOpen"];
 }
 
-void AtomBrowserMainParts::PostDestroyThreads() {
+void AtomBrowserMainParts::FreeAppDelegate() {
   [[NSApp delegate] release];
   [NSApp setDelegate:nil];
 }

atom/browser/atom_browser_main_parts_posix.cc

@@ -0,0 +1,225 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// Most code came from: chrome/browser/chrome_browser_main_posix.cc.
+
+#include "atom/browser/atom_browser_main_parts.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+#include "atom/browser/browser.h"
+#include "base/posix/eintr_wrapper.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+// See comment in |PreEarlyInitialization()|, where sigaction is called.
+void SIGCHLDHandler(int signal) {
+}
+
+// The OSX fork() implementation can crash in the child process before
+// fork() returns.  In that case, the shutdown pipe will still be
+// shared with the parent process.  To prevent child crashes from
+// causing parent shutdowns, |g_pipe_pid| is the pid for the process
+// which registered |g_shutdown_pipe_write_fd|.
+// See <http://crbug.com/175341>.
+pid_t g_pipe_pid = -1;
+int g_shutdown_pipe_write_fd = -1;
+int g_shutdown_pipe_read_fd = -1;
+
+// Common code between SIG{HUP, INT, TERM}Handler.
+void GracefulShutdownHandler(int signal) {
+  // Reinstall the default handler.  We had one shot at graceful shutdown.
+  struct sigaction action;
+  memset(&action, 0, sizeof(action));
+  action.sa_handler = SIG_DFL;
+  RAW_CHECK(sigaction(signal, &action, NULL) == 0);
+
+  RAW_CHECK(g_pipe_pid == getpid());
+  RAW_CHECK(g_shutdown_pipe_write_fd != -1);
+  RAW_CHECK(g_shutdown_pipe_read_fd != -1);
+  size_t bytes_written = 0;
+  do {
+    int rv = HANDLE_EINTR(
+        write(g_shutdown_pipe_write_fd,
+              reinterpret_cast<const char*>(&signal) + bytes_written,
+              sizeof(signal) - bytes_written));
+    RAW_CHECK(rv >= 0);
+    bytes_written += rv;
+  } while (bytes_written < sizeof(signal));
+}
+
+// See comment in |PostMainMessageLoopStart()|, where sigaction is called.
+void SIGHUPHandler(int signal) {
+  RAW_CHECK(signal == SIGHUP);
+  GracefulShutdownHandler(signal);
+}
+
+// See comment in |PostMainMessageLoopStart()|, where sigaction is called.
+void SIGINTHandler(int signal) {
+  RAW_CHECK(signal == SIGINT);
+  GracefulShutdownHandler(signal);
+}
+
+// See comment in |PostMainMessageLoopStart()|, where sigaction is called.
+void SIGTERMHandler(int signal) {
+  RAW_CHECK(signal == SIGTERM);
+  GracefulShutdownHandler(signal);
+}
+
+class ShutdownDetector : public base::PlatformThread::Delegate {
+ public:
+  explicit ShutdownDetector(int shutdown_fd);
+
+  void ThreadMain() override;
+
+ private:
+  const int shutdown_fd_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShutdownDetector);
+};
+
+ShutdownDetector::ShutdownDetector(int shutdown_fd)
+    : shutdown_fd_(shutdown_fd) {
+  CHECK_NE(shutdown_fd_, -1);
+}
+
+// These functions are used to help us diagnose crash dumps that happen
+// during the shutdown process.
+NOINLINE void ShutdownFDReadError() {
+  // Ensure function isn't optimized away.
+  asm("");
+  sleep(UINT_MAX);
+}
+
+NOINLINE void ShutdownFDClosedError() {
+  // Ensure function isn't optimized away.
+  asm("");
+  sleep(UINT_MAX);
+}
+
+NOINLINE void ExitPosted() {
+  // Ensure function isn't optimized away.
+  asm("");
+  sleep(UINT_MAX);
+}
+
+void ShutdownDetector::ThreadMain() {
+  base::PlatformThread::SetName("CrShutdownDetector");
+
+  int signal;
+  size_t bytes_read = 0;
+  ssize_t ret;
+  do {
+    ret = HANDLE_EINTR(
+        read(shutdown_fd_,
+             reinterpret_cast<char*>(&signal) + bytes_read,
+             sizeof(signal) - bytes_read));
+    if (ret < 0) {
+      NOTREACHED() << "Unexpected error: " << strerror(errno);
+      ShutdownFDReadError();
+      break;
+    } else if (ret == 0) {
+      NOTREACHED() << "Unexpected closure of shutdown pipe.";
+      ShutdownFDClosedError();
+      break;
+    }
+    bytes_read += ret;
+  } while (bytes_read < sizeof(signal));
+  VLOG(1) << "Handling shutdown for signal " << signal << ".";
+  base::Closure task =
+      base::Bind(&Browser::Quit, base::Unretained(Browser::Get()));
+
+  if (!BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, task)) {
+    // Without a UI thread to post the exit task to, there aren't many
+    // options.  Raise the signal again.  The default handler will pick it up
+    // and cause an ungraceful exit.
+    RAW_LOG(WARNING, "No UI thread, exiting ungracefully.");
+    kill(getpid(), signal);
+
+    // The signal may be handled on another thread.  Give that a chance to
+    // happen.
+    sleep(3);
+
+    // We really should be dead by now.  For whatever reason, we're not. Exit
+    // immediately, with the exit status set to the signal number with bit 8
+    // set.  On the systems that we care about, this exit status is what is
+    // normally used to indicate an exit by this signal's default handler.
+    // This mechanism isn't a de jure standard, but even in the worst case, it
+    // should at least result in an immediate exit.
+    RAW_LOG(WARNING, "Still here, exiting really ungracefully.");
+    _exit(signal | (1 << 7));
+  }
+  ExitPosted();
+}
+
+}  // namespace
+
+void AtomBrowserMainParts::HandleSIGCHLD() {
+  // We need to accept SIGCHLD, even though our handler is a no-op because
+  // otherwise we cannot wait on children. (According to POSIX 2001.)
+  struct sigaction action;
+  memset(&action, 0, sizeof(action));
+  action.sa_handler = SIGCHLDHandler;
+  CHECK_EQ(sigaction(SIGCHLD, &action, NULL), 0);
+}
+
+void AtomBrowserMainParts::HandleShutdownSignals() {
+  int pipefd[2];
+  int ret = pipe(pipefd);
+  if (ret < 0) {
+    PLOG(DFATAL) << "Failed to create pipe";
+  } else {
+    g_pipe_pid = getpid();
+    g_shutdown_pipe_read_fd = pipefd[0];
+    g_shutdown_pipe_write_fd = pipefd[1];
+#if !defined(ADDRESS_SANITIZER) && !defined(KEEP_SHADOW_STACKS)
+    const size_t kShutdownDetectorThreadStackSize = PTHREAD_STACK_MIN * 2;
+#else
+    // ASan instrumentation and -finstrument-functions (used for keeping the
+    // shadow stacks) bloat the stack frames, so we need to increase the stack
+    // size to avoid hitting the guard page.
+    const size_t kShutdownDetectorThreadStackSize = PTHREAD_STACK_MIN * 4;
+#endif
+    // TODO(viettrungluu,willchan): crbug.com/29675 - This currently leaks, so
+    // if you change this, you'll probably need to change the suppression.
+    if (!base::PlatformThread::CreateNonJoinable(
+            kShutdownDetectorThreadStackSize,
+            new ShutdownDetector(g_shutdown_pipe_read_fd))) {
+      LOG(DFATAL) << "Failed to create shutdown detector task.";
+    }
+  }
+  // Setup signal handlers for shutdown AFTER shutdown pipe is setup because
+  // it may be called right away after handler is set.
+
+  // If adding to this list of signal handlers, note the new signal probably
+  // needs to be reset in child processes. See
+  // base/process_util_posix.cc:LaunchProcess.
+
+  // We need to handle SIGTERM, because that is how many POSIX-based distros ask
+  // processes to quit gracefully at shutdown time.
+  struct sigaction action;
+  memset(&action, 0, sizeof(action));
+  action.sa_handler = SIGTERMHandler;
+  CHECK_EQ(sigaction(SIGTERM, &action, NULL), 0);
+  // Also handle SIGINT - when the user terminates the browser via Ctrl+C. If
+  // the browser process is being debugged, GDB will catch the SIGINT first.
+  action.sa_handler = SIGINTHandler;
+  CHECK_EQ(sigaction(SIGINT, &action, NULL), 0);
+  // And SIGHUP, for when the terminal disappears. On shutdown, many Linux
+  // distros send SIGHUP, SIGTERM, and then SIGKILL.
+  action.sa_handler = SIGHUPHandler;
+  CHECK_EQ(sigaction(SIGHUP, &action, NULL), 0);
+}
+
+}  // namespace atom

atom/browser/atom_download_manager_delegate.cc

@@ -6,6 +6,7 @@
 
 #include <string>
 
+#include "atom/browser/api/atom_api_download_item.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/ui/file_dialog.h"
@@ -73,18 +74,19 @@ void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
   if (relay)
     window = relay->window.get();
 
-  file_dialog::Filters filters;
   base::FilePath path;
-  if (!file_dialog::ShowSaveDialog(window, item->GetURL().spec(), default_path,
-                                   filters, &path)) {
-    return;
+  if (file_dialog::ShowSaveDialog(window, item->GetURL().spec(), default_path,
+                                  file_dialog::Filters(), &path)) {
+    // Remember the last selected download directory.
+    AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
+        download_manager_->GetBrowserContext());
+    browser_context->prefs()->SetFilePath(prefs::kDownloadDefaultDirectory,
+                                          path.DirName());
   }
 
-  // Remeber the last selected download directory.
-  AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
-      download_manager_->GetBrowserContext());
-  browser_context->prefs()->SetFilePath(prefs::kDownloadDefaultDirectory,
-                                        path.DirName());
+  // Running the DownloadTargetCallback with an empty FilePath signals that the
+  // download should be cancelled.
+  // If user cancels the file save dialog, run the callback with empty FilePath.
   callback.Run(path,
                content::DownloadItem::TARGET_DISPOSITION_PROMPT,
                content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, path);
@@ -100,6 +102,25 @@ bool AtomDownloadManagerDelegate::DetermineDownloadTarget(
     const content::DownloadTargetCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
+  if (!download->GetForcedFilePath().empty()) {
+    callback.Run(download->GetForcedFilePath(),
+                 content::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+                 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+                 download->GetForcedFilePath());
+    return true;
+  }
+  base::SupportsUserData::Data* save_path = download->GetUserData(
+      atom::api::DownloadItem::UserDataKey());
+  if (save_path) {
+    const base::FilePath& default_download_path =
+        static_cast<api::DownloadItem::SavePathData*>(save_path)->path();
+    callback.Run(default_download_path,
+                 content::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+                 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+                 default_download_path);
+    return true;
+  }
+
   AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
       download_manager_->GetBrowserContext());
   base::FilePath default_download_path = browser_context->prefs()->GetFilePath(
@@ -110,14 +131,6 @@ bool AtomDownloadManagerDelegate::DetermineDownloadTarget(
     default_download_path = path.Append(FILE_PATH_LITERAL("Downloads"));
   }
 
-  if (!download->GetForcedFilePath().empty()) {
-    callback.Run(download->GetForcedFilePath(),
-                 content::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
-                 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-                 download->GetForcedFilePath());
-    return true;
-  }
-
   CreateDownloadPathCallback download_path_callback =
       base::Bind(&AtomDownloadManagerDelegate::OnDownloadPathGenerated,
                  weak_ptr_factory_.GetWeakPtr(),

atom/browser/atom_resource_dispatcher_host_delegate.cc

@@ -0,0 +1,40 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_resource_dispatcher_host_delegate.h"
+
+#include "atom/browser/login_handler.h"
+#include "atom/common/platform_util.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/base/escape.h"
+#include "url/gurl.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+AtomResourceDispatcherHostDelegate::AtomResourceDispatcherHostDelegate() {
+}
+
+bool AtomResourceDispatcherHostDelegate::HandleExternalProtocol(
+    const GURL& url,
+    int render_process_id,
+    int render_view_id,
+    bool is_main_frame,
+    ui::PageTransition transition,
+    bool has_user_gesture) {
+  GURL escaped_url(net::EscapeExternalHandlerValue(url.spec()));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      base::Bind(base::IgnoreResult(platform_util::OpenExternal), escaped_url));
+  return true;
+}
+
+content::ResourceDispatcherHostLoginDelegate*
+AtomResourceDispatcherHostDelegate::CreateLoginDelegate(
+    net::AuthChallengeInfo* auth_info,
+    net::URLRequest* request) {
+  return new LoginHandler(auth_info, request);
+}
+
+}  // namespace atom

atom/browser/atom_resource_dispatcher_host_delegate.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
+#define ATOM_BROWSER_ATOM_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
+
+#include "content/public/browser/resource_dispatcher_host_delegate.h"
+
+namespace atom {
+
+class AtomResourceDispatcherHostDelegate
+    : public content::ResourceDispatcherHostDelegate {
+ public:
+  AtomResourceDispatcherHostDelegate();
+
+  // content::ResourceDispatcherHostDelegate:
+  bool HandleExternalProtocol(const GURL& url,
+                              int render_process_id,
+                              int render_view_id,
+                              bool is_main_frame,
+                              ui::PageTransition transition,
+                              bool has_user_gesture) override;
+  content::ResourceDispatcherHostLoginDelegate* CreateLoginDelegate(
+      net::AuthChallengeInfo* auth_info,
+      net::URLRequest* request) override;
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_RESOURCE_DISPATCHER_HOST_DELEGATE_H_

atom/browser/auto_updater.cc

@@ -6,14 +6,25 @@
 
 namespace auto_updater {
 
-AutoUpdaterDelegate* AutoUpdater::delegate_ = NULL;
+Delegate* AutoUpdater::delegate_ = nullptr;
 
-AutoUpdaterDelegate* AutoUpdater::GetDelegate() {
+Delegate* AutoUpdater::GetDelegate() {
   return delegate_;
 }
 
-void AutoUpdater::SetDelegate(AutoUpdaterDelegate* delegate) {
+void AutoUpdater::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 }
 
+#if !defined(OS_MACOSX) || defined(MAS_BUILD)
+void AutoUpdater::SetFeedURL(const std::string& url) {
+}
+
+void AutoUpdater::CheckForUpdates() {
+}
+
+void AutoUpdater::QuitAndInstall() {
+}
+#endif
+
 }  // namespace auto_updater

atom/browser/auto_updater.h

@@ -9,21 +9,48 @@
 
 #include "base/basictypes.h"
 
+namespace base {
+class Time;
+}
+
 namespace auto_updater {
 
-class AutoUpdaterDelegate;
+class Delegate {
+ public:
+  // An error happened.
+  virtual void OnError(const std::string& error) {}
+
+  // Checking to see if there is an update
+  virtual void OnCheckingForUpdate() {}
+
+  // There is an update available and it is being downloaded
+  virtual void OnUpdateAvailable() {}
+
+  // There is no available update.
+  virtual void OnUpdateNotAvailable() {}
+
+  // There is a new update which has been downloaded.
+  virtual void OnUpdateDownloaded(const std::string& release_notes,
+                                  const std::string& release_name,
+                                  const base::Time& release_date,
+                                  const std::string& update_url) {}
+
+ protected:
+  virtual ~Delegate() {}
+};
 
 class AutoUpdater {
  public:
   // Gets/Sets the delegate.
-  static AutoUpdaterDelegate* GetDelegate();
-  static void SetDelegate(AutoUpdaterDelegate* delegate);
+  static Delegate* GetDelegate();
+  static void SetDelegate(Delegate* delegate);
 
   static void SetFeedURL(const std::string& url);
   static void CheckForUpdates();
+  static void QuitAndInstall();
 
  private:
-  static AutoUpdaterDelegate* delegate_;
+  static Delegate* delegate_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AutoUpdater);
 };

atom/browser/auto_updater_delegate.h

@@ -1,45 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_
-#define ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_
-
-#include <string>
-
-#include "base/callback_forward.h"
-
-namespace base {
-class Time;
-}
-
-namespace auto_updater {
-
-class AutoUpdaterDelegate {
- public:
-  // An error happened.
-  virtual void OnError(const std::string& error) {}
-
-  // Checking to see if there is an update
-  virtual void OnCheckingForUpdate() {}
-
-  // There is an update available and it is being downloaded
-  virtual void OnUpdateAvailable() {}
-
-  // There is no available update.
-  virtual void OnUpdateNotAvailable() {}
-
-  // There is a new update which has been downloaded.
-  virtual void OnUpdateDownloaded(const std::string& release_notes,
-                                  const std::string& release_name,
-                                  const base::Time& release_date,
-                                  const std::string& update_url,
-                                  const base::Closure& quit_and_install) {}
-
- protected:
-  virtual ~AutoUpdaterDelegate() {}
-};
-
-}  // namespace auto_updater
-
-#endif  // ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_

atom/browser/auto_updater_linux.cc

@@ -1,17 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/auto_updater.h"
-
-namespace auto_updater {
-
-// static
-void AutoUpdater::SetFeedURL(const std::string& url) {
-}
-
-// static
-void AutoUpdater::CheckForUpdates() {
-}
-
-}  // namespace auto_updater

atom/browser/auto_updater_mac.mm

@@ -12,9 +12,6 @@
 #include "base/bind.h"
 #include "base/time/time.h"
 #include "base/strings/sys_string_conversions.h"
-#include "atom/browser/auto_updater_delegate.h"
-
-#include <iostream>
 
 namespace auto_updater {
 
@@ -23,20 +20,12 @@ namespace {
 // The gloal SQRLUpdater object.
 SQRLUpdater* g_updater = nil;
 
-void RelaunchToInstallUpdate() {
-  [[g_updater relaunchToInstallUpdate] subscribeError:^(NSError* error) {
-    AutoUpdaterDelegate* delegate = AutoUpdater::GetDelegate();
-    if (delegate)
-      delegate->OnError(base::SysNSStringToUTF8(error.localizedDescription));
-  }];
-}
-
 }  // namespace
 
 // static
 void AutoUpdater::SetFeedURL(const std::string& feed) {
   if (g_updater == nil) {
-    AutoUpdaterDelegate* delegate = GetDelegate();
+    Delegate* delegate = GetDelegate();
     if (!delegate)
       return;
 
@@ -67,7 +56,7 @@ void AutoUpdater::SetFeedURL(const std::string& feed) {
 
 // static
 void AutoUpdater::CheckForUpdates() {
-  AutoUpdaterDelegate* delegate = GetDelegate();
+  Delegate* delegate = GetDelegate();
   if (!delegate)
     return;
 
@@ -86,8 +75,7 @@ void AutoUpdater::CheckForUpdates() {
             base::SysNSStringToUTF8(update.releaseNotes),
             base::SysNSStringToUTF8(update.releaseName),
             base::Time::FromDoubleT(update.releaseDate.timeIntervalSince1970),
-            base::SysNSStringToUTF8(update.updateURL.absoluteString),
-            base::Bind(RelaunchToInstallUpdate));
+            base::SysNSStringToUTF8(update.updateURL.absoluteString));
         } else {
           // When the completed event is sent with no update, then we know there
           // is no update available.
@@ -100,4 +88,12 @@ void AutoUpdater::CheckForUpdates() {
       }];
 }
 
+void AutoUpdater::QuitAndInstall() {
+  [[g_updater relaunchToInstallUpdate] subscribeError:^(NSError* error) {
+    Delegate* delegate = AutoUpdater::GetDelegate();
+    if (delegate)
+      delegate->OnError(base::SysNSStringToUTF8(error.localizedDescription));
+  }];
+}
+
 }  // namespace auto_updater

atom/browser/auto_updater_win.cc

@@ -1,17 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/auto_updater.h"
-
-namespace auto_updater {
-
-// static
-void AutoUpdater::SetFeedURL(const std::string& url) {
-}
-
-// static
-void AutoUpdater::CheckForUpdates() {
-}
-
-}  // namespace auto_updater

atom/browser/bridge_task_runner.cc

@@ -0,0 +1,64 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/bridge_task_runner.h"
+
+#include "base/message_loop/message_loop.h"
+
+namespace atom {
+
+// static
+std::vector<BridgeTaskRunner::TaskPair> BridgeTaskRunner::tasks_;
+std::vector<BridgeTaskRunner::TaskPair> BridgeTaskRunner::non_nestable_tasks_;
+
+// static
+void BridgeTaskRunner::MessageLoopIsReady() {
+  auto message_loop = base::MessageLoop::current();
+  CHECK(message_loop);
+  for (const TaskPair& task : tasks_) {
+    message_loop->task_runner()->PostDelayedTask(
+        base::get<0>(task), base::get<1>(task), base::get<2>(task));
+  }
+  for (const TaskPair& task : non_nestable_tasks_) {
+    message_loop->task_runner()->PostNonNestableDelayedTask(
+        base::get<0>(task), base::get<1>(task), base::get<2>(task));
+  }
+}
+
+bool BridgeTaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  auto message_loop = base::MessageLoop::current();
+  if (!message_loop) {
+    tasks_.push_back(base::MakeTuple(from_here, task, delay));
+    return true;
+  }
+
+  return message_loop->task_runner()->PostDelayedTask(from_here, task, delay);
+}
+
+bool BridgeTaskRunner::RunsTasksOnCurrentThread() const {
+  auto message_loop = base::MessageLoop::current();
+  if (!message_loop)
+    return true;
+
+  return message_loop->task_runner()->RunsTasksOnCurrentThread();
+}
+
+bool BridgeTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  auto message_loop = base::MessageLoop::current();
+  if (!message_loop) {
+    non_nestable_tasks_.push_back(base::MakeTuple(from_here, task, delay));
+    return true;
+  }
+
+  return message_loop->task_runner()->PostNonNestableDelayedTask(
+      from_here, task, delay);
+}
+
+}  // namespace atom

atom/browser/bridge_task_runner.h

@@ -0,0 +1,46 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
+#define ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
+
+#include <vector>
+
+#include "base/single_thread_task_runner.h"
+#include "base/tuple.h"
+
+namespace atom {
+
+// Post all tasks to the current message loop's task runner if available,
+// otherwise delay the work until message loop is ready.
+class BridgeTaskRunner : public base::SingleThreadTaskRunner {
+ public:
+  BridgeTaskRunner() {}
+  ~BridgeTaskRunner() override {}
+
+  // Called when message loop is ready.
+  static void MessageLoopIsReady();
+
+  // base::SingleThreadTaskRunner:
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override;
+  bool RunsTasksOnCurrentThread() const override;
+  bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      base::TimeDelta delay) override;
+
+ private:
+  using TaskPair = base::Tuple<
+      tracked_objects::Location, base::Closure, base::TimeDelta>;
+  static std::vector<TaskPair> tasks_;
+  static std::vector<TaskPair> non_nestable_tasks_;
+
+  DISALLOW_COPY_AND_ASSIGN(BridgeTaskRunner);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_

atom/browser/browser.cc

@@ -7,16 +7,16 @@
 #include <string>
 
 #include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/native_window.h"
 #include "atom/browser/window_list.h"
 #include "base/message_loop/message_loop.h"
-#include "content/public/browser/client_certificate_delegate.h"
-#include "net/ssl/ssl_cert_request_info.h"
 
 namespace atom {
 
 Browser::Browser()
     : is_quiting_(false),
-      is_ready_(false) {
+      is_ready_(false),
+      is_shutdown_(false) {
   WindowList::AddObserver(this);
 }
 
@@ -30,6 +30,9 @@ Browser* Browser::Get() {
 }
 
 void Browser::Quit() {
+  if (is_quiting_)
+    return;
+
   is_quiting_ = HandleBeforeQuit();
   if (!is_quiting_)
     return;
@@ -41,11 +44,43 @@ void Browser::Quit() {
   window_list->CloseAllWindows();
 }
 
+void Browser::Exit(int code) {
+  if (!AtomBrowserMainParts::Get()->SetExitCode(code)) {
+    // Message loop is not ready, quit directly.
+    exit(code);
+  } else {
+    // Prepare to quit when all windows have been closed..
+    is_quiting_ = true;
+
+    // Must destroy windows before quitting, otherwise bad things can happen.
+    atom::WindowList* window_list = atom::WindowList::GetInstance();
+    if (window_list->size() == 0) {
+      NotifyAndShutdown();
+    } else {
+      // Unlike Quit(), we do not ask to close window, but destroy the window
+      // without asking.
+      for (NativeWindow* window : *window_list)
+        window->CloseContents(nullptr);  // e.g. Destroy()
+    }
+  }
+}
+
 void Browser::Shutdown() {
+  if (is_shutdown_)
+    return;
+
+  is_shutdown_ = true;
+  is_quiting_ = true;
+
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnQuit());
 
-  is_quiting_ = true;
-  base::MessageLoop::current()->Quit();
+  if (base::MessageLoop::current()) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  } else {
+    // There is no message loop available so we are in early stage.
+    exit(0);
+  }
 }
 
 std::string Browser::GetVersion() const {
@@ -74,10 +109,6 @@ std::string Browser::GetName() const {
 
 void Browser::SetName(const std::string& name) {
   name_override_ = name;
-
-#if defined(OS_WIN)
-  SetAppUserModelID(name);
-#endif
 }
 
 bool Browser::OpenFile(const std::string& file_path) {
@@ -93,8 +124,10 @@ void Browser::OpenURL(const std::string& url) {
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnOpenURL(url));
 }
 
-void Browser::ActivateWithNoOpenWindows() {
-  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnActivateWithNoOpenWindows());
+void Browser::Activate(bool has_visible_windows) {
+  FOR_EACH_OBSERVER(BrowserObserver,
+                    observers_,
+                    OnActivate(has_visible_windows));
 }
 
 void Browser::WillFinishLaunching() {
@@ -106,18 +139,14 @@ void Browser::DidFinishLaunching() {
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnFinishLaunching());
 }
 
-void Browser::ClientCertificateSelector(
-    content::WebContents* web_contents,
-    net::SSLCertRequestInfo* cert_request_info,
-    scoped_ptr<content::ClientCertificateDelegate> delegate) {
-  FOR_EACH_OBSERVER(BrowserObserver,
-                    observers_,
-                    OnSelectCertificate(web_contents,
-                                        cert_request_info,
-                                        delegate.Pass()));
+void Browser::RequestLogin(LoginHandler* login_handler) {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnLogin(login_handler));
 }
 
 void Browser::NotifyAndShutdown() {
+  if (is_shutdown_)
+    return;
+
   bool prevent_default = false;
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWillQuit(&prevent_default));
 

atom/browser/browser.h

@@ -11,12 +11,12 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/observer_list.h"
+#include "base/strings/string16.h"
 #include "atom/browser/browser_observer.h"
 #include "atom/browser/window_list_observer.h"
 
 #if defined(OS_WIN)
 #include "base/files/file_path.h"
-#include "base/strings/string16.h"
 #endif
 
 namespace base {
@@ -29,6 +29,8 @@ class MenuModel;
 
 namespace atom {
 
+class LoginHandler;
+
 // This class is used for control application-wide operations.
 class Browser : public WindowListObserver {
  public:
@@ -40,6 +42,9 @@ class Browser : public WindowListObserver {
   // Try to close all windows and quit the application.
   void Quit();
 
+  // Exit the application immediately and set exit code.
+  void Exit(int code);
+
   // Cleanup everything and shutdown the application gracefully.
   void Shutdown();
 
@@ -64,6 +69,9 @@ class Browser : public WindowListObserver {
   // Clear the recent documents list.
   void ClearRecentDocuments();
 
+  // Set the application user model ID.
+  void SetAppUserModelID(const base::string16& name);
+
 #if defined(OS_MACOSX)
   // Bounce the dock icon.
   enum BounceType {
@@ -98,8 +106,10 @@ class Browser : public WindowListObserver {
   // Add a custom task to jump list.
   void SetUserTasks(const std::vector<UserTask>& tasks);
 
-  // Set the application user model ID, called when "SetName" is called.
-  void SetAppUserModelID(const std::string& name);
+  // Returns the application user model ID, if there isn't one, then create
+  // one from app's name.
+  // The returned string managed by Browser, and should not be modified.
+  PCWSTR GetAppUserModelID();
 #endif
 
   // Tell the application to open a file.
@@ -108,18 +118,16 @@ class Browser : public WindowListObserver {
   // Tell the application to open a url.
   void OpenURL(const std::string& url);
 
-  // Tell the application that application is activated with no open windows.
-  void ActivateWithNoOpenWindows();
+  // Tell the application that application is activated with visible/invisible
+  // windows.
+  void Activate(bool has_visible_windows);
 
   // Tell the application the loading has been done.
   void WillFinishLaunching();
   void DidFinishLaunching();
 
-  // Called when client certificate is required.
-  void ClientCertificateSelector(
-      content::WebContents* web_contents,
-      net::SSLCertRequestInfo* cert_request_info,
-      scoped_ptr<content::ClientCertificateDelegate> delegate);
+  // Request basic auth login.
+  void RequestLogin(LoginHandler* login_handler);
 
   void AddObserver(BrowserObserver* obs) {
     observers_.AddObserver(obs);
@@ -129,6 +137,7 @@ class Browser : public WindowListObserver {
     observers_.RemoveObserver(obs);
   }
 
+  bool is_shutting_down() const { return is_shutdown_; }
   bool is_quiting() const { return is_quiting_; }
   bool is_ready() const { return is_ready_; }
 
@@ -153,11 +162,14 @@ class Browser : public WindowListObserver {
   void OnWindowAllClosed() override;
 
   // Observers of the browser.
-  ObserverList<BrowserObserver> observers_;
+  base::ObserverList<BrowserObserver> observers_;
 
   // Whether "ready" event has been emitted.
   bool is_ready_;
 
+  // The browse is being shutdown.
+  bool is_shutdown_;
+
   std::string version_override_;
   std::string name_override_;
 

atom/browser/browser_linux.cc

@@ -31,6 +31,9 @@ void Browser::AddRecentDocument(const base::FilePath& path) {
 void Browser::ClearRecentDocuments() {
 }
 
+void Browser::SetAppUserModelID(const base::string16& name) {
+}
+
 std::string Browser::GetExecutableFileVersion() const {
   return brightray::GetApplicationVersion();
 }

atom/browser/browser_mac.mm

@@ -26,6 +26,9 @@ void Browser::AddRecentDocument(const base::FilePath& path) {
 void Browser::ClearRecentDocuments() {
 }
 
+void Browser::SetAppUserModelID(const base::string16& name) {
+}
+
 std::string Browser::GetExecutableFileVersion() const {
   return brightray::GetApplicationVersion();
 }