Bump v0.30.8

This picks up the fix for https://github.com/atom/atom/issues/7061.

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,26 +6,25 @@
 
 ### [Electron](https://github.com/atom/electron/) 한국어 참조문서
 
-:zap: *프레임워크 이름이 Atom Shell에서 Electron으로 변경되었습니다* :zap:
+:zap: *이전까지 Atom Shell로 알려져 있었습니다* :zap:
 
-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은 JavaScript, HTML 그리고 CSS를 이용하여 Cross-Platform 데스크톱 어플리케이션을 개발할 수 있도록 해주는 프레임워크입니다. 이 프레임워크는 [io.js](http://iojs.org) 와
+[Chromium](http://www.chromium.org) 을 기반으로 만들어 졌으며 [Atom Editor](https://github.com/atom/atom) 에 사용되고 있습니다.
 
-이 프로젝트는 기여자 규약 1.2를 준수합니다. 이 프로젝트에 참여할 때 코드를 유지해야 합니다. 받아들일 수 없는 행동은 atom@github.com로 보고 하십시오.
+Electron에 대한 중요한 알림을 받으려면 Twitter에서 [@ElectronJS](https://twitter.com/electronjs)를 Follow하세요.
 
 ## 다운로드
 
 Linux, Windows, Mac용으로 미리 빌드된 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
 ```
 
@@ -33,22 +32,13 @@ npm install electron-prebuilt --save-dev
 
 - [China](https://npm.taobao.org/mirrors/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)
-- [일본어](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)
+[docs](https://github.com/atom/electron/tree/master/docs/README-ko.md) 에 프레임워크 사용 가이드와 API 레퍼런스가 있습니다.
+추가적으로 Electron을 빌드 하는 방법과 프로젝트에 기여하는 방법이 문서에 포함되어 있으니 참고하시기 바랍니다.
 
 ## 커뮤니티
 
-[Atom 포럼내의 `electron` 카테고리](http://discuss.atom.io/category/electron)와 Freenode `#atom-shell` 채팅 채널에서 활발하게 토론이 이어지고 있습니다.
+[Atom 포럼내의 `electron` 카테고리](http://discuss.atom.io/category/electron) 와 Freenode `#atom-shell` 채팅채널이 있습니다.
 
-[awesome-electron](https://github.com/sindresorhus/awesome-electron) 프로젝트엔 커뮤니티가 운영중인 유용한 예제 어플리케이션과 도구, 리소스가 있으니 한번 참고해 보시기 바랍니다.
+[awesome-electron](https://github.com/sindresorhus/awesome-electron) 에 커뮤니티가 운영중인 유용한 예제 앱과 툴, 리소스가 있으니 한번 탐색해 보시기 바랍니다.

README.md

@@ -43,18 +43,10 @@ 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)
-- [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)
-
 ## 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.
 
-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.32.0',
+    'version%': '0.30.8',
   },
   'includes': [
     'filenames.gypi',
@@ -144,6 +144,7 @@
               'destination': '<(PRODUCT_DIR)',
               'files': [
                 '<@(copied_libraries)',
+                '<(libchromiumcontent_dir)/ffmpegsumo.dll',
                 '<(libchromiumcontent_dir)/libEGL.dll',
                 '<(libchromiumcontent_dir)/libGLESv2.dll',
                 '<(libchromiumcontent_dir)/icudtl.dat',
@@ -192,6 +193,7 @@
               'destination': '<(PRODUCT_DIR)',
               'files': [
                 '<@(copied_libraries)',
+                '<(libchromiumcontent_dir)/libffmpegsumo.so',
                 '<(libchromiumcontent_dir)/icudtl.dat',
                 '<(libchromiumcontent_dir)/content_shell.pak',
                 '<(libchromiumcontent_dir)/natives_blob.bin',
@@ -224,6 +226,8 @@
         # 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)',
@@ -437,6 +441,7 @@
               'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Libraries',
               'files': [
                 '<@(copied_libraries)',
+                '<(libchromiumcontent_dir)/ffmpegsumo.so',
               ],
             },
             {
@@ -457,16 +462,6 @@
                 '${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': [

atom/app/atom_main.cc

@@ -33,7 +33,6 @@
 
 #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)
@@ -135,7 +134,6 @@ 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",
@@ -167,7 +165,6 @@ 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

@@ -38,9 +38,7 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 #else
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 #endif  // defined(DEBUG)
-#else  // defined(OS_WIN)
-  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
-#endif  // !defined(OS_WIN)
+#endif  // defined(OS_WIN)
   logging::InitLogging(settings);
 
   // Logging with pid and timestamp.

atom/app/node_main.cc

@@ -4,21 +4,14 @@
 
 #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 "atom/common/node_includes.h"
-#include "base/command_line.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[]) {
-  base::CommandLine::Init(argc, argv);
-
   argv = uv_setup_args(argc, argv);
   int exec_argc;
   const char** exec_argv;
@@ -26,29 +19,27 @@ int NodeMain(int argc, char *argv[]) {
 
   int exit_code = 1;
   {
-    // Feed gin::PerIsolateData with a task runner.
-    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();
+    gin::IsolateHolder::LoadV8Snapshot();
     gin::IsolateHolder::Initialize(
         gin::IsolateHolder::kNonStrictMode,
         gin::ArrayBufferAllocator::SharedInstance());
 
     JavascriptEnvironment gin_env;
     node::Environment* env = node::CreateEnvironment(
-        gin_env.isolate(), loop, gin_env.context(), argc, argv,
+        gin_env.isolate(), uv_default_loop(), gin_env.context(), argc, argv,
         exec_argc, exec_argv);
 
-    // Start our custom debugger implementation.
-    NodeDebugger node_debugger(gin_env.isolate());
-    if (node_debugger.IsRunning())
-      env->AssignToContext(v8::Debug::GetDebugContext());
+    // Start debugger.
+    node::node_isolate = gin_env.isolate();
+    if (node::use_debug_agent)
+      node::StartDebug(env, node::debug_wait_connect);
 
     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

@@ -1,55 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "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_unref(reinterpret_cast<uv_handle_t*>(timer));
-  delete timer;
-}
-
-}  // namespace atom

atom/app/uv_task_runner.h

@@ -1,44 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef 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);
-
-  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

@@ -19,7 +19,6 @@
 #include "atom/browser/api/atom_api_web_contents.h"
 #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/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
@@ -35,6 +34,8 @@
 #include "base/strings/utf_string_conversions.h"
 #endif
 
+#include "atom/common/node_includes.h"
+
 using atom::Browser;
 
 namespace mate {

atom/browser/api/atom_api_auto_updater.cc

@@ -7,10 +7,11 @@
 #include "base/time/time.h"
 #include "atom/browser/auto_updater.h"
 #include "atom/browser/browser.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 atom {
 
 namespace api {

atom/browser/api/atom_api_content_tracing.cc

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

atom/browser/api/atom_api_cookies.cc

@@ -20,6 +20,8 @@
 #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;
 

atom/browser/api/atom_api_menu.cc

@@ -107,10 +107,6 @@ 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();
 }
@@ -158,7 +154,6 @@ 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

@@ -73,7 +73,6 @@ 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_power_monitor.cc

@@ -5,11 +5,12 @@
 #include "atom/browser/api/atom_api_power_monitor.h"
 
 #include "atom/browser/browser.h"
-#include "atom/common/node_includes.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "native_mate/dictionary.h"
 
+#include "atom/common/node_includes.h"
+
 namespace atom {
 
 namespace api {
@@ -40,9 +41,9 @@ void PowerMonitor::OnResume() {
 // static
 v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
   if (!Browser::Get()->is_ready()) {
-    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+    node::ThrowError(
         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_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 {
 

atom/browser/api/atom_api_protocol.cc

@@ -7,13 +7,17 @@
 #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/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/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/common/native_mate_converters/callback.h"
-#include "atom/common/node_includes.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/node_includes.h"
 
 using content::BrowserThread;
 
@@ -37,35 +41,230 @@ 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("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);
+      .SetMethod("isHandledProtocol", &Protocol::IsHandledProtocol)
+      .SetMethod("_registerProtocol", &Protocol::RegisterProtocol)
+      .SetMethod("_unregisterProtocol", &Protocol::UnregisterProtocol)
+      .SetMethod("_interceptProtocol", &Protocol::InterceptProtocol)
+      .SetMethod("_uninterceptProtocol", &Protocol::UninterceptProtocol);
 }
 
 void Protocol::RegisterStandardSchemes(
@@ -73,86 +272,131 @@ void Protocol::RegisterStandardSchemes(
   atom::AtomBrowserClient::SetCustomSchemes(schemes);
 }
 
-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),
+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),
       callback);
 }
 
-bool Protocol::IsProtocolHandledInIO(const std::string& scheme) {
-  return job_factory_->IsHandledProtocol(scheme);
-}
-
-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::OnIOCompleted,
+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));
 }
 
-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;
+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::OnIOCompleted(
-    const CompletionCallback& callback, ProtocolError error) {
-  // The completion callback is optional.
-  if (callback.is_null())
-    return;
-
-  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)));
-  }
+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));
 }
 
-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";
+void Protocol::UninterceptProtocol(v8::Isolate* isolate,
+                                   const std::string& scheme,
+                                   const JsCompletionCallback& callback) {
+  BrowserThread::PostTaskAndReplyWithResult(BrowserThread::IO, FROM_HERE,
+      base::Bind(&Protocol::UninterceptProtocolInIO,
+                 base::Unretained(this), scheme),
+      base::Bind(&Protocol::OnIOActionCompleted,
+                 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;
+}
+
+int Protocol::UnregisterProtocolInIO(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);
+  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;
+  }
+
+  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,14 +9,10 @@
 #include <map>
 #include <vector>
 
-#include "atom/browser/net/atom_url_request_job_factory.h"
+#include "atom/browser/api/event_emitter.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 "native_mate/wrappable.h"
+#include "net/base/completion_callback.h"
 
 namespace net {
 class URLRequest;
@@ -30,16 +26,31 @@ class AtomURLRequestJobFactory;
 
 namespace api {
 
-class Protocol : public mate::Wrappable {
+class Protocol : public mate::EventEmitter {
  public:
-  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)>;
+  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
+  };
 
   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);
 
@@ -48,139 +59,48 @@ class Protocol : public mate::Wrappable {
       v8::Isolate* isolate);
 
  private:
-  // 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,
-  };
+  typedef std::map<std::string, JsProtocolHandler> ProtocolHandlersMap;
 
-  // 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,
-        scoped_refptr<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_;
-    scoped_refptr<net::URLRequestContextGetter> request_context_;
-    Protocol::Handler handler_;
-
-    DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
-  };
+  // Callback called after performing action on IO thread.
+  void OnIOActionCompleted(const JsCompletionCallback& callback,
+                           int error);
 
   // Register schemes to standard scheme list.
   void RegisterStandardSchemes(const std::vector<std::string>& schemes);
 
-  // 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;
-  }
+  // Returns whether a scheme has been registered.
+  void IsHandledProtocol(const std::string& scheme,
+                         const net::CompletionCallback& callback);
 
-  // Unregister the protocol handler that handles |scheme|.
-  void UnregisterProtocol(const std::string& scheme, mate::Arguments* args);
-  ProtocolError UnregisterProtocolInIO(const std::string& scheme);
+  // 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);
 
-  // Whether the protocol has handler registered.
-  void IsProtocolHandled(const std::string& scheme,
-                         const BooleanCallback& callback);
-  bool IsProtocolHandledInIO(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);
 
-  // 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;
-  }
-
-  // Restore the |scheme| to its original protocol handler.
-  void UninterceptProtocol(const std::string& scheme, mate::Arguments* args);
-  ProtocolError UninterceptProtocolInIO(const std::string& scheme);
-
-  // 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);
+  // 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);
 
   scoped_refptr<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
+  AtomURLRequestJobFactory* job_factory_;
+  ProtocolHandlersMap protocol_handlers_;
 
   DISALLOW_COPY_AND_ASSIGN(Protocol);
 };

atom/browser/api/atom_api_screen.cc

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

atom/browser/api/atom_api_session.cc

@@ -9,11 +9,9 @@
 
 #include "atom/browser/api/atom_api_cookies.h"
 #include "atom/browser/atom_browser_context.h"
-#include "atom/browser/api/atom_api_web_contents.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/node_includes.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
@@ -30,6 +28,8 @@
 #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,19 +101,6 @@ struct Converter<ClearStorageDataOptions> {
   }
 };
 
-template<>
-struct Converter<content::DownloadItem*> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   content::DownloadItem* val) {
-    mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    dict.Set("url", val->GetURL());
-    dict.Set("filename", val->GetSuggestedFilename());
-    dict.Set("mimeType", val->GetMimeType());
-    dict.Set("hasUserGesture", val->HasUserGesture());
-    return dict.GetHandle();
-  }
-};
-
 }  // namespace mate
 
 namespace atom {
@@ -122,10 +109,6 @@ 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,
@@ -232,40 +215,13 @@ 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();
-  bool prevent_default = Emit("will-download", 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) {
@@ -286,7 +242,7 @@ 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(),
@@ -307,7 +263,7 @@ void Session::SetDownloadPath(const base::FilePath& path) {
 
 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_);
@@ -326,47 +282,15 @@ mate::ObjectTemplateBuilder Session::GetObjectTemplateBuilder(
 
 // 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));
 
-  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 SetWrapSession(const WrapSessionCallback& callback) {
-  g_wrap_session = callback;
-}
-
-void ClearWrapSession() {
-  g_wrap_session.Reset();
+  return mate::CreateHandle(isolate, new Session(browser_context));
 }
 
 }  // 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);
-  dict.SetMethod("_clearWrapSession", &atom::api::ClearWrapSession);
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_session, Initialize)

atom/browser/api/atom_api_session.h

@@ -8,7 +8,6 @@
 #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"
 
@@ -28,8 +27,7 @@ class AtomBrowserContext;
 
 namespace api {
 
-class Session: public mate::TrackableObject<Session>,
-               public content::DownloadManager::Observer {
+class Session: public mate::TrackableObject<Session> {
  public:
   using ResolveProxyCallback = base::Callback<void(std::string)>;
 
@@ -37,29 +35,17 @@ class Session: public mate::TrackableObject<Session>,
   static mate::Handle<Session> CreateFrom(
       v8::Isolate* isolate, AtomBrowserContext* 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(); }
+  AtomBrowserContext* browser_context() const { return browser_context_; }
 
  protected:
   explicit Session(AtomBrowserContext* browser_context);
   ~Session();
 
-  // content::DownloadManager::Observer:
-  void OnDownloadCreated(content::DownloadManager* manager,
-                         content::DownloadItem* item) override;
-
-  // mate::Wrappable:
+  // mate::Wrappable implementations:
   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);
@@ -67,10 +53,9 @@ class Session: public mate::TrackableObject<Session>,
   void SetDownloadPath(const base::FilePath& path);
   v8::Local<v8::Value> Cookies(v8::Isolate* isolate);
 
-  // Cached object for cookies API.
   v8::Global<v8::Value> cookies_;
 
-  scoped_refptr<AtomBrowserContext> browser_context_;
+  AtomBrowserContext* browser_context_;  // weak ref
 
   DISALLOW_COPY_AND_ASSIGN(Session);
 };

atom/browser/api/atom_api_tray.cc

@@ -12,12 +12,13 @@
 #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 {
@@ -34,8 +35,7 @@ Tray::~Tray() {
 // static
 mate::Wrappable* Tray::New(v8::Isolate* isolate, const gfx::Image& image) {
   if (!Browser::Get()->is_ready()) {
-    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
-        isolate, "Cannot create Tray before app is ready")));
+    node::ThrowError(isolate, "Cannot create Tray before app is ready");
     return nullptr;
   }
   return new Tray(image);

atom/browser/api/atom_api_web_contents.cc

@@ -11,7 +11,6 @@
 #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"
@@ -154,41 +153,23 @@ WebContents::WebContents(content::WebContents* web_contents)
   web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());
 }
 
-WebContents::WebContents(v8::Isolate* isolate,
-                         const mate::Dictionary& options) {
-  // Whether it is a guest WebContents.
+WebContents::WebContents(const mate::Dictionary& options) {
   bool is_guest = false;
   options.Get("isGuest", &is_guest);
+
   type_ = is_guest ? WEB_VIEW : BROWSER_WINDOW;
 
-  // 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());
-
+  auto browser_context = AtomBrowserMainParts::Get()->browser_context();
   content::WebContents* web_contents;
   if (is_guest) {
     content::SiteInstance* site_instance = content::SiteInstance::CreateForURL(
-        session->browser_context(), GURL("chrome-guest://fake-host"));
-    content::WebContents::CreateParams params(
-        session->browser_context(), site_instance);
+        browser_context, GURL("chrome-guest://fake-host"));
+    content::WebContents::CreateParams params(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(session->browser_context());
+    content::WebContents::CreateParams params(browser_context);
     web_contents = content::WebContents::Create(params);
   }
 
@@ -196,11 +177,6 @@ WebContents::WebContents(v8::Isolate* isolate,
   AttachAsUserData(web_contents);
   InitWithWebContents(web_contents);
 
-  // Save the preferences.
-  base::DictionaryValue web_preferences;
-  mate::ConvertFromV8(isolate, options.GetHandle(), &web_preferences);
-  new WebContentsPreferences(web_contents, &web_preferences);
-
   web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());
 
   if (is_guest) {
@@ -241,7 +217,7 @@ bool WebContents::ShouldCreateWebContents(
     int route_id,
     int main_frame_route_id,
     WindowContainerType window_container_type,
-    const std::string& frame_name,
+    const base::string16& frame_name,
     const GURL& target_url,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace) {
@@ -301,10 +277,7 @@ bool WebContents::IsPopupOrPanel(const content::WebContents* source) const {
 void WebContents::HandleKeyboardEvent(
     content::WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
-  if (event.windowsKeyCode == ui::VKEY_ESCAPE && is_html_fullscreen()) {
-    // Escape exits tabbed fullscreen mode.
-    ExitFullscreenModeForTab(source);
-  } else if (type_ == BROWSER_WINDOW) {
+  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.
@@ -386,16 +359,14 @@ void WebContents::DidFailProvisionalLoad(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     int error_code,
-    const base::string16& error_description,
-    bool was_ignored_by_handler) {
+    const base::string16& error_description) {
   Emit("did-fail-load", error_code, error_description);
 }
 
 void WebContents::DidFailLoad(content::RenderFrameHost* render_frame_host,
                               const GURL& validated_url,
                               int error_code,
-                              const base::string16& error_description,
-                              bool was_ignored_by_handler) {
+                              const base::string16& error_description) {
   Emit("did-fail-load", error_code, error_description);
 }
 
@@ -505,7 +476,6 @@ 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();
@@ -668,6 +638,10 @@ 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_);
 }
 
@@ -717,19 +691,17 @@ void WebContents::PrintToPDF(const base::DictionaryValue& setting,
       PrintToPDF(setting, callback);
 }
 
-void WebContents::AddWorkSpace(mate::Arguments* args,
-                               const base::FilePath& path) {
+void WebContents::AddWorkSpace(const base::FilePath& path) {
   if (path.empty()) {
-    args->ThrowError("path cannot be empty");
+    node::ThrowError(isolate(), "path cannot be empty");
     return;
   }
   DevToolsAddFileSystem(path);
 }
 
-void WebContents::RemoveWorkSpace(mate::Arguments* args,
-                                  const base::FilePath& path) {
+void WebContents::RemoveWorkSpace(const base::FilePath& path) {
   if (path.empty()) {
-    args->ThrowError("path cannot be empty");
+    node::ThrowError(isolate(), "path cannot be empty");
     return;
   }
   DevToolsRemoveFileSystem(path);
@@ -905,7 +877,7 @@ 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(isolate, options));
+  auto handle =  mate::CreateHandle(isolate, new WebContents(options));
   g_wrap_web_contents.Run(handle.ToV8());
   return handle;
 }

atom/browser/api/atom_api_web_contents.h

@@ -10,8 +10,8 @@
 
 #include "atom/browser/api/trackable_object.h"
 #include "atom/browser/common_web_contents_delegate.h"
-#include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/favicon_url.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "native_mate/handle.h"
 #include "ui/gfx/image/image.h"
 
@@ -48,9 +48,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
   static mate::Handle<WebContents> Create(
       v8::Isolate* isolate, const mate::Dictionary& options);
 
-  // mate::TrackableObject:
-  void Destroy() override;
-
+  void Destroy();
   bool IsAlive() const;
   int GetID() const;
   bool Equal(const WebContents* web_contents) const;
@@ -87,8 +85,8 @@ class WebContents : public mate::TrackableObject<WebContents>,
                   const PrintToPDFCallback& callback);
 
   // DevTools workspace api.
-  void AddWorkSpace(mate::Arguments* args, const base::FilePath& path);
-  void RemoveWorkSpace(mate::Arguments* args, const base::FilePath& path);
+  void AddWorkSpace(const base::FilePath& path);
+  void RemoveWorkSpace(const base::FilePath& path);
 
   // Editing commands.
   void Undo();
@@ -118,7 +116,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
  protected:
   explicit WebContents(content::WebContents* web_contents);
-  WebContents(v8::Isolate* isolate, const mate::Dictionary& options);
+  explicit WebContents(const mate::Dictionary& options);
   ~WebContents();
 
   // mate::Wrappable:
@@ -137,7 +135,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
       int route_id,
       int main_frame_route_id,
       WindowContainerType window_container_type,
-      const std::string& frame_name,
+      const base::string16& frame_name,
       const GURL& target_url,
       const std::string& partition_id,
       content::SessionStorageNamespace* session_storage_namespace) override;
@@ -172,13 +170,11 @@ 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,
-                   bool was_ignored_by_handler) override;
+                   const base::string16& error_description) override;
   void DidFailProvisionalLoad(content::RenderFrameHost* render_frame_host,
                               const GURL& validated_url,
                               int error_code,
-                              const base::string16& error_description,
-                              bool was_ignored_by_handler) override;
+                              const base::string16& error_description) override;
   void DidStartLoading() override;
   void DidStopLoading() override;
   void DidGetResourceResponseStart(

atom/browser/api/atom_api_web_view_manager.cc

@@ -3,14 +3,13 @@
 // 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/value_converter.h"
-#include "atom/common/node_includes.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
 #include "content/public/browser/browser_context.h"
 #include "native_mate/dictionary.h"
+#include "net/base/filename_util.h"
 
-using atom::WebContentsPreferences;
+#include "atom/common/node_includes.h"
 
 namespace mate {
 
@@ -26,6 +25,28 @@ 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 {
@@ -44,13 +65,14 @@ void AddGuest(int guest_instance_id,
               int element_instance_id,
               content::WebContents* embedder,
               content::WebContents* guest_web_contents,
-              const base::DictionaryValue& options) {
+              atom::WebViewManager::WebViewInfo info) {
   auto manager = GetWebViewManager(embedder);
-  if (manager)
+  if (manager) {
+    info.guest_instance_id = guest_instance_id;
+    info.embedder = embedder;
     manager->AddGuest(guest_instance_id, element_instance_id, embedder,
-                      guest_web_contents);
-
-  WebContentsPreferences::FromWebContents(guest_web_contents)->Merge(options);
+                      guest_web_contents, info);
+  }
 }
 
 void RemoveGuest(content::WebContents* embedder, int guest_instance_id) {

atom/browser/api/atom_api_window.cc

@@ -13,7 +13,6 @@
 #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/options_switches.h"
 #include "content/public/browser/render_process_host.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
@@ -65,22 +64,9 @@ void OnCapturePageDone(
 
 
 Window::Window(v8::Isolate* isolate, const mate::Dictionary& options) {
-  // Use options['web-preferences'] to create WebContents.
-  mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
-  options.Get(switches::kWebPreferences, &web_preferences);
-
-  // Be compatible with old options which are now in web_preferences.
-  std::string str;
-  double d;
-  if (options.Get(switches::kNodeIntegration, &str))
-    web_preferences.Set(switches::kNodeIntegration, str);
-  if (options.Get(switches::kPreloadScript, &str))
-    web_preferences.Set(switches::kPreloadScript, str);
-  if (options.Get(switches::kZoomFactor, &d))
-    web_preferences.Set(switches::kZoomFactor, d);
-
   // Creates the WebContents used by BrowserWindow.
-  auto web_contents = WebContents::Create(isolate, web_preferences);
+  mate::Dictionary web_contents_options(isolate, v8::Object::New(isolate));
+  auto web_contents = WebContents::Create(isolate, web_contents_options);
   web_contents_.Reset(isolate, web_contents.ToV8());
   api_web_contents_ = web_contents.get();
 
@@ -209,8 +195,8 @@ void Window::OnExecuteWindowsCommand(const std::string& command_name) {
 mate::Wrappable* Window::New(v8::Isolate* isolate,
                              const mate::Dictionary& options) {
   if (!Browser::Get()->is_ready()) {
-    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
-        isolate, "Cannot create BrowserWindow before app is ready")));
+    node::ThrowError(isolate,
+                     "Cannot create BrowserWindow before app is ready");
     return nullptr;
   }
   return new Window(isolate, options);
@@ -221,10 +207,7 @@ bool Window::IsDestroyed() const {
 }
 
 void Window::Destroy() {
-  if (window_) {
-    window_->CloseContents(nullptr);
-    window_.reset();
-  }
+  window_->CloseContents(nullptr);
 }
 
 void Window::Close() {

atom/browser/api/atom_api_window.h

@@ -78,10 +78,8 @@ class Window : public mate::TrackableObject<Window>,
   bool IsDestroyed() const override;
 
  private:
-  // mate::TrackableObject:
-  void Destroy() override;
-
   // APIs for NativeWindow.
+  void Destroy();
   void Close();
   bool IsClosed();
   void Focus();

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);
-  (void)event->SetPrototype(custom_event->CreationContext(), custom_event);
+  event->SetPrototype(custom_event->CreationContext(), custom_event);
   mate::Dictionary(isolate, event).Set("sender", GetWrapper(isolate));
   return event;
 }

atom/browser/api/event_emitter.h

@@ -45,8 +45,6 @@ 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/lib/app.coffee

@@ -1,15 +1,10 @@
 EventEmitter = require('events').EventEmitter
 
 bindings = process.atomBinding 'app'
-sessionBindings = process.atomBinding 'session'
 
 app = bindings.app
 app.__proto__ = EventEmitter.prototype
 
-wrapSession = (session) ->
-  # session is an Event Emitter.
-  session.__proto__ = EventEmitter.prototype
-
 app.setApplicationMenu = (menu) ->
   require('menu').setApplicationMenu menu
 
@@ -46,9 +41,5 @@ app.getDataPath = -> @getPath 'userData'
 app.setDataPath = (path) -> @setPath 'userData', path
 app.resolveProxy = -> @defaultSession.resolveProxy.apply @defaultSession, arguments
 
-# Session wrapper.
-sessionBindings._setWrapSession wrapSession
-process.once 'exit', sessionBindings._clearWrapSession
-
 # Only one App object pemitted.
 module.exports = app

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

@@ -62,12 +62,6 @@ BrowserWindow::loadUrl = -> @webContents.loadUrl.apply @webContents, arguments
 BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
 
 # Be compatible with old API.
-BrowserWindow::undo = -> @webContents.undo()
-BrowserWindow::redo = -> @webContents.redo()
-BrowserWindow::cut = -> @webContents.cut()
-BrowserWindow::copy = -> @webContents.copy()
-BrowserWindow::paste = -> @webContents.paste()
-BrowserWindow::selectAll = -> @webContents.selectAll()
 BrowserWindow::restart = -> @webContents.reload()
 BrowserWindow::getUrl = -> @webContents.getUrl()
 BrowserWindow::reload = -> @webContents.reload.apply @webContents, arguments

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

@@ -3,30 +3,18 @@ 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'
 
-    {click, @selector, @type, @role, @label, @sublabel, @accelerator, @icon, @enabled, @visible, @checked, @submenu} = options
+    {click, @selector, @type, @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'
@@ -39,14 +27,12 @@ class MenuItem
     throw new Error("Unknown menu type #{@type}") if MenuItem.types.indexOf(@type) is -1
 
     @commandId = ++nextCommandId
-    @click = (focusedWindow) =>
+    @click = =>
       # Manually flip the checked flags when clicked.
       @checked = !@checked if @type in ['checkbox', 'radio']
 
-      if @role and rolesMap[@role] and process.platform isnt 'darwin'
-        focusedWindow?[rolesMap[@role]]()
-      else if typeof click is 'function'
-        click this, focusedWindow
+      if typeof click is 'function'
+        click this, BrowserWindow.getFocusedWindow()
       else if typeof @selector is 'string'
         Menu.sendActionToFirstResponder @selector
 

atom/browser/api/lib/menu.coffee

@@ -67,8 +67,7 @@ Menu::_init = ->
     isCommandIdVisible: (commandId) => @commandsMap[commandId]?.visible
     getAcceleratorForCommandId: (commandId) => @commandsMap[commandId]?.accelerator
     getIconForCommandId: (commandId) => @commandsMap[commandId]?.icon
-    executeCommand: (commandId) =>
-      @commandsMap[commandId]?.click BrowserWindow.getFocusedWindow()
+    executeCommand: (commandId) => @commandsMap[commandId]?.click()
     menuWillShow: =>
       # Make sure radio groups have at least one menu item seleted.
       for id, group of @groupsMap
@@ -116,7 +115,6 @@ 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/protocol.coffee

@@ -2,23 +2,63 @@ app = require 'app'
 throw new Error('Can not initialize protocol module before app is ready') unless app.isReady()
 
 protocol = process.atomBinding('protocol').protocol
+EventEmitter = require('events').EventEmitter
 
-# Warn about removed APIs.
-logAndThrow = (callback, message) ->
-  console.error message
-  if callback then callback(new Error(message)) else throw new Error(message)
+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.
 protocol.registerProtocol = (scheme, handler, callback) ->
-  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._registerProtocol scheme, handler, GetWrappedCallback(scheme, callback, 'registered')
+
+protocol.unregisterProtocol = (scheme, callback) ->
+  protocol._unregisterProtocol scheme, GetWrappedCallback(scheme, callback, 'unregistered')
+
 protocol.interceptProtocol = (scheme, handler, callback) ->
-  logAndThrow callback,
-              'interceptProtocol API has been replaced by the
-               intercept[File/Http/Buffer/String]Protocol API family, please
-               switch to the new APIs.'
+  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}) ->
 
 module.exports = protocol

atom/browser/api/trackable_object.cc

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

atom/browser/api/trackable_object.h

@@ -9,9 +9,7 @@
 
 #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;
@@ -30,9 +28,6 @@ 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;
 
@@ -44,14 +39,12 @@ class TrackableObjectBase : public mate::EventEmitter {
 
   // Register a callback that should be destroyed before JavaScript environment
   // gets destroyed.
-  static void RegisterDestructionCallback(const base::Closure& closure);
+  static void RegisterDestructionCallback(void (*callback)());
 
   int32_t weak_map_id_;
   base::SupportsUserData* wrapped_;
 
  private:
-  base::WeakPtrFactory<TrackableObjectBase> weak_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(TrackableObjectBase);
 };
 
@@ -92,8 +85,7 @@ class TrackableObject : public TrackableObjectBase {
   }
 
   TrackableObject() {
-    RegisterDestructionCallback(
-        base::Bind(&TrackableObject<T>::ReleaseAllWeakReferences));
+    RegisterDestructionCallback(&TrackableObject<T>::ReleaseAllWeakReferences);
   }
 
   // Removes this instance from the weak map.

atom/browser/atom_access_token_store.cc

@@ -9,7 +9,6 @@
 #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 {
 
@@ -25,7 +24,6 @@ const char* kGeolocationProviderUrl =
 }  // namespace
 
 AtomAccessTokenStore::AtomAccessTokenStore() {
-  content::GeolocationProvider::GetInstance()->UserDidOptIntoLocationServices();
 }
 
 AtomAccessTokenStore::~AtomAccessTokenStore() {

atom/browser/atom_browser_client.cc

@@ -15,12 +15,11 @@
 #include "atom/browser/atom_speech_recognition_manager_delegate.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/native_window.h"
-#include "atom/browser/web_contents_preferences.h"
+#include "atom/browser/web_view_manager.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"
@@ -37,7 +36,6 @@
 #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 {
 
@@ -54,6 +52,34 @@ 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())
@@ -129,7 +155,15 @@ void AtomBrowserClient::OverrideWebkitPrefs(
 
   // Custom preferences of guest page.
   auto web_contents = content::WebContents::FromRenderViewHost(host);
-  WebContentsPreferences::OverrideWebkitPrefs(web_contents, prefs);
+  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);
 }
 
 std::string AtomBrowserClient::GetApplicationLocale() {
@@ -151,13 +185,6 @@ 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(
@@ -181,18 +208,23 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches(
   }
 #endif
 
-  // 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];
+  NativeWindow* window;
+  WebViewManager::WebViewInfo info;
+  ProcessOwner owner = GetProcessOwner(process_id, &window, &info);
 
-  // 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);
+  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);
+  }
 }
 
 void AtomBrowserClient::DidCreatePpapiPlugin(
@@ -232,15 +264,4 @@ 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,12 +5,10 @@
 #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;
@@ -23,8 +21,7 @@ class SSLCertRequestInfo;
 
 namespace atom {
 
-class AtomBrowserClient : public brightray::BrowserClient,
-                          public content::RenderProcessHostObserver {
+class AtomBrowserClient : public brightray::BrowserClient {
  public:
   AtomBrowserClient();
   virtual ~AtomBrowserClient();
@@ -57,17 +54,10 @@ class AtomBrowserClient : public brightray::BrowserClient,
       net::SSLCertRequestInfo* cert_request_info,
       scoped_ptr<content::ClientCertificateDelegate> delegate) override;
 
-  // brightray::BrowserClient:
+ private:
   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_;
-
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
 };
 

atom/browser/atom_browser_context.cc

@@ -56,10 +56,8 @@ std::string RemoveWhitespace(const std::string& str) {
 
 }  // namespace
 
-AtomBrowserContext::AtomBrowserContext(const std::string& partition,
-                                       bool in_memory)
-    : brightray::BrowserContext(partition, in_memory),
-      job_factory_(new AtomURLRequestJobFactory) {
+AtomBrowserContext::AtomBrowserContext()
+    : job_factory_(new AtomURLRequestJobFactory) {
 }
 
 AtomBrowserContext::~AtomBrowserContext() {
@@ -87,37 +85,32 @@ net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
     content::URLRequestInterceptorScopedVector* interceptors) {
   scoped_ptr<AtomURLRequestJobFactory> job_factory(job_factory_);
 
-  for (auto& it : *handlers) {
-    job_factory->SetProtocolHandler(it.first,
-                                    make_scoped_ptr(it.second.release()));
-  }
+  for (content::ProtocolHandlerMap::iterator it = handlers->begin();
+       it != handlers->end(); ++it)
+    job_factory->SetProtocolHandler(it->first, it->second.release());
   handlers->clear();
 
   job_factory->SetProtocolHandler(
-      url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler));
+      url::kDataScheme, new net::DataProtocolHandler);
   job_factory->SetProtocolHandler(
-      url::kFileScheme, make_scoped_ptr(new asar::AsarProtocolHandler(
+      url::kFileScheme, new asar::AsarProtocolHandler(
           BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
   job_factory->SetProtocolHandler(
-      url::kHttpScheme,
-      make_scoped_ptr(new HttpProtocolHandler(url::kHttpScheme)));
+      url::kHttpScheme, new HttpProtocolHandler(url::kHttpScheme));
   job_factory->SetProtocolHandler(
-      url::kHttpsScheme,
-      make_scoped_ptr(new HttpProtocolHandler(url::kHttpsScheme)));
+      url::kHttpsScheme, new HttpProtocolHandler(url::kHttpsScheme));
   job_factory->SetProtocolHandler(
-      url::kWsScheme,
-      make_scoped_ptr(new HttpProtocolHandler(url::kWsScheme)));
+      url::kWsScheme, new HttpProtocolHandler(url::kWsScheme));
   job_factory->SetProtocolHandler(
-      url::kWssScheme,
-      make_scoped_ptr(new HttpProtocolHandler(url::kWssScheme)));
+      url::kWssScheme, 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,
-      make_scoped_ptr(new net::FtpProtocolHandler(
-          new net::FtpNetworkLayer(host_resolver))));
+      url::kFtpScheme, 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();
@@ -152,7 +145,7 @@ AtomBrowserContext::GetDownloadManagerDelegate() {
 
 content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
   if (!guest_manager_)
-    guest_manager_.reset(new WebViewManager);
+    guest_manager_.reset(new WebViewManager(this));
   return guest_manager_.get();
 }
 
@@ -164,13 +157,3 @@ void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
 }
 
 }  // 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

@@ -17,8 +17,8 @@ class WebViewManager;
 
 class AtomBrowserContext : public brightray::BrowserContext {
  public:
-  AtomBrowserContext(const std::string& partition, bool in_memory);
-  ~AtomBrowserContext() override;
+  AtomBrowserContext();
+  virtual ~AtomBrowserContext();
 
   // brightray::URLRequestContextGetter::Delegate:
   std::string GetUserAgent() override;
@@ -41,8 +41,7 @@ class AtomBrowserContext : public brightray::BrowserContext {
   scoped_ptr<AtomDownloadManagerDelegate> download_manager_delegate_;
   scoped_ptr<WebViewManager> guest_manager_;
 
-  // Managed by brightray::BrowserContext.
-  AtomURLRequestJobFactory* job_factory_;
+  AtomURLRequestJobFactory* job_factory_;  // Weak reference.
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
 };

atom/browser/atom_browser_main_parts.cc

@@ -7,15 +7,11 @@
 #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"
 
@@ -23,6 +19,8 @@
 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
 #endif
 
+#include "atom/common/node_includes.h"
+
 namespace atom {
 
 // static
@@ -54,6 +52,10 @@ void AtomBrowserMainParts::RegisterDestructionCallback(
   destruction_callbacks_.push_back(callback);
 }
 
+brightray::BrowserContext* AtomBrowserMainParts::CreateBrowserContext() {
+  return new AtomBrowserContext();
+}
+
 void AtomBrowserMainParts::PostEarlyInitialization() {
   brightray::BrowserMainParts::PostEarlyInitialization();
 
@@ -61,30 +63,15 @@ void AtomBrowserMainParts::PostEarlyInitialization() {
   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.
-    js_env_.reset(new JavascriptEnvironment);
-  }
+  // 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());
 

atom/browser/atom_browser_main_parts.h

@@ -6,12 +6,10 @@
 #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;
 
@@ -21,8 +19,6 @@ class AtomBindings;
 class Browser;
 class JavascriptEnvironment;
 class NodeBindings;
-class NodeDebugger;
-class BridgeTaskRunner;
 
 class AtomBrowserMainParts : public brightray::BrowserMainParts {
  public:
@@ -38,7 +34,10 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   Browser* browser() { return browser_.get(); }
 
  protected:
-  // content::BrowserMainParts:
+  // Implementations of brightray::BrowserMainParts.
+  brightray::BrowserContext* CreateBrowserContext() override;
+
+  // Implementations of content::BrowserMainParts.
   void PostEarlyInitialization() override;
   void PreMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
@@ -54,15 +53,10 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   // 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_;
-
   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/bridge_task_runner.cc

@@ -1,42 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/bridge_task_runner.h"
-
-#include "base/message_loop/message_loop.h"
-
-namespace atom {
-
-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)
-    return false;
-
-  return message_loop->task_runner()->PostDelayedTask(from_here, task, delay);
-}
-
-bool BridgeTaskRunner::RunsTasksOnCurrentThread() const {
-  auto message_loop = base::MessageLoop::current();
-  if (!message_loop)
-    return false;
-
-  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)
-    return false;
-
-  return message_loop->task_runner()->PostNonNestableDelayedTask(
-      from_here, task, delay);
-}
-
-}  // namespace atom

atom/browser/bridge_task_runner.h

@@ -1,35 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
-#define ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
-
-#include "base/single_thread_task_runner.h"
-
-namespace atom {
-
-// Post all tasks to the current message loop's task runner if available,
-// otherwise fail silently.
-class BridgeTaskRunner : public base::SingleThreadTaskRunner {
- public:
-  BridgeTaskRunner() {}
-  ~BridgeTaskRunner() 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:
-  DISALLOW_COPY_AND_ASSIGN(BridgeTaskRunner);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_

atom/browser/browser.cc

@@ -45,8 +45,7 @@ void Browser::Shutdown() {
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnQuit());
 
   is_quiting_ = true;
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  base::MessageLoop::current()->Quit();
 }
 
 std::string Browser::GetVersion() const {

atom/browser/browser.h

@@ -153,7 +153,7 @@ class Browser : public WindowListObserver {
   void OnWindowAllClosed() override;
 
   // Observers of the browser.
-  base::ObserverList<BrowserObserver> observers_;
+  ObserverList<BrowserObserver> observers_;
 
   // Whether "ready" event has been emitted.
   bool is_ready_;

atom/browser/common_web_contents_delegate.h

@@ -48,8 +48,6 @@ class CommonWebContentsDelegate
 
   NativeWindow* owner_window() const { return owner_window_.get(); }
 
-  bool is_html_fullscreen() const { return html_fullscreen_; }
-
  protected:
   // content::WebContentsDelegate:
   content::WebContents* OpenURLFromTab(

atom/browser/default_app/main.js

@@ -36,176 +36,238 @@ app.once('ready', function() {
   if (Menu.getApplicationMenu())
     return;
 
-  var template = [
-    {
-      label: 'Edit',
-      submenu: [
-        {
-          label: 'Undo',
-          accelerator: 'CmdOrCtrl+Z',
-          role: 'undo'
-        },
-        {
-          label: 'Redo',
-          accelerator: 'Shift+CmdOrCtrl+Z',
-          role: 'redo'
-        },
-        {
-          type: 'separator'
-        },
-        {
-          label: 'Cut',
-          accelerator: 'CmdOrCtrl+X',
-          role: 'cut'
-        },
-        {
-          label: 'Copy',
-          accelerator: 'CmdOrCtrl+C',
-          role: 'copy'
-        },
-        {
-          label: 'Paste',
-          accelerator: 'CmdOrCtrl+V',
-          role: 'paste'
-        },
-        {
-          label: 'Select All',
-          accelerator: 'CmdOrCtrl+A',
-          role: 'selectall'
-        },
-      ]
-    },
-    {
-      label: 'View',
-      submenu: [
-        {
-          label: 'Reload',
-          accelerator: 'CmdOrCtrl+R',
-          click: function(item, focusedWindow) {
-            if (focusedWindow)
-              focusedWindow.reload();
-          }
-        },
-        {
-          label: 'Toggle Full Screen',
-          accelerator: (function() {
-            if (process.platform == 'darwin')
-              return 'Ctrl+Command+F';
-            else
-              return 'F11';
-          })(),
-          click: function(item, focusedWindow) {
-            if (focusedWindow)
-              focusedWindow.setFullScreen(!focusedWindow.isFullScreen());
-          }
-        },
-        {
-          label: 'Toggle Developer Tools',
-          accelerator: (function() {
-            if (process.platform == 'darwin')
-              return 'Alt+Command+I';
-            else
-              return 'Ctrl+Shift+I';
-          })(),
-          click: function(item, focusedWindow) {
-            if (focusedWindow)
-              focusedWindow.toggleDevTools();
-          }
-        },
-      ]
-    },
-    {
-      label: 'Window',
-      role: 'window',
-      submenu: [
-        {
-          label: 'Minimize',
-          accelerator: 'CmdOrCtrl+M',
-          role: 'minimize'
-        },
-        {
-          label: 'Close',
-          accelerator: 'CmdOrCtrl+W',
-          role: 'close'
-        },
-      ]
-    },
-    {
-      label: 'Help',
-      role: 'help',
-      submenu: [
-        {
-          label: 'Learn More',
-          click: function() { require('shell').openExternal('http://electron.atom.io') }
-        },
-        {
-          label: 'Documentation',
-          click: function() { require('shell').openExternal('https://github.com/atom/electron/tree/master/docs#readme') }
-        },
-        {
-          label: 'Community Discussions',
-          click: function() { require('shell').openExternal('https://discuss.atom.io/c/electron') }
-        },
-        {
-          label: 'Search Issues',
-          click: function() { require('shell').openExternal('https://github.com/atom/electron/issues') }
-        }
-      ]
-    },
-  ];
-
+  var template;
   if (process.platform == 'darwin') {
-    template.unshift({
-      label: 'Electron',
-      submenu: [
-        {
-          label: 'About Electron',
-          role: 'about'
-        },
-        {
-          type: 'separator'
-        },
-        {
-          label: 'Services',
-          role: 'services',
-          submenu: []
-        },
-        {
-          type: 'separator'
-        },
-        {
-          label: 'Hide Electron',
-          accelerator: 'Command+H',
-          role: 'hide'
-        },
-        {
-          label: 'Hide Others',
-          accelerator: 'Command+Shift+H',
-          role: 'hideothers:'
-        },
-        {
-          label: 'Show All',
-          role: 'unhide:'
-        },
-        {
-          type: 'separator'
-        },
-        {
-          label: 'Quit',
-          accelerator: 'Command+Q',
-          click: function() { app.quit(); }
-        },
-      ]
-    });
-    template[3].submenu.push(
+    template = [
       {
-        type: 'separator'
+        label: 'Electron',
+        submenu: [
+          {
+            label: 'About Electron',
+            selector: 'orderFrontStandardAboutPanel:'
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Services',
+            submenu: []
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Hide Electron',
+            accelerator: 'Command+H',
+            selector: 'hide:'
+          },
+          {
+            label: 'Hide Others',
+            accelerator: 'Command+Shift+H',
+            selector: 'hideOtherApplications:'
+          },
+          {
+            label: 'Show All',
+            selector: 'unhideAllApplications:'
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Quit',
+            accelerator: 'Command+Q',
+            click: function() { app.quit(); }
+          },
+        ]
       },
       {
-        label: 'Bring All to Front',
-        role: 'front'
+        label: 'Edit',
+        submenu: [
+          {
+            label: 'Undo',
+            accelerator: 'Command+Z',
+            selector: 'undo:'
+          },
+          {
+            label: 'Redo',
+            accelerator: 'Shift+Command+Z',
+            selector: 'redo:'
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Cut',
+            accelerator: 'Command+X',
+            selector: 'cut:'
+          },
+          {
+            label: 'Copy',
+            accelerator: 'Command+C',
+            selector: 'copy:'
+          },
+          {
+            label: 'Paste',
+            accelerator: 'Command+V',
+            selector: 'paste:'
+          },
+          {
+            label: 'Select All',
+            accelerator: 'Command+A',
+            selector: 'selectAll:'
+          },
+        ]
+      },
+      {
+        label: 'View',
+        submenu: [
+          {
+            label: 'Reload',
+            accelerator: 'Command+R',
+            click: function() {
+              var focusedWindow = BrowserWindow.getFocusedWindow();
+              if (focusedWindow)
+                focusedWindow.reload();
+            }
+          },
+          {
+            label: 'Toggle Full Screen',
+            accelerator: 'Ctrl+Command+F',
+            click: function() {
+              var focusedWindow = BrowserWindow.getFocusedWindow();
+              if (focusedWindow)
+                focusedWindow.setFullScreen(!focusedWindow.isFullScreen());
+            }
+          },
+          {
+            label: 'Toggle Developer Tools',
+            accelerator: 'Alt+Command+I',
+            click: function() {
+              var focusedWindow = BrowserWindow.getFocusedWindow();
+              if (focusedWindow)
+                focusedWindow.toggleDevTools();
+            }
+          },
+        ]
+      },
+      {
+        label: 'Window',
+        submenu: [
+          {
+            label: 'Minimize',
+            accelerator: 'Command+M',
+            selector: 'performMiniaturize:'
+          },
+          {
+            label: 'Close',
+            accelerator: 'Command+W',
+            selector: 'performClose:'
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Bring All to Front',
+            selector: 'arrangeInFront:'
+          },
+        ]
+      },
+      {
+        label: 'Help',
+        submenu: [
+          {
+            label: 'Learn More',
+            click: function() { require('shell').openExternal('http://electron.atom.io') }
+          },
+          {
+            label: 'Documentation',
+            click: function() { require('shell').openExternal('https://github.com/atom/electron/tree/master/docs#readme') }
+          },
+          {
+            label: 'Community Discussions',
+            click: function() { require('shell').openExternal('https://discuss.atom.io/c/electron') }
+          },
+          {
+            label: 'Search Issues',
+            click: function() { require('shell').openExternal('https://github.com/atom/electron/issues') }
+          }
+        ]
       }
-    );
+    ];
+  } else {
+    template = [
+      {
+        label: '&File',
+        submenu: [
+          {
+            label: '&Open',
+            accelerator: 'Ctrl+O',
+          },
+          {
+            label: '&Close',
+            accelerator: 'Ctrl+W',
+            click: function() {
+              var focusedWindow = BrowserWindow.getFocusedWindow();
+              if (focusedWindow)
+                focusedWindow.close();
+            }
+          },
+        ]
+      },
+      {
+        label: '&View',
+        submenu: [
+          {
+            label: '&Reload',
+            accelerator: 'Ctrl+R',
+            click: function() {
+              var focusedWindow = BrowserWindow.getFocusedWindow();
+              if (focusedWindow)
+                focusedWindow.reload();
+            }
+          },
+          {
+            label: 'Toggle &Full Screen',
+            accelerator: 'F11',
+            click: function() {
+              var focusedWindow = BrowserWindow.getFocusedWindow();
+              if (focusedWindow)
+                focusedWindow.setFullScreen(!focusedWindow.isFullScreen());
+            }
+          },
+          {
+            label: 'Toggle &Developer Tools',
+            accelerator: 'Shift+Ctrl+I',
+            click: function() {
+              var focusedWindow = BrowserWindow.getFocusedWindow();
+              if (focusedWindow)
+                focusedWindow.toggleDevTools();
+            }
+          },
+        ]
+      },
+      {
+        label: 'Help',
+        submenu: [
+          {
+            label: 'Learn More',
+            click: function() { require('shell').openExternal('http://electron.atom.io') }
+          },
+          {
+            label: 'Documentation',
+            click: function() { require('shell').openExternal('https://github.com/atom/electron/tree/master/docs#readme') }
+          },
+          {
+            label: 'Community Discussions',
+            click: function() { require('shell').openExternal('https://discuss.atom.io/c/electron') }
+          },
+          {
+            label: 'Search Issues',
+            click: function() { require('shell').openExternal('https://github.com/atom/electron/issues') }
+          }
+        ]
+      }
+    ];
   }
 
   var menu = Menu.buildFromTemplate(template);

atom/browser/javascript_environment.cc

@@ -5,7 +5,6 @@
 #include "atom/browser/javascript_environment.h"
 
 #include "gin/array_buffer.h"
-#include "gin/v8_initializer.h"
 
 namespace atom {
 
@@ -20,7 +19,7 @@ JavascriptEnvironment::JavascriptEnvironment()
 }
 
 bool JavascriptEnvironment::Initialize() {
-  gin::V8Initializer::LoadV8Snapshot();
+  gin::IsolateHolder::LoadV8Snapshot();
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
                                  gin::ArrayBufferAllocator::SharedInstance());
   return true;

atom/browser/lib/chrome-extension.coffee

@@ -64,16 +64,14 @@ app.once 'ready', ->
   catch e
 
   # The chrome-extension: can map a extension URL request to real file path.
-  chromeExtensionHandler = (request, callback) ->
+  protocol.registerProtocol 'chrome-extension', (request) ->
     parsed = url.parse request.url
-    return callback() unless parsed.hostname and parsed.path?
-    return callback() unless /extension-\d+/.test parsed.hostname
+    return unless parsed.hostname and parsed.path?
+    return unless /extension-\d+/.test parsed.hostname
 
     directory = getPathForHost parsed.hostname
-    return callback() unless directory?
-    callback path.join(directory, parsed.path)
-  protocol.registerFileProtocol 'chrome-extension', chromeExtensionHandler, (error) ->
-    console.error 'Unable to register chrome-extension protocol' if error
+    return unless directory?
+    return new protocol.RequestFileJob(path.join(directory, parsed.path))
 
   BrowserWindow::_loadDevToolsExtensions = (extensionInfoArray) ->
     @devToolsWebContents?.executeJavaScript "DevToolsAPI.addExtensions(#{JSON.stringify(extensionInfoArray)});"

atom/browser/lib/guest-view-manager.coffee

@@ -30,10 +30,6 @@ guestInstances = {}
 embedderElementsMap = {}
 reverseEmbedderElementsMap = {}
 
-# Moves the last element of array to the first one.
-moveLastToFirst = (list) ->
-  list.unshift list.pop()
-
 # Generate guestInstanceId.
 getNextInstanceId = (webContents) ->
   ++nextInstanceId
@@ -43,20 +39,14 @@ createGuest = (embedder, params) ->
   webViewManager ?= process.atomBinding 'web_view_manager'
 
   id = getNextInstanceId embedder
-  guest = webContents.create {isGuest: true, partition: params.partition, embedder}
+  guest = webContents.create {isGuest: true, embedder}
   guestInstances[id] = {guest, embedder}
 
   # Destroy guest when the embedder is gone or navigated.
   destroyEvents = ['destroyed', 'crashed', 'did-navigate-to-different-page']
   destroy = ->
     destroyGuest embedder, id if guestInstances[id]?
-  for event in destroyEvents
-    embedder.once event, destroy
-    # Users might also listen to the crashed event, so We must ensure the guest
-    # is destroyed before users' listener gets called. It is done by moving our
-    # listener to the first one in queue.
-    listeners = embedder._events[event]
-    moveLastToFirst listeners if Array.isArray listeners
+  embedder.once event, destroy for event in destroyEvents
   guest.once 'destroyed', ->
     embedder.removeListener event, destroy for event in destroyEvents
 
@@ -115,13 +105,11 @@ attachGuest = (embedder, elementInstanceId, guestInstanceId, params) ->
     return unless guestInstances[oldGuestInstanceId]?
     destroyGuest embedder, oldGuestInstanceId
 
-  webPreferences =
-    'guest-instance-id': guestInstanceId
-    'node-integration': params.nodeintegration ? false
-    'plugins': params.plugins
-    'web-security': !params.disablewebsecurity
-  webPreferences['preload-url'] = params.preload if params.preload
-  webViewManager.addGuest guestInstanceId, elementInstanceId, embedder, guest, webPreferences
+  webViewManager.addGuest guestInstanceId, elementInstanceId, embedder, guest,
+    nodeIntegration: params.nodeintegration
+    plugins: params.plugins
+    disableWebSecurity: params.disablewebsecurity
+    preloadUrl: params.preload ? ''
 
   guest.attachParams = params
   embedderElementsMap[key] = guestInstanceId

atom/browser/lib/guest-window-manager.coffee

@@ -57,19 +57,13 @@ ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', (event, guestId, me
   if guestContents?.getUrl().indexOf(targetOrigin) is 0 or targetOrigin is '*'
     guestContents.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', message, targetOrigin
 
-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPENER_POSTMESSAGE', (event, guestId, message, targetOrigin, sourceOrigin) ->
+ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPENER_POSTMESSAGE', (event, message, targetOrigin) ->
   embedder = v8Util.getHiddenValue event.sender, 'embedder'
   if embedder?.getUrl().indexOf(targetOrigin) is 0 or targetOrigin is '*'
-    embedder.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', guestId, message, sourceOrigin
+    embedder.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', message, targetOrigin
 
 ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', (event, guestId, method, args...) ->
   BrowserWindow.fromId(guestId)?.webContents?[method] args...
 
-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_GET_GUEST_ID', (event) ->
-  embedder = v8Util.getHiddenValue event.sender, 'embedder'
-  if embedder?
-    guest = BrowserWindow.fromWebContents event.sender
-    if guest?
-      event.returnValue = guest.id
-      return
-  event.returnValue = null
+ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_IS_GUEST_WINDOW', (event) ->
+  event.returnValue = v8Util.getHiddenValue(event.sender, 'embedder') isnt undefined

atom/browser/lib/init.coffee

@@ -92,8 +92,5 @@ app.setAppPath packagePath
 # Load the chrome extension support.
 require './chrome-extension'
 
-# Set main startup script of the app.
-mainStartupScript = packageJson.main or 'index.js'
-
 # Finally load app's main.js and transfer control to C++.
-Module._load path.join(packagePath, mainStartupScript), Module, true
+Module._load path.join(packagePath, packageJson.main), Module, true

atom/browser/lib/objects-registry.coffee

@@ -1,65 +1,82 @@
 EventEmitter = require('events').EventEmitter
+IDWeakMap = process.atomBinding('id_weak_map').IDWeakMap
 v8Util = process.atomBinding 'v8_util'
 
+# Class to reference all objects.
+class ObjectsStore
+  @stores = {}
+
+  constructor: ->
+    @nextId = 0
+    @objects = []
+
+  getNextId: ->
+    ++@nextId
+
+  add: (obj) ->
+    id = @getNextId()
+    @objects[id] = obj
+    id
+
+  has: (id) ->
+    @objects[id]?
+
+  remove: (id) ->
+    throw new Error("Invalid key #{id} for ObjectsStore") unless @has id
+    delete @objects[id]
+
+  get: (id) ->
+    throw new Error("Invalid key #{id} for ObjectsStore") unless @has id
+    @objects[id]
+
+  @forRenderView: (key) ->
+    @stores[key] = new ObjectsStore unless @stores[key]?
+    @stores[key]
+
+  @releaseForRenderView: (key) ->
+    delete @stores[key]
+
 class ObjectsRegistry extends EventEmitter
   constructor: ->
     @setMaxListeners Number.MAX_VALUE
-    @nextId = 0
 
-    # Stores all objects by ref-counting.
-    # (id) => {object, count}
-    @storage = {}
-
-    # Stores the IDs of objects referenced by WebContents.
-    # (webContentsId) => {(id) => (count)}
-    @owners = {}
+    # Objects in weak map will be not referenced (so we won't leak memory), and
+    # every object created in browser will have a unique id in weak map.
+    @objectsWeakMap = new IDWeakMap
+    @objectsWeakMap.add = (obj) ->
+      id = IDWeakMap::add.call this, obj
+      v8Util.setHiddenValue obj, 'atomId', id
+      id
 
   # Register a new object, the object would be kept referenced until you release
   # it explicitly.
-  add: (webContentsId, obj) ->
-    id = @saveToStorage obj
-    # Remember the owner.
-    @owners[webContentsId] ?= {}
-    @owners[webContentsId][id] ?= 0
-    @owners[webContentsId][id]++
-    # Returns object's id
-    id
+  add: (key, obj) ->
+    # Some native objects may already been added to objectsWeakMap, be care not
+    # to add it twice.
+    @objectsWeakMap.add obj unless v8Util.getHiddenValue obj, 'atomId'
+    id = v8Util.getHiddenValue obj, 'atomId'
 
-  # Get an object according to its ID.
+    # Store and reference the object, then return the storeId which points to
+    # where the object is stored. The caller can later dereference the object
+    # with the storeId.
+    # We use a difference key because the same object can be referenced for
+    # multiple times by the same renderer view.
+    store = ObjectsStore.forRenderView key
+    storeId = store.add obj
+
+    [id, storeId]
+
+  # Get an object according to its id.
   get: (id) ->
-    @storage[id]?.object
+    @objectsWeakMap.get id
 
-  # Dereference an object according to its ID.
-  remove: (webContentsId, id) ->
-    @dereference id, 1
-    # Also reduce the count in owner.
-    pointer = @owners[webContentsId]
-    --pointer[id]
-    delete pointer[id] if pointer[id] is 0
+  # Remove an object according to its storeId.
+  remove: (key, storeId) ->
+    ObjectsStore.forRenderView(key).remove storeId
 
-  # Clear all references to objects refrenced by the WebContents.
-  clear: (webContentsId) ->
-    @emit "clear-#{webContentsId}"
-    return unless @owners[webContentsId]?
-    @dereference id, count for id, count of @owners[webContentsId]
-    delete @owners[webContentsId]
-
-  # Private: Saves the object into storage and assigns an ID for it.
-  saveToStorage: (object) ->
-    id = v8Util.getHiddenValue object, 'atomId'
-    unless id
-      id = ++@nextId
-      @storage[id] = {count: 0, object}
-      v8Util.setHiddenValue object, 'atomId', id
-    ++@storage[id].count
-    id
-
-  # Private: Dereference the object from store.
-  dereference: (id, count) ->
-    pointer = @storage[id]
-    pointer.count -= count
-    if pointer.count is 0
-      v8Util.deleteHiddenValue pointer.object, 'atomId'
-      delete @storage[id]
+  # Clear all references to objects from renderer view.
+  clear: (key) ->
+    @emit "clear-#{key}"
+    ObjectsStore.releaseForRenderView key
 
 module.exports = new ObjectsRegistry

atom/browser/lib/rpc-server.coffee

@@ -4,7 +4,7 @@ objectsRegistry = require './objects-registry.js'
 v8Util = process.atomBinding 'v8_util'
 
 # Convert a real value into meta data.
-valueToMeta = (sender, value, optimizeSimpleObject=false) ->
+valueToMeta = (sender, value) ->
   meta = type: typeof value
 
   meta.type = 'buffer' if Buffer.isBuffer value
@@ -12,10 +12,6 @@ valueToMeta = (sender, value, optimizeSimpleObject=false) ->
   meta.type = 'array' if Array.isArray value
   meta.type = 'promise' if value? and value.constructor.name is 'Promise'
 
-  # Treat simple objects as value.
-  if optimizeSimpleObject and meta.type is 'object' and v8Util.getHiddenValue value, 'simple'
-    meta.type = 'value'
-
   # Treat the arguments object as array.
   meta.type = 'array' if meta.type is 'object' and value.callee? and value.length?
 
@@ -28,7 +24,7 @@ valueToMeta = (sender, value, optimizeSimpleObject=false) ->
     # Reference the original value if it's an object, because when it's
     # passed to renderer we would assume the renderer keeps a reference of
     # it.
-    meta.id = objectsRegistry.add sender.getId(), value
+    [meta.id, meta.storeId] = objectsRegistry.add sender.getId(), value
 
     meta.members = []
     meta.members.push {name: prop, type: typeof field} for prop, field of value
@@ -84,11 +80,11 @@ unwrapArgs = (sender, args) ->
 callFunction = (event, func, caller, args) ->
   if v8Util.getHiddenValue(func, 'asynchronous') and typeof args[args.length - 1] isnt 'function'
     args.push (ret) ->
-      event.returnValue = valueToMeta event.sender, ret, true
+      event.returnValue = valueToMeta event.sender, ret
     func.apply caller, args
   else
     ret = func.apply caller, args
-    event.returnValue = valueToMeta event.sender, ret, true
+    event.returnValue = valueToMeta event.sender, ret
 
 # Send by BrowserWindow when its render view is deleted.
 process.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (id) ->
@@ -174,8 +170,8 @@ ipc.on 'ATOM_BROWSER_MEMBER_GET', (event, id, name) ->
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_DEREFERENCE', (event, id) ->
-  objectsRegistry.remove event.sender.getId(), id
+ipc.on 'ATOM_BROWSER_DEREFERENCE', (event, storeId) ->
+  objectsRegistry.remove event.sender.getId(), storeId
 
 ipc.on 'ATOM_BROWSER_GUEST_WEB_CONTENTS', (event, guestInstanceId) ->
   try

atom/browser/native_window.cc

@@ -15,10 +15,12 @@
 #include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/options_switches.h"
+#include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/prefs/pref_service.h"
 #include "base/message_loop/message_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "brightray/browser/inspectable_web_contents.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
@@ -29,6 +31,8 @@
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/renderer_preferences.h"
+#include "content/public/common/web_preferences.h"
 #include "ipc/ipc_message_macros.h"
 #include "native_mate/dictionary.h"
 #include "ui/gfx/codec/png_codec.h"
@@ -39,6 +43,10 @@
 #include "ui/gfx/screen.h"
 #include "ui/gl/gpu_switching_manager.h"
 
+#if defined(OS_WIN)
+#include "ui/gfx/switches.h"
+#endif
+
 using content::NavigationEntry;
 using content::RenderWidgetHostView;
 using content::RenderWidgetHost;
@@ -49,6 +57,17 @@ namespace atom {
 
 namespace {
 
+// Array of available web runtime features.
+const char* kWebRuntimeFeatures[] = {
+  switches::kExperimentalFeatures,
+  switches::kExperimentalCanvasFeatures,
+  switches::kSubpixelFontScaling,
+  switches::kOverlayScrollbars,
+  switches::kOverlayFullscreenVideo,
+  switches::kSharedWorker,
+  switches::kPageVisibility,
+};
+
 // Convert draggable regions in raw format to SkRegion format. Caller is
 // responsible for deleting the returned SkRegion instance.
 scoped_ptr<SkRegion> DraggableRegionsToSkRegion(
@@ -75,7 +94,9 @@ NativeWindow::NativeWindow(
       transparent_(false),
       enable_larger_than_screen_(false),
       is_closed_(false),
+      node_integration_(true),
       has_dialog_attached_(false),
+      zoom_factor_(1.0),
       aspect_ratio_(0.0),
       inspectable_web_contents_(inspectable_web_contents),
       weak_factory_(this) {
@@ -84,6 +105,7 @@ NativeWindow::NativeWindow(
   options.Get(switches::kFrame, &has_frame_);
   options.Get(switches::kTransparent, &transparent_);
   options.Get(switches::kEnableLargerThanScreen, &enable_larger_than_screen_);
+  options.Get(switches::kNodeIntegration, &node_integration_);
 
   // Tell the content module to initialize renderer widget with transparent
   // mode.
@@ -92,6 +114,25 @@ NativeWindow::NativeWindow(
   // Read icon before window is created.
   options.Get(switches::kIcon, &icon_);
 
+  // The "preload" option must be absolute path.
+  if (options.Get(switches::kPreloadScript, &preload_script_) &&
+      !preload_script_.IsAbsolute()) {
+    LOG(ERROR) << "Path of \"preload\" script must be absolute.";
+    preload_script_.clear();
+  }
+
+  // Be compatible with old API of "node-integration" option.
+  std::string old_string_token;
+  if (options.Get(switches::kNodeIntegration, &old_string_token) &&
+      old_string_token != "disable")
+    node_integration_ = true;
+
+  // Read the web preferences.
+  options.Get(switches::kWebPreferences, &web_preferences_);
+
+  // Read the zoom factor before any navigation.
+  options.Get(switches::kZoomFactor, &zoom_factor_);
+
   WindowList::AddWindow(this);
 }
 
@@ -340,6 +381,81 @@ void NativeWindow::RendererResponsive(content::WebContents* source) {
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererResponsive());
 }
 
+void NativeWindow::AppendExtraCommandLineSwitches(
+    base::CommandLine* command_line) {
+  // Append --node-integration to renderer process.
+  command_line->AppendSwitchASCII(switches::kNodeIntegration,
+                                  node_integration_ ? "true" : "false");
+
+  // Append --preload.
+  if (!preload_script_.empty())
+    command_line->AppendSwitchPath(switches::kPreloadScript, preload_script_);
+
+  // Append --zoom-factor.
+  if (zoom_factor_ != 1.0)
+    command_line->AppendSwitchASCII(switches::kZoomFactor,
+                                    base::DoubleToString(zoom_factor_));
+
+  if (web_preferences_.IsEmpty())
+    return;
+
+  bool b;
+#if defined(OS_WIN)
+  // Check if DirectWrite is disabled.
+  if (web_preferences_.Get(switches::kDirectWrite, &b) && !b)
+    command_line->AppendSwitch(::switches::kDisableDirectWrite);
+#endif
+
+  // Check if plugins are enabled.
+  if (web_preferences_.Get("plugins", &b) && b)
+    command_line->AppendSwitch(switches::kEnablePlugins);
+
+  // This set of options are not availabe in WebPreferences, so we have to pass
+  // them via command line and enable them in renderer procss.
+  for (size_t i = 0; i < arraysize(kWebRuntimeFeatures); ++i) {
+    const char* feature = kWebRuntimeFeatures[i];
+    if (web_preferences_.Get(feature, &b))
+      command_line->AppendSwitchASCII(feature, b ? "true" : "false");
+  }
+}
+
+void NativeWindow::OverrideWebkitPrefs(content::WebPreferences* prefs) {
+  if (web_preferences_.IsEmpty())
+    return;
+
+  bool b;
+  std::vector<base::FilePath> list;
+  if (web_preferences_.Get("javascript", &b))
+    prefs->javascript_enabled = b;
+  if (web_preferences_.Get("images", &b))
+    prefs->images_enabled = b;
+  if (web_preferences_.Get("java", &b))
+    prefs->java_enabled = b;
+  if (web_preferences_.Get("text-areas-are-resizable", &b))
+    prefs->text_areas_are_resizable = b;
+  if (web_preferences_.Get("webgl", &b))
+    prefs->experimental_webgl_enabled = b;
+  if (web_preferences_.Get("webaudio", &b))
+    prefs->webaudio_enabled = b;
+  if (web_preferences_.Get("web-security", &b)) {
+    prefs->web_security_enabled = b;
+    prefs->allow_displaying_insecure_content = !b;
+    prefs->allow_running_insecure_content = !b;
+  }
+  if (web_preferences_.Get("allow-displaying-insecure-content", &b))
+    prefs->allow_displaying_insecure_content = b;
+  if (web_preferences_.Get("allow-running-insecure-content", &b))
+    prefs->allow_running_insecure_content = b;
+  if (web_preferences_.Get("extra-plugin-dirs", &list)) {
+    if (content::PluginService::GetInstance()->NPAPIPluginsSupported()) {
+      for (size_t i = 0; i < list.size(); ++i)
+        content::PluginService::GetInstance()->AddExtraPluginDir(list[i]);
+    } else {
+      LOG(WARNING) << "NPAPI plugins not supported on this platform";
+    }
+  }
+}
+
 void NativeWindow::NotifyWindowClosed() {
   if (is_closed_)
     return;

atom/browser/native_window.h

@@ -19,17 +19,23 @@
 #include "content/public/browser/readback_types.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
+#include "native_mate/persistent_dictionary.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 
 class SkRegion;
 
+namespace base {
+class CommandLine;
+}
+
 namespace brightray {
 class InspectableWebContents;
 }
 
 namespace content {
 struct NativeWebKeyboardEvent;
+struct WebPreferences;
 }
 
 namespace gfx {
@@ -183,6 +189,10 @@ class NativeWindow : public content::WebContentsObserver,
       content::WebContents*,
       const content::NativeWebKeyboardEvent& event) {}
 
+  // Called when renderer process is going to be started.
+  void AppendExtraCommandLineSwitches(base::CommandLine* command_line);
+  void OverrideWebkitPrefs(content::WebPreferences* prefs);
+
   // Public API used by platform-dependent delegates and observers to send UI
   // related notifications.
   void NotifyWindowClosed();
@@ -272,6 +282,9 @@ class NativeWindow : public content::WebContentsObserver,
   // The windows has been closed.
   bool is_closed_;
 
+  // Whether node integration is enabled.
+  bool node_integration_;
+
   // There is a dialog that has been attached to window.
   bool has_dialog_attached_;
 
@@ -279,6 +292,15 @@ class NativeWindow : public content::WebContentsObserver,
   // it should be cancelled when we can prove that the window is responsive.
   base::CancelableClosure window_unresposive_closure_;
 
+  // Web preferences.
+  mate::PersistentDictionary web_preferences_;
+
+  // The script to load before page's JavaScript starts to run.
+  base::FilePath preload_script_;
+
+  // Page's default zoom factor.
+  double zoom_factor_;
+
   // Used to maintain the aspect ratio of a view which is inside of the
   // content view.
   double aspect_ratio_;
@@ -288,7 +310,7 @@ class NativeWindow : public content::WebContentsObserver,
   brightray::InspectableWebContents* inspectable_web_contents_;
 
   // Observers of this window.
-  base::ObserverList<NativeWindowObserver> observers_;
+  ObserverList<NativeWindowObserver> observers_;
 
   base::WeakPtrFactory<NativeWindow> weak_factory_;
 

atom/browser/net/adapter_request_job.cc

@@ -0,0 +1,148 @@
+// 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/net/adapter_request_job.h"
+
+#include "base/threading/sequenced_worker_pool.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/browser/net/asar/url_request_asar_job.h"
+#include "atom/common/asar/asar_util.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_file_job.h"
+
+namespace atom {
+
+AdapterRequestJob::AdapterRequestJob(ProtocolHandler* protocol_handler,
+                                     net::URLRequest* request,
+                                     net::NetworkDelegate* network_delegate)
+    : URLRequestJob(request, network_delegate),
+      protocol_handler_(protocol_handler),
+      weak_factory_(this) {
+}
+
+void AdapterRequestJob::Start() {
+  DCHECK(!real_job_.get());
+  GetJobType();
+}
+
+void AdapterRequestJob::Kill() {
+  if (real_job_.get())  // Kill could happen when real_job_ is created.
+    real_job_->Kill();
+}
+
+bool AdapterRequestJob::ReadRawData(net::IOBuffer* buf,
+                                    int buf_size,
+                                    int *bytes_read) {
+  DCHECK(!real_job_.get());
+  // Read post-filtered data if available.
+  if (real_job_->HasFilter())
+    return real_job_->Read(buf, buf_size, bytes_read);
+  else
+    return real_job_->ReadRawData(buf, buf_size, bytes_read);
+}
+
+bool AdapterRequestJob::IsRedirectResponse(GURL* location,
+                                           int* http_status_code) {
+  DCHECK(!real_job_.get());
+  return real_job_->IsRedirectResponse(location, http_status_code);
+}
+
+net::Filter* AdapterRequestJob::SetupFilter() const {
+  DCHECK(!real_job_.get());
+  return real_job_->SetupFilter();
+}
+
+bool AdapterRequestJob::GetMimeType(std::string* mime_type) const {
+  DCHECK(!real_job_.get());
+  return real_job_->GetMimeType(mime_type);
+}
+
+bool AdapterRequestJob::GetCharset(std::string* charset) {
+  DCHECK(!real_job_.get());
+  return real_job_->GetCharset(charset);
+}
+
+void AdapterRequestJob::GetResponseInfo(net::HttpResponseInfo* info) {
+  real_job_->GetResponseInfo(info);
+}
+
+int AdapterRequestJob::GetResponseCode() const {
+  return real_job_->GetResponseCode();
+}
+
+void AdapterRequestJob::GetLoadTimingInfo(
+    net::LoadTimingInfo* load_timing_info) const {
+  real_job_->GetLoadTimingInfo(load_timing_info);
+}
+
+base::WeakPtr<AdapterRequestJob> AdapterRequestJob::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+void AdapterRequestJob::CreateErrorJobAndStart(int error_code) {
+  real_job_ = new net::URLRequestErrorJob(
+      request(), network_delegate(), error_code);
+  real_job_->Start();
+}
+
+void AdapterRequestJob::CreateStringJobAndStart(const std::string& mime_type,
+                                                const std::string& charset,
+                                                const std::string& data) {
+  real_job_ = new URLRequestStringJob(
+      request(), network_delegate(), mime_type, charset, data);
+  real_job_->Start();
+}
+
+void AdapterRequestJob::CreateBufferJobAndStart(
+    const std::string& mime_type,
+    const std::string& charset,
+    scoped_refptr<base::RefCountedBytes> data) {
+  real_job_ = new URLRequestBufferJob(
+      request(), network_delegate(), mime_type, charset, data);
+  real_job_->Start();
+}
+
+void AdapterRequestJob::CreateFileJobAndStart(const base::FilePath& path) {
+  real_job_ = asar::CreateJobFromPath(
+      path,
+      request(),
+      network_delegate(),
+      content::BrowserThread::GetBlockingPool()->
+          GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
+  real_job_->Start();
+}
+
+void AdapterRequestJob::CreateHttpJobAndStart(
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
+    const GURL& url,
+    const std::string& method,
+    const std::string& referrer) {
+  if (!url.is_valid()) {
+    CreateErrorJobAndStart(net::ERR_INVALID_URL);
+    return;
+  }
+
+  real_job_ = new URLRequestFetchJob(request_context_getter, request(),
+                                     network_delegate(), url, method, referrer);
+  real_job_->Start();
+}
+
+void AdapterRequestJob::CreateJobFromProtocolHandlerAndStart() {
+  real_job_ = protocol_handler_->MaybeCreateJob(request(),
+                                                network_delegate());
+  if (!real_job_.get()) {
+    CreateErrorJobAndStart(net::ERR_NOT_IMPLEMENTED);
+  } else {
+    // Copy headers from original request.
+    real_job_->SetExtraRequestHeaders(request()->extra_request_headers());
+    real_job_->Start();
+  }
+}
+
+}  // namespace atom

atom/browser/net/adapter_request_job.h

@@ -0,0 +1,88 @@
+// 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_NET_ADAPTER_REQUEST_JOB_H_
+#define ATOM_BROWSER_NET_ADAPTER_REQUEST_JOB_H_
+
+#include <string>
+
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/weak_ptr.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_job.h"
+#include "net/url_request/url_request_job_factory.h"
+#include "v8/include/v8.h"
+
+namespace base {
+class FilePath;
+}
+
+namespace atom {
+
+class AtomBrowserContext;
+
+// Ask JS which type of job it wants, and then delegate corresponding methods.
+class AdapterRequestJob : public net::URLRequestJob {
+ public:
+  typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
+
+  AdapterRequestJob(ProtocolHandler* protocol_handler,
+                    net::URLRequest* request,
+                    net::NetworkDelegate* network_delegate);
+
+ public:
+  // net::URLRequestJob:
+  void Start() override;
+  void Kill() override;
+  bool ReadRawData(net::IOBuffer* buf,
+                   int buf_size,
+                   int *bytes_read) override;
+  bool IsRedirectResponse(GURL* location,
+                          int* http_status_code) override;
+  net::Filter* SetupFilter() const override;
+  bool GetMimeType(std::string* mime_type) const override;
+  bool GetCharset(std::string* charset) override;
+  void GetResponseInfo(net::HttpResponseInfo* info) override;
+  int GetResponseCode() const override;
+  void GetLoadTimingInfo(
+      net::LoadTimingInfo* load_timing_info) const override;
+
+  base::WeakPtr<AdapterRequestJob> GetWeakPtr();
+
+  ProtocolHandler* default_protocol_handler() { return protocol_handler_; }
+
+  // Override this function to determine which job should be started.
+  virtual void GetJobType() = 0;
+
+  void CreateErrorJobAndStart(int error_code);
+  void CreateStringJobAndStart(const std::string& mime_type,
+                               const std::string& charset,
+                               const std::string& data);
+  void CreateBufferJobAndStart(const std::string& mime_type,
+                               const std::string& charset,
+                               scoped_refptr<base::RefCountedBytes> data);
+  void CreateFileJobAndStart(const base::FilePath& path);
+  void CreateHttpJobAndStart(
+      scoped_refptr<net::URLRequestContextGetter> request_context_getter,
+      const GURL& url,
+      const std::string& method,
+      const std::string& referrer);
+  void CreateJobFromProtocolHandlerAndStart();
+
+ private:
+  // The delegated request job.
+  scoped_refptr<net::URLRequestJob> real_job_;
+
+  // Default protocol handler.
+  ProtocolHandler* protocol_handler_;
+
+  base::WeakPtrFactory<AdapterRequestJob> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(AdapterRequestJob);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NET_ADAPTER_REQUEST_JOB_H_

atom/browser/net/asar/asar_protocol_handler.cc

@@ -5,11 +5,45 @@
 #include "atom/browser/net/asar/asar_protocol_handler.h"
 
 #include "atom/browser/net/asar/url_request_asar_job.h"
+#include "atom/common/asar/archive.h"
+#include "atom/common/asar/asar_util.h"
 #include "net/base/filename_util.h"
 #include "net/base/net_errors.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_file_job.h"
 
 namespace asar {
 
+// static
+net::URLRequestJob* CreateJobFromPath(
+    const base::FilePath& full_path,
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    const scoped_refptr<base::TaskRunner> file_task_runner) {
+  // Create asar:// job when the path contains "xxx.asar/", otherwise treat the
+  // URL request as file://.
+  base::FilePath asar_path, relative_path;
+  if (!GetAsarArchivePath(full_path, &asar_path, &relative_path))
+    return new net::URLRequestFileJob(request, network_delegate, full_path,
+                                      file_task_runner);
+
+  std::shared_ptr<Archive> archive = GetOrCreateAsarArchive(asar_path);
+  Archive::FileInfo file_info;
+  if (!archive || !archive->GetFileInfo(relative_path, &file_info))
+    return new net::URLRequestErrorJob(request, network_delegate,
+                                       net::ERR_FILE_NOT_FOUND);
+
+  if (file_info.unpacked) {
+    base::FilePath real_path;
+    archive->CopyFileOut(relative_path, &real_path);
+    return new net::URLRequestFileJob(request, network_delegate, real_path,
+                                      file_task_runner);
+  }
+
+  return new URLRequestAsarJob(request, network_delegate, archive,
+                               relative_path, file_info, file_task_runner);
+}
+
 AsarProtocolHandler::AsarProtocolHandler(
     const scoped_refptr<base::TaskRunner>& file_task_runner)
     : file_task_runner_(file_task_runner) {}
@@ -22,9 +56,8 @@ net::URLRequestJob* AsarProtocolHandler::MaybeCreateJob(
     net::NetworkDelegate* network_delegate) const {
   base::FilePath full_path;
   net::FileURLToFilePath(request->url(), &full_path);
-  URLRequestAsarJob* job = new URLRequestAsarJob(request, network_delegate);
-  job->Initialize(file_task_runner_, full_path);
-  return job;
+  return CreateJobFromPath(full_path, request, network_delegate,
+                           file_task_runner_);
 }
 
 bool AsarProtocolHandler::IsSafeRedirectTarget(const GURL& location) const {

atom/browser/net/asar/url_request_asar_job.cc

@@ -5,128 +5,48 @@
 #include "atom/browser/net/asar/url_request_asar_job.h"
 
 #include <string>
-#include <vector>
 
-#include "base/bind.h"
-#include "base/files/file_util.h"
-#include "base/strings/string_util.h"
-#include "base/synchronization/lock.h"
-#include "base/task_runner.h"
-#include "atom/common/asar/archive.h"
-#include "atom/common/asar/asar_util.h"
 #include "net/base/file_stream.h"
-#include "net/base/filename_util.h"
 #include "net/base/io_buffer.h"
-#include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
-#include "net/filter/filter.h"
-#include "net/http/http_util.h"
 #include "net/url_request/url_request_status.h"
 
-#if defined(OS_WIN)
-#include "base/win/shortcut.h"
-#endif
-
 namespace asar {
 
-URLRequestAsarJob::FileMetaInfo::FileMetaInfo()
-    : file_size(0),
-      mime_type_result(false),
-      file_exists(false),
-      is_directory(false) {
-}
-
 URLRequestAsarJob::URLRequestAsarJob(
     net::URLRequest* request,
-    net::NetworkDelegate* network_delegate)
+    net::NetworkDelegate* network_delegate,
+    std::shared_ptr<Archive> archive,
+    const base::FilePath& file_path,
+    const Archive::FileInfo& file_info,
+    const scoped_refptr<base::TaskRunner>& file_task_runner)
     : net::URLRequestJob(request, network_delegate),
-      type_(TYPE_ERROR),
+      archive_(archive),
+      file_path_(file_path),
+      file_info_(file_info),
+      stream_(new net::FileStream(file_task_runner)),
       remaining_bytes_(0),
+      file_task_runner_(file_task_runner),
       weak_ptr_factory_(this) {}
 
 URLRequestAsarJob::~URLRequestAsarJob() {}
 
-void URLRequestAsarJob::Initialize(
-    const scoped_refptr<base::TaskRunner> file_task_runner,
-    const base::FilePath& file_path) {
-  // Determine whether it is an asar file.
-  base::FilePath asar_path, relative_path;
-  if (!GetAsarArchivePath(file_path, &asar_path, &relative_path)) {
-    InitializeFileJob(file_task_runner, file_path);
-    return;
-  }
-
-  std::shared_ptr<Archive> archive = GetOrCreateAsarArchive(asar_path);
-  Archive::FileInfo file_info;
-  if (!archive || !archive->GetFileInfo(relative_path, &file_info)) {
-    type_ = TYPE_ERROR;
-    return;
-  }
-
-  if (file_info.unpacked) {
-    base::FilePath real_path;
-    archive->CopyFileOut(relative_path, &real_path);
-    InitializeFileJob(file_task_runner, real_path);
-    return;
-  }
-
-  InitializeAsarJob(file_task_runner, archive, relative_path, file_info);
-}
-
-void URLRequestAsarJob::InitializeAsarJob(
-    const scoped_refptr<base::TaskRunner> file_task_runner,
-    std::shared_ptr<Archive> archive,
-    const base::FilePath& file_path,
-    const Archive::FileInfo& file_info) {
-  type_ = TYPE_ASAR;
-  file_task_runner_ = file_task_runner;
-  stream_.reset(new net::FileStream(file_task_runner_));
-  archive_ = archive;
-  file_path_ = file_path;
-  file_info_ = file_info;
-}
-
-void URLRequestAsarJob::InitializeFileJob(
-    const scoped_refptr<base::TaskRunner> file_task_runner,
-    const base::FilePath& file_path) {
-  type_ = TYPE_FILE;
-  file_task_runner_ = file_task_runner;
-  stream_.reset(new net::FileStream(file_task_runner_));
-  file_path_ = file_path;
-}
-
 void URLRequestAsarJob::Start() {
-  if (type_ == TYPE_ASAR) {
-    remaining_bytes_ = static_cast<int64>(file_info_.size);
+  remaining_bytes_ = static_cast<int64>(file_info_.size);
 
-    int flags = base::File::FLAG_OPEN |
-                base::File::FLAG_READ |
-                base::File::FLAG_ASYNC;
-    int rv = stream_->Open(archive_->path(), flags,
-                           base::Bind(&URLRequestAsarJob::DidOpen,
-                                      weak_ptr_factory_.GetWeakPtr()));
-    if (rv != net::ERR_IO_PENDING)
-      DidOpen(rv);
-  } else if (type_ == TYPE_FILE) {
-    FileMetaInfo* meta_info = new FileMetaInfo();
-    file_task_runner_->PostTaskAndReply(
-        FROM_HERE,
-        base::Bind(&URLRequestAsarJob::FetchMetaInfo, file_path_,
-                   base::Unretained(meta_info)),
-        base::Bind(&URLRequestAsarJob::DidFetchMetaInfo,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   base::Owned(meta_info)));
-  } else {
-    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                           net::ERR_FILE_NOT_FOUND));
-  }
+  int flags = base::File::FLAG_OPEN |
+              base::File::FLAG_READ |
+              base::File::FLAG_ASYNC;
+  int rv = stream_->Open(archive_->path(), flags,
+                         base::Bind(&URLRequestAsarJob::DidOpen,
+                                    weak_ptr_factory_.GetWeakPtr()));
+  if (rv != net::ERR_IO_PENDING)
+    DidOpen(rv);
 }
 
 void URLRequestAsarJob::Kill() {
-  stream_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
-
   URLRequestJob::Kill();
 }
 
@@ -165,97 +85,8 @@ bool URLRequestAsarJob::ReadRawData(net::IOBuffer* dest,
   return false;
 }
 
-bool URLRequestAsarJob::IsRedirectResponse(GURL* location,
-                                           int* http_status_code) {
-  if (type_ != TYPE_FILE)
-    return false;
-#if defined(OS_WIN)
-  // Follow a Windows shortcut.
-  // We just resolve .lnk file, ignore others.
-  if (!base::LowerCaseEqualsASCII(file_path_.Extension(), ".lnk"))
-    return false;
-
-  base::FilePath new_path = file_path_;
-  bool resolved;
-  resolved = base::win::ResolveShortcut(new_path, &new_path, NULL);
-
-  // If shortcut is not resolved succesfully, do not redirect.
-  if (!resolved)
-    return false;
-
-  *location = net::FilePathToFileURL(new_path);
-  *http_status_code = 301;
-  return true;
-#else
-  return false;
-#endif
-}
-
-net::Filter* URLRequestAsarJob::SetupFilter() const {
-  // Bug 9936 - .svgz files needs to be decompressed.
-  return base::LowerCaseEqualsASCII(file_path_.Extension(), ".svgz")
-      ? net::Filter::GZipFactory() : NULL;
-}
-
 bool URLRequestAsarJob::GetMimeType(std::string* mime_type) const {
-  if (type_ == TYPE_ASAR) {
-    return net::GetMimeTypeFromFile(file_path_, mime_type);
-  } else {
-    if (meta_info_.mime_type_result) {
-      *mime_type = meta_info_.mime_type;
-      return true;
-    }
-    return false;
-  }
-}
-
-void URLRequestAsarJob::SetExtraRequestHeaders(
-    const net::HttpRequestHeaders& headers) {
-  std::string range_header;
-  if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) {
-    // We only care about "Range" header here.
-    std::vector<net::HttpByteRange> ranges;
-    if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) {
-      if (ranges.size() == 1) {
-        byte_range_ = ranges[0];
-      } else {
-        NotifyDone(net::URLRequestStatus(
-            net::URLRequestStatus::FAILED,
-            net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
-      }
-    }
-  }
-}
-
-void URLRequestAsarJob::FetchMetaInfo(const base::FilePath& file_path,
-                                      FileMetaInfo* meta_info) {
-  base::File::Info file_info;
-  meta_info->file_exists = base::GetFileInfo(file_path, &file_info);
-  if (meta_info->file_exists) {
-    meta_info->file_size = file_info.size;
-    meta_info->is_directory = file_info.is_directory;
-  }
-  // On Windows GetMimeTypeFromFile() goes to the registry. Thus it should be
-  // done in WorkerPool.
-  meta_info->mime_type_result =
-      net::GetMimeTypeFromFile(file_path, &meta_info->mime_type);
-}
-
-void URLRequestAsarJob::DidFetchMetaInfo(const FileMetaInfo* meta_info) {
-  meta_info_ = *meta_info;
-  if (!meta_info_.file_exists || meta_info_.is_directory) {
-    DidOpen(net::ERR_FILE_NOT_FOUND);
-    return;
-  }
-
-  int flags = base::File::FLAG_OPEN |
-              base::File::FLAG_READ |
-              base::File::FLAG_ASYNC;
-  int rv = stream_->Open(file_path_, flags,
-                         base::Bind(&URLRequestAsarJob::DidOpen,
-                                    weak_ptr_factory_.GetWeakPtr()));
-  if (rv != net::ERR_IO_PENDING)
-    DidOpen(rv);
+  return net::GetMimeTypeFromFile(file_path_, mime_type);
 }
 
 void URLRequestAsarJob::DidOpen(int result) {
@@ -264,57 +95,24 @@ void URLRequestAsarJob::DidOpen(int result) {
     return;
   }
 
-  if (type_ == TYPE_ASAR) {
-    int rv = stream_->Seek(file_info_.offset,
-                           base::Bind(&URLRequestAsarJob::DidSeek,
-                                      weak_ptr_factory_.GetWeakPtr()));
-    if (rv != net::ERR_IO_PENDING) {
-      // stream_->Seek() failed, so pass an intentionally erroneous value
-      // into DidSeek().
-      DidSeek(-1);
-    }
-  } else {
-    if (!byte_range_.ComputeBounds(meta_info_.file_size)) {
-      NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                 net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
-      return;
-    }
-
-    remaining_bytes_ = byte_range_.last_byte_position() -
-                       byte_range_.first_byte_position() + 1;
-
-    if (remaining_bytes_ > 0 && byte_range_.first_byte_position() != 0) {
-      int rv = stream_->Seek(byte_range_.first_byte_position(),
-                             base::Bind(&URLRequestAsarJob::DidSeek,
-                                        weak_ptr_factory_.GetWeakPtr()));
-      if (rv != net::ERR_IO_PENDING) {
-        // stream_->Seek() failed, so pass an intentionally erroneous value
-        // into DidSeek().
-        DidSeek(-1);
-      }
-    } else {
-      // We didn't need to call stream_->Seek() at all, so we pass to DidSeek()
-      // the value that would mean seek success. This way we skip the code
-      // handling seek failure.
-      DidSeek(byte_range_.first_byte_position());
-    }
+  int rv = stream_->Seek(base::File::FROM_BEGIN,
+                         file_info_.offset,
+                         base::Bind(&URLRequestAsarJob::DidSeek,
+                                    weak_ptr_factory_.GetWeakPtr()));
+  if (rv != net::ERR_IO_PENDING) {
+    // stream_->Seek() failed, so pass an intentionally erroneous value
+    // into DidSeek().
+    DidSeek(-1);
   }
 }
 
 void URLRequestAsarJob::DidSeek(int64 result) {
-  if (type_ == TYPE_ASAR) {
-    if (result != static_cast<int64>(file_info_.offset)) {
-      NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                       net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
-      return;
-    }
-  } else {
-    if (result != byte_range_.first_byte_position()) {
-      NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                       net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
-      return;
-    }
+  if (result != static_cast<int64>(file_info_.offset)) {
+    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                     net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
+    return;
   }
+
   set_expected_content_size(remaining_bytes_);
   NotifyHeadersComplete();
 }

atom/browser/net/asar/url_request_asar_job.h

@@ -8,12 +8,10 @@
 #include <memory>
 #include <string>
 
-#include "atom/browser/net/js_asker.h"
 #include "atom/common/asar/archive.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "net/http/http_byte_range.h"
 #include "net/url_request/url_request_job.h"
 
 namespace base {
@@ -36,20 +34,11 @@ net::URLRequestJob* CreateJobFromPath(
 class URLRequestAsarJob : public net::URLRequestJob {
  public:
   URLRequestAsarJob(net::URLRequest* request,
-                    net::NetworkDelegate* network_delegate);
-
-  void Initialize(const scoped_refptr<base::TaskRunner> file_task_runner,
-                  const base::FilePath& file_path);
-
- protected:
-  virtual ~URLRequestAsarJob();
-
-  void InitializeAsarJob(const scoped_refptr<base::TaskRunner> file_task_runner,
-                         std::shared_ptr<Archive> archive,
-                         const base::FilePath& file_path,
-                         const Archive::FileInfo& file_info);
-  void InitializeFileJob(const scoped_refptr<base::TaskRunner> file_task_runner,
-                         const base::FilePath& file_path);
+                    net::NetworkDelegate* network_delegate,
+                    std::shared_ptr<Archive> archive,
+                    const base::FilePath& file_path,
+                    const Archive::FileInfo& file_info,
+                    const scoped_refptr<base::TaskRunner>& file_task_runner);
 
   // net::URLRequestJob:
   void Start() override;
@@ -57,39 +46,12 @@ class URLRequestAsarJob : public net::URLRequestJob {
   bool ReadRawData(net::IOBuffer* buf,
                    int buf_size,
                    int* bytes_read) override;
-  bool IsRedirectResponse(GURL* location, int* http_status_code) override;
-  net::Filter* SetupFilter() const override;
   bool GetMimeType(std::string* mime_type) const override;
-  void SetExtraRequestHeaders(const net::HttpRequestHeaders& headers) override;
+
+ protected:
+  virtual ~URLRequestAsarJob();
 
  private:
-  // Meta information about the file. It's used as a member in the
-  // URLRequestFileJob and also passed between threads because disk access is
-  // necessary to obtain it.
-  struct FileMetaInfo {
-    FileMetaInfo();
-
-    // Size of the file.
-    int64 file_size;
-    // Mime type associated with the file.
-    std::string mime_type;
-    // Result returned from GetMimeTypeFromFile(), i.e. flag showing whether
-    // obtaining of the mime type was successful.
-    bool mime_type_result;
-    // Flag showing whether the file exists.
-    bool file_exists;
-    // Flag showing whether the file name actually refers to a directory.
-    bool is_directory;
-  };
-
-  // Fetches file info on a background thread.
-  static void FetchMetaInfo(const base::FilePath& file_path,
-                            FileMetaInfo* meta_info);
-
-  // Callback after fetching file info on a background thread.
-  void DidFetchMetaInfo(const FileMetaInfo* meta_info);
-
-
   // Callback after opening file on a background thread.
   void DidOpen(int result);
 
@@ -100,25 +62,15 @@ class URLRequestAsarJob : public net::URLRequestJob {
   // Callback after data is asynchronously read from the file into |buf|.
   void DidRead(scoped_refptr<net::IOBuffer> buf, int result);
 
-  // The type of this job.
-  enum JobType {
-    TYPE_ERROR,
-    TYPE_ASAR,
-    TYPE_FILE,
-  };
-  JobType type_;
-
   std::shared_ptr<Archive> archive_;
   base::FilePath file_path_;
   Archive::FileInfo file_info_;
 
   scoped_ptr<net::FileStream> stream_;
-  FileMetaInfo meta_info_;
-  scoped_refptr<base::TaskRunner> file_task_runner_;
-
-  net::HttpByteRange byte_range_;
   int64 remaining_bytes_;
 
+  const scoped_refptr<base::TaskRunner> file_task_runner_;
+
   base::WeakPtrFactory<URLRequestAsarJob> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestAsarJob);

atom/browser/net/atom_url_request_job_factory.cc

@@ -23,7 +23,10 @@ AtomURLRequestJobFactory::~AtomURLRequestJobFactory() {
 }
 
 bool AtomURLRequestJobFactory::SetProtocolHandler(
-    const std::string& scheme, scoped_ptr<ProtocolHandler> protocol_handler) {
+    const std::string& scheme,
+    ProtocolHandler* protocol_handler) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (!protocol_handler) {
     ProtocolHandlerMap::iterator it = protocol_handler_map_.find(scheme);
     if (it == protocol_handler_map_.end())
@@ -36,17 +39,21 @@ bool AtomURLRequestJobFactory::SetProtocolHandler(
 
   if (ContainsKey(protocol_handler_map_, scheme))
     return false;
-  protocol_handler_map_[scheme] = protocol_handler.release();
+  protocol_handler_map_[scheme] = protocol_handler;
   return true;
 }
 
-scoped_ptr<ProtocolHandler> AtomURLRequestJobFactory::ReplaceProtocol(
-    const std::string& scheme, scoped_ptr<ProtocolHandler> protocol_handler) {
+ProtocolHandler* AtomURLRequestJobFactory::ReplaceProtocol(
+    const std::string& scheme,
+    ProtocolHandler* protocol_handler) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(protocol_handler);
+
   if (!ContainsKey(protocol_handler_map_, scheme))
     return nullptr;
   ProtocolHandler* original_protocol_handler = protocol_handler_map_[scheme];
-  protocol_handler_map_[scheme] = protocol_handler.release();
-  return make_scoped_ptr(original_protocol_handler);
+  protocol_handler_map_[scheme] = protocol_handler;
+  return original_protocol_handler;
 }
 
 ProtocolHandler* AtomURLRequestJobFactory::GetProtocolHandler(

atom/browser/net/atom_url_request_job_factory.h

@@ -10,7 +10,8 @@
 #include <string>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/synchronization/lock.h"
 #include "net/url_request/url_request_job_factory.h"
 
@@ -24,13 +25,13 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
   // Sets the ProtocolHandler for a scheme. Returns true on success, false on
   // failure (a ProtocolHandler already exists for |scheme|). On success,
   // URLRequestJobFactory takes ownership of |protocol_handler|.
-  bool SetProtocolHandler(
-      const std::string& scheme, scoped_ptr<ProtocolHandler> protocol_handler);
+  bool SetProtocolHandler(const std::string& scheme,
+                          ProtocolHandler* protocol_handler);
 
   // Intercepts the ProtocolHandler for a scheme. Returns the original protocol
   // handler on success, otherwise returns NULL.
-  scoped_ptr<ProtocolHandler> ReplaceProtocol(
-      const std::string& scheme, scoped_ptr<ProtocolHandler> protocol_handler);
+  ProtocolHandler* ReplaceProtocol(const std::string& scheme,
+                                     ProtocolHandler* protocol_handler);
 
   // Returns the protocol handler registered with scheme.
   ProtocolHandler* GetProtocolHandler(const std::string& scheme) const;

atom/browser/net/js_asker.cc

@@ -1,131 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/net/js_asker.h"
-
-#include <vector>
-
-#include "atom/common/native_mate_converters/callback.h"
-#include "atom/common/native_mate_converters/v8_value_converter.h"
-#include "native_mate/function_template.h"
-
-namespace atom {
-
-namespace internal {
-
-namespace {
-
-struct CallbackHolder {
-  ResponseCallback callback;
-};
-
-// Cached JavaScript version of |HandlerCallback|.
-v8::Persistent<v8::FunctionTemplate> g_handler_callback_;
-
-// The callback which is passed to |handler|.
-void HandlerCallback(v8::Isolate* isolate,
-                     v8::Local<v8::External> external,
-                     v8::Local<v8::Object> state,
-                     mate::Arguments* args) {
-  // Check if the callback has already been called.
-  v8::Local<v8::String> called_symbol = mate::StringToSymbol(isolate, "called");
-  if (state->Has(called_symbol))
-    return;  // no nothing
-  else
-    state->Set(called_symbol, v8::Boolean::New(isolate, true));
-
-  // If there is no argument passed then we failed.
-  scoped_ptr<CallbackHolder> holder(
-      static_cast<CallbackHolder*>(external->Value()));
-  CHECK(holder);
-  v8::Local<v8::Value> value;
-  if (!args->GetNext(&value)) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(holder->callback, false, nullptr));
-    return;
-  }
-
-  // Pass whatever user passed to the actaul request job.
-  V8ValueConverter converter;
-  v8::Local<v8::Context> context = args->isolate()->GetCurrentContext();
-  scoped_ptr<base::Value> options(converter.FromV8Value(value, context));
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(holder->callback, true, base::Passed(&options)));
-}
-
-// func.bind(func, arg1, arg2).
-// NB(zcbenz): Using C++11 version crashes VS.
-v8::Local<v8::Value> BindFunctionWith(v8::Isolate* isolate,
-                                      v8::Local<v8::Context> context,
-                                      v8::Local<v8::Function> func,
-                                      v8::Local<v8::Value> arg1,
-                                      v8::Local<v8::Value> arg2) {
-  v8::MaybeLocal<v8::Value> bind = func->Get(mate::StringToV8(isolate, "bind"));
-  CHECK(!bind.IsEmpty());
-  v8::Local<v8::Function> bind_func =
-      v8::Local<v8::Function>::Cast(bind.ToLocalChecked());
-  v8::Local<v8::Value> converted[] = { func, arg1, arg2 };
-  return bind_func->Call(
-      context, func, arraysize(converted), converted).ToLocalChecked();
-}
-
-// Generate the callback that will be passed to |handler|.
-v8::MaybeLocal<v8::Value> GenerateCallback(v8::Isolate* isolate,
-                                           v8::Local<v8::Context> context,
-                                           const ResponseCallback& callback) {
-  // The FunctionTemplate is cached.
-  if (g_handler_callback_.IsEmpty())
-    g_handler_callback_.Reset(
-        isolate,
-        mate::CreateFunctionTemplate(isolate, base::Bind(&HandlerCallback)));
-
-  v8::Local<v8::FunctionTemplate> handler_callback =
-      v8::Local<v8::FunctionTemplate>::New(isolate, g_handler_callback_);
-  CallbackHolder* holder = new CallbackHolder;
-  holder->callback = callback;
-  return BindFunctionWith(isolate, context, handler_callback->GetFunction(),
-                          v8::External::New(isolate, holder),
-                          v8::Object::New(isolate));
-}
-
-}  // namespace
-
-void AskForOptions(v8::Isolate* isolate,
-                   const JavaScriptHandler& handler,
-                   net::URLRequest* request,
-                   const ResponseCallback& callback) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  v8::Locker locker(isolate);
-  v8::HandleScope handle_scope(isolate);
-  v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Context::Scope context_scope(context);
-  // We don't convert the callback to C++ directly because creating
-  // FunctionTemplate will cause memory leak since V8 never releases it. So we
-  // have to create the function object in JavaScript to work around it.
-  v8::MaybeLocal<v8::Value> wrapped_callback = GenerateCallback(
-      isolate, context, callback);
-  if (wrapped_callback.IsEmpty()) {
-    callback.Run(false, nullptr);
-    return;
-  }
-  handler.Run(request, wrapped_callback.ToLocalChecked());
-}
-
-bool IsErrorOptions(base::Value* value, int* error) {
-  if (value->IsType(base::Value::TYPE_DICTIONARY)) {
-    base::DictionaryValue* dict = static_cast<base::DictionaryValue*>(value);
-    if (dict->GetInteger("error", error))
-      return true;
-  } else if (value->IsType(base::Value::TYPE_INTEGER)) {
-    if (value->GetAsInteger(error))
-      return true;
-  }
-  return false;
-}
-
-}  // namespace internal
-
-}  // namespace atom

atom/browser/net/js_asker.h

@@ -1,102 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_NET_JS_ASKER_H_
-#define ATOM_BROWSER_NET_JS_ASKER_H_
-
-#include "base/callback.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "base/values.h"
-#include "content/public/browser/browser_thread.h"
-#include "net/base/net_errors.h"
-#include "net/http/http_response_headers.h"
-#include "net/url_request/url_request_context_getter.h"
-#include "net/url_request/url_request_job.h"
-#include "v8/include/v8.h"
-
-namespace atom {
-
-using JavaScriptHandler =
-    base::Callback<void(const net::URLRequest*, v8::Local<v8::Value>)>;
-
-namespace internal {
-
-using ResponseCallback =
-    base::Callback<void(bool, scoped_ptr<base::Value> options)>;
-
-// Ask handler for options in UI thread.
-void AskForOptions(v8::Isolate* isolate,
-                   const JavaScriptHandler& handler,
-                   net::URLRequest* request,
-                   const ResponseCallback& callback);
-
-// Test whether the |options| means an error.
-bool IsErrorOptions(base::Value* value, int* error);
-
-}  // namespace internal
-
-template<typename RequestJob>
-class JsAsker : public RequestJob {
- public:
-  JsAsker(net::URLRequest* request, net::NetworkDelegate* network_delegate)
-      : RequestJob(request, network_delegate), weak_factory_(this) {}
-
-  // Called by |CustomProtocolHandler| to store handler related information.
-  void SetHandlerInfo(
-      v8::Isolate* isolate,
-      scoped_refptr<net::URLRequestContextGetter> request_context_getter,
-      const JavaScriptHandler& handler) {
-    isolate_ = isolate;
-    request_context_getter_ = request_context_getter;
-    handler_ = handler;
-  }
-
-  // Subclass should do initailze work here.
-  virtual void StartAsync(scoped_ptr<base::Value> options) = 0;
-
-  net::URLRequestContextGetter* request_context_getter() const {
-    return request_context_getter_.get();
-  }
-
- private:
-  // RequestJob:
-  void Start() override {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&internal::AskForOptions,
-                   isolate_,
-                   handler_,
-                   RequestJob::request(),
-                   base::Bind(&JsAsker::OnResponse,
-                              weak_factory_.GetWeakPtr())));
-  }
-  void GetResponseInfo(net::HttpResponseInfo* info) override {
-    info->headers = new net::HttpResponseHeaders("");
-  }
-
-  // Called when the JS handler has sent the response, we need to decide whether
-  // to start, or fail the job.
-  void OnResponse(bool success, scoped_ptr<base::Value> value) {
-    int error = net::ERR_NOT_IMPLEMENTED;
-    if (success && value && !internal::IsErrorOptions(value.get(), &error)) {
-      StartAsync(value.Pass());
-    } else {
-      RequestJob::NotifyStartError(
-          net::URLRequestStatus(net::URLRequestStatus::FAILED, error));
-    }
-  }
-
-  v8::Isolate* isolate_;
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
-  JavaScriptHandler handler_;
-
-  base::WeakPtrFactory<JsAsker> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(JsAsker);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_NET_JS_ASKER_H_

atom/browser/net/url_request_async_asar_job.cc

@@ -1,37 +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/net/url_request_async_asar_job.h"
-
-namespace atom {
-
-UrlRequestAsyncAsarJob::UrlRequestAsyncAsarJob(
-    net::URLRequest* request,
-    net::NetworkDelegate* network_delegate)
-    : JsAsker<asar::URLRequestAsarJob>(request, network_delegate) {
-}
-
-void UrlRequestAsyncAsarJob::StartAsync(scoped_ptr<base::Value> options) {
-  base::FilePath::StringType file_path;
-  if (options->IsType(base::Value::TYPE_DICTIONARY)) {
-    static_cast<base::DictionaryValue*>(options.get())->GetString(
-        "path", &file_path);
-  } else if (options->IsType(base::Value::TYPE_STRING)) {
-    options->GetAsString(&file_path);
-  }
-
-  if (file_path.empty()) {
-    NotifyStartError(net::URLRequestStatus(
-          net::URLRequestStatus::FAILED, net::ERR_NOT_IMPLEMENTED));
-  } else {
-    asar::URLRequestAsarJob::Initialize(
-        content::BrowserThread::GetBlockingPool()->
-            GetTaskRunnerWithShutdownBehavior(
-                base::SequencedWorkerPool::SKIP_ON_SHUTDOWN),
-        base::FilePath(file_path));
-    asar::URLRequestAsarJob::Start();
-  }
-}
-
-}  // namespace atom

atom/browser/net/url_request_async_asar_job.h

@@ -1,27 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_NET_URL_REQUEST_ASYNC_ASAR_JOB_H_
-#define ATOM_BROWSER_NET_URL_REQUEST_ASYNC_ASAR_JOB_H_
-
-#include "atom/browser/net/asar/url_request_asar_job.h"
-#include "atom/browser/net/js_asker.h"
-
-namespace atom {
-
-// Like URLRequestAsarJob, but asks the JavaScript handler for file path.
-class UrlRequestAsyncAsarJob : public JsAsker<asar::URLRequestAsarJob> {
- public:
-  UrlRequestAsyncAsarJob(net::URLRequest*, net::NetworkDelegate*);
-
-  // JsAsker:
-  void StartAsync(scoped_ptr<base::Value> options) override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(UrlRequestAsyncAsarJob);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_NET_URL_REQUEST_ASYNC_ASAR_JOB_H_

atom/browser/net/url_request_buffer_job.cc

@@ -11,32 +11,15 @@
 namespace atom {
 
 URLRequestBufferJob::URLRequestBufferJob(
-    net::URLRequest* request, net::NetworkDelegate* network_delegate)
-    : JsAsker<net::URLRequestSimpleJob>(request, network_delegate) {
-}
-
-void URLRequestBufferJob::StartAsync(scoped_ptr<base::Value> options) {
-  const base::BinaryValue* binary = nullptr;
-  if (options->IsType(base::Value::TYPE_DICTIONARY)) {
-    base::DictionaryValue* dict =
-        static_cast<base::DictionaryValue*>(options.get());
-    dict->GetString("mimeType", &mime_type_);
-    dict->GetString("charset", &charset_);
-    dict->GetBinary("data", &binary);
-  } else if (options->IsType(base::Value::TYPE_BINARY)) {
-    options->GetAsBinary(&binary);
-  }
-
-  if (!binary) {
-    NotifyStartError(net::URLRequestStatus(
-          net::URLRequestStatus::FAILED, net::ERR_NOT_IMPLEMENTED));
-    return;
-  }
-
-  data_ = new base::RefCountedBytes(
-      reinterpret_cast<const unsigned char*>(binary->GetBuffer()),
-      binary->GetSize());
-  net::URLRequestSimpleJob::Start();
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    const std::string& mime_type,
+    const std::string& charset,
+    scoped_refptr<base::RefCountedBytes> data)
+    : net::URLRequestSimpleJob(request, network_delegate),
+      mime_type_(mime_type),
+      charset_(charset),
+      buffer_data_(data) {
 }
 
 int URLRequestBufferJob::GetRefCountedData(
@@ -46,7 +29,7 @@ int URLRequestBufferJob::GetRefCountedData(
     const net::CompletionCallback& callback) const {
   *mime_type = mime_type_;
   *charset = charset_;
-  *data = data_;
+  *data = buffer_data_;
   return net::OK;
 }
 

atom/browser/net/url_request_buffer_job.h

@@ -7,18 +7,19 @@
 
 #include <string>
 
-#include "atom/browser/net/js_asker.h"
 #include "base/memory/ref_counted_memory.h"
 #include "net/url_request/url_request_simple_job.h"
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
-class URLRequestBufferJob : public JsAsker<net::URLRequestSimpleJob> {
+class URLRequestBufferJob : public net::URLRequestSimpleJob {
  public:
-  URLRequestBufferJob(net::URLRequest*, net::NetworkDelegate*);
-
-  // JsAsker:
-  void StartAsync(scoped_ptr<base::Value> options) override;
+  URLRequestBufferJob(net::URLRequest* request,
+                      net::NetworkDelegate* network_delegate,
+                      const std::string& mime_type,
+                      const std::string& charset,
+                      scoped_refptr<base::RefCountedBytes> data);
 
   // URLRequestSimpleJob:
   int GetRefCountedData(std::string* mime_type,
@@ -29,7 +30,7 @@ class URLRequestBufferJob : public JsAsker<net::URLRequestSimpleJob> {
  private:
   std::string mime_type_;
   std::string charset_;
-  scoped_refptr<base::RefCountedBytes> data_;
+  scoped_refptr<base::RefCountedBytes> buffer_data_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestBufferJob);
 };

atom/browser/net/url_request_fetch_job.cc

@@ -23,7 +23,7 @@ namespace {
 
 // Convert string to RequestType.
 net::URLFetcher::RequestType GetRequestType(const std::string& raw) {
-  std::string method = base::StringToUpperASCII(raw);
+  std::string method = StringToUpperASCII(raw);
   if (method.empty() || method == "GET")
     return net::URLFetcher::GET;
   else if (method == "POST")
@@ -75,65 +75,42 @@ class ResponsePiper : public net::URLFetcherResponseWriter {
 }  // namespace
 
 URLRequestFetchJob::URLRequestFetchJob(
-    net::URLRequest* request, net::NetworkDelegate* network_delegate)
-    : JsAsker<net::URLRequestJob>(request, network_delegate),
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    const GURL& url,
+    const std::string& method,
+    const std::string& referrer)
+    : net::URLRequestJob(request, network_delegate),
       pending_buffer_size_(0) {
-}
-
-void URLRequestFetchJob::StartAsync(scoped_ptr<base::Value> options) {
-  if (!options->IsType(base::Value::TYPE_DICTIONARY)) {
-    NotifyStartError(net::URLRequestStatus(
-          net::URLRequestStatus::FAILED, net::ERR_NOT_IMPLEMENTED));
-    return;
-  }
-
-  std::string url, method, referrer;
-  base::Value* session = nullptr;
-  base::DictionaryValue* dict =
-      static_cast<base::DictionaryValue*>(options.get());
-  dict->GetString("url", &url);
-  dict->GetString("method", &method);
-  dict->GetString("referrer", &referrer);
-  dict->Get("session", &session);
-
-  // Check if URL is valid.
-  GURL formated_url(url);
-  if (!formated_url.is_valid()) {
-    NotifyStartError(net::URLRequestStatus(
-          net::URLRequestStatus::FAILED, net::ERR_INVALID_URL));
-    return;
-  }
-
   // Use |request|'s method if |method| is not specified.
   net::URLFetcher::RequestType request_type;
   if (method.empty())
-    request_type = GetRequestType(request()->method());
+    request_type = GetRequestType(request->method());
   else
     request_type = GetRequestType(method);
 
-  fetcher_ = net::URLFetcher::Create(formated_url, request_type, this);
+  fetcher_.reset(net::URLFetcher::Create(url, request_type, this));
+  // Use request context if provided else create one.
+  if (request_context_getter)
+    fetcher_->SetRequestContext(request_context_getter.get());
+  else
+    fetcher_->SetRequestContext(GetRequestContext());
+
   fetcher_->SaveResponseWithWriter(make_scoped_ptr(new ResponsePiper(this)));
 
-  // When |session| is set to |null| we use a new request context for fetch job.
-  if (session && session->IsType(base::Value::TYPE_NULL))
-    fetcher_->SetRequestContext(CreateRequestContext());
-  else
-    fetcher_->SetRequestContext(request_context_getter());
-
   // Use |request|'s referrer if |referrer| is not specified.
-  if (referrer.empty())
-    fetcher_->SetReferrer(request()->referrer());
-  else
+  if (referrer.empty()) {
+    fetcher_->SetReferrer(request->referrer());
+  } else {
     fetcher_->SetReferrer(referrer);
+  }
 
   // Use |request|'s headers.
-  fetcher_->SetExtraRequestHeaders(
-      request()->extra_request_headers().ToString());
-
-  fetcher_->Start();
+  fetcher_->SetExtraRequestHeaders(request->extra_request_headers().ToString());
 }
 
-net::URLRequestContextGetter* URLRequestFetchJob::CreateRequestContext() {
+net::URLRequestContextGetter* URLRequestFetchJob::GetRequestContext() {
   if (!url_request_context_getter_.get()) {
     auto task_runner = base::ThreadTaskRunnerHandle::Get();
     net::URLRequestContextBuilder builder;
@@ -173,8 +150,12 @@ int URLRequestFetchJob::DataAvailable(net::IOBuffer* buffer, int num_bytes) {
   return bytes_read;
 }
 
+void URLRequestFetchJob::Start() {
+  fetcher_->Start();
+}
+
 void URLRequestFetchJob::Kill() {
-  JsAsker<URLRequestJob>::Kill();
+  URLRequestJob::Kill();
   fetcher_.reset();
 }
 

atom/browser/net/url_request_fetch_job.h

@@ -7,7 +7,6 @@
 
 #include <string>
 
-#include "atom/browser/net/js_asker.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_job.h"
@@ -16,20 +15,22 @@ namespace atom {
 
 class AtomBrowserContext;
 
-class URLRequestFetchJob : public JsAsker<net::URLRequestJob>,
+class URLRequestFetchJob : public net::URLRequestJob,
                            public net::URLFetcherDelegate {
  public:
-  URLRequestFetchJob(net::URLRequest*, net::NetworkDelegate*);
+  URLRequestFetchJob(scoped_refptr<net::URLRequestContextGetter> context_getter,
+                     net::URLRequest* request,
+                     net::NetworkDelegate* network_delegate,
+                     const GURL& url,
+                     const std::string& method,
+                     const std::string& referrer);
 
-  // Called by response writer.
+  net::URLRequestContextGetter* GetRequestContext();
   void HeadersCompleted();
   int DataAvailable(net::IOBuffer* buffer, int num_bytes);
 
- protected:
-  // JsAsker:
-  void StartAsync(scoped_ptr<base::Value> options) override;
-
   // net::URLRequestJob:
+  void Start() override;
   void Kill() override;
   bool ReadRawData(net::IOBuffer* buf,
                    int buf_size,
@@ -42,9 +43,6 @@ class URLRequestFetchJob : public JsAsker<net::URLRequestJob>,
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
  private:
-  // Create a independent request context.
-  net::URLRequestContextGetter* CreateRequestContext();
-
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   scoped_ptr<net::URLFetcher> fetcher_;
   scoped_refptr<net::IOBuffer> pending_buffer_;

atom/browser/net/url_request_string_job.cc

@@ -10,22 +10,15 @@
 
 namespace atom {
 
-URLRequestStringJob::URLRequestStringJob(
-    net::URLRequest* request, net::NetworkDelegate* network_delegate)
-    : JsAsker<net::URLRequestSimpleJob>(request, network_delegate) {
-}
-
-void URLRequestStringJob::StartAsync(scoped_ptr<base::Value> options) {
-  if (options->IsType(base::Value::TYPE_DICTIONARY)) {
-    base::DictionaryValue* dict =
-        static_cast<base::DictionaryValue*>(options.get());
-    dict->GetString("mimeType", &mime_type_);
-    dict->GetString("charset", &charset_);
-    dict->GetString("data", &data_);
-  } else if (options->IsType(base::Value::TYPE_STRING)) {
-    options->GetAsString(&data_);
-  }
-  net::URLRequestSimpleJob::Start();
+URLRequestStringJob::URLRequestStringJob(net::URLRequest* request,
+                                         net::NetworkDelegate* network_delegate,
+                                         const std::string& mime_type,
+                                         const std::string& charset,
+                                         const std::string& data)
+    : net::URLRequestSimpleJob(request, network_delegate),
+      mime_type_(mime_type),
+      charset_(charset),
+      data_(data) {
 }
 
 int URLRequestStringJob::GetData(

atom/browser/net/url_request_string_job.h

@@ -5,19 +5,19 @@
 #ifndef ATOM_BROWSER_NET_URL_REQUEST_STRING_JOB_H_
 #define ATOM_BROWSER_NET_URL_REQUEST_STRING_JOB_H_
 
-#include <string>
-
-#include "atom/browser/net/js_asker.h"
 #include "net/url_request/url_request_simple_job.h"
 
+#include <string>
+
 namespace atom {
 
-class URLRequestStringJob : public JsAsker<net::URLRequestSimpleJob> {
+class URLRequestStringJob : public net::URLRequestSimpleJob {
  public:
-  URLRequestStringJob(net::URLRequest*, net::NetworkDelegate*);
-
-  // JsAsker:
-  void StartAsync(scoped_ptr<base::Value> options) override;
+  URLRequestStringJob(net::URLRequest* request,
+                      net::NetworkDelegate* network_delegate,
+                      const std::string& mime_type,
+                      const std::string& charset,
+                      const std::string& data);
 
   // URLRequestSimpleJob:
   int GetData(std::string* mime_type,

atom/browser/node_debugger.cc

@@ -1,209 +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/node_debugger.h"
-
-#include <string>
-
-#include "base/bind.h"
-#include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "content/public/browser/browser_thread.h"
-#include "net/test/embedded_test_server/tcp_listen_socket.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace {
-
-// NodeDebugger is stored in Isolate's data, slots 0, 1, 3 have already been
-// taken by gin, blink and node, using 2 is a safe option for now.
-const int kIsolateSlot = 2;
-
-const char* kContentLength = "Content-Length";
-
-}  // namespace
-
-NodeDebugger::NodeDebugger(v8::Isolate* isolate)
-    : isolate_(isolate),
-      thread_("NodeDebugger"),
-      content_length_(-1),
-      weak_factory_(this) {
-  bool use_debug_agent = false;
-  int port = 5858;
-  bool wait_for_connection = false;
-
-  std::string port_str;
-  base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
-  if (cmd->HasSwitch("debug")) {
-    use_debug_agent = true;
-    port_str = cmd->GetSwitchValueASCII("debug");
-  }
-  if (cmd->HasSwitch("debug-brk")) {
-    use_debug_agent = true;
-    wait_for_connection = true;
-    port_str = cmd->GetSwitchValueASCII("debug-brk");
-  }
-
-  if (use_debug_agent) {
-    if (!port_str.empty())
-      base::StringToInt(port_str, &port);
-
-    isolate_->SetData(kIsolateSlot, this);
-    v8::Debug::SetMessageHandler(DebugMessageHandler);
-
-    if (wait_for_connection)
-      v8::Debug::DebugBreak(isolate_);
-
-    uv_async_init(uv_default_loop(), &weak_up_ui_handle_, ProcessMessageInUI);
-
-    // Start a new IO thread.
-    base::Thread::Options options;
-    options.message_loop_type = base::MessageLoop::TYPE_IO;
-    if (!thread_.StartWithOptions(options)) {
-      LOG(ERROR) << "Unable to start debugger thread";
-      return;
-    }
-
-    // Start the server in new IO thread.
-    thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&NodeDebugger::StartServer, weak_factory_.GetWeakPtr(),
-                   port));
-  }
-}
-
-NodeDebugger::~NodeDebugger() {
-  thread_.Stop();
-}
-
-bool NodeDebugger::IsRunning() const {
-  return thread_.IsRunning();
-}
-
-void NodeDebugger::StartServer(int port) {
-  server_ = net::test_server::TCPListenSocket::CreateAndListen(
-      "127.0.0.1", port, this);
-  if (!server_) {
-    LOG(ERROR) << "Cannot start debugger server";
-    return;
-  }
-}
-
-void NodeDebugger::CloseSession() {
-  accepted_socket_.reset();
-}
-
-void NodeDebugger::OnMessage(const std::string& message) {
-  if (message.find("\"type\":\"request\",\"command\":\"disconnect\"}") !=
-          std::string::npos)
-    CloseSession();
-
-  base::string16 message16 = base::UTF8ToUTF16(message);
-  v8::Debug::SendCommand(
-      isolate_,
-      reinterpret_cast<const uint16_t*>(message16.data()), message16.size());
-
-  uv_async_send(&weak_up_ui_handle_);
-}
-
-void NodeDebugger::SendMessage(const std::string& message) {
-  if (accepted_socket_) {
-    std::string header = base::StringPrintf(
-        "%s: %d\r\n\r\n", kContentLength, static_cast<int>(message.size()));
-    accepted_socket_->Send(header);
-    accepted_socket_->Send(message);
-  }
-}
-
-void NodeDebugger::SendConnectMessage() {
-  accepted_socket_->Send(base::StringPrintf(
-      "Type: connect\r\n"
-      "V8-Version: %s\r\n"
-      "Protocol-Version: 1\r\n"
-      "Embedding-Host: %s\r\n"
-      "%s: 0\r\n",
-      v8::V8::GetVersion(), ATOM_PRODUCT_NAME, kContentLength), true);
-}
-
-// static
-void NodeDebugger::ProcessMessageInUI(uv_async_t* handle) {
-  v8::Debug::ProcessDebugMessages();
-}
-
-// static
-void NodeDebugger::DebugMessageHandler(const v8::Debug::Message& message) {
-  NodeDebugger* self = static_cast<NodeDebugger*>(
-      message.GetIsolate()->GetData(kIsolateSlot));
-
-  if (self) {
-    std::string message8(*v8::String::Utf8Value(message.GetJSON()));
-    self->thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&NodeDebugger::SendMessage, self->weak_factory_.GetWeakPtr(),
-                   message8));
-  }
-}
-
-void NodeDebugger::DidAccept(
-    net::test_server::StreamListenSocket* server,
-    scoped_ptr<net::test_server::StreamListenSocket> socket) {
-  // Only accept one session.
-  if (accepted_socket_) {
-    socket->Send(std::string("Remote debugging session already active"), true);
-    return;
-  }
-
-  accepted_socket_ = socket.Pass();
-  SendConnectMessage();
-}
-
-void NodeDebugger::DidRead(net::test_server::StreamListenSocket* socket,
-                           const char* data,
-                           int len) {
-  buffer_.append(data, len);
-
-  do {
-    if (buffer_.size() == 0)
-      return;
-
-    // Read the "Content-Length" header.
-    if (content_length_ < 0) {
-      size_t pos = buffer_.find("\r\n\r\n");
-      if (pos == std::string::npos)
-        return;
-
-      // We can be sure that the header is "Content-Length: xxx\r\n".
-      std::string content_length = buffer_.substr(16, pos - 16);
-      if (!base::StringToInt(content_length, &content_length_)) {
-        DidClose(accepted_socket_.get());
-        return;
-      }
-
-      // Strip header from buffer.
-      buffer_ = buffer_.substr(pos + 4);
-    }
-
-    // Read the message.
-    if (buffer_.size() >= static_cast<size_t>(content_length_)) {
-      std::string message = buffer_.substr(0, content_length_);
-      buffer_ = buffer_.substr(content_length_);
-
-      OnMessage(message);
-
-      // Get ready for next message.
-      content_length_ = -1;
-    }
-  } while (true);
-}
-
-void NodeDebugger::DidClose(net::test_server::StreamListenSocket* socket) {
-  // If we lost the connection, then simulate a disconnect msg:
-  OnMessage("{\"seq\":1,\"type\":\"request\",\"command\":\"disconnect\"}");
-}
-
-}  // namespace atom

atom/browser/node_debugger.h

@@ -1,65 +0,0 @@
-// Copyright (c) 2014 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_NODE_DEBUGGER_H_
-#define ATOM_BROWSER_NODE_DEBUGGER_H_
-
-#include <string>
-
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
-#include "base/threading/thread.h"
-#include "net/test/embedded_test_server/stream_listen_socket.h"
-#include "v8/include/v8-debug.h"
-#include "vendor/node/deps/uv/include/uv.h"
-
-namespace atom {
-
-// Add support for node's "--debug" switch.
-class NodeDebugger : public net::test_server::StreamListenSocket::Delegate {
- public:
-  explicit NodeDebugger(v8::Isolate* isolate);
-  virtual ~NodeDebugger();
-
-  bool IsRunning() const;
-
- private:
-  void StartServer(int port);
-  void CloseSession();
-  void OnMessage(const std::string& message);
-  void SendMessage(const std::string& message);
-  void SendConnectMessage();
-
-  static void ProcessMessageInUI(uv_async_t* handle);
-
-  static void DebugMessageHandler(const v8::Debug::Message& message);
-
-  // net::test_server::StreamListenSocket::Delegate:
-  void DidAccept(
-      net::test_server::StreamListenSocket* server,
-      scoped_ptr<net::test_server::StreamListenSocket> socket) override;
-  void DidRead(net::test_server::StreamListenSocket* socket,
-               const char* data,
-               int len) override;
-  void DidClose(net::test_server::StreamListenSocket* socket) override;
-
-  v8::Isolate* isolate_;
-
-  uv_async_t weak_up_ui_handle_;
-
-  base::Thread thread_;
-  scoped_ptr<net::test_server::StreamListenSocket> server_;
-  scoped_ptr<net::test_server::StreamListenSocket> accepted_socket_;
-
-  std::string buffer_;
-  int content_length_;
-
-  base::WeakPtrFactory<NodeDebugger> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(NodeDebugger);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_NODE_DEBUGGER_H_

atom/browser/resources/mac/Info.plist

@@ -17,7 +17,7 @@
   <key>CFBundleIconFile</key>
   <string>atom.icns</string>
   <key>CFBundleVersion</key>
-  <string>0.32.0</string>
+  <string>0.30.8</string>
   <key>LSMinimumSystemVersion</key>
   <string>10.8.0</string>
   <key>NSMainNibFile</key>

atom/browser/resources/win/atom.manifest

@@ -1,21 +1,6 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
 
-  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-    <application>
-      <!-- Windows 10 -->
-      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
-      <!-- Windows 8.1 -->
-      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
-      <!-- Windows 8 -->
-      <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
-      <!-- Windows 7 -->
-      <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
-      <!-- Windows Vista -->
-      <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
-    </application>
-  </compatibility>
-
   <dependency>
     <dependentAssembly>
       <assemblyIdentity type="Win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"></assemblyIdentity>

atom/browser/resources/win/atom.rc

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

atom/browser/ui/atom_menu_model.cc

@@ -4,8 +4,6 @@
 
 #include "atom/browser/ui/atom_menu_model.h"
 
-#include "base/stl_util.h"
-
 namespace atom {
 
 AtomMenuModel::AtomMenuModel(Delegate* delegate)
@@ -16,17 +14,6 @@ AtomMenuModel::AtomMenuModel(Delegate* delegate)
 AtomMenuModel::~AtomMenuModel() {
 }
 
-void AtomMenuModel::SetRole(int index, const base::string16& role) {
-  roles_[index] = role;
-}
-
-base::string16 AtomMenuModel::GetRoleAt(int index) {
-  if (ContainsKey(roles_, index))
-    return roles_[index];
-  else
-    return base::string16();
-}
-
 void AtomMenuModel::MenuClosed() {
   ui::SimpleMenuModel::MenuClosed();
   FOR_EACH_OBSERVER(Observer, observers_, MenuClosed());

atom/browser/ui/atom_menu_model.h

@@ -5,8 +5,6 @@
 #ifndef ATOM_BROWSER_UI_ATOM_MENU_MODEL_H_
 #define ATOM_BROWSER_UI_ATOM_MENU_MODEL_H_
 
-#include <map>
-
 #include "base/observer_list.h"
 #include "ui/base/models/simple_menu_model.h"
 
@@ -33,17 +31,13 @@ class AtomMenuModel : public ui::SimpleMenuModel {
   void AddObserver(Observer* obs) { observers_.AddObserver(obs); }
   void RemoveObserver(Observer* obs) { observers_.RemoveObserver(obs); }
 
-  void SetRole(int index, const base::string16& role);
-  base::string16 GetRoleAt(int index);
-
   // ui::SimpleMenuModel:
   void MenuClosed() override;
 
  private:
   Delegate* delegate_;  // weak ref.
 
-  std::map<int, base::string16> roles_;
-  base::ObserverList<Observer> observers_;
+  ObserverList<Observer> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomMenuModel);
 };

atom/browser/ui/cocoa/atom_menu_controller.h

@@ -59,4 +59,17 @@ class MenuModel;
 
 @end
 
+// Exposed only for unit testing, do not call directly.
+@interface AtomMenuController (PrivateExposedForTesting)
+- (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item;
+@end
+
+// Protected methods that subclassers can override.
+@interface AtomMenuController (Protected)
+- (void)addItemToMenu:(NSMenu*)menu
+              atIndex:(NSInteger)index
+            fromModel:(ui::MenuModel*)model;
+- (NSMenu*)menuFromModel:(ui::MenuModel*)model;
+@end
+
 #endif  // ATOM_BROWSER_UI_COCOA_ATOM_MENU_CONTROLLER_H_

atom/browser/ui/cocoa/atom_menu_controller.mm

@@ -8,36 +8,16 @@
 #include "atom/browser/ui/atom_menu_model.h"
 #include "base/logging.h"
 #include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/accelerators/platform_accelerator_cocoa.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "ui/events/cocoa/cocoa_event_utils.h"
 #include "ui/gfx/image/image.h"
 
-namespace {
-
-struct Role {
-  SEL selector;
-  const char* role;
-};
-Role kRolesMap[] = {
-  { @selector(orderFrontStandardAboutPanel:), "about" },
-  { @selector(hide:), "hide" },
-  { @selector(hideOtherApplications:), "hideothers" },
-  { @selector(unhideAllApplications:), "unhide" },
-  { @selector(arrangeInFront:), "front" },
-  { @selector(undo:), "undo" },
-  { @selector(redo:), "redo" },
-  { @selector(cut:), "cut" },
-  { @selector(copy:), "copy" },
-  { @selector(paste:), "paste" },
-  { @selector(selectAll:), "selectall" },
-  { @selector(performMiniaturize:), "minimize" },
-  { @selector(performClose:), "close" },
-};
-
-}  // namespace
+@interface AtomMenuController (Private)
+- (void)addSeparatorToMenu:(NSMenu*)menu
+                   atIndex:(int)index;
+@end
 
 @implementation AtomMenuController
 
@@ -121,9 +101,7 @@ Role kRolesMap[] = {
 // associated with the entry in the model identified by |modelIndex|.
 - (void)addItemToMenu:(NSMenu*)menu
               atIndex:(NSInteger)index
-            fromModel:(ui::MenuModel*)ui_model {
-  atom::AtomMenuModel* model = static_cast<atom::AtomMenuModel*>(ui_model);
-
+            fromModel:(ui::MenuModel*)model {
   base::string16 label16 = model->GetLabelAt(index);
   NSString* label = l10n_util::FixUpWindowsStyleLabel(label16);
   base::scoped_nsobject<NSMenuItem> item(
@@ -146,13 +124,13 @@ Role kRolesMap[] = {
     [submenu setTitle:[item title]];
     [item setSubmenu:submenu];
 
-    // Set submenu's role.
-    base::string16 role = model->GetRoleAt(index);
-    if (role == base::ASCIIToUTF16("window"))
+    // Hack to set window and help menu.
+    if ([[item title] isEqualToString:@"Window"] && [submenu numberOfItems] > 0)
       [NSApp setWindowsMenu:submenu];
-    else if (role == base::ASCIIToUTF16("help"))
+    else if ([[item title] isEqualToString:@"Help"])
       [NSApp setHelpMenu:submenu];
-    if (role == base::ASCIIToUTF16("services"))
+    if ([[item title] isEqualToString:@"Services"] &&
+        [submenu numberOfItems] == 0)
       [NSApp setServicesMenu:submenu];
   } else {
     // The MenuModel works on indexes so we can't just set the command id as the
@@ -161,6 +139,7 @@ Role kRolesMap[] = {
     // model. Setting the target to |self| allows this class to participate
     // in validation of the menu items.
     [item setTag:index];
+    [item setTarget:self];
     NSValue* modelObject = [NSValue valueWithPointer:model];
     [item setRepresentedObject:modelObject];  // Retains |modelObject|.
     ui::Accelerator accelerator;
@@ -174,19 +153,6 @@ Role kRolesMap[] = {
             platformAccelerator->modifier_mask()];
       }
     }
-
-    // Set menu item's role.
-    base::string16 role = model->GetRoleAt(index);
-    if (role.empty()) {
-      [item setTarget:self];
-    } else {
-      for (const Role& pair : kRolesMap) {
-        if (role == base::ASCIIToUTF16(pair.role)) {
-          [item setAction:pair.selector];
-          break;
-        }
-      }
-    }
   }
   [menu insertItem:item atIndex:index];
 }

atom/browser/ui/file_dialog_gtk.cc

@@ -19,10 +19,7 @@ namespace {
 // Makes sure that .jpg also shows .JPG.
 gboolean FileFilterCaseInsensitive(const GtkFileFilterInfo* file_info,
                                    std::string* file_extension) {
-  // Makes .* file extension matches all file types.
-  if (*file_extension == ".*")
-    return true;
-  return base::EndsWith(file_info->filename, *file_extension, false);
+  return EndsWith(file_info->filename, *file_extension, false);
 }
 
 // Deletes |data| when gtk_file_filter_add_custom() is done with it.

atom/browser/ui/file_dialog_mac.mm

@@ -23,12 +23,6 @@ void SetAllowedFileTypes(NSSavePanel* dialog, const Filters& filters) {
   for (size_t i = 0; i < filters.size(); ++i) {
     const Filter& filter = filters[i];
     for (size_t j = 0; j < filter.second.size(); ++j) {
-      // If we meet a '*' file extension, we allow all the file types and no
-      // need to set the specified file types.
-      if (filter.second[j] == "*") {
-        [dialog setAllowsOtherFileTypes:YES];
-        return;
-      }
       base::ScopedCFTypeRef<CFStringRef> ext_cf(
           base::SysUTF8ToCFStringRef(filter.second[j]));
       [file_type_set addObject:base::mac::CFToNSCast(ext_cf.get())];

atom/browser/ui/file_dialog_win.cc

@@ -252,7 +252,7 @@ bool ShowSaveDialog(atom::NativeWindow* parent_window,
 
     bool matched = false;
     for (size_t i = 0; i < filter.second.size(); ++i) {
-      if (base::EndsWith(file_name, filter.second[i], false)) {
+      if (EndsWith(file_name, filter.second[i], false)) {
         matched = true;
         break;;
       }

atom/browser/ui/message_box_win.cc

@@ -78,9 +78,9 @@ int ShowMessageBoxUTF16(HWND parent,
                         const base::string16& message,
                         const base::string16& detail,
                         const gfx::ImageSkia& icon) {
-  TASKDIALOG_FLAGS flags =
-      TDF_SIZE_TO_CONTENT |  // Show all content.
-      TDF_ALLOW_DIALOG_CANCELLATION;  // Allow canceling the dialog.
+  TASKDIALOG_FLAGS flags = TDF_SIZE_TO_CONTENT;  // show all content.
+  if (cancel_id != 0)
+    flags |= TDF_ALLOW_DIALOG_CANCELLATION;  // allow dialog to be cancelled.
 
   TASKDIALOGCONFIG config = { 0 };
   config.cbSize     = sizeof(config);

atom/browser/ui/tray_icon.h

@@ -67,7 +67,7 @@ class TrayIcon {
   TrayIcon();
 
  private:
-  base::ObserverList<TrayIconObserver> observers_;
+  ObserverList<TrayIconObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(TrayIcon);
 };

atom/browser/ui/tray_icon_cocoa.mm

@@ -207,14 +207,8 @@ const CGFloat kVerticalTitleMargin = 2;
   }
   inMouseEventSequence_ = NO;
 
-  // Show menu when there is a context menu.
-  // NB(hokein): Make tray's behavior more like official one's.
-  // When the tray icon gets clicked quickly multiple times, the
-  // event.clickCount doesn't always return 1. Instead, it returns a value that
-  // counts the clicked times.
-  // So we don't check the clickCount here, just pop up the menu for each click
-  // event.
-  if (menuController_)
+  // Show menu when single clicked on the icon.
+  if (event.clickCount == 1 && menuController_)
     [statusItem_ popUpStatusItemMenu:[menuController_ menu]];
 
   // Don't emit click events when menu is showing.

atom/browser/ui/x/x_window_utils.cc

@@ -41,7 +41,7 @@ void SetWindowType(::Window xwindow, const std::string& type) {
   XDisplay* xdisplay = gfx::GetXDisplay();
   std::string type_prefix = "_NET_WM_WINDOW_TYPE_";
   ::Atom window_type = XInternAtom(
-      xdisplay, (type_prefix + base::StringToUpperASCII(type)).c_str(), False);
+      xdisplay, (type_prefix + StringToUpperASCII(type)).c_str(), False);
   XChangeProperty(xdisplay, xwindow,
                   XInternAtom(xdisplay, "_NET_WM_WINDOW_TYPE", False),
                   XA_ATOM,

atom/browser/web_contents_preferences.cc

@@ -1,154 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/web_contents_preferences.h"
-
-#include <string>
-
-#include "atom/common/options_switches.h"
-#include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
-#include "content/public/common/web_preferences.h"
-#include "net/base/filename_util.h"
-
-#if defined(OS_WIN)
-#include "ui/gfx/switches.h"
-#endif
-
-DEFINE_WEB_CONTENTS_USER_DATA_KEY(atom::WebContentsPreferences);
-
-namespace atom {
-
-namespace {
-
-// Array of available web runtime features.
-const char* kWebRuntimeFeatures[] = {
-  switches::kExperimentalFeatures,
-  switches::kExperimentalCanvasFeatures,
-  switches::kSubpixelFontScaling,
-  switches::kOverlayScrollbars,
-  switches::kOverlayFullscreenVideo,
-  switches::kSharedWorker,
-  switches::kPageVisibility,
-};
-
-}  // namespace
-
-WebContentsPreferences::WebContentsPreferences(
-    content::WebContents* web_contents,
-    base::DictionaryValue* web_preferences) {
-  web_preferences_.Swap(web_preferences);
-  web_contents->SetUserData(UserDataKey(), this);
-}
-
-WebContentsPreferences::~WebContentsPreferences() {
-}
-
-void WebContentsPreferences::Merge(const base::DictionaryValue& extend) {
-  web_preferences_.MergeDictionary(&extend);
-}
-
-// static
-void WebContentsPreferences::AppendExtraCommandLineSwitches(
-    content::WebContents* web_contents, base::CommandLine* command_line) {
-  WebContentsPreferences* self = FromWebContents(web_contents);
-  if (!self)
-    return;
-
-  base::DictionaryValue& web_preferences = self->web_preferences_;
-
-  bool b;
-#if defined(OS_WIN)
-  // Check if DirectWrite is disabled.
-  if (web_preferences.GetBoolean(switches::kDirectWrite, &b) && !b)
-    command_line->AppendSwitch(::switches::kDisableDirectWrite);
-#endif
-
-  // Check if plugins are enabled.
-  if (web_preferences.GetBoolean("plugins", &b) && b)
-    command_line->AppendSwitch(switches::kEnablePlugins);
-
-  // This set of options are not availabe in WebPreferences, so we have to pass
-  // them via command line and enable them in renderer procss.
-  for (size_t i = 0; i < arraysize(kWebRuntimeFeatures); ++i) {
-    const char* feature = kWebRuntimeFeatures[i];
-    if (web_preferences.GetBoolean(feature, &b))
-      command_line->AppendSwitchASCII(feature, b ? "true" : "false");
-  }
-
-  // Check if we have node integration specified.
-  bool node_integration = true;
-  web_preferences.GetBoolean(switches::kNodeIntegration, &node_integration);
-  // Be compatible with old API of "node-integration" option.
-  std::string old_token;
-  if (web_preferences.GetString(switches::kNodeIntegration, &old_token) &&
-      old_token != "disable")
-    node_integration = true;
-  command_line->AppendSwitchASCII(switches::kNodeIntegration,
-                                  node_integration ? "true" : "false");
-
-  // The preload script.
-  base::FilePath::StringType preload;
-  if (web_preferences.GetString(switches::kPreloadScript, &preload)) {
-    if (base::FilePath(preload).IsAbsolute())
-      command_line->AppendSwitchNative(switches::kPreloadScript, preload);
-    else
-      LOG(ERROR) << "preload script must have abosulute path.";
-  } else if (web_preferences.GetString(switches::kPreloadUrl, &preload)) {
-    // Translate to file path if there is "preload-url" option.
-    base::FilePath preload_path;
-    if (net::FileURLToFilePath(GURL(preload), &preload_path))
-      command_line->AppendSwitchPath(switches::kPreloadScript, preload_path);
-    else
-      LOG(ERROR) << "preload url must be file:// protocol.";
-  }
-
-  // The zoom factor.
-  double zoom_factor = 1.0;
-  if (web_preferences.GetDouble(switches::kZoomFactor, &zoom_factor) &&
-      zoom_factor != 1.0)
-    command_line->AppendSwitchASCII(switches::kZoomFactor,
-                                    base::DoubleToString(zoom_factor));
-
-  // --guest-instance-id, which is used to identify guest WebContents.
-  int guest_instance_id;
-  if (web_preferences.GetInteger(switches::kGuestInstanceID,
-                                 &guest_instance_id))
-      command_line->AppendSwitchASCII(switches::kGuestInstanceID,
-                                      base::IntToString(guest_instance_id));
-}
-
-// static
-void WebContentsPreferences::OverrideWebkitPrefs(
-    content::WebContents* web_contents, content::WebPreferences* prefs) {
-  WebContentsPreferences* self = FromWebContents(web_contents);
-  if (!self)
-    return;
-
-  bool b;
-  if (self->web_preferences_.GetBoolean("javascript", &b))
-    prefs->javascript_enabled = b;
-  if (self->web_preferences_.GetBoolean("images", &b))
-    prefs->images_enabled = b;
-  if (self->web_preferences_.GetBoolean("java", &b))
-    prefs->java_enabled = b;
-  if (self->web_preferences_.GetBoolean("text-areas-are-resizable", &b))
-    prefs->text_areas_are_resizable = b;
-  if (self->web_preferences_.GetBoolean("webgl", &b))
-    prefs->experimental_webgl_enabled = b;
-  if (self->web_preferences_.GetBoolean("webaudio", &b))
-    prefs->webaudio_enabled = b;
-  if (self->web_preferences_.GetBoolean("web-security", &b)) {
-    prefs->web_security_enabled = b;
-    prefs->allow_displaying_insecure_content = !b;
-    prefs->allow_running_insecure_content = !b;
-  }
-  if (self->web_preferences_.GetBoolean("allow-displaying-insecure-content",
-                                        &b))
-    prefs->allow_displaying_insecure_content = b;
-  if (self->web_preferences_.GetBoolean("allow-running-insecure-content", &b))
-    prefs->allow_running_insecure_content = b;
-}
-
-}  // namespace atom

atom/browser/web_contents_preferences.h

@@ -1,50 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_WEB_CONTENTS_PREFERENCES_H_
-#define ATOM_BROWSER_WEB_CONTENTS_PREFERENCES_H_
-
-#include "base/values.h"
-#include "content/public/browser/web_contents_user_data.h"
-
-namespace base {
-class CommandLine;
-}
-
-namespace content {
-struct WebPreferences;
-}
-
-namespace atom {
-
-// Stores and applies the preferences of WebContents.
-class WebContentsPreferences
-    : public content::WebContentsUserData<WebContentsPreferences> {
- public:
-  // Append command paramters according to |web_contents|'s preferences.
-  static void AppendExtraCommandLineSwitches(
-      content::WebContents* web_contents, base::CommandLine* command_line);
-
-  // Modify the WebPreferences according to |web_contents|'s preferences.
-  static void OverrideWebkitPrefs(
-      content::WebContents* web_contents, content::WebPreferences* prefs);
-
-  WebContentsPreferences(content::WebContents* web_contents,
-                         base::DictionaryValue* web_preferences);
-  ~WebContentsPreferences() override;
-
-  // $.extend(|web_preferences_|, |new_web_preferences|).
-  void Merge(const base::DictionaryValue& new_web_preferences);
-
- private:
-  friend class content::WebContentsUserData<WebContentsPreferences>;
-
-  base::DictionaryValue web_preferences_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebContentsPreferences);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_WEB_CONTENTS_PREFERENCES_H_

atom/browser/web_view_guest_delegate.cc

@@ -158,11 +158,9 @@ void WebViewGuestDelegate::SetGuestHost(content::GuestHost* guest_host) {
 void WebViewGuestDelegate::WillAttach(
     content::WebContents* embedder_web_contents,
     int element_instance_id,
-    bool is_full_page_plugin,
-    const base::Closure& completion_callback) {
+    bool is_full_page_plugin) {
   embedder_web_contents_ = embedder_web_contents;
   is_full_page_plugin_ = is_full_page_plugin;
-  completion_callback.Run();
 }
 
 void WebViewGuestDelegate::GuestSizeChangedDueToAutoSize(

atom/browser/web_view_guest_delegate.h

@@ -70,8 +70,7 @@ class WebViewGuestDelegate : public content::BrowserPluginGuestDelegate,
   void SetGuestHost(content::GuestHost* guest_host) final;
   void WillAttach(content::WebContents* embedder_web_contents,
                   int element_instance_id,
-                  bool is_full_page_plugin,
-                  const base::Closure& completion_callback) final;
+                  bool is_full_page_plugin) final;
 
  private:
   // This method is invoked when the contents auto-resized to give the container

atom/browser/web_view_manager.cc

@@ -10,7 +10,33 @@
 
 namespace atom {
 
-WebViewManager::WebViewManager() {
+namespace {
+
+WebViewManager* GetManagerFromWebContents(
+    const content::WebContents* web_contents) {
+  auto context = web_contents->GetBrowserContext();
+  if (!context)
+    return nullptr;
+  return static_cast<WebViewManager*>(context->GetGuestManager());
+}
+
+}  // namespace
+
+// static
+bool WebViewManager::GetInfoForWebContents(
+    const content::WebContents* web_contents, WebViewInfo* info) {
+  auto manager = GetManagerFromWebContents(web_contents);
+  if (!manager)
+    return false;
+  base::AutoLock auto_lock(manager->lock_);
+  auto iter = manager->webview_info_map_.find(web_contents);
+  if (iter == manager->webview_info_map_.end())
+    return false;
+  *info = iter->second;
+  return true;
+}
+
+WebViewManager::WebViewManager(content::BrowserContext* context) {
 }
 
 WebViewManager::~WebViewManager() {
@@ -19,8 +45,11 @@ WebViewManager::~WebViewManager() {
 void WebViewManager::AddGuest(int guest_instance_id,
                               int element_instance_id,
                               content::WebContents* embedder,
-                              content::WebContents* web_contents) {
-  web_contents_embedder_map_[guest_instance_id] = { web_contents, embedder };
+                              content::WebContents* web_contents,
+                              const WebViewInfo& info) {
+  base::AutoLock auto_lock(lock_);
+  web_contents_embdder_map_[guest_instance_id] = { web_contents, embedder };
+  webview_info_map_[web_contents] = info;
 
   // Map the element in embedder to guest.
   int owner_process_id = embedder->GetRenderProcessHost()->GetID();
@@ -29,10 +58,13 @@ void WebViewManager::AddGuest(int guest_instance_id,
 }
 
 void WebViewManager::RemoveGuest(int guest_instance_id) {
-  if (!ContainsKey(web_contents_embedder_map_, guest_instance_id))
+  base::AutoLock auto_lock(lock_);
+  if (!ContainsKey(web_contents_embdder_map_, guest_instance_id))
     return;
 
-  web_contents_embedder_map_.erase(guest_instance_id);
+  auto web_contents = web_contents_embdder_map_[guest_instance_id].web_contents;
+  web_contents_embdder_map_.erase(guest_instance_id);
+  webview_info_map_.erase(web_contents);
 
   // Remove the record of element in embedder too.
   for (const auto& element : element_instance_id_to_guest_map_)
@@ -50,15 +82,15 @@ content::WebContents* WebViewManager::GetGuestByInstanceID(
     return nullptr;
 
   int guest_instance_id = element_instance_id_to_guest_map_[key];
-  if (ContainsKey(web_contents_embedder_map_, guest_instance_id))
-    return web_contents_embedder_map_[guest_instance_id].web_contents;
+  if (ContainsKey(web_contents_embdder_map_, guest_instance_id))
+    return web_contents_embdder_map_[guest_instance_id].web_contents;
   else
     return nullptr;
 }
 
 bool WebViewManager::ForEachGuest(content::WebContents* embedder_web_contents,
                                   const GuestCallback& callback) {
-  for (auto& item : web_contents_embedder_map_)
+  for (auto& item : web_contents_embdder_map_)
     if (item.second.embedder == embedder_web_contents &&
         callback.Run(item.second.web_contents))
       return true;

atom/browser/web_view_manager.h

@@ -7,19 +7,41 @@
 
 #include <map>
 
+#include "base/files/file_path.h"
+#include "base/synchronization/lock.h"
 #include "content/public/browser/browser_plugin_guest_manager.h"
 
+namespace content {
+class BrowserContext;
+class RenderProcessHost;
+}
+
 namespace atom {
 
 class WebViewManager : public content::BrowserPluginGuestManager {
  public:
-  WebViewManager();
-  ~WebViewManager() override;
+  struct WebViewInfo {
+    int guest_instance_id;
+    content::WebContents* embedder;
+    bool node_integration;
+    bool plugins;
+    bool disable_web_security;
+    base::FilePath preload_script;
+  };
+
+  // Finds the WebViewManager attached with |web_contents| and returns the
+  // WebViewInfo of it.
+  static bool GetInfoForWebContents(const content::WebContents* web_contents,
+                                    WebViewInfo* info);
+
+  explicit WebViewManager(content::BrowserContext* context);
+  virtual ~WebViewManager();
 
   void AddGuest(int guest_instance_id,
                 int element_instance_id,
                 content::WebContents* embedder,
-                content::WebContents* web_contents);
+                content::WebContents* web_contents,
+                const WebViewInfo& info);
   void RemoveGuest(int guest_instance_id);
 
  protected:
@@ -35,7 +57,7 @@ class WebViewManager : public content::BrowserPluginGuestManager {
     content::WebContents* embedder;
   };
   // guest_instance_id => (web_contents, embedder)
-  std::map<int, WebContentsWithEmbedder> web_contents_embedder_map_;
+  std::map<int, WebContentsWithEmbedder> web_contents_embdder_map_;
 
   struct ElementInstanceKey {
     int embedder_process_id;
@@ -59,6 +81,12 @@ class WebViewManager : public content::BrowserPluginGuestManager {
   // (embedder_process_id, element_instance_id) => guest_instance_id
   std::map<ElementInstanceKey, int> element_instance_id_to_guest_map_;
 
+  typedef std::map<const content::WebContents*, WebViewInfo> WebViewInfoMap;
+  // web_contents => (guest_instance_id, embedder, ...)
+  WebViewInfoMap webview_info_map_;
+
+  base::Lock lock_;
+
   DISALLOW_COPY_AND_ASSIGN(WebViewManager);
 };
 

atom/browser/window_list.cc

@@ -13,7 +13,7 @@
 namespace atom {
 
 // static
-base::LazyInstance<base::ObserverList<WindowListObserver>>::Leaky
+base::LazyInstance<ObserverList<WindowListObserver>>::Leaky
     WindowList::observers_ = LAZY_INSTANCE_INITIALIZER;
 
 // static

atom/browser/window_list.h

@@ -60,8 +60,7 @@ class WindowList {
 
   // A list of observers which will be notified of every window addition and
   // removal across all WindowLists.
-  static base::LazyInstance<base::ObserverList<WindowListObserver>>::Leaky
-      observers_;
+  static base::LazyInstance<ObserverList<WindowListObserver>>::Leaky observers_;
 
   static WindowList* instance_;
 

atom/common/api/atom_api_asar.cc

@@ -10,12 +10,13 @@
 #include "atom/common/asar/archive.h"
 #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 "native_mate/arguments.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 #include "native_mate/wrappable.h"
 
+#include "atom/common/node_includes.h"
+
 namespace {
 
 class Archive : public mate::Wrappable {