Bump v0.36.11

[ci skip]

📝 Update Korean docs as upstream

[ci skip]

ISSUE_TEMPLATE.md

@@ -0,0 +1,2 @@
+* Electron version:
+* Operating system:

README-ko.md

@@ -49,12 +49,15 @@ API 레퍼런스가 있습니다. Electron을 빌드 하는 방법과 프로젝
 
 ## 참조 문서 (번역)
 
-- [브라질 포르투칼어](https://github.com/atom/electron/tree/master/docs-translations/pt-BR)
+- [브라질 포르투갈어](https://github.com/atom/electron/tree/master/docs-translations/pt-BR)
 - [한국어](https://github.com/atom/electron/tree/master/docs-translations/ko-KR)
 - [일본어](https://github.com/atom/electron/tree/master/docs-translations/jp)
 - [스페인어](https://github.com/atom/electron/tree/master/docs-translations/es)
 - [중국어 간체](https://github.com/atom/electron/tree/master/docs-translations/zh-CN)
 - [중국어 번체](https://github.com/atom/electron/tree/master/docs-translations/zh-TW)
+- [우크라이나어](https://github.com/atom/electron/tree/master/docs-translations/uk-UA)
+- [러시아어](https://github.com/atom/electron/tree/master/docs-translations/ru-RU)
+- [프랑스어](https://github.com/atom/electron/tree/master/docs-translations/fr-FR)
 
 ## 시작하기
 
@@ -68,6 +71,9 @@ API 레퍼런스가 있습니다. Electron을 빌드 하는 방법과 프로젝
 - Atom 포럼의 [`electron`](http://discuss.atom.io/c/electron) 카테고리
 - Freenode 채팅의 `#atom-shell` 채널
 - Slack의 [`Atom`](http://atom-slack.herokuapp.com/) 채널
+- [`electron-br`](https://electron-br.slack.com) *(브라질)* 커뮤니티
+- [`electron-kr`](http://www.meetup.com/electron-kr/) *(한국)* 커뮤니티
+- [`electron-jp`](https://electron-jp-slackin.herokuapp.com/) *(일본)* 커뮤니티
 
 [awesome-electron](https://github.com/sindresorhus/awesome-electron) 프로젝트에
 커뮤니티가 운영중인 유용한 예제 어플리케이션과 도구, 리소스가 있으니 한번 참고해 보시기

README.md

@@ -54,6 +54,7 @@ contains documents describing how to build and contribute to Electron.
 - [Traditional Chinese](https://github.com/atom/electron/tree/master/docs-translations/zh-TW)
 - [Ukrainian](https://github.com/atom/electron/tree/master/docs-translations/uk-UA)
 - [Russian](https://github.com/atom/electron/tree/master/docs-translations/ru-RU)
+- [French](https://github.com/atom/electron/tree/master/docs-translations/fr-FR)
 
 ## Quick Start
 
@@ -69,6 +70,8 @@ forums
 - `#atom-shell` channel on Freenode
 - [`Atom`](http://atom-slack.herokuapp.com/) channel on Slack
 - [`electron-br`](https://electron-br.slack.com) *(Brazilian Portuguese)*
+- [`electron-kr`](http://www.meetup.com/electron-kr/) *(Korean)*
+- [`electron-jp`](https://electron-jp-slackin.herokuapp.com/) *(Japanese)*
 
 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.36.1',
+    'version%': '0.36.11',
   },
   'includes': [
     'filenames.gypi',
@@ -28,7 +28,7 @@
       'target_name': '<(project_name)',
       'type': 'executable',
       'dependencies': [
-        'compile_coffee',
+        'js2asar',
         '<(project_name)_lib',
       ],
       'sources': [
@@ -69,7 +69,7 @@
             {
               'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources',
               'files': [
-                'atom/browser/default_app',
+                'default_app',
               ],
             },
           ],
@@ -121,10 +121,6 @@
               ],
             }],
           ],
-        }, {  # OS=="mac"
-          'dependencies': [
-            'make_locale_paks',
-          ],
         }],  # OS!="mac"
         ['OS=="win"', {
           'include_dirs': [
@@ -148,6 +144,7 @@
                   }, {
                     'copied_libraries': [
                       '<(libchromiumcontent_dir)/pdf.dll',
+                      '<(libchromiumcontent_dir)/ffmpeg.dll',
                     ],
                   }],
                 ],
@@ -155,6 +152,7 @@
               'destination': '<(PRODUCT_DIR)',
               'files': [
                 '<@(copied_libraries)',
+                '<(libchromiumcontent_dir)/locales',
                 '<(libchromiumcontent_dir)/libEGL.dll',
                 '<(libchromiumcontent_dir)/libGLESv2.dll',
                 '<(libchromiumcontent_dir)/icudtl.dat',
@@ -173,7 +171,7 @@
             {
               'destination': '<(PRODUCT_DIR)/resources',
               'files': [
-                'atom/browser/default_app',
+                'default_app',
               ]
             },
           ],
@@ -196,6 +194,7 @@
                   }, {
                     'copied_libraries': [
                       '<(PRODUCT_DIR)/lib/libnode.so',
+                      '<(libchromiumcontent_dir)/libffmpeg.so',
                     ],
                   }],
                 ],
@@ -203,6 +202,7 @@
               'destination': '<(PRODUCT_DIR)',
               'files': [
                 '<@(copied_libraries)',
+                '<(libchromiumcontent_dir)/locales',
                 '<(libchromiumcontent_dir)/icudtl.dat',
                 '<(libchromiumcontent_dir)/content_shell.pak',
                 '<(libchromiumcontent_dir)/natives_blob.bin',
@@ -212,7 +212,7 @@
             {
               'destination': '<(PRODUCT_DIR)/resources',
               'files': [
-                'atom/browser/default_app',
+                'default_app',
               ]
             },
           ],
@@ -223,7 +223,7 @@
       'target_name': '<(project_name)_lib',
       'type': 'static_library',
       'dependencies': [
-        'atom_coffee2c',
+        'atom_js2c',
         'vendor/brightray/brightray.gyp:brightray',
         'vendor/node/node.gyp:node',
       ],
@@ -235,6 +235,8 @@
         # Defined in Chromium but not exposed in its gyp file.
         'V8_USE_EXTERNAL_STARTUP_DATA',
         'ENABLE_PLUGINS',
+        'ENABLE_PEPPER_CDMS',
+        'USE_PROPRIETARY_CODECS',
       ],
       'sources': [
         '<@(lib_sources)',
@@ -260,6 +262,8 @@
         '<(libchromiumcontent_src_dir)/third_party/libyuv/include',
         # The 'third_party/webrtc/modules/desktop_capture/desktop_frame.h' is using 'webrtc/base/scoped_ptr.h'.
         '<(libchromiumcontent_src_dir)/third_party/',
+        '<(libchromiumcontent_src_dir)/components/cdm',
+        '<(libchromiumcontent_src_dir)/third_party/widevine',
       ],
       'direct_dependent_settings': {
         'include_dirs': [
@@ -349,11 +353,11 @@
       ],
     },  # target <(product_name)_lib
     {
-      'target_name': 'compile_coffee',
+      'target_name': 'js2asar',
       'type': 'none',
       'actions': [
         {
-          'action_name': 'compile_coffee',
+          'action_name': 'js2asar',
           'variables': {
             'conditions': [
               ['OS=="mac"', {
@@ -364,41 +368,41 @@
             ],
           },
           'inputs': [
-            '<@(coffee_sources)',
+            '<@(js_sources)',
           ],
           'outputs': [
             '<(resources_path)/atom.asar',
           ],
           'action': [
             'python',
-            'tools/coffee2asar.py',
+            'tools/js2asar.py',
             '<@(_outputs)',
             '<@(_inputs)',
           ],
         }
       ],
-    },  # target compile_coffee
+    },  # target js2asar
     {
-      'target_name': 'atom_coffee2c',
+      'target_name': 'atom_js2c',
       'type': 'none',
       'actions': [
         {
-          'action_name': 'atom_coffee2c',
+          'action_name': 'atom_js2c',
           'inputs': [
-            '<@(coffee2c_sources)',
+            '<@(js2c_sources)',
           ],
           'outputs': [
             '<(SHARED_INTERMEDIATE_DIR)/atom_natives.h',
           ],
           'action': [
             'python',
-            'tools/coffee2c.py',
+            'tools/js2c.py',
             '<@(_outputs)',
             '<@(_inputs)',
           ],
         }
       ],
-    },  # target atom_coffee2c
+    },  # target atom_js2c
   ],
   'conditions': [
     ['OS=="mac"', {
@@ -459,6 +463,7 @@
                   }, {
                     'copied_libraries': [
                       '<(PRODUCT_DIR)/libnode.dylib',
+                      '<(libchromiumcontent_dir)/libffmpeg.dylib',
                     ],
                   }],
                 ],
@@ -498,6 +503,16 @@
                 'Libraries',
               ],
             },
+            {
+              'postbuild_name': 'Copy locales',
+              'action': [
+                'tools/mac/copy-locales.py',
+                '-d',
+                '<(libchromiumcontent_dir)/locales',
+                '${BUILT_PRODUCTS_DIR}/<(product_name) Framework.framework/Resources',
+                '<@(locales)',
+              ],
+            },
           ],
           'conditions': [
             ['mas_build==0', {
@@ -542,31 +557,6 @@
           },
         },  # target helper
       ],
-    }, {  # OS=="mac"
-      'targets': [
-        {
-          'target_name': 'make_locale_paks',
-          'type': 'none',
-          'actions': [
-            {
-              'action_name': 'Make Empty Paks',
-              'inputs': [
-                'tools/make_locale_paks.py',
-              ],
-              'outputs': [
-                '<(PRODUCT_DIR)/locales'
-              ],
-              'action': [
-                'python',
-                'tools/make_locale_paks.py',
-                '<(PRODUCT_DIR)',
-                '<@(locales)',
-              ],
-              'msvs_cygwin_shell': 0,
-            },
-          ],
-        },
-      ],
     }],  # OS!="mac"
   ],
 }

atom/app/atom_content_client.cc

@@ -11,14 +11,22 @@
 #include "atom/common/chrome_version.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
+#include "base/files/file_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "content/public/common/user_agent.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
+#include "third_party/widevine/cdm/stub/widevine_cdm_version.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "url/url_constants.h"
 
+#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
+#include "chrome/common/widevine_cdm_constants.h"
+#endif
+
 namespace atom {
 
 namespace {
@@ -63,6 +71,45 @@ content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
   return plugin;
 }
 
+#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
+content::PepperPluginInfo CreateWidevineCdmInfo(const base::FilePath& path,
+                                                const std::string& version) {
+  content::PepperPluginInfo widevine_cdm;
+  widevine_cdm.is_out_of_process = true;
+  widevine_cdm.path = path;
+  widevine_cdm.name = kWidevineCdmDisplayName;
+  widevine_cdm.description = kWidevineCdmDescription +
+                             std::string(" (version: ") +
+                             version + ")";
+  widevine_cdm.version = version;
+  content::WebPluginMimeType widevine_cdm_mime_type(
+      kWidevineCdmPluginMimeType,
+      kWidevineCdmPluginExtension,
+      kWidevineCdmPluginMimeTypeDescription);
+
+  // Add the supported codecs as if they came from the component manifest.
+  std::vector<std::string> codecs;
+  codecs.push_back(kCdmSupportedCodecVorbis);
+  codecs.push_back(kCdmSupportedCodecVp8);
+  codecs.push_back(kCdmSupportedCodecVp9);
+#if defined(USE_PROPRIETARY_CODECS)
+  codecs.push_back(kCdmSupportedCodecAac);
+  codecs.push_back(kCdmSupportedCodecAvc1);
+#endif  // defined(USE_PROPRIETARY_CODECS)
+  std::string codec_string = base::JoinString(
+      codecs, std::string(1, kCdmSupportedCodecsValueDelimiter));
+  widevine_cdm_mime_type.additional_param_names.push_back(
+      base::ASCIIToUTF16(kCdmSupportedCodecsParamName));
+  widevine_cdm_mime_type.additional_param_values.push_back(
+      base::ASCIIToUTF16(codec_string));
+
+  widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
+  widevine_cdm.permissions = kWidevineCdmPluginPermissions;
+
+  return widevine_cdm;
+}
+#endif
+
 void ConvertStringWithSeparatorToVector(std::vector<std::string>* vec,
                                         const char* separator,
                                         const char* cmd_switch) {
@@ -76,6 +123,43 @@ void ConvertStringWithSeparatorToVector(std::vector<std::string>* vec,
 
 }  // namespace
 
+void AddPepperFlashFromCommandLine(
+    std::vector<content::PepperPluginInfo>* plugins) {
+  auto command_line = base::CommandLine::ForCurrentProcess();
+  auto flash_path = command_line->GetSwitchValueNative(
+      switches::kPpapiFlashPath);
+  if (flash_path.empty())
+    return;
+
+  auto flash_version = command_line->GetSwitchValueASCII(
+      switches::kPpapiFlashVersion);
+
+  plugins->push_back(
+      CreatePepperFlashInfo(base::FilePath(flash_path), flash_version));
+}
+
+#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
+void AddWidevineCdmFromCommandLine(
+    std::vector<content::PepperPluginInfo>* plugins) {
+  auto command_line = base::CommandLine::ForCurrentProcess();
+  auto widevine_cdm_path = command_line->GetSwitchValueNative(
+      switches::kWidevineCdmPath);
+  if (widevine_cdm_path.empty())
+    return;
+
+  if (!base::PathExists(base::FilePath(widevine_cdm_path)))
+    return;
+
+  auto widevine_cdm_version = command_line->GetSwitchValueASCII(
+      switches::kWidevineCdmVersion);
+  if (widevine_cdm_version.empty())
+    return;
+
+  plugins->push_back(CreateWidevineCdmInfo(base::FilePath(widevine_cdm_path),
+                                           widevine_cdm_version));
+}
+#endif
+
 AtomContentClient::AtomContentClient() {
 }
 
@@ -92,6 +176,10 @@ std::string AtomContentClient::GetUserAgent() const {
       ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING);
 }
 
+base::string16 AtomContentClient::GetLocalizedString(int message_id) const {
+  return l10n_util::GetStringUTF16(message_id);
+}
+
 void AtomContentClient::AddAdditionalSchemes(
     std::vector<url::SchemeWithType>* standard_schemes,
     std::vector<std::string>* savable_schemes) {
@@ -107,17 +195,10 @@ void AtomContentClient::AddAdditionalSchemes(
 
 void AtomContentClient::AddPepperPlugins(
     std::vector<content::PepperPluginInfo>* plugins) {
-  auto command_line = base::CommandLine::ForCurrentProcess();
-  auto flash_path = command_line->GetSwitchValuePath(
-      switches::kPpapiFlashPath);
-  if (flash_path.empty())
-    return;
-
-  auto flash_version = command_line->GetSwitchValueASCII(
-      switches::kPpapiFlashVersion);
-
-  plugins->push_back(
-      CreatePepperFlashInfo(flash_path, flash_version));
+  AddPepperFlashFromCommandLine(plugins);
+#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
+  AddWidevineCdmFromCommandLine(plugins);
+#endif
 }
 
 void AtomContentClient::AddServiceWorkerSchemes(

atom/app/atom_content_client.h

@@ -22,6 +22,7 @@ class AtomContentClient : public brightray::ContentClient {
   // content::ContentClient:
   std::string GetProduct() const override;
   std::string GetUserAgent() const override;
+  base::string16 GetLocalizedString(int message_id) const override;
   void AddAdditionalSchemes(
       std::vector<url::SchemeWithType>* standard_schemes,
       std::vector<std::string>* savable_schemes) override;

atom/app/atom_main_delegate.cc

@@ -18,6 +18,7 @@
 #include "base/logging.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/common/content_switches.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace atom {
@@ -137,16 +138,4 @@ scoped_ptr<brightray::ContentClient> AtomMainDelegate::CreateContentClient() {
   return scoped_ptr<brightray::ContentClient>(new AtomContentClient).Pass();
 }
 
-void AtomMainDelegate::AddDataPackFromPath(
-    ui::ResourceBundle* bundle, const base::FilePath& pak_dir) {
-#if defined(OS_WIN)
-  bundle->AddDataPackFromPath(
-      pak_dir.Append(FILE_PATH_LITERAL("ui_resources_200_percent.pak")),
-      ui::SCALE_FACTOR_200P);
-  bundle->AddDataPackFromPath(
-      pak_dir.Append(FILE_PATH_LITERAL("content_resources_200_percent.pak")),
-      ui::SCALE_FACTOR_200P);
-#endif
-}
-
 }  // namespace atom

atom/app/atom_main_delegate.h

@@ -25,8 +25,6 @@ class AtomMainDelegate : public brightray::MainDelegate {
 
   // brightray::MainDelegate:
   scoped_ptr<brightray::ContentClient> CreateContentClient() override;
-  void AddDataPackFromPath(
-      ui::ResourceBundle* bundle, const base::FilePath& pak_dir) override;
 #if defined(OS_MACOSX)
   void OverrideChildProcessPath() override;
   void OverrideFrameworkBundlePath() override;

atom/app/uv_task_runner.cc

@@ -37,7 +37,7 @@ bool UvTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay) {
-  return PostDelayedTask(from_here, task, delay);;
+  return PostDelayedTask(from_here, task, delay);
 }
 
 // static

atom/browser/api/atom_api_app.cc

@@ -18,6 +18,7 @@
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
@@ -34,9 +35,11 @@
 #include "native_mate/object_template_builder.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/gfx/image/image.h"
 
 #if defined(OS_WIN)
 #include "base/strings/utf_string_conversions.h"
+#include "ui/base/win/shell.h"
 #endif
 
 using atom::Browser;
@@ -129,19 +132,20 @@ void OnClientCertificateSelected(
     std::shared_ptr<content::ClientCertificateDelegate> delegate,
     mate::Arguments* args) {
   mate::Dictionary cert_data;
-  if (!(args->Length() == 1 && args->GetNext(&cert_data))) {
+  if (!args->GetNext(&cert_data)) {
     args->ThrowError();
     return;
   }
 
-  std::string encoded_data;
-  cert_data.Get("data", &encoded_data);
+  v8::Local<v8::Object> data;
+  if (!cert_data.Get("data", &data))
+    return;
 
-  auto certs =
-      net::X509Certificate::CreateCertificateListFromBytes(
-          encoded_data.data(), encoded_data.size(),
-          net::X509Certificate::FORMAT_AUTO);
-  delegate->ContinueWithCertificate(certs[0].get());
+  auto certs = net::X509Certificate::CreateCertificateListFromBytes(
+      node::Buffer::Data(data), node::Buffer::Length(data),
+      net::X509Certificate::FORMAT_AUTO);
+  if (certs.size() > 0)
+    delegate->ContinueWithCertificate(certs[0].get());
 }
 
 void PassLoginInformation(scoped_refptr<LoginHandler> login_handler,
@@ -279,6 +283,12 @@ void App::OnGpuProcessCrashed(base::TerminationStatus exit_code) {
   Emit("gpu-process-crashed");
 }
 
+#if defined(OS_MACOSX)
+void App::OnPlatformThemeChanged() {
+  Emit("platform-theme-changed");
+}
+#endif
+
 base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
   bool succeed = false;
   base::FilePath path;
@@ -318,6 +328,12 @@ std::string App::GetLocale() {
   return l10n_util::GetApplicationLocale("");
 }
 
+#if defined(OS_WIN)
+bool App::IsAeroGlassEnabled() {
+  return ui::win::IsAeroGlassEnabled();
+}
+#endif
+
 bool App::MakeSingleInstance(
     const ProcessSingleton::NotificationCallback& callback) {
   if (process_singleton_.get())
@@ -358,9 +374,16 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
                  base::Bind(&Browser::ClearRecentDocuments, browser))
       .SetMethod("setAppUserModelId",
                  base::Bind(&Browser::SetAppUserModelID, browser))
+#if defined(OS_MACOSX)
+      .SetMethod("hide", base::Bind(&Browser::Hide, browser))
+      .SetMethod("show", base::Bind(&Browser::Show, browser))
+      .SetMethod("isDarkMode",
+                 base::Bind(&Browser::IsDarkMode, browser))
+#endif
 #if defined(OS_WIN)
       .SetMethod("setUserTasks",
                  base::Bind(&Browser::SetUserTasks, browser))
+      .SetMethod("isAeroGlassEnabled", &App::IsAeroGlassEnabled)
 #endif
       .SetMethod("setPath", &App::SetPath)
       .SetMethod("getPath", &App::GetPath)
@@ -440,6 +463,7 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
   dict.SetMethod("dockHide", base::Bind(&Browser::DockHide, browser));
   dict.SetMethod("dockShow", base::Bind(&Browser::DockShow, browser));
   dict.SetMethod("dockSetMenu", &DockSetMenu);
+  dict.SetMethod("dockSetIcon", base::Bind(&Browser::DockSetIcon, browser));
 #endif
 }
 

atom/browser/api/atom_api_app.h

@@ -71,6 +71,10 @@ class App : public AtomBrowserClient::Delegate,
   // content::GpuDataManagerObserver:
   void OnGpuProcessCrashed(base::TerminationStatus exit_code) override;
 
+#if defined(OS_MACOSX)
+  void OnPlatformThemeChanged() override;
+#endif
+
   // mate::Wrappable:
   mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override;
@@ -88,6 +92,10 @@ class App : public AtomBrowserClient::Delegate,
       const ProcessSingleton::NotificationCallback& callback);
   std::string GetLocale();
 
+#if defined(OS_WIN)
+  bool IsAeroGlassEnabled();
+#endif
+
   scoped_ptr<ProcessSingleton> process_singleton_;
 
   DISALLOW_COPY_AND_ASSIGN(App);

atom/browser/api/atom_api_debugger.cc

@@ -0,0 +1,195 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_debugger.h"
+
+#include <string>
+
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
+#include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/web_contents.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+
+using content::DevToolsAgentHost;
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+// The wrapDebugger funtion which is implemented in JavaScript.
+using WrapDebuggerCallback = base::Callback<void(v8::Local<v8::Value>)>;
+WrapDebuggerCallback g_wrap_debugger;
+
+}  // namespace
+
+Debugger::Debugger(content::WebContents* web_contents)
+    : web_contents_(web_contents),
+      previous_request_id_(0) {
+}
+
+Debugger::~Debugger() {
+}
+
+void Debugger::AgentHostClosed(DevToolsAgentHost* agent_host,
+                               bool replaced_with_another_client) {
+  std::string detach_reason = "target closed";
+  if (replaced_with_another_client)
+    detach_reason = "replaced with devtools";
+  Emit("detach", detach_reason);
+}
+
+void Debugger::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
+                                       const std::string& message) {
+  DCHECK(agent_host == agent_host_.get());
+
+  scoped_ptr<base::Value> parsed_message(base::JSONReader::Read(message));
+  if (!parsed_message->IsType(base::Value::TYPE_DICTIONARY))
+    return;
+
+  base::DictionaryValue* dict =
+      static_cast<base::DictionaryValue*>(parsed_message.get());
+  int id;
+  if (!dict->GetInteger("id", &id)) {
+    std::string method;
+    if (!dict->GetString("method", &method))
+      return;
+    base::DictionaryValue* params_value = nullptr;
+    base::DictionaryValue params;
+    if (dict->GetDictionary("params", &params_value))
+      params.Swap(params_value);
+    Emit("message", method, params);
+  } else {
+    auto send_command_callback = pending_requests_[id];
+    pending_requests_.erase(id);
+    if (send_command_callback.is_null())
+      return;
+    base::DictionaryValue* error_body = nullptr;
+    base::DictionaryValue error;
+    if (dict->GetDictionary("error", &error_body))
+      error.Swap(error_body);
+
+    base::DictionaryValue* result_body = nullptr;
+    base::DictionaryValue result;
+    if (dict->GetDictionary("result", &result_body))
+      result.Swap(result_body);
+    send_command_callback.Run(error, result);
+  }
+}
+
+void Debugger::Attach(mate::Arguments* args) {
+  std::string protocol_version;
+  args->GetNext(&protocol_version);
+
+  if (!protocol_version.empty() &&
+      !DevToolsAgentHost::IsSupportedProtocolVersion(protocol_version)) {
+    args->ThrowError("Requested protocol version is not supported");
+    return;
+  }
+  agent_host_ = DevToolsAgentHost::GetOrCreateFor(web_contents_);
+  if (!agent_host_.get()) {
+    args->ThrowError("No target available");
+    return;
+  }
+  if (agent_host_->IsAttached()) {
+    args->ThrowError("Another debugger is already attached to this target");
+    return;
+  }
+
+  agent_host_->AttachClient(this);
+}
+
+bool Debugger::IsAttached() {
+  return agent_host_.get() ? agent_host_->IsAttached() : false;
+}
+
+void Debugger::Detach() {
+  if (!agent_host_.get())
+    return;
+  agent_host_->DetachClient();
+  AgentHostClosed(agent_host_.get(), false);
+  agent_host_ = nullptr;
+}
+
+void Debugger::SendCommand(mate::Arguments* args) {
+  if (!agent_host_.get())
+    return;
+
+  std::string method;
+  if (!args->GetNext(&method)) {
+    args->ThrowError();
+    return;
+  }
+  base::DictionaryValue command_params;
+  args->GetNext(&command_params);
+  SendCommandCallback callback;
+  args->GetNext(&callback);
+
+  base::DictionaryValue request;
+  int request_id = ++previous_request_id_;
+  pending_requests_[request_id] = callback;
+  request.SetInteger("id", request_id);
+  request.SetString("method", method);
+  if (!command_params.empty())
+    request.Set("params", command_params.DeepCopy());
+
+  std::string json_args;
+  base::JSONWriter::Write(request, &json_args);
+  agent_host_->DispatchProtocolMessage(json_args);
+}
+
+// static
+mate::Handle<Debugger> Debugger::Create(
+    v8::Isolate* isolate,
+    content::WebContents* web_contents) {
+  auto handle = mate::CreateHandle(isolate, new Debugger(web_contents));
+  g_wrap_debugger.Run(handle.ToV8());
+  return handle;
+}
+
+// static
+void Debugger::BuildPrototype(v8::Isolate* isolate,
+                              v8::Local<v8::ObjectTemplate> prototype) {
+  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("attach", &Debugger::Attach)
+      .SetMethod("isAttached", &Debugger::IsAttached)
+      .SetMethod("detach", &Debugger::Detach)
+      .SetMethod("sendCommand", &Debugger::SendCommand);
+}
+
+void ClearWrapDebugger() {
+  g_wrap_debugger.Reset();
+}
+
+void SetWrapDebugger(const WrapDebuggerCallback& callback) {
+  g_wrap_debugger = callback;
+
+  // Cleanup the wrapper on exit.
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(
+      base::Bind(ClearWrapDebugger));
+}
+
+}  // 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("_setWrapDebugger", &atom::api::SetWrapDebugger);
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_debugger, Initialize);

atom/browser/api/atom_api_debugger.h

@@ -0,0 +1,75 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_DEBUGGER_H_
+#define ATOM_BROWSER_API_ATOM_API_DEBUGGER_H_
+
+#include <map>
+#include <string>
+
+#include "atom/browser/api/trackable_object.h"
+#include "base/callback.h"
+#include "base/values.h"
+#include "content/public/browser/devtools_agent_host_client.h"
+#include "native_mate/handle.h"
+
+namespace content {
+class DevToolsAgentHost;
+class WebContents;
+}
+
+namespace mate {
+class Arguments;
+}
+
+namespace atom {
+
+namespace api {
+
+class Debugger: public mate::TrackableObject<Debugger>,
+                public content::DevToolsAgentHostClient {
+ public:
+  using SendCommandCallback =
+      base::Callback<void(const base::DictionaryValue&,
+                          const base::DictionaryValue&)>;
+
+  static mate::Handle<Debugger> Create(
+      v8::Isolate* isolate, content::WebContents* web_contents);
+
+  // mate::TrackableObject:
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::ObjectTemplate> prototype);
+
+ protected:
+  explicit Debugger(content::WebContents* web_contents);
+  ~Debugger();
+
+  // content::DevToolsAgentHostClient:
+  void AgentHostClosed(content::DevToolsAgentHost* agent_host,
+                       bool replaced_with_another_client) override;
+  void DispatchProtocolMessage(content::DevToolsAgentHost* agent_host,
+                               const std::string& message) override;
+
+ private:
+  using PendingRequestMap = std::map<int, SendCommandCallback>;
+
+  void Attach(mate::Arguments* args);
+  bool IsAttached();
+  void Detach();
+  void SendCommand(mate::Arguments* args);
+
+  content::WebContents* web_contents_;  // Weak Reference.
+  scoped_refptr<content::DevToolsAgentHost> agent_host_;
+
+  PendingRequestMap pending_requests_;
+  int previous_request_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(Debugger);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_DEBUGGER_H_

atom/browser/api/atom_api_dialog.cc

@@ -41,6 +41,7 @@ namespace {
 
 void ShowMessageBox(int type,
                     const std::vector<std::string>& buttons,
+                    int default_id,
                     int cancel_id,
                     int options,
                     const std::string& title,
@@ -54,12 +55,13 @@ void ShowMessageBox(int type,
   if (mate::Converter<atom::MessageBoxCallback>::FromV8(args->isolate(),
                                                         peek,
                                                         &callback)) {
-    atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons, cancel_id,
-                         options, title, message, detail, icon, callback);
+    atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons,
+                         default_id, cancel_id, options, title,
+                         message, detail, icon, callback);
   } else {
     int chosen = atom::ShowMessageBox(window, (atom::MessageBoxType)type,
-                                      buttons, cancel_id, options, title,
-                                      message, detail, icon);
+                                      buttons, default_id, cancel_id,
+                                      options, title, message, detail, icon);
     args->Return(chosen);
   }
 }

atom/browser/api/atom_api_download_item.cc

@@ -12,6 +12,7 @@
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/node_includes.h"
 #include "base/memory/linked_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "native_mate/dictionary.h"
 #include "net/base/filename_util.h"
@@ -47,80 +48,49 @@ namespace atom {
 namespace api {
 
 namespace {
+
 // The wrapDownloadItem funtion which is implemented in JavaScript
 using WrapDownloadItemCallback = base::Callback<void(v8::Local<v8::Value>)>;
 WrapDownloadItemCallback g_wrap_download_item;
 
-char kDownloadItemSavePathKey[] = "DownloadItemSavePathKey";
-
 std::map<uint32, linked_ptr<v8::Global<v8::Value>>> g_download_item_objects;
+
 }  // namespace
 
-DownloadItem::SavePathData::SavePathData(const base::FilePath& path) :
-  path_(path) {
-}
-
-const base::FilePath& DownloadItem::SavePathData::path() {
-  return path_;
-}
-
-DownloadItem::DownloadItem(content::DownloadItem* download_item) :
-    download_item_(download_item) {
+DownloadItem::DownloadItem(content::DownloadItem* download_item)
+    : download_item_(download_item) {
   download_item_->AddObserver(this);
+  AttachAsUserData(download_item);
 }
 
 DownloadItem::~DownloadItem() {
-  if (download_item_)
-    OnDownloadDestroyed(download_item_);
+  if (download_item_) {
+    // Destroyed by either garbage collection or destroy().
+    download_item_->RemoveObserver(this);
+    download_item_->Remove();
+  }
+
+  // Remove from the global map.
+  auto iter = g_download_item_objects.find(weak_map_id());
+  if (iter != g_download_item_objects.end())
+    g_download_item_objects.erase(iter);
 }
 
 void DownloadItem::OnDownloadUpdated(content::DownloadItem* item) {
-  download_item_->IsDone() ? Emit("done", item->GetState()) : Emit("updated");
+  if (download_item_->IsDone()) {
+    Emit("done", item->GetState());
+
+    // Destroy the item once item is downloaded.
+    base::MessageLoop::current()->PostTask(FROM_HERE, GetDestroyClosure());
+  } else {
+    Emit("updated");
+  }
 }
 
 void DownloadItem::OnDownloadDestroyed(content::DownloadItem* download_item) {
-  download_item_->RemoveObserver(this);
-  auto iter = g_download_item_objects.find(download_item_->GetId());
-  if (iter != g_download_item_objects.end())
-    g_download_item_objects.erase(iter);
   download_item_ = nullptr;
-}
-
-int64 DownloadItem::GetReceivedBytes() {
-  return download_item_->GetReceivedBytes();
-}
-
-int64 DownloadItem::GetTotalBytes() {
-  return download_item_->GetTotalBytes();
-}
-
-const GURL& DownloadItem::GetURL() {
-  return download_item_->GetURL();
-}
-
-std::string DownloadItem::GetMimeType() {
-  return download_item_->GetMimeType();
-}
-
-bool DownloadItem::HasUserGesture() {
-  return download_item_->HasUserGesture();
-}
-
-std::string DownloadItem::GetFilename() {
-  return base::UTF16ToUTF8(net::GenerateFileName(GetURL(),
-                           GetContentDisposition(),
-                           std::string(),
-                           download_item_->GetSuggestedFilename(),
-                           GetMimeType(),
-                           std::string()).LossyDisplayName());
-}
-
-std::string DownloadItem::GetContentDisposition() {
-  return download_item_->GetContentDisposition();
-}
-
-void DownloadItem::SetSavePath(const base::FilePath& path) {
-  download_item_->SetUserData(UserDataKey(), new SavePathData(path));
+  // Destroy the native class immediately when downloadItem is destroyed.
+  delete this;
 }
 
 void DownloadItem::Pause() {
@@ -133,6 +103,48 @@ void DownloadItem::Resume() {
 
 void DownloadItem::Cancel() {
   download_item_->Cancel(true);
+  download_item_->Remove();
+}
+
+int64 DownloadItem::GetReceivedBytes() const {
+  return download_item_->GetReceivedBytes();
+}
+
+int64 DownloadItem::GetTotalBytes() const {
+  return download_item_->GetTotalBytes();
+}
+
+std::string DownloadItem::GetMimeType() const {
+  return download_item_->GetMimeType();
+}
+
+bool DownloadItem::HasUserGesture() const {
+  return download_item_->HasUserGesture();
+}
+
+std::string DownloadItem::GetFilename() const {
+  return base::UTF16ToUTF8(net::GenerateFileName(GetURL(),
+                           GetContentDisposition(),
+                           std::string(),
+                           download_item_->GetSuggestedFilename(),
+                           GetMimeType(),
+                           std::string()).LossyDisplayName());
+}
+
+std::string DownloadItem::GetContentDisposition() const {
+  return download_item_->GetContentDisposition();
+}
+
+const GURL& DownloadItem::GetURL() const {
+  return download_item_->GetURL();
+}
+
+void DownloadItem::SetSavePath(const base::FilePath& path) {
+  save_path_ = path;
+}
+
+base::FilePath DownloadItem::GetSavePath() const {
+  return save_path_;
 }
 
 // static
@@ -145,29 +157,31 @@ void DownloadItem::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("cancel", &DownloadItem::Cancel)
       .SetMethod("getReceivedBytes", &DownloadItem::GetReceivedBytes)
       .SetMethod("getTotalBytes", &DownloadItem::GetTotalBytes)
-      .SetMethod("getURL", &DownloadItem::GetURL)
       .SetMethod("getMimeType", &DownloadItem::GetMimeType)
       .SetMethod("hasUserGesture", &DownloadItem::HasUserGesture)
       .SetMethod("getFilename", &DownloadItem::GetFilename)
       .SetMethod("getContentDisposition", &DownloadItem::GetContentDisposition)
-      .SetMethod("setSavePath", &DownloadItem::SetSavePath);
+      .SetMethod("getURL", &DownloadItem::GetURL)
+      .SetMethod("setSavePath", &DownloadItem::SetSavePath)
+      .SetMethod("getSavePath", &DownloadItem::GetSavePath);
 }
 
 // static
 mate::Handle<DownloadItem> DownloadItem::Create(
     v8::Isolate* isolate, content::DownloadItem* item) {
+  auto existing = TrackableObject::FromWrappedClass(isolate, item);
+  if (existing)
+    return mate::CreateHandle(isolate, static_cast<DownloadItem*>(existing));
+
   auto handle = mate::CreateHandle(isolate, new DownloadItem(item));
   g_wrap_download_item.Run(handle.ToV8());
-  g_download_item_objects[item->GetId()] = make_linked_ptr(
+
+  // Reference this object in case it got garbage collected.
+  g_download_item_objects[handle->weak_map_id()] = make_linked_ptr(
       new v8::Global<v8::Value>(isolate, handle.ToV8()));
   return handle;
 }
 
-// static
-void* DownloadItem::UserDataKey() {
-  return &kDownloadItemSavePathKey;
-}
-
 void ClearWrapDownloadItem() {
   g_wrap_download_item.Reset();
 }

atom/browser/api/atom_api_download_item.h

@@ -20,22 +20,26 @@ namespace api {
 class DownloadItem : public mate::TrackableObject<DownloadItem>,
                      public content::DownloadItem::Observer {
  public:
-  class SavePathData : public base::SupportsUserData::Data {
-   public:
-    explicit SavePathData(const base::FilePath& path);
-    const base::FilePath& path();
-   private:
-    base::FilePath path_;
-  };
-
   static mate::Handle<DownloadItem> Create(v8::Isolate* isolate,
                                            content::DownloadItem* item);
-  static void* UserDataKey();
 
   // mate::TrackableObject:
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Local<v8::ObjectTemplate> prototype);
 
+  void Pause();
+  void Resume();
+  void Cancel();
+  int64 GetReceivedBytes() const;
+  int64 GetTotalBytes() const;
+  std::string GetMimeType() const;
+  bool HasUserGesture() const;
+  std::string GetFilename() const;
+  std::string GetContentDisposition() const;
+  const GURL& GetURL() const;
+  void SetSavePath(const base::FilePath& path);
+  base::FilePath GetSavePath() const;
+
  protected:
   explicit DownloadItem(content::DownloadItem* download_item);
   ~DownloadItem();
@@ -44,19 +48,8 @@ class DownloadItem : public mate::TrackableObject<DownloadItem>,
   void OnDownloadUpdated(content::DownloadItem* download) override;
   void OnDownloadDestroyed(content::DownloadItem* download) override;
 
-  void Pause();
-  void Resume();
-  void Cancel();
-  int64 GetReceivedBytes();
-  int64 GetTotalBytes();
-  std::string GetMimeType();
-  bool HasUserGesture();
-  std::string GetFilename();
-  std::string GetContentDisposition();
-  const GURL& GetURL();
-  void SetSavePath(const base::FilePath& path);
-
  private:
+  base::FilePath save_path_;
   content::DownloadItem* download_item_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItem);

atom/browser/api/atom_api_menu.cc

@@ -169,8 +169,7 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("isItemCheckedAt", &Menu::IsItemCheckedAt)
       .SetMethod("isEnabledAt", &Menu::IsEnabledAt)
       .SetMethod("isVisibleAt", &Menu::IsVisibleAt)
-      .SetMethod("_popup", &Menu::Popup)
-      .SetMethod("_popupAt", &Menu::PopupAt);
+      .SetMethod("popupAt", &Menu::PopupAt);
 }
 
 }  // namespace api

atom/browser/api/atom_api_menu.h

@@ -51,8 +51,9 @@ class Menu : public mate::TrackableObject<Menu>,
   void ExecuteCommand(int command_id, int event_flags) override;
   void MenuWillShow(ui::SimpleMenuModel* source) override;
 
-  virtual void Popup(Window* window) = 0;
-  virtual void PopupAt(Window* window, int x, int y) = 0;
+  virtual void PopupAt(Window* window,
+                       int x = -1, int y = -1,
+                       int positioning_item = 0) = 0;
 
   scoped_ptr<AtomMenuModel> model_;
   Menu* parent_;

atom/browser/api/atom_api_menu_mac.h

@@ -19,8 +19,7 @@ class MenuMac : public Menu {
  protected:
   MenuMac();
 
-  void Popup(Window* window) override;
-  void PopupAt(Window* window, int x, int y) override;
+  void PopupAt(Window* window, int x, int y, int positioning_item = 0) override;
 
   base::scoped_nsobject<AtomMenuController> menu_controller_;
 

atom/browser/api/atom_api_menu_mac.mm

@@ -18,39 +18,7 @@ namespace api {
 MenuMac::MenuMac() {
 }
 
-void MenuMac::Popup(Window* window) {
-  NativeWindow* native_window = window->window();
-  if (!native_window)
-    return;
-  content::WebContents* web_contents = native_window->web_contents();
-  if (!web_contents)
-    return;
-
-  NSWindow* nswindow = native_window->GetNativeWindow();
-  base::scoped_nsobject<AtomMenuController> menu_controller(
-      [[AtomMenuController alloc] initWithModel:model_.get()]);
-
-  // Fake out a context menu event.
-  NSEvent* currentEvent = [NSApp currentEvent];
-  NSPoint position = [nswindow mouseLocationOutsideOfEventStream];
-  NSTimeInterval eventTime = [currentEvent timestamp];
-  NSEvent* clickEvent = [NSEvent mouseEventWithType:NSRightMouseDown
-                                           location:position
-                                      modifierFlags:NSRightMouseDownMask
-                                          timestamp:eventTime
-                                       windowNumber:[nswindow windowNumber]
-                                            context:nil
-                                        eventNumber:0
-                                         clickCount:1
-                                           pressure:1.0];
-
-  // Show the menu.
-  [NSMenu popUpContextMenu:[menu_controller menu]
-                 withEvent:clickEvent
-                   forView:web_contents->GetContentNativeView()];
-}
-
-void MenuMac::PopupAt(Window* window, int x, int y) {
+void MenuMac::PopupAt(Window* window, int x, int y, int positioning_item) {
   NativeWindow* native_window = window->window();
   if (!native_window)
     return;
@@ -63,10 +31,23 @@ void MenuMac::PopupAt(Window* window, int x, int y) {
   NSMenu* menu = [menu_controller menu];
   NSView* view = web_contents->GetContentNativeView();
 
+  // Which menu item to show.
+  NSMenuItem* item = nil;
+  if (positioning_item < [menu numberOfItems] && positioning_item >= 0)
+    item = [menu itemAtIndex:positioning_item];
+
+  // (-1, -1) means showing on mouse location.
+  NSPoint position;
+  if (x == -1 || y == -1) {
+    NSWindow* nswindow = native_window->GetNativeWindow();
+    position = [view convertPoint:[nswindow mouseLocationOutsideOfEventStream]
+                         fromView:nil];
+  } else {
+    position = NSMakePoint(x, [view frame].size.height - y);
+  }
+
   // Show the menu.
-  [menu popUpMenuPositioningItem:[menu itemAtIndex:0]
-                      atLocation:NSMakePoint(x, [view frame].size.height - y)
-                          inView:view];
+  [menu popUpMenuPositioningItem:item atLocation:position inView:view];
 }
 
 // static

atom/browser/api/atom_api_menu_views.cc

@@ -16,11 +16,7 @@ namespace api {
 MenuViews::MenuViews() {
 }
 
-void MenuViews::Popup(Window* window) {
-  PopupAtPoint(window, gfx::Screen::GetNativeScreen()->GetCursorScreenPoint());
-}
-
-void MenuViews::PopupAt(Window* window, int x, int y) {
+void MenuViews::PopupAt(Window* window, int x, int y, int positioning_item) {
   NativeWindow* native_window = static_cast<NativeWindow*>(window->window());
   if (!native_window)
     return;
@@ -31,18 +27,23 @@ void MenuViews::PopupAt(Window* window, int x, int y) {
   if (!view)
     return;
 
-  gfx::Point origin = view->GetViewBounds().origin();
-  PopupAtPoint(window, gfx::Point(origin.x() + x, origin.y() + y));
-}
+  // (-1, -1) means showing on mouse location.
+  gfx::Point location;
+  if (x == -1 || y == -1) {
+    location = gfx::Screen::GetNativeScreen()->GetCursorScreenPoint();
+  } else {
+    gfx::Point origin = view->GetViewBounds().origin();
+    location = gfx::Point(origin.x() + x, origin.y() + y);
+  }
 
-void MenuViews::PopupAtPoint(Window* window, const gfx::Point& point) {
+  // Show the menu.
   views::MenuRunner menu_runner(
       model(),
       views::MenuRunner::CONTEXT_MENU | views::MenuRunner::HAS_MNEMONICS);
   ignore_result(menu_runner.RunMenuAt(
       static_cast<NativeWindowViews*>(window->window())->widget(),
       NULL,
-      gfx::Rect(point, gfx::Size()),
+      gfx::Rect(location, gfx::Size()),
       views::MENU_ANCHOR_TOPLEFT,
       ui::MENU_SOURCE_MOUSE));
 }

atom/browser/api/atom_api_menu_views.h

@@ -17,12 +17,9 @@ class MenuViews : public Menu {
   MenuViews();
 
  protected:
-  void Popup(Window* window) override;
-  void PopupAt(Window* window, int x, int y) override;
+  void PopupAt(Window* window, int x, int y, int positioning_item = 0) override;
 
  private:
-  void PopupAtPoint(Window* window, const gfx::Point& point);
-
   DISALLOW_COPY_AND_ASSIGN(MenuViews);
 };
 

atom/browser/api/atom_api_session.cc

@@ -14,14 +14,17 @@
 #include "atom/browser/api/save_page_handler.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/atom_permission_manager.h"
 #include "atom/browser/net/atom_cert_verifier.h"
 #include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/content_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/node_includes.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "brightray/browser/net/devtools_network_conditions.h"
@@ -33,6 +36,7 @@
 #include "native_mate/object_template_builder.h"
 #include "net/base/load_flags.h"
 #include "net/disk_cache/disk_cache.h"
+#include "net/dns/host_cache.h"
 #include "net/proxy/proxy_service.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/url_request/url_request_context.h"
@@ -114,14 +118,25 @@ struct Converter<net::ProxyConfig> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Local<v8::Value> val,
                      net::ProxyConfig* out) {
-    std::string proxy;
-    if (!ConvertFromV8(isolate, val, &proxy))
+    std::string proxy_rules;
+    GURL pac_url;
+    mate::Dictionary options;
+    // Fallback to previous API when passed String.
+    // https://git.io/vuhjj
+    if (ConvertFromV8(isolate, val, &proxy_rules)) {
+      pac_url = GURL(proxy_rules);  // Assume it is PAC script if it is URL.
+    } else if (ConvertFromV8(isolate, val, &options)) {
+      options.Get("pacScript", &pac_url);
+      options.Get("proxyRules", &proxy_rules);
+    } else {
       return false;
-    auto pac_url = GURL(proxy);
-    if (pac_url.is_valid()) {
+    }
+
+    // pacScript takes precedence over proxyRules.
+    if (!pac_url.is_empty() && pac_url.is_valid()) {
       out->set_pac_url(pac_url);
     } else {
-      out->proxy_rules().ParseFromString(proxy);
+      out->proxy_rules().ParseFromString(proxy_rules);
     }
     return true;
   }
@@ -193,7 +208,7 @@ class ResolveProxyHelper {
 };
 
 // Runs the callback in UI thread.
-template <typename ...T>
+template<typename ...T>
 void RunCallbackInUI(const base::Callback<void(T...)>& callback, T... result) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(callback, result...));
@@ -201,19 +216,35 @@ void RunCallbackInUI(const base::Callback<void(T...)>& callback, T... result) {
 
 // Callback of HttpCache::GetBackend.
 void OnGetBackend(disk_cache::Backend** backend_ptr,
+                  Session::CacheAction action,
                   const net::CompletionCallback& callback,
                   int result) {
   if (result != net::OK) {
     RunCallbackInUI(callback, result);
   } else if (backend_ptr && *backend_ptr) {
-    (*backend_ptr)->DoomAllEntries(base::Bind(&RunCallbackInUI<int>, callback));
+    if (action == Session::CacheAction::CLEAR) {
+      (*backend_ptr)->DoomAllEntries(base::Bind(&RunCallbackInUI<int>,
+                                                callback));
+    } else if (action == Session::CacheAction::STATS) {
+      base::StringPairs stats;
+      (*backend_ptr)->GetStats(&stats);
+      for (size_t i = 0; i < stats.size(); ++i) {
+        if (stats[i].first == "Current size") {
+          int current_size;
+          base::StringToInt(stats[i].second, &current_size);
+          RunCallbackInUI(callback, current_size);
+          break;
+        }
+      }
+    }
   } else {
     RunCallbackInUI<int>(callback, net::ERR_FAILED);
   }
 }
 
-void ClearHttpCacheInIO(
+void DoCacheActionInIO(
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
+    Session::CacheAction action,
     const net::CompletionCallback& callback) {
   auto request_context = context_getter->GetURLRequestContext();
   auto http_cache = request_context->http_transaction_factory()->GetCache();
@@ -224,7 +255,7 @@ void ClearHttpCacheInIO(
   using BackendPtr = disk_cache::Backend*;
   BackendPtr* backend_ptr = new BackendPtr(nullptr);
   net::CompletionCallback on_get_backend =
-      base::Bind(&OnGetBackend, base::Owned(backend_ptr), callback);
+      base::Bind(&OnGetBackend, base::Owned(backend_ptr), action, callback);
   int rv = http_cache->GetBackend(backend_ptr, on_get_backend);
   if (rv != net::ERR_IO_PENDING)
     on_get_backend.Run(net::OK);
@@ -241,6 +272,19 @@ void SetProxyInIO(net::URLRequestContextGetter* getter,
   RunCallbackInUI(callback);
 }
 
+void ClearHostResolverCacheInIO(
+    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
+    const base::Closure& callback) {
+  auto request_context = context_getter->GetURLRequestContext();
+  auto cache = request_context->host_resolver()->GetHostCache();
+  if (cache) {
+    cache->clear();
+    DCHECK_EQ(0u, cache->size());
+    if (!callback.is_null())
+      RunCallbackInUI(callback);
+  }
+}
+
 }  // namespace
 
 Session::Session(AtomBrowserContext* browser_context)
@@ -276,10 +320,12 @@ void Session::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
   new ResolveProxyHelper(browser_context(), url, callback);
 }
 
-void Session::ClearCache(const net::CompletionCallback& callback) {
+template<Session::CacheAction action>
+void Session::DoCacheAction(const net::CompletionCallback& callback) {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(&ClearHttpCacheInIO,
+      base::Bind(&DoCacheActionInIO,
                  make_scoped_refptr(browser_context_->GetRequestContext()),
+                 action,
                  callback));
 }
 
@@ -301,6 +347,12 @@ void Session::ClearStorageData(mate::Arguments* args) {
       base::Time(), base::Time::Max(), callback);
 }
 
+void Session::FlushStorageData() {
+  auto storage_partition =
+      content::BrowserContext::GetStoragePartition(browser_context(), nullptr);
+  storage_partition->Flush();
+}
+
 void Session::SetProxy(const net::ProxyConfig& config,
                        const base::Closure& callback) {
   auto getter = browser_context_->GetRequestContext();
@@ -361,6 +413,28 @@ void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
   browser_context_->cert_verifier()->SetVerifyProc(proc);
 }
 
+void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
+                                          mate::Arguments* args) {
+  AtomPermissionManager::RequestHandler handler;
+  if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &handler))) {
+    args->ThrowError("Must pass null or function");
+    return;
+  }
+  auto permission_manager = static_cast<AtomPermissionManager*>(
+      browser_context()->GetPermissionManager());
+  permission_manager->SetPermissionRequestHandler(handler);
+}
+
+void Session::ClearHostResolverCache(mate::Arguments* args) {
+  base::Closure callback;
+  args->GetNext(&callback);
+
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&ClearHostResolverCacheInIO,
+                 make_scoped_refptr(browser_context_->GetRequestContext()),
+                 callback));
+}
+
 v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
   if (cookies_.IsEmpty()) {
     auto handle = atom::api::Cookies::Create(isolate, browser_context());
@@ -403,13 +477,18 @@ void Session::BuildPrototype(v8::Isolate* isolate,
   mate::ObjectTemplateBuilder(isolate, prototype)
       .MakeDestroyable()
       .SetMethod("resolveProxy", &Session::ResolveProxy)
-      .SetMethod("clearCache", &Session::ClearCache)
+      .SetMethod("getCacheSize", &Session::DoCacheAction<CacheAction::STATS>)
+      .SetMethod("clearCache", &Session::DoCacheAction<CacheAction::CLEAR>)
       .SetMethod("clearStorageData", &Session::ClearStorageData)
+      .SetMethod("flushStorageData", &Session::FlushStorageData)
       .SetMethod("setProxy", &Session::SetProxy)
       .SetMethod("setDownloadPath", &Session::SetDownloadPath)
       .SetMethod("enableNetworkEmulation", &Session::EnableNetworkEmulation)
       .SetMethod("disableNetworkEmulation", &Session::DisableNetworkEmulation)
       .SetMethod("setCertificateVerifyProc", &Session::SetCertVerifyProc)
+      .SetMethod("setPermissionRequestHandler",
+                 &Session::SetPermissionRequestHandler)
+      .SetMethod("clearHostResolverCache", &Session::ClearHostResolverCache)
       .SetProperty("cookies", &Session::Cookies)
       .SetProperty("webRequest", &Session::WebRequest);
 }

atom/browser/api/atom_api_session.h

@@ -38,6 +38,11 @@ class Session: public mate::TrackableObject<Session>,
  public:
   using ResolveProxyCallback = base::Callback<void(std::string)>;
 
+  enum class CacheAction {
+    CLEAR,
+    STATS,
+  };
+
   // Gets or creates Session from the |browser_context|.
   static mate::Handle<Session> CreateFrom(
       v8::Isolate* isolate, AtomBrowserContext* browser_context);
@@ -62,13 +67,18 @@ class Session: public mate::TrackableObject<Session>,
 
  private:
   void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
-  void ClearCache(const net::CompletionCallback& callback);
+  template<CacheAction action>
+  void DoCacheAction(const net::CompletionCallback& callback);
   void ClearStorageData(mate::Arguments* args);
+  void FlushStorageData();
   void SetProxy(const net::ProxyConfig& config, const base::Closure& callback);
   void SetDownloadPath(const base::FilePath& path);
   void EnableNetworkEmulation(const mate::Dictionary& options);
   void DisableNetworkEmulation();
   void SetCertVerifyProc(v8::Local<v8::Value> proc, mate::Arguments* args);
+  void SetPermissionRequestHandler(v8::Local<v8::Value> val,
+                                   mate::Arguments* args);
+  void ClearHostResolverCache(mate::Arguments* args);
   v8::Local<v8::Value> Cookies(v8::Isolate* isolate);
   v8::Local<v8::Value> WebRequest(v8::Isolate* isolate);
 

atom/browser/api/atom_api_web_contents.cc

@@ -7,12 +7,14 @@
 #include <set>
 #include <string>
 
+#include "atom/browser/api/atom_api_debugger.h"
 #include "atom/browser/api/atom_api_session.h"
 #include "atom/browser/api/atom_api_window.h"
 #include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/native_window.h"
+#include "atom/browser/web_contents_permission_helper.h"
 #include "atom/browser/web_contents_preferences.h"
 #include "atom/browser/web_view_guest_delegate.h"
 #include "atom/common/api/api_messages.h"
@@ -26,6 +28,7 @@
 #include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/mouse_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "brightray/browser/inspectable_web_contents.h"
@@ -33,7 +36,6 @@
 #include "chrome/browser/printing/print_view_manager_basic.h"
 #include "chrome/browser/printing/print_preview_message_handler.h"
 #include "content/common/view_messages.h"
-#include "content/public/browser/browser_plugin_guest_manager.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_details.h"
@@ -75,15 +77,6 @@ void SetUserAgentInIO(scoped_refptr<net::URLRequestContextGetter> getter,
           user_agent));
 }
 
-bool NotifyZoomLevelChanged(
-    double level, content::WebContents* guest_web_contents) {
-  guest_web_contents->SendToAllFrames(
-      new AtomViewMsg_SetZoomLevel(MSG_ROUTING_NONE, level));
-
-  // Return false to iterate over all guests.
-  return false;
-}
-
 }  // namespace
 
 namespace mate {
@@ -224,7 +217,9 @@ WebContents::WebContents(content::WebContents* web_contents)
 }
 
 WebContents::WebContents(v8::Isolate* isolate,
-                         const mate::Dictionary& options) {
+                         const mate::Dictionary& options)
+    : embedder_(nullptr),
+      request_id_(0) {
   // Whether it is a guest WebContents.
   bool is_guest = false;
   options.Get("isGuest", &is_guest);
@@ -270,16 +265,19 @@ WebContents::WebContents(v8::Isolate* isolate,
   // Save the preferences in C++.
   new WebContentsPreferences(web_contents, options);
 
+  // Intialize permission helper.
+  WebContentsPermissionHelper::CreateForWebContents(web_contents);
+
   web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());
 
   if (is_guest) {
     guest_delegate_->Initialize(this);
 
     NativeWindow* owner_window = nullptr;
-    WebContents* embedder = nullptr;
-    if (options.Get("embedder", &embedder) && embedder) {
+    if (options.Get("embedder", &embedder_) && embedder_) {
       // New WebContents's owner_window is the embedder's owner_window.
-      auto relay = NativeWindowRelay::FromWebContents(embedder->web_contents());
+      auto relay =
+          NativeWindowRelay::FromWebContents(embedder_->web_contents());
       if (relay)
         owner_window = relay->window.get();
     }
@@ -289,14 +287,18 @@ WebContents::WebContents(v8::Isolate* isolate,
 }
 
 WebContents::~WebContents() {
-  if (type_ == WEB_VIEW && managed_web_contents()) {
-    // When force destroying the "destroyed" event is not emitted.
+  // The destroy() is called.
+  if (managed_web_contents()) {
+    // For webview we need to tell content module to do some cleanup work before
+    // destroying it.
+    if (type_ == WEB_VIEW)
+      guest_delegate_->Destroy();
+
+    // The WebContentsDestroyed will not be called automatically because we
+    // unsubscribe from webContents before destroying it. So we have to manually
+    // call it here to make sure "destroyed" event is emitted.
+    RenderViewDeleted(web_contents()->GetRenderViewHost());
     WebContentsDestroyed();
-
-    guest_delegate_->Destroy();
-
-    Observe(nullptr);
-    DestroyWebContents();
   }
 }
 
@@ -391,6 +393,18 @@ void WebContents::HandleKeyboardEvent(
 
 void WebContents::EnterFullscreenModeForTab(content::WebContents* source,
                                             const GURL& origin) {
+  auto permission_helper =
+      WebContentsPermissionHelper::FromWebContents(source);
+  auto callback = base::Bind(&WebContents::OnEnterFullscreenModeForTab,
+                             base::Unretained(this), source, origin);
+  permission_helper->RequestFullscreenPermission(callback);
+}
+
+void WebContents::OnEnterFullscreenModeForTab(content::WebContents* source,
+                                              const GURL& origin,
+                                              bool allowed) {
+  if (!allowed)
+    return;
   CommonWebContentsDelegate::EnterFullscreenModeForTab(source, origin);
   Emit("enter-html-full-screen");
 }
@@ -421,23 +435,66 @@ bool WebContents::HandleContextMenu(const content::ContextMenuParams& params) {
   return true;
 }
 
+bool WebContents::OnGoToEntryOffset(int offset) {
+  GoToOffset(offset);
+  return false;
+}
+
+void WebContents::FindReply(content::WebContents* web_contents,
+                            int request_id,
+                            int number_of_matches,
+                            const gfx::Rect& selection_rect,
+                            int active_match_ordinal,
+                            bool final_update) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+
+  mate::Dictionary result = mate::Dictionary::CreateEmpty(isolate());
+  if (number_of_matches == -1) {
+    result.Set("requestId", request_id);
+    result.Set("selectionArea", selection_rect);
+    result.Set("finalUpdate", final_update);
+    Emit("found-in-page", result);
+  } else if (final_update) {
+    result.Set("requestId", request_id);
+    result.Set("matches", number_of_matches);
+    result.Set("finalUpdate", final_update);
+    Emit("found-in-page", result);
+  }
+}
+
+bool WebContents::CheckMediaAccessPermission(
+    content::WebContents* web_contents,
+    const GURL& security_origin,
+    content::MediaStreamType type) {
+  return true;
+}
+
+void WebContents::RequestMediaAccessPermission(
+    content::WebContents* web_contents,
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback) {
+  auto permission_helper =
+      WebContentsPermissionHelper::FromWebContents(web_contents);
+  permission_helper->RequestMediaAccessPermission(request, callback);
+}
+
+void WebContents::RequestToLockMouse(
+    content::WebContents* web_contents,
+    bool user_gesture,
+    bool last_unlocked_by_target) {
+  auto permission_helper =
+      WebContentsPermissionHelper::FromWebContents(web_contents);
+  permission_helper->RequestPointerLockPermission(user_gesture);
+}
+
 void WebContents::BeforeUnloadFired(const base::TimeTicks& proceed_time) {
   // Do nothing, we override this method just to avoid compilation error since
   // there are two virtual functions named BeforeUnloadFired.
 }
 
 void WebContents::RenderViewDeleted(content::RenderViewHost* render_view_host) {
-  int process_id = render_view_host->GetProcess()->GetID();
-  Emit("render-view-deleted", process_id);
-
-  // process.emit('ATOM_BROWSER_RELEASE_RENDER_VIEW', processId);
-  // Tell the rpc server that a render view has been deleted and we need to
-  // release all objects owned by it.
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  node::Environment* env = node::Environment::GetCurrent(isolate());
-  mate::EmitEvent(isolate(), env->process_object(),
-                  "ATOM_BROWSER_RELEASE_RENDER_VIEW", process_id);
+  Emit("render-view-deleted", render_view_host->GetProcess()->GetID());
 }
 
 void WebContents::RenderProcessGone(base::TerminationStatus status) {
@@ -452,6 +509,22 @@ void WebContents::PluginCrashed(const base::FilePath& plugin_path,
   Emit("plugin-crashed", info.name, info.version);
 }
 
+void WebContents::MediaStartedPlaying() {
+  Emit("media-started-playing");
+}
+
+void WebContents::MediaPaused() {
+  Emit("media-paused");
+}
+
+void WebContents::DidChangeThemeColor(SkColor theme_color) {
+  std::string hex_theme_color = base::StringPrintf("#%02X%02X%02X",
+    SkColorGetR(theme_color),
+    SkColorGetG(theme_color),
+    SkColorGetB(theme_color));
+  Emit("did-change-theme-color", hex_theme_color);
+}
+
 void WebContents::DocumentLoadedInFrame(
     content::RenderFrameHost* render_frame_host) {
   if (!render_frame_host->GetParent())
@@ -521,7 +594,9 @@ void WebContents::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (details.is_navigation_to_different_page())
-    Emit("did-navigate-to-different-page");
+    Emit("did-navigate", params.url);
+  else if (details.is_in_page)
+    Emit("did-navigate-in-page", params.url);
 }
 
 void WebContents::TitleWasSet(content::NavigationEntry* entry,
@@ -578,18 +653,42 @@ bool WebContents::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
                                     OnRendererMessageSync)
-    IPC_MESSAGE_HANDLER(AtomViewHostMsg_ZoomLevelChanged, OnZoomLevelChanged)
+    IPC_MESSAGE_HANDLER_CODE(ViewHostMsg_SetCursor, OnCursorChange,
+      handled = false)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
+// There are three ways of destroying a webContents:
+// 1. call webContents.destory();
+// 2. garbage collection;
+// 3. user closes the window of webContents;
+// For webview only #1 will happen, for BrowserWindow both #1 and #3 may
+// happen. The #2 should never happen for webContents, because webview is
+// managed by GuestViewManager, and BrowserWindow's webContents is managed
+// by api::Window.
+// For #1, the destructor will do the cleanup work and we only need to make
+// sure "destroyed" event is emitted. For #3, the content::WebContents will
+// be destroyed on close, and WebContentsDestroyed would be called for it, so
+// we need to make sure the api::WebContents is also deleted.
 void WebContents::WebContentsDestroyed() {
-  // The RenderViewDeleted was not called when the WebContents is destroyed.
-  RenderViewDeleted(web_contents()->GetRenderViewHost());
-  Emit("destroyed");
+  // This event is only for internal use, which is emitted when WebContents is
+  // being destroyed.
+  Emit("will-destroy");
+
+  // Cleanup relationships with other parts.
   RemoveFromWeakMap();
+
+  // We can not call Destroy here because we need to call Emit first, but we
+  // also do not want any method to be used, so just mark as destroyed here.
+  MarkDestroyed();
+
+  Emit("destroyed");
+
+  // Destroy the native class in next tick.
+  base::MessageLoop::current()->PostTask(FROM_HERE, GetDestroyClosure());
 }
 
 void WebContents::NavigationEntryCommitted(
@@ -607,6 +706,14 @@ bool WebContents::Equal(const WebContents* web_contents) const {
 }
 
 void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
+  if (!url.is_valid()) {
+    Emit("did-fail-load",
+         static_cast<int>(net::ERR_INVALID_URL),
+         net::ErrorToShortString(net::ERR_INVALID_URL),
+         url.possibly_invalid_spec());
+    return;
+  }
+
   content::NavigationController::LoadURLParams params(url);
 
   GURL http_referrer;
@@ -701,11 +808,6 @@ bool WebContents::SavePage(const base::FilePath& full_file_path,
   return handler->Handle(full_file_path, save_type);
 }
 
-void WebContents::ExecuteJavaScript(const base::string16& code,
-                                    bool has_user_gesture) {
-  Send(new AtomViewMsg_ExecuteJavaScript(routing_id(), code, has_user_gesture));
-}
-
 void WebContents::OpenDevTools(mate::Arguments* args) {
   if (type_ == REMOTE)
     return;
@@ -735,6 +837,13 @@ bool WebContents::IsDevToolsOpened() {
   return managed_web_contents()->IsDevToolsViewShowing();
 }
 
+bool WebContents::IsDevToolsFocused() {
+  if (type_ == REMOTE)
+    return false;
+
+  return managed_web_contents()->GetView()->IsDevToolsViewFocused();
+}
+
 void WebContents::EnableDeviceEmulation(
     const blink::WebDeviceEmulationParams& params) {
   if (type_ == REMOTE)
@@ -889,6 +998,25 @@ void WebContents::ReplaceMisspelling(const base::string16& word) {
   web_contents()->ReplaceMisspelling(word);
 }
 
+uint32 WebContents::FindInPage(mate::Arguments* args) {
+  uint32 request_id = GetNextRequestId();
+  base::string16 search_text;
+  blink::WebFindOptions options;
+  if (!args->GetNext(&search_text) || search_text.empty()) {
+    args->ThrowError("Must provide a non-empty search content");
+    return 0;
+  }
+
+  args->GetNext(&options);
+
+  web_contents()->Find(request_id, search_text, options);
+  return request_id;
+}
+
+void WebContents::StopFindInPage(content::StopFindAction action) {
+  web_contents()->StopFinding(action);
+}
+
 void WebContents::Focus() {
   web_contents()->Focus();
 }
@@ -919,7 +1047,7 @@ void WebContents::SendInputEvent(v8::Isolate* isolate,
       return;
     }
   } else if (blink::WebInputEvent::isKeyboardEventType(type)) {
-    content::NativeWebKeyboardEvent keyboard_event;;
+    content::NativeWebKeyboardEvent keyboard_event;
     if (mate::ConvertFromV8(isolate, input_event, &keyboard_event)) {
       host->ForwardKeyboardEvent(keyboard_event);
       return;
@@ -941,7 +1069,7 @@ void WebContents::BeginFrameSubscription(
   const auto view = web_contents()->GetRenderWidgetHostView();
   if (view) {
     scoped_ptr<FrameSubscriber> frame_subscriber(new FrameSubscriber(
-        isolate(), view->GetVisibleViewportSize(), callback));
+        isolate(), view, callback));
     view->BeginFrameSubscription(frame_subscriber.Pass());
   }
 }
@@ -952,6 +1080,19 @@ void WebContents::EndFrameSubscription() {
     view->EndFrameSubscription();
 }
 
+void WebContents::OnCursorChange(const content::WebCursor& cursor) {
+  content::WebCursor::CursorInfo info;
+  cursor.GetCursorInfo(&info);
+
+  if (cursor.IsCustom()) {
+    Emit("cursor-changed", CursorTypeToString(info),
+      gfx::Image::CreateFrom1xBitmap(info.custom_image),
+      info.image_scale_factor);
+  } else {
+    Emit("cursor-changed", CursorTypeToString(info));
+  }
+}
+
 void WebContents::SetSize(const SetSizeParams& params) {
   if (guest_delegate_)
     guest_delegate_->SetSize(params);
@@ -983,6 +1124,12 @@ v8::Local<v8::Value> WebContents::Session(v8::Isolate* isolate) {
   return v8::Local<v8::Value>::New(isolate, session_);
 }
 
+content::WebContents* WebContents::HostWebContents() {
+  if (!embedder_)
+    return nullptr;
+  return embedder_->web_contents();
+}
+
 v8::Local<v8::Value> WebContents::DevToolsWebContents(v8::Isolate* isolate) {
   if (devtools_web_contents_.IsEmpty())
     return v8::Null(isolate);
@@ -990,6 +1137,14 @@ v8::Local<v8::Value> WebContents::DevToolsWebContents(v8::Isolate* isolate) {
     return v8::Local<v8::Value>::New(isolate, devtools_web_contents_);
 }
 
+v8::Local<v8::Value> WebContents::Debugger(v8::Isolate* isolate) {
+  if (debugger_.IsEmpty()) {
+    auto handle = atom::api::Debugger::Create(isolate, web_contents());
+    debugger_.Reset(isolate, handle.ToV8());
+  }
+  return v8::Local<v8::Value>::New(isolate, debugger_);
+}
+
 // static
 void WebContents::BuildPrototype(v8::Isolate* isolate,
                                  v8::Local<v8::ObjectTemplate> prototype) {
@@ -1012,10 +1167,10 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getUserAgent", &WebContents::GetUserAgent)
       .SetMethod("insertCSS", &WebContents::InsertCSS)
       .SetMethod("savePage", &WebContents::SavePage)
-      .SetMethod("_executeJavaScript", &WebContents::ExecuteJavaScript)
       .SetMethod("openDevTools", &WebContents::OpenDevTools)
       .SetMethod("closeDevTools", &WebContents::CloseDevTools)
       .SetMethod("isDevToolsOpened", &WebContents::IsDevToolsOpened)
+      .SetMethod("isDevToolsFocused", &WebContents::IsDevToolsFocused)
       .SetMethod("enableDeviceEmulation",
                  &WebContents::EnableDeviceEmulation)
       .SetMethod("disableDeviceEmulation",
@@ -1035,6 +1190,8 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("unselect", &WebContents::Unselect)
       .SetMethod("replace", &WebContents::Replace)
       .SetMethod("replaceMisspelling", &WebContents::ReplaceMisspelling)
+      .SetMethod("findInPage", &WebContents::FindInPage)
+      .SetMethod("stopFindInPage", &WebContents::StopFindInPage)
       .SetMethod("focus", &WebContents::Focus)
       .SetMethod("tabTraverse", &WebContents::TabTraverse)
       .SetMethod("_send", &WebContents::SendIPCMessage)
@@ -1056,7 +1213,9 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("addWorkSpace", &WebContents::AddWorkSpace)
       .SetMethod("removeWorkSpace", &WebContents::RemoveWorkSpace)
       .SetProperty("session", &WebContents::Session)
-      .SetProperty("devToolsWebContents", &WebContents::DevToolsWebContents);
+      .SetProperty("hostWebContents", &WebContents::HostWebContents)
+      .SetProperty("devToolsWebContents", &WebContents::DevToolsWebContents)
+      .SetProperty("debugger", &WebContents::Debugger);
 }
 
 AtomBrowserContext* WebContents::GetBrowserContext() const {
@@ -1076,15 +1235,6 @@ void WebContents::OnRendererMessageSync(const base::string16& channel,
   EmitWithSender(base::UTF16ToUTF8(channel), web_contents(), message, args);
 }
 
-void WebContents::OnZoomLevelChanged(double level) {
-  auto manager = web_contents()->GetBrowserContext()->GetGuestManager();
-  if (!manager)
-    return;
-  manager->ForEachGuest(web_contents(),
-                        base::Bind(&NotifyZoomLevelChanged,
-                                   level));
-}
-
 // static
 mate::Handle<WebContents> WebContents::CreateFrom(
     v8::Isolate* isolate, content::WebContents* web_contents) {

atom/browser/api/atom_api_web_contents.h

@@ -14,6 +14,7 @@
 #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/common/cursors/webcursor.h"
 #include "native_mate/handle.h"
 #include "ui/gfx/image/image.h"
 
@@ -74,11 +75,10 @@ class WebContents : public mate::TrackableObject<WebContents>,
   bool SavePage(const base::FilePath& full_file_path,
                 const content::SavePageType& save_type,
                 const SavePageHandler::SavePageCallback& callback);
-  void ExecuteJavaScript(const base::string16& code,
-                         bool has_user_gesture);
   void OpenDevTools(mate::Arguments* args);
   void CloseDevTools();
   bool IsDevToolsOpened();
+  bool IsDevToolsFocused();
   void ToggleDevTools();
   void EnableDeviceEmulation(const blink::WebDeviceEmulationParams& params);
   void DisableDeviceEmulation();
@@ -110,6 +110,8 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void Unselect();
   void Replace(const base::string16& word);
   void ReplaceMisspelling(const base::string16& word);
+  uint32 FindInPage(mate::Arguments* args);
+  void StopFindInPage(content::StopFindAction action);
 
   // Focus.
   void Focus();
@@ -132,6 +134,11 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void SetAllowTransparency(bool allow);
   bool IsGuest() const;
 
+  // Callback triggered on permission response.
+  void OnEnterFullscreenModeForTab(content::WebContents* source,
+                                   const GURL& origin,
+                                   bool allowed);
+
   // Returns the web preferences of current WebContents.
   v8::Local<v8::Value> GetWebPreferences(v8::Isolate* isolate);
 
@@ -140,7 +147,9 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
   // Properties.
   v8::Local<v8::Value> Session(v8::Isolate* isolate);
+  content::WebContents* HostWebContents();
   v8::Local<v8::Value> DevToolsWebContents(v8::Isolate* isolate);
+  v8::Local<v8::Value> Debugger(v8::Isolate* isolate);
 
   // mate::TrackableObject:
   static void BuildPrototype(v8::Isolate* isolate,
@@ -186,6 +195,25 @@ class WebContents : public mate::TrackableObject<WebContents>,
   void RendererUnresponsive(content::WebContents* source) override;
   void RendererResponsive(content::WebContents* source) override;
   bool HandleContextMenu(const content::ContextMenuParams& params) override;
+  bool OnGoToEntryOffset(int offset) override;
+  void FindReply(content::WebContents* web_contents,
+                 int request_id,
+                 int number_of_matches,
+                 const gfx::Rect& selection_rect,
+                 int active_match_ordinal,
+                 bool final_update) override;
+  bool CheckMediaAccessPermission(
+      content::WebContents* web_contents,
+      const GURL& security_origin,
+      content::MediaStreamType type) override;
+  void RequestMediaAccessPermission(
+      content::WebContents* web_contents,
+      const content::MediaStreamRequest& request,
+      const content::MediaResponseCallback& callback) override;
+  void RequestToLockMouse(
+      content::WebContents* web_contents,
+      bool user_gesture,
+      bool last_unlocked_by_target) override;
 
   // content::WebContentsObserver:
   void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
@@ -224,6 +252,9 @@ class WebContents : public mate::TrackableObject<WebContents>,
       const std::vector<content::FaviconURL>& urls) override;
   void PluginCrashed(const base::FilePath& plugin_path,
                      base::ProcessId plugin_pid) override;
+  void MediaStartedPlaying() override;
+  void MediaPaused() override;
+  void DidChangeThemeColor(SkColor theme_color) override;
 
   // brightray::InspectableWebContentsViewDelegate:
   void DevToolsFocused() override;
@@ -239,6 +270,13 @@ class WebContents : public mate::TrackableObject<WebContents>,
 
   AtomBrowserContext* GetBrowserContext() const;
 
+  uint32 GetNextRequestId() {
+    return ++request_id_;
+  }
+
+  // Called when we receive a CursorChange message from chromium.
+  void OnCursorChange(const content::WebCursor& cursor);
+
   // Called when received a message from renderer.
   void OnRendererMessage(const base::string16& channel,
                          const base::ListValue& args);
@@ -248,18 +286,21 @@ class WebContents : public mate::TrackableObject<WebContents>,
                              const base::ListValue& args,
                              IPC::Message* message);
 
-  // Called when guests need to be notified of
-  // embedders' zoom level change.
-  void OnZoomLevelChanged(double level);
-
   v8::Global<v8::Value> session_;
   v8::Global<v8::Value> devtools_web_contents_;
+  v8::Global<v8::Value> debugger_;
 
   scoped_ptr<WebViewGuestDelegate> guest_delegate_;
 
+  // The host webcontents that may contain this webcontents.
+  WebContents* embedder_;
+
   // The type of current WebContents.
   Type type_;
 
+  // Request id used for findInPage request.
+  uint32 request_id_;
+
   DISALLOW_COPY_AND_ASSIGN(WebContents);
 };
 

atom/browser/api/atom_api_window.cc

@@ -107,16 +107,14 @@ void TranslateOldOptions(v8::Isolate* isolate, v8::Local<v8::Object> options) {
   }
 }
 
-#if defined(OS_WIN)
 // Converts binary data to Buffer.
 v8::Local<v8::Value> ToBuffer(v8::Isolate* isolate, void* val, int size) {
-  auto buffer = node::Buffer::New(isolate, static_cast<char*>(val), size);
+  auto buffer = node::Buffer::Copy(isolate, static_cast<char*>(val), size);
   if (buffer.IsEmpty())
     return v8::Null(isolate);
   else
     return buffer.ToLocalChecked();
 }
-#endif
 
 }  // namespace
 
@@ -193,6 +191,14 @@ void Window::OnWindowFocus() {
   Emit("focus");
 }
 
+void Window::OnWindowShow() {
+  Emit("show");
+}
+
+void Window::OnWindowHide() {
+  Emit("hide");
+}
+
 void Window::OnWindowMaximize() {
   Emit("maximize");
 }
@@ -229,6 +235,14 @@ void Window::OnWindowLeaveFullScreen() {
   Emit("leave-full-screen");
 }
 
+void Window::OnWindowScrollTouchBegin() {
+  Emit("scroll-touch-begin");
+}
+
+void Window::OnWindowScrollTouchEnd() {
+  Emit("scroll-touch-end");
+}
+
 void Window::OnWindowEnterHtmlFullScreen() {
   Emit("enter-html-full-screen");
 }
@@ -288,6 +302,10 @@ void Window::Focus() {
   window_->Focus(true);
 }
 
+void Window::Blur() {
+  window_->Focus(false);
+}
+
 bool Window::IsFocused() {
   return window_->IsFocused();
 }
@@ -340,16 +358,20 @@ bool Window::IsFullscreen() {
   return window_->IsFullscreen();
 }
 
-void Window::SetBounds(const gfx::Rect& bounds) {
-  window_->SetBounds(bounds);
+void Window::SetBounds(const gfx::Rect& bounds, mate::Arguments* args) {
+  bool animate = false;
+  args->GetNext(&animate);
+  window_->SetBounds(bounds, animate);
 }
 
 gfx::Rect Window::GetBounds() {
   return window_->GetBounds();
 }
 
-void Window::SetSize(int width, int height) {
-  window_->SetSize(gfx::Size(width, height));
+void Window::SetSize(int width, int height, mate::Arguments* args) {
+  bool animate = false;
+  args->GetNext(&animate);
+  window_->SetSize(gfx::Size(width, height), animate);
 }
 
 std::vector<int> Window::GetSize() {
@@ -360,8 +382,10 @@ std::vector<int> Window::GetSize() {
   return result;
 }
 
-void Window::SetContentSize(int width, int height) {
-  window_->SetContentSize(gfx::Size(width, height));
+void Window::SetContentSize(int width, int height, mate::Arguments* args) {
+  bool animate = false;
+  args->GetNext(&animate);
+  window_->SetContentSize(gfx::Size(width, height), animate);
 }
 
 std::vector<int> Window::GetContentSize() {
@@ -404,6 +428,46 @@ bool Window::IsResizable() {
   return window_->IsResizable();
 }
 
+void Window::SetMovable(bool movable) {
+  window_->SetMovable(movable);
+}
+
+bool Window::IsMovable() {
+  return window_->IsMovable();
+}
+
+void Window::SetMinimizable(bool minimizable) {
+  window_->SetMinimizable(minimizable);
+}
+
+bool Window::IsMinimizable() {
+  return window_->IsMinimizable();
+}
+
+void Window::SetMaximizable(bool maximizable) {
+  window_->SetMaximizable(maximizable);
+}
+
+bool Window::IsMaximizable() {
+  return window_->IsMaximizable();
+}
+
+void Window::SetFullScreenable(bool fullscreenable) {
+  window_->SetFullScreenable(fullscreenable);
+}
+
+bool Window::IsFullScreenable() {
+  return window_->IsFullScreenable();
+}
+
+void Window::SetClosable(bool closable) {
+  window_->SetClosable(closable);
+}
+
+bool Window::IsClosable() {
+  return window_->IsClosable();
+}
+
 void Window::SetAlwaysOnTop(bool top) {
   window_->SetAlwaysOnTop(top);
 }
@@ -416,8 +480,10 @@ void Window::Center() {
   window_->Center();
 }
 
-void Window::SetPosition(int x, int y) {
-  window_->SetPosition(gfx::Point(x, y));
+void Window::SetPosition(int x, int y, mate::Arguments* args) {
+  bool animate = false;
+  args->GetNext(&animate);
+  window_->SetPosition(gfx::Point(x, y), animate);
 }
 
 std::vector<int> Window::GetPosition() {
@@ -456,6 +522,14 @@ void Window::SetBackgroundColor(const std::string& color_name) {
   window_->SetBackgroundColor(color_name);
 }
 
+void Window::SetHasShadow(bool has_shadow) {
+  window_->SetHasShadow(has_shadow);
+}
+
+bool Window::HasShadow() {
+  return window_->HasShadow();
+}
+
 void Window::FocusOnWebView() {
   window_->FocusOnWebView();
 }
@@ -468,10 +542,6 @@ bool Window::IsWebViewFocused() {
   return window_->IsWebViewFocused();
 }
 
-bool Window::IsDevToolsFocused() {
-  return window_->IsDevToolsFocused();
-}
-
 void Window::SetRepresentedFilename(const std::string& filename) {
   window_->SetRepresentedFilename(filename);
 }
@@ -598,6 +668,12 @@ void Window::SetAspectRatio(double aspect_ratio, mate::Arguments* args) {
   window_->SetAspectRatio(aspect_ratio, extra_size);
 }
 
+v8::Local<v8::Value> Window::GetNativeWindowHandle() {
+  gfx::AcceleratedWidget handle = window_->GetAcceleratedWidget();
+  return ToBuffer(
+      isolate(), static_cast<void*>(&handle), sizeof(gfx::AcceleratedWidget));
+}
+
 void Window::SetVisibleOnAllWorkspaces(bool visible) {
   return window_->SetVisibleOnAllWorkspaces(visible);
 }
@@ -624,6 +700,7 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .MakeDestroyable()
       .SetMethod("close", &Window::Close)
       .SetMethod("focus", &Window::Focus)
+      .SetMethod("blur", &Window::Blur)
       .SetMethod("isFocused", &Window::IsFocused)
       .SetMethod("show", &Window::Show)
       .SetMethod("showInactive", &Window::ShowInactive)
@@ -638,6 +715,7 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setFullScreen", &Window::SetFullScreen)
       .SetMethod("isFullScreen", &Window::IsFullscreen)
       .SetMethod("setAspectRatio", &Window::SetAspectRatio)
+      .SetMethod("getNativeWindowHandle", &Window::GetNativeWindowHandle)
       .SetMethod("getBounds", &Window::GetBounds)
       .SetMethod("setBounds", &Window::SetBounds)
       .SetMethod("getSize", &Window::GetSize)
@@ -650,6 +728,16 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getMaximumSize", &Window::GetMaximumSize)
       .SetMethod("setResizable", &Window::SetResizable)
       .SetMethod("isResizable", &Window::IsResizable)
+      .SetMethod("setMovable", &Window::SetMovable)
+      .SetMethod("isMovable", &Window::IsMovable)
+      .SetMethod("setMinimizable", &Window::SetMinimizable)
+      .SetMethod("isMinimizable", &Window::IsMinimizable)
+      .SetMethod("setMaximizable", &Window::SetMaximizable)
+      .SetMethod("isMaximizable", &Window::IsMaximizable)
+      .SetMethod("setFullScreenable", &Window::SetFullScreenable)
+      .SetMethod("isFullScreenable", &Window::IsFullScreenable)
+      .SetMethod("setClosable", &Window::SetClosable)
+      .SetMethod("isClosable", &Window::IsClosable)
       .SetMethod("setAlwaysOnTop", &Window::SetAlwaysOnTop)
       .SetMethod("isAlwaysOnTop", &Window::IsAlwaysOnTop)
       .SetMethod("center", &Window::Center)
@@ -662,6 +750,8 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setKiosk", &Window::SetKiosk)
       .SetMethod("isKiosk", &Window::IsKiosk)
       .SetMethod("setBackgroundColor", &Window::SetBackgroundColor)
+      .SetMethod("setHasShadow", &Window::SetHasShadow)
+      .SetMethod("hasShadow", &Window::HasShadow)
       .SetMethod("setRepresentedFilename", &Window::SetRepresentedFilename)
       .SetMethod("getRepresentedFilename", &Window::GetRepresentedFilename)
       .SetMethod("setDocumentEdited", &Window::SetDocumentEdited)
@@ -670,7 +760,6 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("focusOnWebView", &Window::FocusOnWebView)
       .SetMethod("blurWebView", &Window::BlurWebView)
       .SetMethod("isWebViewFocused", &Window::IsWebViewFocused)
-      .SetMethod("isDevToolsFocused", &Window::IsDevToolsFocused)
       .SetMethod("capturePage", &Window::CapturePage)
       .SetMethod("setProgressBar", &Window::SetProgressBar)
       .SetMethod("setOverlayIcon", &Window::SetOverlayIcon)

atom/browser/api/atom_api_window.h

@@ -58,6 +58,8 @@ class Window : public mate::TrackableObject<Window>,
   void OnWindowClosed() override;
   void OnWindowBlur() override;
   void OnWindowFocus() override;
+  void OnWindowShow() override;
+  void OnWindowHide() override;
   void OnWindowMaximize() override;
   void OnWindowUnmaximize() override;
   void OnWindowMinimize() override;
@@ -65,6 +67,8 @@ class Window : public mate::TrackableObject<Window>,
   void OnWindowResize() override;
   void OnWindowMove() override;
   void OnWindowMoved() override;
+  void OnWindowScrollTouchBegin() override;
+  void OnWindowScrollTouchEnd() override;
   void OnWindowEnterFullScreen() override;
   void OnWindowLeaveFullScreen() override;
   void OnWindowEnterHtmlFullScreen() override;
@@ -81,6 +85,7 @@ class Window : public mate::TrackableObject<Window>,
   // APIs for NativeWindow.
   void Close();
   void Focus();
+  void Blur();
   bool IsFocused();
   void Show();
   void ShowInactive();
@@ -94,11 +99,11 @@ class Window : public mate::TrackableObject<Window>,
   bool IsMinimized();
   void SetFullScreen(bool fullscreen);
   bool IsFullscreen();
-  void SetBounds(const gfx::Rect& bounds);
+  void SetBounds(const gfx::Rect& bounds, mate::Arguments* args);
   gfx::Rect GetBounds();
-  void SetSize(int width, int height);
+  void SetSize(int width, int height, mate::Arguments* args);
   std::vector<int> GetSize();
-  void SetContentSize(int width, int height);
+  void SetContentSize(int width, int height, mate::Arguments* args);
   std::vector<int> GetContentSize();
   void SetMinimumSize(int width, int height);
   std::vector<int> GetMinimumSize();
@@ -106,10 +111,20 @@ class Window : public mate::TrackableObject<Window>,
   std::vector<int> GetMaximumSize();
   void SetResizable(bool resizable);
   bool IsResizable();
+  void SetMovable(bool movable);
+  bool IsMovable();
+  void SetMinimizable(bool minimizable);
+  bool IsMinimizable();
+  void SetMaximizable(bool maximizable);
+  bool IsMaximizable();
+  void SetFullScreenable(bool fullscreenable);
+  bool IsFullScreenable();
+  void SetClosable(bool closable);
+  bool IsClosable();
   void SetAlwaysOnTop(bool top);
   bool IsAlwaysOnTop();
   void Center();
-  void SetPosition(int x, int y);
+  void SetPosition(int x, int y, mate::Arguments* args);
   std::vector<int> GetPosition();
   void SetTitle(const std::string& title);
   std::string GetTitle();
@@ -118,10 +133,11 @@ class Window : public mate::TrackableObject<Window>,
   void SetKiosk(bool kiosk);
   bool IsKiosk();
   void SetBackgroundColor(const std::string& color_name);
+  void SetHasShadow(bool has_shadow);
+  bool HasShadow();
   void FocusOnWebView();
   void BlurWebView();
   bool IsWebViewFocused();
-  bool IsDevToolsFocused();
   void SetRepresentedFilename(const std::string& filename);
   std::string GetRepresentedFilename();
   void SetDocumentEdited(bool edited);
@@ -138,6 +154,7 @@ class Window : public mate::TrackableObject<Window>,
   void SetMenuBarVisibility(bool visible);
   bool IsMenuBarVisible();
   void SetAspectRatio(double aspect_ratio, mate::Arguments* args);
+  v8::Local<v8::Value> GetNativeWindowHandle();
 
 #if defined(OS_WIN)
   typedef base::Callback<void(v8::Local<v8::Value>,

atom/browser/api/frame_subscriber.cc

@@ -4,19 +4,18 @@
 
 #include "atom/browser/api/frame_subscriber.h"
 
-#include "atom/common/node_includes.h"
 #include "base/bind.h"
-#include "media/base/video_frame.h"
-#include "media/base/yuv_convert.h"
+#include "atom/common/node_includes.h"
+#include "content/public/browser/render_widget_host.h"
 
 namespace atom {
 
 namespace api {
 
 FrameSubscriber::FrameSubscriber(v8::Isolate* isolate,
-                                 const gfx::Size& size,
+                                 content::RenderWidgetHostView* view,
                                  const FrameCaptureCallback& callback)
-    : isolate_(isolate), size_(size), callback_(callback) {
+    : isolate_(isolate), view_(view), callback_(callback), weak_factory_(this) {
 }
 
 bool FrameSubscriber::ShouldCaptureFrame(
@@ -24,39 +23,39 @@ bool FrameSubscriber::ShouldCaptureFrame(
     base::TimeTicks present_time,
     scoped_refptr<media::VideoFrame>* storage,
     DeliverFrameCallback* callback) {
-  *storage = media::VideoFrame::CreateFrame(
-      media::PIXEL_FORMAT_YV12,
-      size_, gfx::Rect(size_), size_, base::TimeDelta());
-  *callback = base::Bind(&FrameSubscriber::OnFrameDelivered,
-                         base::Unretained(this), *storage);
-  return true;
+  const auto host = view_ ? view_->GetRenderWidgetHost() : nullptr;
+  if (!view_ || !host)
+    return false;
+
+  const auto size = view_->GetVisibleViewportSize();
+
+  host->CopyFromBackingStore(
+      gfx::Rect(size),
+      size,
+      base::Bind(&FrameSubscriber::OnFrameDelivered,
+                 weak_factory_.GetWeakPtr(), callback_),
+      kBGRA_8888_SkColorType);
+
+  return false;
 }
 
-void FrameSubscriber::OnFrameDelivered(
-    scoped_refptr<media::VideoFrame> frame, base::TimeTicks, bool result) {
-  if (!result)
+void FrameSubscriber::OnFrameDelivered(const FrameCaptureCallback& callback,
+  const SkBitmap& bitmap, content::ReadbackResponse response) {
+  if (bitmap.computeSize64() == 0)
     return;
 
   v8::Locker locker(isolate_);
   v8::HandleScope handle_scope(isolate_);
 
-  gfx::Rect rect = frame->visible_rect();
-  size_t rgb_arr_size = rect.width() * rect.height() * 4;
+  size_t rgb_arr_size = bitmap.width() * bitmap.height() *
+    bitmap.bytesPerPixel();
   v8::MaybeLocal<v8::Object> buffer = node::Buffer::New(isolate_, rgb_arr_size);
   if (buffer.IsEmpty())
     return;
 
-  // Convert a frame of YUV to 32 bit ARGB.
-  media::ConvertYUVToRGB32(frame->data(media::VideoFrame::kYPlane),
-                           frame->data(media::VideoFrame::kUPlane),
-                           frame->data(media::VideoFrame::kVPlane),
-                           reinterpret_cast<uint8*>(
-                              node::Buffer::Data(buffer.ToLocalChecked())),
-                           rect.width(), rect.height(),
-                           frame->stride(media::VideoFrame::kYPlane),
-                           frame->stride(media::VideoFrame::kUVPlane),
-                           rect.width() * 4,
-                           media::YV12);
+  bitmap.copyPixelsTo(
+    reinterpret_cast<uint8*>(node::Buffer::Data(buffer.ToLocalChecked())),
+    rgb_arr_size);
 
   callback_.Run(buffer.ToLocalChecked());
 }

atom/browser/api/frame_subscriber.h

@@ -6,7 +6,11 @@
 #define ATOM_BROWSER_API_FRAME_SUBSCRIBER_H_
 
 #include "base/callback.h"
+#include "base/memory/weak_ptr.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
+#include "content/public/browser/readback_types.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/geometry/size.h"
 #include "v8/include/v8.h"
 
@@ -19,7 +23,7 @@ class FrameSubscriber : public content::RenderWidgetHostViewFrameSubscriber {
   using FrameCaptureCallback = base::Callback<void(v8::Local<v8::Value>)>;
 
   FrameSubscriber(v8::Isolate* isolate,
-                  const gfx::Size& size,
+                  content::RenderWidgetHostView* view,
                   const FrameCaptureCallback& callback);
 
   bool ShouldCaptureFrame(const gfx::Rect& damage_rect,
@@ -28,13 +32,15 @@ class FrameSubscriber : public content::RenderWidgetHostViewFrameSubscriber {
                           DeliverFrameCallback* callback) override;
 
  private:
-  void OnFrameDelivered(
-      scoped_refptr<media::VideoFrame> frame, base::TimeTicks, bool);
+  void OnFrameDelivered(const FrameCaptureCallback& callback,
+    const SkBitmap& bitmap, content::ReadbackResponse response);
 
   v8::Isolate* isolate_;
-  gfx::Size size_;
+  content::RenderWidgetHostView* view_;
   FrameCaptureCallback callback_;
 
+  base::WeakPtrFactory<FrameSubscriber> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(FrameSubscriber);
 };
 

atom/browser/api/lib/app.coffee

@@ -1,72 +0,0 @@
-{deprecate, session, Menu} = require 'electron'
-{EventEmitter} = require 'events'
-
-bindings = process.atomBinding 'app'
-downloadItemBindings = process.atomBinding 'download_item'
-
-app = bindings.app
-app.__proto__ = EventEmitter.prototype
-
-app.setApplicationMenu = (menu) ->
-  Menu.setApplicationMenu menu
-
-app.getApplicationMenu = ->
-  Menu.getApplicationMenu()
-
-app.commandLine =
-  appendSwitch: bindings.appendSwitch,
-  appendArgument: bindings.appendArgument
-
-if process.platform is 'darwin'
-  app.dock =
-    bounce: (type='informational') -> bindings.dockBounce type
-    cancelBounce: bindings.dockCancelBounce
-    setBadge: bindings.dockSetBadgeText
-    getBadge: bindings.dockGetBadgeText
-    hide: bindings.dockHide
-    show: bindings.dockShow
-    setMenu: bindings.dockSetMenu
-
-appPath = null
-app.setAppPath = (path) ->
-  appPath = path
-
-app.getAppPath = ->
-  appPath
-
-# Routes the events to webContents.
-for name in ['login', 'certificate-error', 'select-client-certificate']
-  do (name) ->
-    app.on name, (event, webContents, args...) ->
-      webContents.emit name, event, args...
-
-# Deprecated.
-app.getHomeDir = deprecate 'app.getHomeDir', 'app.getPath', ->
-  @getPath 'home'
-app.getDataPath = deprecate 'app.getDataPath', 'app.getPath', ->
-  @getPath 'userData'
-app.setDataPath = deprecate 'app.setDataPath', 'app.setPath', (path) ->
-  @setPath 'userData', path
-app.resolveProxy = deprecate 'app.resolveProxy', 'session.defaultSession.resolveProxy', (url, callback) ->
-  session.defaultSession.resolveProxy url, callback
-deprecate.rename app, 'terminate', 'quit'
-deprecate.event app, 'finish-launching', 'ready', ->
-  setImmediate => # give default app a chance to setup default menu.
-    @emit 'finish-launching'
-deprecate.event app, 'activate-with-no-open-windows', 'activate', (event, hasVisibleWindows) ->
-  @emit 'activate-with-no-open-windows', event if not hasVisibleWindows
-deprecate.event app, 'select-certificate', 'select-client-certificate'
-
-# Wrappers for native classes.
-wrapDownloadItem = (downloadItem) ->
-  # downloadItem is an EventEmitter.
-  downloadItem.__proto__ = EventEmitter.prototype
-  # Deprecated.
-  deprecate.property downloadItem, 'url', 'getURL'
-  deprecate.property downloadItem, 'filename', 'getFilename'
-  deprecate.property downloadItem, 'mimeType', 'getMimeType'
-  deprecate.rename downloadItem, 'getUrl', 'getURL'
-downloadItemBindings._setWrapDownloadItem wrapDownloadItem
-
-# Only one App object pemitted.
-module.exports = app

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

@@ -1,12 +0,0 @@
-{deprecate} = require 'electron'
-
-autoUpdater =
-  if process.platform is 'win32'
-    require './auto-updater/auto-updater-win'
-  else
-    require './auto-updater/auto-updater-native'
-
-# Deprecated.
-deprecate.rename autoUpdater, 'setFeedUrl', 'setFeedURL'
-
-module.exports = autoUpdater

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

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

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

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

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

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

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

@@ -1,112 +0,0 @@
-{ipcMain, deprecate} = require 'electron'
-{EventEmitter} = require 'events'
-
-{BrowserWindow} = process.atomBinding 'window'
-BrowserWindow::__proto__ = EventEmitter.prototype
-
-BrowserWindow::_init = ->
-  {app} = require 'electron'  # avoid recursive require.
-
-  # Simulate the application menu on platforms other than OS X.
-  if process.platform isnt 'darwin'
-    menu = app.getApplicationMenu()
-    @setMenu menu if menu?
-
-  # Make new windows requested by links behave like "window.open"
-  @webContents.on '-new-window', (event, url, frameName) ->
-    options = show: true, width: 800, height: 600
-    ipcMain.emit 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', event, url, frameName, options
-
-  # window.resizeTo(...)
-  # window.moveTo(...)
-  @webContents.on 'move', (event, size) =>
-    @setBounds size
-
-  # Hide the auto-hide menu when webContents is focused.
-  @webContents.on 'activate', =>
-    if process.platform isnt 'darwin' and @isMenuBarAutoHide() and @isMenuBarVisible()
-      @setMenuBarVisibility false
-
-  # Forward the crashed event.
-  @webContents.on 'crashed', =>
-    @emit 'crashed'
-
-  # Change window title to page title.
-  @webContents.on 'page-title-updated', (event, title, explicitSet) =>
-    @emit 'page-title-updated', event, title
-    @setTitle title unless event.defaultPrevented
-
-  # Sometimes the webContents doesn't get focus when window is shown, so we have
-  # to force focusing on webContents in this case. The safest way is to focus it
-  # when we first start to load URL, if we do it earlier it won't have effect,
-  # if we do it later we might move focus in the page.
-  # Though this hack is only needed on OS X when the app is launched from
-  # Finder, we still do it on all platforms in case of other bugs we don't know.
-  @webContents.once 'load-url', ->
-    @focus()
-
-  # Redirect focus/blur event to app instance too.
-  @on 'blur', (event) =>
-    app.emit 'browser-window-blur', event, this
-  @on 'focus', (event) =>
-    app.emit 'browser-window-focus', event, this
-
-  # Notify the creation of the window.
-  app.emit 'browser-window-created', {}, this
-
-  # Be compatible with old APIs.
-  @webContents.on 'devtools-focused', => @emit 'devtools-focused'
-  @webContents.on 'devtools-opened', => @emit 'devtools-opened'
-  @webContents.on 'devtools-closed', => @emit 'devtools-closed'
-  Object.defineProperty this, 'devToolsWebContents',
-    enumerable: true,
-    configurable: false,
-    get: -> @webContents.devToolsWebContents
-
-BrowserWindow.getFocusedWindow = ->
-  windows = BrowserWindow.getAllWindows()
-  return window for window in windows when window.isFocused()
-
-BrowserWindow.fromWebContents = (webContents) ->
-  windows = BrowserWindow.getAllWindows()
-  return window for window in windows when window.webContents?.equal webContents
-
-BrowserWindow.fromDevToolsWebContents = (webContents) ->
-  windows = BrowserWindow.getAllWindows()
-  return window for window in windows when window.devToolsWebContents?.equal webContents
-
-# Helpers.
-BrowserWindow::loadURL = -> @webContents.loadURL.apply @webContents, arguments
-BrowserWindow::getURL = -> @webContents.getURL()
-BrowserWindow::reload = -> @webContents.reload.apply @webContents, arguments
-BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
-BrowserWindow::openDevTools = -> @webContents.openDevTools.apply @webContents, arguments
-BrowserWindow::closeDevTools = -> @webContents.closeDevTools()
-BrowserWindow::isDevToolsOpened = -> @webContents.isDevToolsOpened()
-BrowserWindow::toggleDevTools = -> @webContents.toggleDevTools()
-BrowserWindow::inspectElement = -> @webContents.inspectElement.apply @webContents, arguments
-BrowserWindow::inspectServiceWorker = -> @webContents.inspectServiceWorker()
-
-# Deprecated.
-deprecate.member BrowserWindow, 'undo', 'webContents'
-deprecate.member BrowserWindow, 'redo', 'webContents'
-deprecate.member BrowserWindow, 'cut', 'webContents'
-deprecate.member BrowserWindow, 'copy', 'webContents'
-deprecate.member BrowserWindow, 'paste', 'webContents'
-deprecate.member BrowserWindow, 'selectAll', 'webContents'
-deprecate.member BrowserWindow, 'reloadIgnoringCache', 'webContents'
-deprecate.member BrowserWindow, 'isLoading', 'webContents'
-deprecate.member BrowserWindow, 'isWaitingForResponse', 'webContents'
-deprecate.member BrowserWindow, 'stop', 'webContents'
-deprecate.member BrowserWindow, 'isCrashed', 'webContents'
-deprecate.member BrowserWindow, 'print', 'webContents'
-deprecate.member BrowserWindow, 'printToPDF', 'webContents'
-deprecate.rename BrowserWindow, 'restart', 'reload'
-deprecate.rename BrowserWindow, 'loadUrl', 'loadURL'
-deprecate.rename BrowserWindow, 'getUrl', 'getURL'
-BrowserWindow::executeJavaScriptInDevTools = deprecate 'executeJavaScriptInDevTools', 'devToolsWebContents.executeJavaScript', (code) ->
-  @devToolsWebContents?.executeJavaScript code
-BrowserWindow::getPageTitle = deprecate 'getPageTitle', 'webContents.getTitle', ->
-  @webContents?.getTitle()
-
-module.exports = BrowserWindow

atom/browser/api/lib/content-tracing.coffee

@@ -1 +0,0 @@
-module.exports = process.atomBinding 'content_tracing'

atom/browser/api/lib/dialog.coffee

@@ -1,125 +0,0 @@
-{app, BrowserWindow} = require 'electron'
-
-binding = process.atomBinding 'dialog'
-v8Util = process.atomBinding 'v8_util'
-
-fileDialogProperties =
-  openFile:        1 << 0
-  openDirectory:   1 << 1
-  multiSelections: 1 << 2
-  createDirectory: 1 << 3
-
-messageBoxTypes = ['none', 'info', 'warning', 'error', 'question']
-
-messageBoxOptions =
-  noLink: 1 << 0
-
-parseArgs = (window, options, callback) ->
-  unless window is null or window?.constructor is BrowserWindow
-    # Shift.
-    callback = options
-    options = window
-    window = null
-  if not callback? and typeof options is 'function'
-    # Shift.
-    callback = options
-    options = null
-  [window, options, callback]
-
-checkAppInitialized = ->
-  throw new Error('dialog module can only be used after app is ready') unless app.isReady()
-
-module.exports =
-  showOpenDialog: (args...) ->
-    checkAppInitialized()
-    [window, options, callback] = parseArgs args...
-
-    options ?= title: 'Open', properties: ['openFile']
-    options.properties ?= ['openFile']
-    throw new TypeError('Properties need to be array') unless Array.isArray options.properties
-
-    properties = 0
-    for prop, value of fileDialogProperties
-      properties |= value if prop in options.properties
-
-    options.title ?= ''
-    options.defaultPath ?= ''
-    options.filters ?= []
-
-    wrappedCallback =
-      if typeof callback is 'function'
-        (success, result) -> callback(if success then result)
-      else
-        null
-
-    binding.showOpenDialog String(options.title),
-                           String(options.defaultPath),
-                           options.filters
-                           properties,
-                           window,
-                           wrappedCallback
-
-  showSaveDialog: (args...) ->
-    checkAppInitialized()
-    [window, options, callback] = parseArgs args...
-
-    options ?= title: 'Save'
-    options.title ?= ''
-    options.defaultPath ?= ''
-    options.filters ?= []
-
-    wrappedCallback =
-      if typeof callback is 'function'
-        (success, result) -> callback(if success then result)
-      else
-        null
-
-    binding.showSaveDialog String(options.title),
-                           String(options.defaultPath),
-                           options.filters
-                           window,
-                           wrappedCallback
-
-  showMessageBox: (args...) ->
-    checkAppInitialized()
-    [window, options, callback] = parseArgs args...
-
-    options ?= type: 'none'
-    options.type ?= 'none'
-    messageBoxType = messageBoxTypes.indexOf options.type
-    throw new TypeError('Invalid message box type') unless messageBoxType > -1
-
-    throw new TypeError('Buttons need to be array') unless Array.isArray options.buttons
-
-    options.title ?= ''
-    options.message ?= ''
-    options.detail ?= ''
-    options.icon ?= null
-
-    # Choose a default button to get selected when dialog is cancelled.
-    unless options.cancelId?
-      options.cancelId = 0
-      for text, i in options.buttons
-        if text.toLowerCase() in ['cancel', 'no']
-          options.cancelId = i
-          break
-
-    flags = if options.noLink then messageBoxOptions.noLink else 0
-
-    binding.showMessageBox messageBoxType,
-                           options.buttons,
-                           options.cancelId,
-                           flags,
-                           options.title,
-                           options.message,
-                           options.detail,
-                           options.icon,
-                           window,
-                           callback
-
-  showErrorBox: (args...) ->
-    binding.showErrorBox args...
-
-# Mark standard asynchronous functions.
-for api in ['showMessageBox', 'showOpenDialog', 'showSaveDialog']
-  v8Util.setHiddenValue module.exports[api], 'asynchronous', true

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

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

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

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

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

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

atom/browser/api/lib/ipc.coffee

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

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

@@ -1,73 +0,0 @@
-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'
-
-# Maps methods that should be called directly on the BrowserWindow instance
-methodInBrowserWindow =
-  minimize: true
-  close: true
-
-class MenuItem
-  @types = ['normal', 'separator', 'submenu', 'checkbox', 'radio']
-
-  constructor: (options) ->
-    {Menu} = require 'electron'
-
-    {click, @selector, @type, @role, @label, @sublabel, @accelerator, @icon, @enabled, @visible, @checked, @submenu} = options
-
-    if @submenu? and @submenu.constructor isnt Menu
-      @submenu = Menu.buildFromTemplate @submenu
-    @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'
-    @overrideProperty 'label', ''
-    @overrideProperty 'sublabel', ''
-    @overrideProperty 'enabled', true
-    @overrideProperty 'visible', true
-    @overrideProperty 'checked', false
-
-    throw new Error("Unknown menu type #{@type}") if MenuItem.types.indexOf(@type) is -1
-
-    @commandId = ++nextCommandId
-    @click = (focusedWindow) =>
-      # Manually flip the checked flags when clicked.
-      @checked = !@checked if @type in ['checkbox', 'radio']
-
-      if @role and rolesMap[@role] and process.platform isnt 'darwin' and focusedWindow?
-        methodName = rolesMap[@role]
-        if methodInBrowserWindow[methodName]
-          focusedWindow[methodName]()
-        else
-          focusedWindow.webContents?[methodName]()
-      else if typeof click is 'function'
-        click this, focusedWindow
-      else if typeof @selector is 'string'
-        Menu.sendActionToFirstResponder @selector
-
-  overrideProperty: (name, defaultValue=null) ->
-    this[name] ?= defaultValue
-
-  overrideReadOnlyProperty: (name, defaultValue=null) ->
-    this[name] ?= defaultValue
-    Object.defineProperty this, name,
-      enumerable: true
-      writable: false
-      value: this[name]
-
-module.exports = MenuItem

atom/browser/api/lib/menu.coffee

@@ -1,178 +0,0 @@
-{BrowserWindow, MenuItem} = require 'electron'
-{EventEmitter} = require 'events'
-
-v8Util = process.atomBinding 'v8_util'
-bindings = process.atomBinding 'menu'
-
-# Automatically generated radio menu item's group id.
-nextGroupId = 0
-
-# Search between seperators to find a radio menu item and return its group id,
-# otherwise generate a group id.
-generateGroupId = (items, pos) ->
-  if pos > 0
-    for i in [pos - 1..0]
-      item = items[i]
-      return item.groupId if item.type is 'radio'
-      break if item.type is 'separator'
-  else if pos < items.length
-    for i in [pos..items.length - 1]
-      item = items[i]
-      return item.groupId if item.type is 'radio'
-      break if item.type is 'separator'
-  ++nextGroupId
-
-# Returns the index of item according to |id|.
-indexOfItemById = (items, id) ->
-  return i for item, i in items when item.id is id
-  -1
-
-# Returns the index of where to insert the item according to |position|.
-indexToInsertByPosition = (items, position) ->
-  return items.length unless position
-
-  [query, id] = position.split '='
-  insertIndex = indexOfItemById items, id
-  if insertIndex is -1 and query isnt 'endof'
-    console.warn "Item with id '#{id}' is not found"
-    return items.length
-
-  switch query
-    when 'after'
-      insertIndex++
-    when 'endof'
-      # If the |id| doesn't exist, then create a new group with the |id|.
-      if insertIndex is -1
-        items.push id: id, type: 'separator'
-        insertIndex = items.length - 1
-
-      # Find the end of the group.
-      insertIndex++
-      while insertIndex < items.length and items[insertIndex].type isnt 'separator'
-        insertIndex++
-
-  insertIndex
-
-Menu = bindings.Menu
-Menu::__proto__ = EventEmitter.prototype
-
-Menu::_init = ->
-  @commandsMap = {}
-  @groupsMap = {}
-  @items = []
-  @delegate =
-    isCommandIdChecked: (commandId) => @commandsMap[commandId]?.checked
-    isCommandIdEnabled: (commandId) => @commandsMap[commandId]?.enabled
-    isCommandIdVisible: (commandId) => @commandsMap[commandId]?.visible
-    getAcceleratorForCommandId: (commandId) => @commandsMap[commandId]?.accelerator
-    getIconForCommandId: (commandId) => @commandsMap[commandId]?.icon
-    executeCommand: (commandId) =>
-      @commandsMap[commandId]?.click BrowserWindow.getFocusedWindow()
-    menuWillShow: =>
-      # Make sure radio groups have at least one menu item seleted.
-      for id, group of @groupsMap
-        checked = false
-        for radioItem in group when radioItem.checked
-          checked = true
-          break
-        v8Util.setHiddenValue group[0], 'checked', true unless checked
-
-Menu::popup = (window, x, y) ->
-  unless window?.constructor is BrowserWindow
-    # Shift.
-    y = x
-    x = window
-    window = BrowserWindow.getFocusedWindow()
-  if x? and y?
-    @_popupAt(window, x, y)
-  else
-    @_popup window
-
-Menu::append = (item) ->
-  @insert @getItemCount(), item
-
-Menu::insert = (pos, item) ->
-  throw new TypeError('Invalid item') unless item?.constructor is MenuItem
-
-  switch item.type
-    when 'normal' then @insertItem pos, item.commandId, item.label
-    when 'checkbox' then @insertCheckItem pos, item.commandId, item.label
-    when 'separator' then @insertSeparator pos
-    when 'submenu' then @insertSubMenu pos, item.commandId, item.label, item.submenu
-    when 'radio'
-      # Grouping radio menu items.
-      item.overrideReadOnlyProperty 'groupId', generateGroupId(@items, pos)
-      @groupsMap[item.groupId] ?= []
-      @groupsMap[item.groupId].push item
-
-      # Setting a radio menu item should flip other items in the group.
-      v8Util.setHiddenValue item, 'checked', item.checked
-      Object.defineProperty item, 'checked',
-        enumerable: true
-        get: -> v8Util.getHiddenValue item, 'checked'
-        set: (val) =>
-          for otherItem in @groupsMap[item.groupId] when otherItem isnt item
-            v8Util.setHiddenValue otherItem, 'checked', false
-          v8Util.setHiddenValue item, 'checked', true
-
-      @insertRadioItem pos, item.commandId, item.label, item.groupId
-
-  @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
-
-  # Remember the items.
-  @items.splice pos, 0, item
-  @commandsMap[item.commandId] = item
-
-# Force menuWillShow to be called
-Menu::_callMenuWillShow = ->
-  @delegate?.menuWillShow()
-  item.submenu._callMenuWillShow() for item in @items when item.submenu?
-
-applicationMenu = null
-Menu.setApplicationMenu = (menu) ->
-  throw new TypeError('Invalid menu') unless menu is null or menu.constructor is Menu
-  applicationMenu = menu  # Keep a reference.
-
-  if process.platform is 'darwin'
-    return if menu is null
-    menu._callMenuWillShow()
-    bindings.setApplicationMenu menu
-  else
-    windows = BrowserWindow.getAllWindows()
-    w.setMenu menu for w in windows
-
-Menu.getApplicationMenu = -> applicationMenu
-
-Menu.sendActionToFirstResponder = bindings.sendActionToFirstResponder
-
-Menu.buildFromTemplate = (template) ->
-  throw new TypeError('Invalid template for Menu') unless Array.isArray template
-
-  positionedTemplate = []
-  insertIndex = 0
-
-  for item in template
-    if item.position
-      insertIndex = indexToInsertByPosition positionedTemplate, item.position
-    else
-      # If no |position| is specified, insert after last item.
-      insertIndex++
-    positionedTemplate.splice insertIndex, 0, item
-
-  menu = new Menu
-
-  for item in positionedTemplate
-    throw new TypeError('Invalid template for MenuItem') unless typeof item is 'object'
-
-    menuItem = new MenuItem(item)
-    menuItem[key] ?= value for key, value of item
-    menu.append menuItem
-
-  menu
-
-module.exports = Menu

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

@@ -1,122 +0,0 @@
-{ipcMain} = require 'electron'
-
-# The history operation in renderer is redirected to browser.
-ipcMain.on 'ATOM_SHELL_NAVIGATION_CONTROLLER', (event, method, args...) ->
-  event.sender[method] args...
-
-ipcMain.on 'ATOM_SHELL_SYNC_NAVIGATION_CONTROLLER', (event, method, args...) ->
-  event.returnValue = event.sender[method] args...
-
-# JavaScript implementation of Chromium's NavigationController.
-# Instead of relying on Chromium for history control, we compeletely do history
-# control on user land, and only rely on WebContents.loadURL for navigation.
-# This helps us avoid Chromium's various optimizations so we can ensure renderer
-# process is restarted everytime.
-class NavigationController
-  constructor: (@webContents) ->
-    @clearHistory()
-
-    # webContents may have already navigated to a page.
-    if @webContents._getURL()
-      @currentIndex++
-      @history.push @webContents._getURL()
-
-    @webContents.on 'navigation-entry-commited', (event, url, inPage, replaceEntry) =>
-      if @inPageIndex > -1 and not inPage
-        # Navigated to a new page, clear in-page mark.
-        @inPageIndex = -1
-      else if @inPageIndex is -1 and inPage
-        # Started in-page navigations.
-        @inPageIndex = @currentIndex
-
-      if @pendingIndex >= 0 # Go to index.
-        @currentIndex = @pendingIndex
-        @pendingIndex = -1
-        @history[@currentIndex] = url
-      else if replaceEntry # Non-user initialized navigation.
-        @history[@currentIndex] = url
-      else  # Normal navigation.
-        @history = @history.slice 0, @currentIndex + 1  # Clear history.
-        currentEntry = @history[@currentIndex]
-        if currentEntry?.url isnt url
-          @currentIndex++
-          @history.push url
-
-  loadURL: (url, options={}) ->
-    @pendingIndex = -1
-    @webContents._loadURL url, options
-    @webContents.emit 'load-url', url, options
-
-  getURL: ->
-    if @currentIndex is -1
-      ''
-    else
-      @history[@currentIndex]
-
-  stop: ->
-    @pendingIndex = -1
-    @webContents._stop()
-
-  reload: ->
-    @pendingIndex = @currentIndex
-    @webContents._loadURL @getURL(), {}
-
-  reloadIgnoringCache: ->
-    @pendingIndex = @currentIndex
-    @webContents._loadURL @getURL(), {extraHeaders: "pragma: no-cache\n"}
-
-  canGoBack: ->
-    @getActiveIndex() > 0
-
-  canGoForward: ->
-    @getActiveIndex() < @history.length - 1
-
-  canGoToIndex: (index) ->
-    index >=0 and index < @history.length
-
-  canGoToOffset: (offset) ->
-    @canGoToIndex @currentIndex + offset
-
-  clearHistory: ->
-    @history = []
-    @currentIndex = -1
-    @pendingIndex = -1
-    @inPageIndex = -1
-
-  goBack: ->
-    return unless @canGoBack()
-    @pendingIndex = @getActiveIndex() - 1
-    if @inPageIndex > -1 and @pendingIndex >= @inPageIndex
-      @webContents._goBack()
-    else
-      @webContents._loadURL @history[@pendingIndex], {}
-
-  goForward: ->
-    return unless @canGoForward()
-    @pendingIndex = @getActiveIndex() + 1
-    if @inPageIndex > -1 and @pendingIndex >= @inPageIndex
-      @webContents._goForward()
-    else
-      @webContents._loadURL @history[@pendingIndex], {}
-
-  goToIndex: (index) ->
-    return unless @canGoToIndex index
-    @pendingIndex = index
-    @webContents._loadURL @history[@pendingIndex], {}
-
-  goToOffset: (offset) ->
-    return unless @canGoToOffset offset
-    pendingIndex = @currentIndex + offset
-    if @inPageIndex > -1 and pendingIndex >= @inPageIndex
-      @pendingIndex = pendingIndex
-      @webContents._goToOffset offset
-    else
-      @goToIndex pendingIndex
-
-  getActiveIndex: ->
-    if @pendingIndex is -1 then @currentIndex else @pendingIndex
-
-  length: ->
-    @history.length
-
-module.exports = NavigationController

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

@@ -1,7 +0,0 @@
-{EventEmitter} = require 'events'
-
-{powerMonitor} = process.atomBinding 'power_monitor'
-
-powerMonitor.__proto__ = EventEmitter.prototype
-
-module.exports = powerMonitor

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

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

atom/browser/api/lib/protocol.coffee

@@ -1,25 +0,0 @@
-{app} = require 'electron'
-
-throw new Error('Can not initialize protocol module before app is ready') unless app.isReady()
-
-{protocol} = process.atomBinding 'protocol'
-
-# Warn about removed APIs.
-logAndThrow = (callback, message) ->
-  console.error message
-  if callback then callback(new Error(message)) else throw new Error(message)
-protocol.registerProtocol = (scheme, handler, callback) ->
-  logAndThrow callback,
-              'registerProtocol API has been replaced by the
-               register[File/Http/Buffer/String]Protocol API family, please
-               switch to the new APIs.'
-protocol.isHandledProtocol = (scheme, callback) ->
-  logAndThrow callback,
-              'isHandledProtocol API has been replaced by isProtocolHandled.'
-protocol.interceptProtocol = (scheme, handler, callback) ->
-  logAndThrow callback,
-              'interceptProtocol API has been replaced by the
-               intercept[File/Http/Buffer/String]Protocol API family, please
-               switch to the new APIs.'
-
-module.exports = protocol

atom/browser/api/lib/screen.coffee

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

atom/browser/api/lib/session.coffee

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

atom/browser/api/lib/tray.coffee

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

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

@@ -1,137 +0,0 @@
-{EventEmitter} = require 'events'
-{deprecate, ipcMain, session, NavigationController, Menu} = require 'electron'
-
-binding = process.atomBinding 'web_contents'
-
-nextId = 0
-getNextId = -> ++nextId
-
-PDFPageSize =
-  A5:
-    custom_display_name: "A5"
-    height_microns: 210000
-    name: "ISO_A5"
-    width_microns: 148000
-  A4:
-    custom_display_name: "A4"
-    height_microns: 297000
-    name: "ISO_A4"
-    is_default: "true"
-    width_microns: 210000
-  A3:
-    custom_display_name: "A3"
-    height_microns: 420000
-    name: "ISO_A3"
-    width_microns: 297000
-  Legal:
-    custom_display_name: "Legal"
-    height_microns: 355600
-    name: "NA_LEGAL"
-    width_microns: 215900
-  Letter:
-    custom_display_name: "Letter"
-    height_microns: 279400
-    name: "NA_LETTER"
-    width_microns: 215900
-  Tabloid:
-    height_microns: 431800
-    name: "NA_LEDGER"
-    width_microns: 279400
-    custom_display_name: "Tabloid"
-
-wrapWebContents = (webContents) ->
-  # webContents is an EventEmitter.
-  webContents.__proto__ = EventEmitter.prototype
-
-  # WebContents::send(channel, args..)
-  webContents.send = (channel, args...) ->
-    @_send channel, [args...]
-
-  # Make sure webContents.executeJavaScript would run the code only when the
-  # web contents has been loaded.
-  webContents.executeJavaScript = (code, hasUserGesture=false) ->
-    if @getURL() and not @isLoading()
-      @_executeJavaScript code, hasUserGesture
-    else
-      webContents.once 'did-finish-load', @_executeJavaScript.bind(this, code, hasUserGesture)
-
-  # The navigation controller.
-  controller = new NavigationController(webContents)
-  for name, method of NavigationController.prototype when method instanceof Function
-    do (name, method) ->
-      webContents[name] = -> method.apply controller, arguments
-
-  # Dispatch IPC messages to the ipc module.
-  webContents.on 'ipc-message', (event, packed) ->
-    [channel, args...] = packed
-    ipcMain.emit channel, event, args...
-  webContents.on 'ipc-message-sync', (event, packed) ->
-    [channel, args...] = packed
-    Object.defineProperty event, 'returnValue', set: (value) -> event.sendReply JSON.stringify(value)
-    ipcMain.emit channel, event, args...
-
-  # Handle context menu action request from pepper plugin.
-  webContents.on 'pepper-context-menu', (event, params) ->
-    menu = Menu.buildFromTemplate params.menu
-    menu.popup params.x, params.y
-
-  # This error occurs when host could not be found.
-  webContents.on 'did-fail-provisional-load', (args...) ->
-    # Calling loadURL during this event might cause crash, so delay the event
-    # until next tick.
-    setImmediate => @emit 'did-fail-load', args...
-
-  # Delays the page-title-updated event to next tick.
-  webContents.on '-page-title-updated', (args...) ->
-    setImmediate => @emit 'page-title-updated', args...
-
-  # Deprecated.
-  deprecate.rename webContents, 'loadUrl', 'loadURL'
-  deprecate.rename webContents, 'getUrl', 'getURL'
-  deprecate.event webContents, 'page-title-set', 'page-title-updated', (args...) ->
-    @emit 'page-title-set', args...
-
-  webContents.printToPDF = (options, callback) ->
-    printingSetting =
-      pageRage: []
-      mediaSize: {}
-      landscape: false
-      color: 2
-      headerFooterEnabled: false
-      marginsType: 0
-      isFirstRequest: false
-      requestID: getNextId()
-      previewModifiable: true
-      printToPDF: true
-      printWithCloudPrint: false
-      printWithPrivet: false
-      printWithExtension: false
-      deviceName: "Save as PDF"
-      generateDraftData: true
-      fitToPageEnabled: false
-      duplex: 0
-      copies: 1
-      collate: true
-      shouldPrintBackgrounds: false
-      shouldPrintSelectionOnly: false
-
-    if options.landscape
-      printingSetting.landscape = options.landscape
-    if options.marginsType
-      printingSetting.marginsType = options.marginsType
-    if options.printSelectionOnly
-      printingSetting.shouldPrintSelectionOnly = options.printSelectionOnly
-    if options.printBackground
-      printingSetting.shouldPrintBackgrounds = options.printBackground
-
-    if options.pageSize and PDFPageSize[options.pageSize]
-      printingSetting.mediaSize = PDFPageSize[options.pageSize]
-    else
-      printingSetting.mediaSize = PDFPageSize['A4']
-
-    @_printToPDF printingSetting, callback
-
-binding._setWrapWebContents wrapWebContents
-
-module.exports.create = (options={}) ->
-  binding.create(options)

atom/browser/atom_browser_client.cc

@@ -15,6 +15,7 @@
 #include "atom/browser/atom_resource_dispatcher_host_delegate.h"
 #include "atom/browser/atom_speech_recognition_manager_delegate.h"
 #include "atom/browser/native_window.h"
+#include "atom/browser/web_contents_permission_helper.h"
 #include "atom/browser/web_contents_preferences.h"
 #include "atom/browser/window_list.h"
 #include "atom/common/options_switches.h"
@@ -25,6 +26,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/printing/printing_message_filter.h"
 #include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
+#include "chrome/browser/renderer_host/pepper/widevine_cdm_message_filter.h"
 #include "chrome/browser/speech/tts_message_filter.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/client_certificate_delegate.h"
@@ -105,6 +107,8 @@ void AtomBrowserClient::RenderProcessWillLaunch(
   int process_id = host->GetID();
   host->AddFilter(new printing::PrintingMessageFilter(process_id));
   host->AddFilter(new TtsMessageFilter(process_id, host->GetBrowserContext()));
+  host->AddFilter(
+      new WidevineCdmMessageFilter(process_id, host->GetBrowserContext()));
 }
 
 content::SpeechRecognitionManagerDelegate*
@@ -278,6 +282,24 @@ brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
   return new AtomBrowserMainParts;
 }
 
+void AtomBrowserClient::WebNotificationAllowed(
+    int render_process_id,
+    const base::Callback<void(bool)>& callback) {
+  content::WebContents* web_contents = content::WebContents::FromRenderViewHost(
+      content::RenderViewHost::FromID(render_process_id, kDefaultRoutingID));
+  if (!web_contents) {
+    callback.Run(false);
+    return;
+  }
+  auto permission_helper =
+      WebContentsPermissionHelper::FromWebContents(web_contents);
+  if (!permission_helper) {
+    callback.Run(false);
+    return;
+  }
+  permission_helper->RequestWebNotificationPermission(callback);
+}
+
 void AtomBrowserClient::RenderProcessHostDestroyed(
     content::RenderProcessHost* host) {
   int process_id = host->GetID();

atom/browser/atom_browser_client.h

@@ -81,6 +81,9 @@ class AtomBrowserClient : public brightray::BrowserClient,
   // brightray::BrowserClient:
   brightray::BrowserMainParts* OverrideCreateBrowserMainParts(
       const content::MainFunctionParams&) override;
+  void WebNotificationAllowed(
+      int render_process_id,
+      const base::Callback<void(bool)>& callback) override;
 
   // content::RenderProcessHostObserver:
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;

atom/browser/atom_browser_context.cc

@@ -13,17 +13,20 @@
 #include "atom/browser/net/atom_url_request_job_factory.h"
 #include "atom/browser/net/asar/asar_protocol_handler.h"
 #include "atom/browser/net/http_protocol_handler.h"
+#include "atom/browser/atom_permission_manager.h"
 #include "atom/browser/web_view_manager.h"
 #include "atom/common/atom_version.h"
 #include "atom/common/chrome_version.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
+#include "base/path_service.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/url_constants.h"
@@ -167,6 +170,12 @@ content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
   return guest_manager_.get();
 }
 
+content::PermissionManager* AtomBrowserContext::GetPermissionManager() {
+  if (!permission_manager_.get())
+    permission_manager_.reset(new AtomPermissionManager);
+  return permission_manager_.get();
+}
+
 scoped_ptr<net::CertVerifier> AtomBrowserContext::CreateCertVerifier() {
   DCHECK(!cert_verifier_);
   cert_verifier_ = new AtomCertVerifier;
@@ -180,8 +189,10 @@ net::SSLConfigService* AtomBrowserContext::CreateSSLConfigService() {
 void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
   pref_registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory,
                                       base::FilePath());
+  base::FilePath download_dir;
+  PathService::Get(chrome::DIR_DEFAULT_DOWNLOADS, &download_dir);
   pref_registry->RegisterFilePathPref(prefs::kDownloadDefaultDirectory,
-                                      base::FilePath());
+                                      download_dir);
 }
 
 bool AtomBrowserContext::AllowNTLMCredentialsForDomain(const GURL& origin) {

atom/browser/atom_browser_context.h

@@ -14,6 +14,7 @@ namespace atom {
 class AtomDownloadManagerDelegate;
 class AtomCertVerifier;
 class AtomNetworkDelegate;
+class AtomPermissionManager;
 class AtomURLRequestJobFactory;
 class WebViewManager;
 
@@ -37,6 +38,7 @@ class AtomBrowserContext : public brightray::BrowserContext {
   // content::BrowserContext:
   content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
   content::BrowserPluginGuestManager* GetGuestManager() override;
+  content::PermissionManager* GetPermissionManager() override;
 
   // brightray::BrowserContext:
   void RegisterPrefs(PrefRegistrySimple* pref_registry) override;
@@ -52,6 +54,7 @@ class AtomBrowserContext : public brightray::BrowserContext {
  private:
   scoped_ptr<AtomDownloadManagerDelegate> download_manager_delegate_;
   scoped_ptr<WebViewManager> guest_manager_;
+  scoped_ptr<AtomPermissionManager> permission_manager_;
 
   // Managed by brightray::BrowserContext.
   AtomCertVerifier* cert_verifier_;

atom/browser/atom_browser_main_parts.cc

@@ -21,6 +21,7 @@
 
 #if defined(USE_X11)
 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
+#include "ui/events/devices/x11/touch_factory_x11.h"
 #endif
 
 namespace atom {
@@ -116,6 +117,10 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
   node_bindings_->PrepareMessageLoop();
   node_bindings_->RunMessageLoop();
 
+#if defined(USE_X11)
+  ui::TouchFactory::SetTouchDeviceListFromCommandLine();
+#endif
+
   // Start idle gc.
   gc_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMinutes(1),

atom/browser/atom_browser_main_parts.h

@@ -31,7 +31,7 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 
   static AtomBrowserMainParts* Get();
 
-  // Sets the exit code, will fail if the the message loop is not ready.
+  // Sets the exit code, will fail if the message loop is not ready.
   bool SetExitCode(int code);
 
   // Gets the exit code

atom/browser/atom_browser_main_parts_mac.mm

@@ -13,20 +13,14 @@
 namespace atom {
 
 void AtomBrowserMainParts::PreMainMessageLoopStart() {
-  // Initialize locale setting.
-  l10n_util::OverrideLocaleWithCocoaLocale();
-
   // Force the NSApplication subclass to be used.
-  NSApplication* application = [AtomApplication sharedApplication];
+  [AtomApplication sharedApplication];
 
+  // Set our own application delegate.
   AtomApplicationDelegate* delegate = [[AtomApplicationDelegate alloc] init];
   [NSApp setDelegate:(id<NSFileManagerDelegate>)delegate];
 
-  NSBundle* frameworkBundle = base::mac::FrameworkBundle();
-  NSNib* mainNib = [[NSNib alloc] initWithNibNamed:@"MainMenu"
-                                            bundle:frameworkBundle];
-  [mainNib instantiateWithOwner:application topLevelObjects:nil];
-  [mainNib release];
+  brightray::BrowserMainParts::PreMainMessageLoopStart();
 
   // Prevent Cocoa from turning command-line arguments into
   // |-application:openFiles:|, since we already handle them directly.

atom/browser/atom_download_manager_delegate.cc

@@ -109,27 +109,30 @@ bool AtomDownloadManagerDelegate::DetermineDownloadTarget(
                  download->GetForcedFilePath());
     return true;
   }
-  base::SupportsUserData::Data* save_path = download->GetUserData(
-      atom::api::DownloadItem::UserDataKey());
-  if (save_path) {
-    const base::FilePath& default_download_path =
-        static_cast<api::DownloadItem::SavePathData*>(save_path)->path();
-    callback.Run(default_download_path,
-                 content::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
-                 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
-                 default_download_path);
-    return true;
+
+  // Try to get the save path from JS wrapper.
+  {
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);
+    api::DownloadItem* download_item = api::DownloadItem::FromWrappedClass(
+        isolate, download);
+    if (download_item) {
+      base::FilePath save_path = download_item->GetSavePath();
+      if (!save_path.empty()) {
+        callback.Run(save_path,
+                     content::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+                     content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+                     save_path);
+        return true;
+      }
+    }
   }
 
   AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
       download_manager_->GetBrowserContext());
   base::FilePath default_download_path = browser_context->prefs()->GetFilePath(
       prefs::kDownloadDefaultDirectory);
-  // If users didn't set download path, use 'Downloads' directory by default.
-  if (default_download_path.empty()) {
-    auto path = download_manager_->GetBrowserContext()->GetPath();
-    default_download_path = path.Append(FILE_PATH_LITERAL("Downloads"));
-  }
 
   CreateDownloadPathCallback download_path_callback =
       base::Bind(&AtomDownloadManagerDelegate::OnDownloadPathGenerated,

atom/browser/atom_permission_manager.cc

@@ -0,0 +1,136 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_permission_manager.h"
+
+#include "content/public/browser/child_process_security_policy.h"
+#include "content/public/browser/permission_type.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+
+namespace atom {
+
+namespace {
+
+// Must be kept in sync with atom_browser_client.cc
+int kDefaultRoutingID = 2;
+
+bool WebContentsDestroyed(int process_id) {
+  auto rvh = content::RenderViewHost::FromID(process_id, kDefaultRoutingID);
+  if (rvh) {
+    auto contents = content::WebContents::FromRenderViewHost(rvh);
+    return contents->IsBeingDestroyed();
+  }
+
+  return true;
+}
+
+}  // namespace
+
+AtomPermissionManager::AtomPermissionManager()
+    : request_id_(0) {
+}
+
+AtomPermissionManager::~AtomPermissionManager() {
+}
+
+void AtomPermissionManager::SetPermissionRequestHandler(
+    const RequestHandler& handler) {
+  if (handler.is_null() && !pending_requests_.empty()) {
+    for (const auto& request : pending_requests_) {
+      if (!WebContentsDestroyed(request.second.render_process_id))
+        request.second.callback.Run(content::PERMISSION_STATUS_DENIED);
+    }
+    pending_requests_.clear();
+  }
+  request_handler_ = handler;
+}
+
+int AtomPermissionManager::RequestPermission(
+    content::PermissionType permission,
+    content::RenderFrameHost* render_frame_host,
+    const GURL& requesting_origin,
+    bool user_gesture,
+    const ResponseCallback& response_callback) {
+  int process_id = render_frame_host->GetProcess()->GetID();
+
+  if (permission == content::PermissionType::MIDI_SYSEX) {
+    content::ChildProcessSecurityPolicy::GetInstance()->
+        GrantSendMidiSysExMessage(process_id);
+  }
+
+  if (!request_handler_.is_null()) {
+    auto web_contents =
+        content::WebContents::FromRenderFrameHost(render_frame_host);
+    ++request_id_;
+    auto callback = base::Bind(&AtomPermissionManager::OnPermissionResponse,
+                               base::Unretained(this),
+                               request_id_,
+                               requesting_origin,
+                               response_callback);
+    pending_requests_[request_id_] = { process_id, callback };
+    request_handler_.Run(web_contents, permission, callback);
+    return request_id_;
+  }
+
+  response_callback.Run(content::PERMISSION_STATUS_GRANTED);
+  return kNoPendingOperation;
+}
+
+void AtomPermissionManager::OnPermissionResponse(
+    int request_id,
+    const GURL& origin,
+    const ResponseCallback& callback,
+    content::PermissionStatus status) {
+  auto request = pending_requests_.find(request_id);
+  if (request != pending_requests_.end()) {
+    if (!WebContentsDestroyed(request->second.render_process_id))
+      callback.Run(status);
+    pending_requests_.erase(request);
+  }
+}
+
+void AtomPermissionManager::CancelPermissionRequest(int request_id) {
+  auto request = pending_requests_.find(request_id);
+  if (request != pending_requests_.end()) {
+    if (!WebContentsDestroyed(request->second.render_process_id))
+      request->second.callback.Run(content::PERMISSION_STATUS_DENIED);
+    pending_requests_.erase(request);
+  }
+}
+
+void AtomPermissionManager::ResetPermission(
+    content::PermissionType permission,
+    const GURL& requesting_origin,
+    const GURL& embedding_origin) {
+}
+
+content::PermissionStatus AtomPermissionManager::GetPermissionStatus(
+    content::PermissionType permission,
+    const GURL& requesting_origin,
+    const GURL& embedding_origin) {
+  return content::PERMISSION_STATUS_GRANTED;
+}
+
+void AtomPermissionManager::RegisterPermissionUsage(
+    content::PermissionType permission,
+    const GURL& requesting_origin,
+    const GURL& embedding_origin) {
+}
+
+int AtomPermissionManager::SubscribePermissionStatusChange(
+    content::PermissionType permission,
+    const GURL& requesting_origin,
+    const GURL& embedding_origin,
+    const ResponseCallback& callback) {
+  return -1;
+}
+
+void AtomPermissionManager::UnsubscribePermissionStatusChange(
+    int subscription_id) {
+}
+
+}  // namespace atom

atom/browser/atom_permission_manager.h

@@ -0,0 +1,84 @@
+// Copyright (c) 2016 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_PERMISSION_MANAGER_H_
+#define ATOM_BROWSER_ATOM_PERMISSION_MANAGER_H_
+
+#include <map>
+
+#include "base/callback.h"
+#include "content/public/browser/permission_manager.h"
+
+namespace content {
+class WebContents;
+}
+
+namespace atom {
+
+class AtomPermissionManager : public content::PermissionManager {
+ public:
+  AtomPermissionManager();
+  ~AtomPermissionManager() override;
+
+  using ResponseCallback =
+      base::Callback<void(content::PermissionStatus)>;
+  using RequestHandler =
+      base::Callback<void(content::WebContents*,
+                          content::PermissionType,
+                          const ResponseCallback&)>;
+
+  // Handler to dispatch permission requests in JS.
+  void SetPermissionRequestHandler(const RequestHandler& handler);
+
+  // content::PermissionManager:
+  int RequestPermission(
+      content::PermissionType permission,
+      content::RenderFrameHost* render_frame_host,
+      const GURL& requesting_origin,
+      bool user_gesture,
+      const ResponseCallback& callback) override;
+
+ protected:
+  void OnPermissionResponse(int request_id,
+                            const GURL& url,
+                            const ResponseCallback& callback,
+                            content::PermissionStatus status);
+
+  // content::PermissionManager:
+  void CancelPermissionRequest(int request_id) override;
+  void ResetPermission(content::PermissionType permission,
+                       const GURL& requesting_origin,
+                       const GURL& embedding_origin) override;
+  content::PermissionStatus GetPermissionStatus(
+      content::PermissionType permission,
+      const GURL& requesting_origin,
+      const GURL& embedding_origin) override;
+  void RegisterPermissionUsage(content::PermissionType permission,
+                               const GURL& requesting_origin,
+                               const GURL& embedding_origin) override;
+  int SubscribePermissionStatusChange(
+      content::PermissionType permission,
+      const GURL& requesting_origin,
+      const GURL& embedding_origin,
+      const base::Callback<void(content::PermissionStatus)>& callback) override;
+  void UnsubscribePermissionStatusChange(int subscription_id) override;
+
+ private:
+  struct RequestInfo {
+    int render_process_id;
+    ResponseCallback callback;
+  };
+
+  RequestHandler request_handler_;
+
+  std::map<int, RequestInfo> pending_requests_;
+
+  int request_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomPermissionManager);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_PERMISSION_MANAGER_H_

atom/browser/atom_resource_dispatcher_host_delegate.cc

@@ -26,7 +26,8 @@ bool AtomResourceDispatcherHostDelegate::HandleExternalProtocol(
     bool has_user_gesture) {
   GURL escaped_url(net::EscapeExternalHandlerValue(url.spec()));
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      base::Bind(base::IgnoreResult(platform_util::OpenExternal), escaped_url));
+      base::Bind(
+          base::IgnoreResult(platform_util::OpenExternal), escaped_url, true));
   return true;
 }
 

atom/browser/browser.cc

@@ -181,4 +181,8 @@ void Browser::OnWindowAllClosed() {
     FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWindowAllClosed());
 }
 
+void Browser::PlatformThemeChanged() {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnPlatformThemeChanged());
+}
+
 }  // namespace atom

atom/browser/browser.h

@@ -27,6 +27,10 @@ namespace ui {
 class MenuModel;
 }
 
+namespace gfx {
+class Image;
+}
+
 namespace atom {
 
 class LoginHandler;
@@ -73,6 +77,15 @@ class Browser : public WindowListObserver {
   void SetAppUserModelID(const base::string16& name);
 
 #if defined(OS_MACOSX)
+  // Hide the application.
+  void Hide();
+
+  // Show the application.
+  void Show();
+
+  // Check if the system is in Dark Mode.
+  bool IsDarkMode();
+
   // Bounce the dock icon.
   enum BounceType {
     BOUNCE_CRITICAL = 0,
@@ -91,6 +104,9 @@ class Browser : public WindowListObserver {
 
   // Set docks' menu.
   void DockSetMenu(ui::MenuModel* model);
+
+  // Set docks' icon.
+  void DockSetIcon(const gfx::Image& image);
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_WIN)
@@ -129,6 +145,9 @@ class Browser : public WindowListObserver {
   // Request basic auth login.
   void RequestLogin(LoginHandler* login_handler);
 
+  // Tell the application that plaform's theme changed.
+  void PlatformThemeChanged();
+
   void AddObserver(BrowserObserver* obs) {
     observers_.AddObserver(obs);
   }

atom/browser/browser_mac.mm

@@ -18,6 +18,19 @@ void Browser::Focus() {
   [[AtomApplication sharedApplication] activateIgnoringOtherApps:YES];
 }
 
+void Browser::Hide() {
+  [[AtomApplication sharedApplication] hide:nil];
+}
+
+void Browser::Show() {
+  [[AtomApplication sharedApplication] unhide:nil];
+}
+
+bool Browser::IsDarkMode() {
+  NSString *mode = [[NSUserDefaults standardUserDefaults] stringForKey:@"AppleInterfaceStyle"];
+  return [mode isEqualToString: @"Dark"];
+}
+
 void Browser::AddRecentDocument(const base::FilePath& path) {
   NSString* path_string = base::mac::FilePathToNSString(path);
   if (!path_string)
@@ -29,6 +42,7 @@ void Browser::AddRecentDocument(const base::FilePath& path) {
 }
 
 void Browser::ClearRecentDocuments() {
+  [[NSDocumentController sharedDocumentController] clearRecentDocuments:nil];
 }
 
 void Browser::SetAppUserModelID(const base::string16& name) {
@@ -43,11 +57,12 @@ std::string Browser::GetExecutableFileProductName() const {
 }
 
 int Browser::DockBounce(BounceType type) {
-  return [[AtomApplication sharedApplication] requestUserAttention:(NSRequestUserAttentionType)type];
+  return [[AtomApplication sharedApplication]
+      requestUserAttention:(NSRequestUserAttentionType)type];
 }
 
-void Browser::DockCancelBounce(int rid) {
-  [[AtomApplication sharedApplication] cancelUserAttentionRequest:rid];
+void Browser::DockCancelBounce(int request_id) {
+  [[AtomApplication sharedApplication] cancelUserAttentionRequest:request_id];
 }
 
 void Browser::DockSetBadgeText(const std::string& label) {
@@ -70,8 +85,29 @@ void Browser::DockHide() {
 }
 
 void Browser::DockShow() {
+  BOOL active = [[NSRunningApplication currentApplication] isActive];
   ProcessSerialNumber psn = { 0, kCurrentProcess };
-  TransformProcessType(&psn, kProcessTransformToForegroundApplication);
+  if (active) {
+    // Workaround buggy behavior of TransformProcessType.
+    // http://stackoverflow.com/questions/7596643/
+    NSArray* runningApps = [NSRunningApplication
+        runningApplicationsWithBundleIdentifier:@"com.apple.dock"];
+    for (NSRunningApplication* app in runningApps) {
+      [app activateWithOptions:NSApplicationActivateIgnoringOtherApps];
+      break;
+    }
+    dispatch_time_t one_ms = dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC);
+    dispatch_after(one_ms, dispatch_get_main_queue(), ^{
+      TransformProcessType(&psn, kProcessTransformToForegroundApplication);
+      dispatch_time_t one_ms = dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC);
+      dispatch_after(one_ms, dispatch_get_main_queue(), ^{
+        [[NSRunningApplication currentApplication]
+            activateWithOptions:NSApplicationActivateIgnoringOtherApps];
+      });
+    });
+  } else {
+    TransformProcessType(&psn, kProcessTransformToForegroundApplication);
+  }
 }
 
 void Browser::DockSetMenu(ui::MenuModel* model) {
@@ -79,4 +115,9 @@ void Browser::DockSetMenu(ui::MenuModel* model) {
   [delegate setApplicationDockMenu:model];
 }
 
+void Browser::DockSetIcon(const gfx::Image& image) {
+  [[AtomApplication sharedApplication]
+      setApplicationIconImage:image.AsNSImage()];
+}
+
 }  // namespace atom

atom/browser/browser_observer.h

@@ -45,6 +45,8 @@ class BrowserObserver {
   // The browser requests HTTP login.
   virtual void OnLogin(LoginHandler* login_handler) {}
 
+  virtual void OnPlatformThemeChanged() {}
+
  protected:
   virtual ~BrowserObserver() {}
 };

atom/browser/common_web_contents_delegate.cc

@@ -181,13 +181,6 @@ content::WebContents* CommonWebContentsDelegate::OpenURLFromTab(
   return source;
 }
 
-void CommonWebContentsDelegate::RequestToLockMouse(
-    content::WebContents* web_contents,
-    bool user_gesture,
-    bool last_unlocked_by_target) {
-  GetWebContents()->GotResponseToLockMouseRequest(true);
-}
-
 bool CommonWebContentsDelegate::CanOverscrollContent() const {
   return false;
 }

atom/browser/common_web_contents_delegate.h

@@ -9,10 +9,10 @@
 #include <string>
 #include <vector>
 
-#include "brightray/browser/default_web_contents_delegate.h"
 #include "brightray/browser/inspectable_web_contents_impl.h"
 #include "brightray/browser/inspectable_web_contents_delegate.h"
 #include "brightray/browser/inspectable_web_contents_view_delegate.h"
+#include "content/public/browser/web_contents_delegate.h"
 
 namespace atom {
 
@@ -21,7 +21,7 @@ class NativeWindow;
 class WebDialogHelper;
 
 class CommonWebContentsDelegate
-    : public brightray::DefaultWebContentsDelegate,
+    : public content::WebContentsDelegate,
       public brightray::InspectableWebContentsDelegate,
       public brightray::InspectableWebContentsViewDelegate {
  public:
@@ -59,9 +59,6 @@ class CommonWebContentsDelegate
   content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) override;
-  void RequestToLockMouse(content::WebContents* web_contents,
-                          bool user_gesture,
-                          bool last_unlocked_by_target) override;
   bool CanOverscrollContent() const override;
   content::JavaScriptDialogManager* GetJavaScriptDialogManager(
       content::WebContents* source) override;

atom/browser/default_app/default_app.js

@@ -1,21 +0,0 @@
-const electron = require('electron');
-const app = electron.app;
-const BrowserWindow = electron.BrowserWindow;
-
-var mainWindow = null;
-
-// Quit when all windows are closed.
-app.on('window-all-closed', function() {
-  app.quit();
-});
-
-app.on('ready', function() {
-  mainWindow = new BrowserWindow({
-    width: 800,
-    height: 600,
-    autoHideMenuBar: true,
-    useContentSize: true,
-  });
-  mainWindow.loadURL('file://' + __dirname + '/index.html');
-  mainWindow.focus();
-});

atom/browser/lib/chrome-extension.coffee

@@ -1,96 +0,0 @@
-electron = require 'electron'
-fs   = require 'fs'
-path = require 'path'
-url  = require 'url'
-
-# Mapping between hostname and file path.
-hostPathMap = {}
-hostPathMapNextKey = 0
-
-getHostForPath = (path) ->
-  key = "extension-#{++hostPathMapNextKey}"
-  hostPathMap[key] = path
-  key
-
-getPathForHost = (host) ->
-  hostPathMap[host]
-
-# Cache extensionInfo.
-extensionInfoMap = {}
-
-getExtensionInfoFromPath = (srcDirectory) ->
-  manifest = JSON.parse fs.readFileSync(path.join(srcDirectory, 'manifest.json'))
-  unless extensionInfoMap[manifest.name]?
-    # We can not use 'file://' directly because all resources in the extension
-    # will be treated as relative to the root in Chrome.
-    page = url.format
-      protocol: 'chrome-extension'
-      slashes: true
-      hostname: getHostForPath srcDirectory
-      pathname: manifest.devtools_page
-    extensionInfoMap[manifest.name] =
-      startPage: page
-      name: manifest.name
-      srcDirectory: srcDirectory
-      exposeExperimentalAPIs: true
-    extensionInfoMap[manifest.name]
-
-# The loaded extensions cache and its persistent path.
-loadedExtensions = null
-loadedExtensionsPath = null
-
-# Persistent loaded extensions.
-{app} = electron
-app.on 'will-quit', ->
-  try
-    loadedExtensions = Object.keys(extensionInfoMap).map (key) -> extensionInfoMap[key].srcDirectory
-    try
-      fs.mkdirSync path.dirname(loadedExtensionsPath)
-    catch e
-    fs.writeFileSync loadedExtensionsPath, JSON.stringify(loadedExtensions)
-  catch e
-
-# We can not use protocol or BrowserWindow until app is ready.
-app.once 'ready', ->
-  {protocol, BrowserWindow} = electron
-
-  # Load persistented extensions.
-  loadedExtensionsPath = path.join app.getPath('userData'), 'DevTools Extensions'
-
-  try
-    loadedExtensions = JSON.parse fs.readFileSync(loadedExtensionsPath)
-    loadedExtensions = [] unless Array.isArray loadedExtensions
-    # Preheat the extensionInfo cache.
-    getExtensionInfoFromPath srcDirectory for srcDirectory in loadedExtensions
-  catch e
-
-  # The chrome-extension: can map a extension URL request to real file path.
-  chromeExtensionHandler = (request, callback) ->
-    parsed = url.parse request.url
-    return callback() unless parsed.hostname and parsed.path?
-    return callback() 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
-
-  BrowserWindow::_loadDevToolsExtensions = (extensionInfoArray) ->
-    @devToolsWebContents?.executeJavaScript "DevToolsAPI.addExtensions(#{JSON.stringify(extensionInfoArray)});"
-
-  BrowserWindow.addDevToolsExtension = (srcDirectory) ->
-    extensionInfo = getExtensionInfoFromPath srcDirectory
-    if extensionInfo
-      window._loadDevToolsExtensions [extensionInfo] for window in BrowserWindow.getAllWindows()
-      extensionInfo.name
-
-  BrowserWindow.removeDevToolsExtension = (name) ->
-    delete extensionInfoMap[name]
-
-  # Load persistented extensions when devtools is opened.
-  init = BrowserWindow::_init
-  BrowserWindow::_init = ->
-    init.call this
-    @on 'devtools-opened', ->
-      @_loadDevToolsExtensions Object.keys(extensionInfoMap).map (key) -> extensionInfoMap[key]

atom/browser/lib/desktop-capturer.coffee

@@ -1,37 +0,0 @@
-{ipcMain} = require 'electron'
-{desktopCapturer} = process.atomBinding 'desktop_capturer'
-
-deepEqual = (opt1, opt2) ->
-  return JSON.stringify(opt1) is JSON.stringify(opt2)
-
-# A queue for holding all requests from renderer process.
-requestsQueue = []
-
-ipcMain.on 'ATOM_BROWSER_DESKTOP_CAPTURER_GET_SOURCES', (event, captureWindow, captureScreen, thumbnailSize, id) ->
-  request = id: id, options: {captureWindow, captureScreen, thumbnailSize}, webContents: event.sender
-  requestsQueue.push request
-  desktopCapturer.startHandling captureWindow, captureScreen, thumbnailSize if requestsQueue.length is 1
-  # If the WebContents is destroyed before receiving result, just remove the
-  # reference from requestsQueue to make the module not send the result to it.
-  event.sender.once 'destroyed', ->
-    request.webContents = null
-
-desktopCapturer.emit = (event, name, sources) ->
-  # Receiving sources result from main process, now send them back to renderer.
-  handledRequest = requestsQueue.shift 0
-  result = ({ id: source.id, name: source.name, thumbnail: source.thumbnail.toDataUrl() } for source in sources)
-  handledRequest.webContents?.send "ATOM_RENDERER_DESKTOP_CAPTURER_RESULT_#{handledRequest.id}", result
-
-  # Check the queue to see whether there is other same request. If has, handle
-  # it for reducing redunplicated `desktopCaptuer.startHandling` calls.
-  unhandledRequestsQueue = []
-  for request in requestsQueue
-    if deepEqual handledRequest.options, request.options
-      request.webContents?.send "ATOM_RENDERER_DESKTOP_CAPTURER_RESULT_#{request.id}", errorMessage, result
-    else
-      unhandledRequestsQueue.push request
-  requestsQueue = unhandledRequestsQueue
-  # If the requestsQueue is not empty, start a new request handling.
-  if requestsQueue.length > 0
-    {captureWindow, captureScreen, thumbnailSize} = requestsQueue[0].options
-    desktopCapturer.startHandling captureWindow, captureScreen, thumbnailSize

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

@@ -1,164 +0,0 @@
-{ipcMain, webContents} = require 'electron'
-
-webViewManager = null  # Doesn't exist in early initialization.
-
-supportedWebViewEvents = [
-  'load-commit'
-  'did-finish-load'
-  'did-fail-load'
-  'did-frame-finish-load'
-  'did-start-loading'
-  'did-stop-loading'
-  'did-get-response-details'
-  'did-get-redirect-request'
-  'dom-ready'
-  'console-message'
-  'new-window'
-  'close'
-  'crashed'
-  'gpu-crashed'
-  'plugin-crashed'
-  'destroyed'
-  'page-title-updated'
-  'page-favicon-updated'
-  'enter-html-full-screen'
-  'leave-html-full-screen'
-]
-
-nextInstanceId = 0
-guestInstances = {}
-embedderElementsMap = {}
-reverseEmbedderElementsMap = {}
-
-# Moves the last element of array to the first one.
-moveLastToFirst = (list) ->
-  list.unshift list.pop()
-
-# Generate guestInstanceId.
-getNextInstanceId = (webContents) ->
-  ++nextInstanceId
-
-# Create a new guest instance.
-createGuest = (embedder, params) ->
-  webViewManager ?= process.atomBinding 'web_view_manager'
-
-  id = getNextInstanceId embedder
-  guest = webContents.create {isGuest: true, partition: params.partition, 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
-  guest.once 'destroyed', ->
-    embedder.removeListener event, destroy for event in destroyEvents
-
-  # Init guest web view after attached.
-  guest.once 'did-attach', ->
-    params = @attachParams
-    delete @attachParams
-
-    @viewInstanceId = params.instanceId
-    @setSize
-      normal:
-        width: params.elementWidth, height: params.elementHeight
-      enableAutoSize: params.autosize
-      min:
-        width: params.minwidth, height: params.minheight
-      max:
-        width: params.maxwidth, height: params.maxheight
-
-    if params.src
-      opts = {}
-      opts.httpReferrer = params.httpreferrer if params.httpreferrer
-      opts.userAgent = params.useragent if params.useragent
-      @loadURL params.src, opts
-
-    if params.allowtransparency?
-      @setAllowTransparency params.allowtransparency
-
-    guest.allowPopups = params.allowpopups
-
-  # Dispatch events to embedder.
-  for event in supportedWebViewEvents
-    do (event) ->
-      guest.on event, (_, args...) ->
-        embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-#{guest.viewInstanceId}", event, args...
-
-  # Dispatch guest's IPC messages to embedder.
-  guest.on 'ipc-message-host', (_, packed) ->
-    [channel, args...] = packed
-    embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_IPC_MESSAGE-#{guest.viewInstanceId}", channel, args...
-
-  # Autosize.
-  guest.on 'size-changed', (_, args...) ->
-    embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_SIZE_CHANGED-#{guest.viewInstanceId}", args...
-
-  id
-
-# Attach the guest to an element of embedder.
-attachGuest = (embedder, elementInstanceId, guestInstanceId, params) ->
-  guest = guestInstances[guestInstanceId].guest
-
-  # Destroy the old guest when attaching.
-  key = "#{embedder.getId()}-#{elementInstanceId}"
-  oldGuestInstanceId = embedderElementsMap[key]
-  if oldGuestInstanceId?
-    # Reattachment to the same guest is not currently supported.
-    return unless oldGuestInstanceId != guestInstanceId
-
-    return unless guestInstances[oldGuestInstanceId]?
-    destroyGuest embedder, oldGuestInstanceId
-
-  webPreferences =
-    guestInstanceId: guestInstanceId
-    nodeIntegration: params.nodeintegration ? false
-    plugins: params.plugins
-    webSecurity: !params.disablewebsecurity
-  webPreferences.preloadURL = params.preload if params.preload
-  webViewManager.addGuest guestInstanceId, elementInstanceId, embedder, guest, webPreferences
-
-  guest.attachParams = params
-  embedderElementsMap[key] = guestInstanceId
-  reverseEmbedderElementsMap[guestInstanceId] = key
-
-# Destroy an existing guest instance.
-destroyGuest = (embedder, id) ->
-  webViewManager.removeGuest embedder, id
-  guestInstances[id].guest.destroy()
-  delete guestInstances[id]
-
-  key = reverseEmbedderElementsMap[id]
-  if key?
-    delete reverseEmbedderElementsMap[id]
-    delete embedderElementsMap[key]
-
-ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_CREATE_GUEST', (event, params, requestId) ->
-  event.sender.send "ATOM_SHELL_RESPONSE_#{requestId}", createGuest(event.sender, params)
-
-ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_ATTACH_GUEST', (event, elementInstanceId, guestInstanceId, params) ->
-  attachGuest event.sender, elementInstanceId, guestInstanceId, params
-
-ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_DESTROY_GUEST', (event, id) ->
-  destroyGuest event.sender, id
-
-ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_SET_SIZE', (event, id, params) ->
-  guestInstances[id]?.guest.setSize params
-
-ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_SET_ALLOW_TRANSPARENCY', (event, id, allowtransparency) ->
-  guestInstances[id]?.guest.setAllowTransparency allowtransparency
-
-# Returns WebContents from its guest id.
-exports.getGuest = (id) ->
-  guestInstances[id]?.guest
-
-# Returns the embedder of the guest.
-exports.getEmbedder = (id) ->
-  guestInstances[id]?.embedder

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

@@ -1,86 +0,0 @@
-{ipcMain, BrowserWindow} = require 'electron'
-v8Util = process.atomBinding 'v8_util'
-
-frameToGuest = {}
-
-# Copy attribute of |parent| to |child| if it is not defined in |child|.
-mergeOptions = (child, parent) ->
-  for own key, value of parent when key not of child
-    if typeof value is 'object'
-      child[key] = mergeOptions {}, value
-    else
-      child[key] = value
-  child
-
-# Merge |options| with the |embedder|'s window's options.
-mergeBrowserWindowOptions = (embedder, options) ->
-  if embedder.browserWindowOptions?
-    # Inherit the original options if it is a BrowserWindow.
-    mergeOptions options, embedder.browserWindowOptions
-  else
-    # Or only inherit web-preferences if it is a webview.
-    options.webPreferences ?= {}
-    mergeOptions options.webPreferences, embedder.getWebPreferences()
-  options
-
-# Create a new guest created by |embedder| with |options|.
-createGuest = (embedder, url, frameName, options) ->
-  guest = frameToGuest[frameName]
-  if frameName and guest?
-    guest.loadURL url
-    return guest.id
-
-  # Remember the embedder window's id.
-  options.webPreferences ?= {}
-  options.webPreferences.openerId = BrowserWindow.fromWebContents(embedder)?.id
-
-  guest = new BrowserWindow(options)
-  guest.loadURL url
-
-  # When |embedder| is destroyed we should also destroy attached guest, and if
-  # guest is closed by user then we should prevent |embedder| from double
-  # closing guest.
-  guestId = guest.id
-  closedByEmbedder = ->
-    guest.removeListener 'closed', closedByUser
-    guest.destroy()
-  closedByUser = ->
-    embedder.send "ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_#{guestId}"
-    embedder.removeListener 'render-view-deleted', closedByEmbedder
-  embedder.once 'render-view-deleted', closedByEmbedder
-  guest.once 'closed', closedByUser
-
-  if frameName
-    frameToGuest[frameName] = guest
-    guest.frameName = frameName
-    guest.once 'closed', ->
-      delete frameToGuest[frameName]
-
-  guest.id
-
-# Routed window.open messages.
-ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', (event, args...) ->
-  [url, frameName, options] = args
-  options = mergeBrowserWindowOptions event.sender, options
-  event.sender.emit 'new-window', event, url, frameName, 'new-window', options
-  if (event.sender.isGuest() and not event.sender.allowPopups) or event.defaultPrevented
-    event.returnValue = null
-  else
-    event.returnValue = createGuest event.sender, url, frameName, options
-
-ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSE', (event, guestId) ->
-  BrowserWindow.fromId(guestId)?.destroy()
-
-ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', (event, guestId, method, args...) ->
-  BrowserWindow.fromId(guestId)?[method] args...
-
-ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', (event, guestId, message, targetOrigin, sourceOrigin) ->
-  sourceId = BrowserWindow.fromWebContents(event.sender)?.id
-  return unless sourceId?
-
-  guestContents = BrowserWindow.fromId(guestId)?.webContents
-  if guestContents?.getURL().indexOf(targetOrigin) is 0 or targetOrigin is '*'
-    guestContents?.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', sourceId, message, sourceOrigin
-
-ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', (event, guestId, method, args...) ->
-  BrowserWindow.fromId(guestId)?.webContents?[method] args...

atom/browser/lib/init.coffee

@@ -1,118 +0,0 @@
-fs     = require 'fs'
-path   = require 'path'
-util   = require 'util'
-Module = require 'module'
-
-# We modified the original process.argv to let node.js load the atom.js,
-# we need to restore it here.
-process.argv.splice 1, 1
-
-# Clear search paths.
-require path.resolve(__dirname, '..', '..', 'common', 'lib', 'reset-search-paths')
-
-# Import common settings.
-require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init')
-
-globalPaths = Module.globalPaths
-unless process.env.ELECTRON_HIDE_INTERNAL_MODULES
-  globalPaths.push path.resolve(__dirname, '..', 'api', 'lib')
-
-# Expose public APIs.
-globalPaths.push path.resolve(__dirname, '..', 'api', 'lib', 'exports')
-
-if process.platform is 'win32'
-  # Redirect node's console to use our own implementations, since node can not
-  # handle console output when running as GUI program.
-  consoleLog = (args...) ->
-    process.log util.format(args...) + "\n"
-  streamWrite = (chunk, encoding, callback) ->
-    chunk = chunk.toString(encoding) if Buffer.isBuffer chunk
-    process.log chunk
-    callback() if callback
-    true
-  console.log = console.error = console.warn = consoleLog
-  process.stdout.write = process.stderr.write = streamWrite
-
-  # Always returns EOF for stdin stream.
-  Readable = require('stream').Readable
-  stdin = new Readable
-  stdin.push null
-  process.__defineGetter__ 'stdin', -> stdin
-
-# Don't quit on fatal error.
-process.on 'uncaughtException', (error) ->
-  # Do nothing if the user has a custom uncaught exception handler.
-  if process.listeners('uncaughtException').length > 1
-    return
-
-  # Show error in GUI.
-  {dialog} = require 'electron'
-  stack = error.stack ? "#{error.name}: #{error.message}"
-  message = "Uncaught Exception:\n#{stack}"
-  dialog.showErrorBox 'A JavaScript error occurred in the main process', message
-
-# Emit 'exit' event on quit.
-{app} = require 'electron'
-app.on 'quit', (event, exitCode) ->
-  process.emit 'exit', exitCode
-
-# Map process.exit to app.exit, which quits gracefully.
-process.exit = app.exit
-
-# Load the RPC server.
-require './rpc-server'
-
-# Load the guest view manager.
-require './guest-view-manager'
-require './guest-window-manager'
-
-# Now we try to load app's package.json.
-packageJson = null
-
-searchPaths = [ 'app', 'app.asar', 'default_app' ]
-for packagePath in searchPaths
-  try
-    packagePath = path.join process.resourcesPath, packagePath
-    packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
-    break
-  catch e
-    continue
-
-unless packageJson?
-  process.nextTick -> process.exit 1
-  throw new Error("Unable to find a valid app")
-
-# Set application's version.
-app.setVersion packageJson.version if packageJson.version?
-
-# Set application's name.
-if packageJson.productName?
-  app.setName packageJson.productName
-else if packageJson.name?
-  app.setName packageJson.name
-
-# Set application's desktop name.
-if packageJson.desktopName?
-  app.setDesktopName packageJson.desktopName
-else
-  app.setDesktopName "#{app.getName()}.desktop"
-
-# Chrome 42 disables NPAPI plugins by default, reenable them here
-app.commandLine.appendSwitch 'enable-npapi'
-
-# Set the user path according to application's name.
-app.setPath 'userData', path.join(app.getPath('appData'), app.getName())
-app.setPath 'userCache', path.join(app.getPath('cache'), app.getName())
-app.setAppPath packagePath
-
-# Load the chrome extension support.
-require './chrome-extension'
-
-# Load internal desktop-capturer module.
-require './desktop-capturer'
-
-# 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

atom/browser/lib/objects-registry.coffee

@@ -1,67 +0,0 @@
-{EventEmitter} = require 'events'
-v8Util = process.atomBinding 'v8_util'
-
-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 = {}
-
-  # 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
-
-  # Get an object according to its ID.
-  get: (id) ->
-    @storage[id]?.object
-
-  # Dereference an object according to its ID.
-  remove: (webContentsId, id) ->
-    @dereference id, 1
-    # Also reduce the count in owner.
-    pointer = @owners[webContentsId]
-    return unless pointer?
-    --pointer[id]
-    delete pointer[id] if pointer[id] is 0
-
-  # 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]
-    return unless pointer?
-    pointer.count -= count
-    if pointer.count is 0
-      v8Util.deleteHiddenValue pointer.object, 'atomId'
-      delete @storage[id]
-
-module.exports = new ObjectsRegistry

atom/browser/lib/rpc-server.coffee

@@ -1,228 +0,0 @@
-path = require 'path'
-
-electron = require 'electron'
-{ipcMain} = electron
-objectsRegistry = require './objects-registry'
-
-v8Util = process.atomBinding 'v8_util'
-{IDWeakMap} = process.atomBinding 'id_weak_map'
-
-# Convert a real value into meta data.
-valueToMeta = (sender, value, optimizeSimpleObject=false) ->
-  meta = type: typeof value
-
-  meta.type = 'buffer' if Buffer.isBuffer value
-  meta.type = 'value' if value is null
-  meta.type = 'array' if Array.isArray value
-  meta.type = 'error' if value instanceof Error
-  meta.type = 'date' if value instanceof Date
-  meta.type = 'promise' if 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?
-
-  if meta.type is 'array'
-    meta.members = []
-    meta.members.push valueToMeta(sender, el) for el in value
-  else if meta.type is 'object' or meta.type is 'function'
-    meta.name = value.constructor.name
-
-    # 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.members = ({name, type: typeof field} for name, field of value)
-  else if meta.type is 'buffer'
-    meta.value = Array::slice.call value, 0
-  else if meta.type is 'promise'
-    meta.then = valueToMeta sender, value.then.bind(value)
-  else if meta.type is 'error'
-    meta.members = plainObjectToMeta value
-  else if meta.type is 'date'
-    meta.value = value.getTime()
-  else
-    meta.type = 'value'
-    meta.value = value
-
-  meta
-
-# Convert object to meta by value.
-plainObjectToMeta = (obj) ->
-  Object.getOwnPropertyNames(obj).map (name) -> {name, value: obj[name]}
-
-# Convert Error into meta data.
-exceptionToMeta = (error) ->
-  type: 'exception', message: error.message, stack: (error.stack || error)
-
-# Convert array of meta data from renderer into array of real values.
-unwrapArgs = (sender, args) ->
-  metaToValue = (meta) ->
-    switch meta.type
-      when 'value' then meta.value
-      when 'remote-object' then objectsRegistry.get meta.id
-      when 'array' then unwrapArgs sender, meta.value
-      when 'buffer' then new Buffer(meta.value)
-      when 'promise' then Promise.resolve(then: metaToValue(meta.then))
-      when 'object'
-        ret = v8Util.createObjectWithName meta.name
-        for member in meta.members
-          ret[member.name] = metaToValue(member.value)
-        ret
-      when 'function-with-return-value'
-        returnValue = metaToValue meta.value
-        -> returnValue
-      when 'function'
-        # Cache the callbacks in renderer.
-        unless sender.callbacks
-          sender.callbacks = new IDWeakMap
-          sender.on 'render-view-deleted', ->
-            sender.callbacks.clear()
-        return sender.callbacks.get meta.id if sender.callbacks.has meta.id
-
-        rendererReleased = false
-        objectsRegistry.once "clear-#{sender.getId()}", ->
-          rendererReleased = true
-
-        ret = ->
-          if rendererReleased
-            throw new Error("Attempting to call a function in a renderer window
-              that has been closed or released. Function provided here: #{meta.location}.")
-          sender.send 'ATOM_RENDERER_CALLBACK', meta.id, valueToMeta(sender, arguments)
-        v8Util.setDestructor ret, ->
-          return if rendererReleased
-          sender.callbacks.remove meta.id
-          sender.send 'ATOM_RENDERER_RELEASE_CALLBACK', meta.id
-        sender.callbacks.set meta.id, ret
-        ret
-      else throw new TypeError("Unknown type: #{meta.type}")
-
-  args.map metaToValue
-
-# Call a function and send reply asynchronously if it's a an asynchronous
-# style function and the caller didn't pass a callback.
-callFunction = (event, func, caller, args) ->
-  funcMarkedAsync = v8Util.getHiddenValue(func, 'asynchronous')
-  funcPassedCallback = typeof args[args.length - 1] is 'function'
-
-  try
-    if funcMarkedAsync and not funcPassedCallback
-      args.push (ret) ->
-        event.returnValue = valueToMeta event.sender, ret, true
-      func.apply caller, args
-    else
-      ret = func.apply caller, args
-      event.returnValue = valueToMeta event.sender, ret, true
-  catch e
-    # Catch functions thrown further down in function invocation and wrap
-    # them with the function name so it's easier to trace things like
-    # `Error processing argument -1.`
-    funcName = func.name ? "anonymous"
-    throw new Error("Could not call remote function `#{funcName}`.
-                     Check that the function signature is correct.
-                     Underlying error: #{e.message}")
-
-# Send by BrowserWindow when its render view is deleted.
-process.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (id) ->
-  objectsRegistry.clear id
-
-ipcMain.on 'ATOM_BROWSER_REQUIRE', (event, module) ->
-  try
-    event.returnValue = valueToMeta event.sender, process.mainModule.require(module)
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_GET_BUILTIN', (event, module) ->
-  try
-    event.returnValue = valueToMeta event.sender, electron[module]
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_GLOBAL', (event, name) ->
-  try
-    event.returnValue = valueToMeta event.sender, global[name]
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_CURRENT_WINDOW', (event) ->
-  try
-    event.returnValue = valueToMeta event.sender, event.sender.getOwnerBrowserWindow()
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_CURRENT_WEB_CONTENTS', (event) ->
-  event.returnValue = valueToMeta event.sender, event.sender
-
-ipcMain.on 'ATOM_BROWSER_CONSTRUCTOR', (event, id, args) ->
-  try
-    args = unwrapArgs event.sender, args
-    constructor = objectsRegistry.get id
-    # Call new with array of arguments.
-    # http://stackoverflow.com/questions/1606797/use-of-apply-with-new-operator-is-this-possible
-    obj = new (Function::bind.apply(constructor, [null].concat(args)))
-    event.returnValue = valueToMeta event.sender, obj
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_FUNCTION_CALL', (event, id, args) ->
-  try
-    args = unwrapArgs event.sender, args
-    func = objectsRegistry.get id
-    callFunction event, func, global, args
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_MEMBER_CONSTRUCTOR', (event, id, method, args) ->
-  try
-    args = unwrapArgs event.sender, args
-    constructor = objectsRegistry.get(id)[method]
-    # Call new with array of arguments.
-    obj = new (Function::bind.apply(constructor, [null].concat(args)))
-    event.returnValue = valueToMeta event.sender, obj
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_MEMBER_CALL', (event, id, method, args) ->
-  try
-    args = unwrapArgs event.sender, args
-    obj = objectsRegistry.get id
-    callFunction event, obj[method], obj, args
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_MEMBER_SET', (event, id, name, value) ->
-  try
-    obj = objectsRegistry.get id
-    obj[name] = value
-    event.returnValue = null
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_MEMBER_GET', (event, id, name) ->
-  try
-    obj = objectsRegistry.get id
-    event.returnValue = valueToMeta event.sender, obj[name]
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_DEREFERENCE', (event, id) ->
-  objectsRegistry.remove event.sender.getId(), id
-
-ipcMain.on 'ATOM_BROWSER_GUEST_WEB_CONTENTS', (event, guestInstanceId) ->
-  try
-    guestViewManager = require './guest-view-manager'
-    event.returnValue = valueToMeta event.sender, guestViewManager.getGuest(guestInstanceId)
-  catch e
-    event.returnValue = exceptionToMeta e
-
-ipcMain.on 'ATOM_BROWSER_ASYNC_CALL_TO_GUEST_VIEW', (event, guestInstanceId, method, args...) ->
-  try
-    guestViewManager = require './guest-view-manager'
-    guest = guestViewManager.getGuest(guestInstanceId)
-    guest[method].apply(guest, args)
-  catch e
-    event.returnValue = exceptionToMeta e

atom/browser/mac/atom_application_delegate.mm

@@ -24,6 +24,9 @@
   // Don't add the "Enter Full Screen" menu item automatically.
   [[NSUserDefaults standardUserDefaults] setBool:NO forKey:@"NSFullScreenMenuItemEverywhere"];
 
+  // Add observer to monitor the system's Dark Mode theme.
+  [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(platformThemeChanged:) name:@"AppleInterfaceThemeChangedNotification" object:nil];
+
   atom::Browser::Get()->WillFinishLaunching();
 }
 
@@ -59,4 +62,8 @@
   return flag;
 }
 
+- (void)platformThemeChanged:(NSNotification *)notify {
+  atom::Browser::Get()->PlatformThemeChanged();
+}
+
 @end

atom/browser/native_window.cc

@@ -32,10 +32,10 @@
 #include "ipc/ipc_message_macros.h"
 #include "native_mate/dictionary.h"
 #include "ui/gfx/codec/png_codec.h"
-#include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gl/gpu_switching_manager.h"
 
@@ -115,22 +115,41 @@ void NativeWindow::InitFromOptions(const mate::Dictionary& options) {
   } else {
     SetSizeConstraints(size_constraints);
   }
-#if defined(OS_WIN) || defined(USE_X11)
+#if defined(USE_X11)
   bool resizable;
   if (options.Get(options::kResizable, &resizable)) {
     SetResizable(resizable);
   }
 #endif
+#if defined(OS_WIN) || defined(USE_X11)
+  bool closable;
+  if (options.Get(options::kClosable, &closable)) {
+    SetClosable(closable);
+  }
+#endif
+  bool movable;
+  if (options.Get(options::kMovable, &movable)) {
+    SetMovable(movable);
+  }
+  bool has_shadow;
+  if (options.Get(options::kHasShadow, &has_shadow)) {
+    SetHasShadow(has_shadow);
+  }
   bool top;
   if (options.Get(options::kAlwaysOnTop, &top) && top) {
     SetAlwaysOnTop(true);
   }
-#if defined(OS_MACOSX) || defined(OS_WIN)
-  bool fullscreen;
-  if (options.Get(options::kFullscreen, &fullscreen) && fullscreen) {
+  // Disable fullscreen button if 'fullscreen' is specified to false.
+  bool fullscreenable = true;
+  bool fullscreen = false;
+  if (options.Get(options::kFullscreen, &fullscreen) && !fullscreen)
+    fullscreenable = false;
+  // Overriden by 'fullscreenable'.
+  options.Get(options::kFullScreenable, &fullscreenable);
+  SetFullScreenable(fullscreenable);
+  if (fullscreen) {
     SetFullScreen(true);
   }
-#endif
   bool skip;
   if (options.Get(options::kSkipTaskbar, &skip) && skip) {
     SetSkipTaskbar(skip);
@@ -154,24 +173,24 @@ void NativeWindow::InitFromOptions(const mate::Dictionary& options) {
     Show();
 }
 
-void NativeWindow::SetSize(const gfx::Size& size) {
-  SetBounds(gfx::Rect(GetPosition(), size));
+void NativeWindow::SetSize(const gfx::Size& size, bool animate) {
+  SetBounds(gfx::Rect(GetPosition(), size), animate);
 }
 
 gfx::Size NativeWindow::GetSize() {
   return GetBounds().size();
 }
 
-void NativeWindow::SetPosition(const gfx::Point& position) {
-  SetBounds(gfx::Rect(position, GetSize()));
+void NativeWindow::SetPosition(const gfx::Point& position, bool animate) {
+  SetBounds(gfx::Rect(position, GetSize()), animate);
 }
 
 gfx::Point NativeWindow::GetPosition() {
   return GetBounds().origin();
 }
 
-void NativeWindow::SetContentSize(const gfx::Size& size) {
-  SetSize(ContentSizeToWindowSize(size));
+void NativeWindow::SetContentSize(const gfx::Size& size, bool animate) {
+  SetSize(ContentSizeToWindowSize(size), animate);
 }
 
 gfx::Size NativeWindow::GetContentSize() {
@@ -268,10 +287,6 @@ bool NativeWindow::IsWebViewFocused() {
   return host_view && host_view->HasFocus();
 }
 
-bool NativeWindow::IsDevToolsFocused() {
-  return inspectable_web_contents_->GetView()->IsDevToolsViewFocused();
-}
-
 void NativeWindow::CapturePage(const gfx::Rect& rect,
                                const CapturePageCallback& callback) {
   const auto view = web_contents()->GetRenderWidgetHostView();
@@ -282,22 +297,22 @@ void NativeWindow::CapturePage(const gfx::Rect& rect,
   }
 
   // Capture full page if user doesn't specify a |rect|.
-  const gfx::Rect view_rect = rect.IsEmpty() ? view->GetViewBounds() :
-                                               rect;
+  const gfx::Size view_size = rect.IsEmpty() ? view->GetViewBounds().size() :
+                                               rect.size();
 
   // By default, the requested bitmap size is the view size in screen
   // coordinates.  However, if there's more pixel detail available on the
   // current system, increase the requested bitmap size to capture it all.
-  gfx::Size bitmap_size = view_rect.size();
+  gfx::Size bitmap_size = view_size;
   const gfx::NativeView native_view = view->GetNativeView();
   gfx::Screen* const screen = gfx::Screen::GetScreenFor(native_view);
   const float scale =
       screen->GetDisplayNearestWindow(native_view).device_scale_factor();
   if (scale > 1.0f)
-    bitmap_size = gfx::ScaleToCeiledSize(view_rect.size(), scale);
+    bitmap_size = gfx::ScaleToCeiledSize(view_size, scale);
 
   host->CopyFromBackingStore(
-      view_rect,
+      gfx::Rect(rect.origin(), view_size),
       bitmap_size,
       base::Bind(&NativeWindow::OnCapturePageDone,
                  weak_factory_.GetWeakPtr(),
@@ -413,6 +428,14 @@ void NativeWindow::NotifyWindowFocus() {
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowFocus());
 }
 
+void NativeWindow::NotifyWindowShow() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowShow());
+}
+
+void NativeWindow::NotifyWindowHide() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowHide());
+}
+
 void NativeWindow::NotifyWindowMaximize() {
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowMaximize());
 }
@@ -446,6 +469,16 @@ void NativeWindow::NotifyWindowEnterFullScreen() {
                     OnWindowEnterFullScreen());
 }
 
+void NativeWindow::NotifyWindowScrollTouchBegin() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
+                    OnWindowScrollTouchBegin());
+}
+
+void NativeWindow::NotifyWindowScrollTouchEnd() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
+                    OnWindowScrollTouchEnd());
+}
+
 void NativeWindow::NotifyWindowLeaveFullScreen() {
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
                     OnWindowLeaveFullScreen());
@@ -555,4 +588,27 @@ void NativeWindow::OnCapturePageDone(const CapturePageCallback& callback,
   callback.Run(bitmap);
 }
 
+SkColor NativeWindow::ParseHexColor(const std::string& name) {
+  auto color = name.substr(1);
+  unsigned length = color.size();
+  SkColor result = (length != 8 ? 0xFF000000 : 0x00000000);
+  unsigned value = 0;
+  if (length != 3 && length != 6 && length != 8)
+    return result;
+  for (unsigned i = 0; i < length; ++i) {
+    if (!base::IsHexDigit(color[i]))
+      return result;
+    value <<= 4;
+    value |= (color[i] < 'A' ? color[i] - '0' : (color[i] - 'A' + 10) & 0xF);
+  }
+  if (length == 6 || length == 8) {
+    result |= value;
+    return result;
+  }
+  result |= (value & 0xF00) << 12 | (value & 0xF00) << 8
+      | (value & 0xF0) << 8 | (value & 0xF0) << 4
+      | (value & 0xF) << 4 | (value & 0xF);
+  return result;
+}
+
 }  // namespace atom

atom/browser/native_window.h

@@ -105,13 +105,13 @@ class NativeWindow : public base::SupportsUserData,
   virtual bool IsMinimized() = 0;
   virtual void SetFullScreen(bool fullscreen) = 0;
   virtual bool IsFullscreen() const = 0;
-  virtual void SetBounds(const gfx::Rect& bounds) = 0;
+  virtual void SetBounds(const gfx::Rect& bounds, bool animate = false) = 0;
   virtual gfx::Rect GetBounds() = 0;
-  virtual void SetSize(const gfx::Size& size);
+  virtual void SetSize(const gfx::Size& size, bool animate = false);
   virtual gfx::Size GetSize();
-  virtual void SetPosition(const gfx::Point& position);
+  virtual void SetPosition(const gfx::Point& position, bool animate = false);
   virtual gfx::Point GetPosition();
-  virtual void SetContentSize(const gfx::Size& size);
+  virtual void SetContentSize(const gfx::Size& size, bool animate = false);
   virtual gfx::Size GetContentSize();
   virtual void SetSizeConstraints(
       const extensions::SizeConstraints& size_constraints);
@@ -125,6 +125,16 @@ class NativeWindow : public base::SupportsUserData,
   virtual gfx::Size GetMaximumSize();
   virtual void SetResizable(bool resizable) = 0;
   virtual bool IsResizable() = 0;
+  virtual void SetMovable(bool movable) = 0;
+  virtual bool IsMovable() = 0;
+  virtual void SetMinimizable(bool minimizable) = 0;
+  virtual bool IsMinimizable() = 0;
+  virtual void SetMaximizable(bool maximizable) = 0;
+  virtual bool IsMaximizable() = 0;
+  virtual void SetFullScreenable(bool fullscreenable) = 0;
+  virtual bool IsFullScreenable() = 0;
+  virtual void SetClosable(bool closable) = 0;
+  virtual bool IsClosable() = 0;
   virtual void SetAlwaysOnTop(bool top) = 0;
   virtual bool IsAlwaysOnTop() = 0;
   virtual void Center() = 0;
@@ -135,6 +145,8 @@ class NativeWindow : public base::SupportsUserData,
   virtual void SetKiosk(bool kiosk) = 0;
   virtual bool IsKiosk() = 0;
   virtual void SetBackgroundColor(const std::string& color_name) = 0;
+  virtual void SetHasShadow(bool has_shadow) = 0;
+  virtual bool HasShadow() = 0;
   virtual void SetRepresentedFilename(const std::string& filename);
   virtual std::string GetRepresentedFilename();
   virtual void SetDocumentEdited(bool edited);
@@ -143,6 +155,7 @@ class NativeWindow : public base::SupportsUserData,
   virtual void SetMenu(ui::MenuModel* menu);
   virtual bool HasModalDialog();
   virtual gfx::NativeWindow GetNativeWindow() = 0;
+  virtual gfx::AcceleratedWidget GetAcceleratedWidget() = 0;
 
   // Taskbar/Dock APIs.
   virtual void SetProgressBar(double progress) = 0;
@@ -157,7 +170,6 @@ class NativeWindow : public base::SupportsUserData,
   virtual void FocusOnWebView();
   virtual void BlurWebView();
   virtual bool IsWebViewFocused();
-  virtual bool IsDevToolsFocused();
 
   // Captures the page with |rect|, |callback| would be called when capturing is
   // done.
@@ -198,6 +210,8 @@ class NativeWindow : public base::SupportsUserData,
   void NotifyWindowClosed();
   void NotifyWindowBlur();
   void NotifyWindowFocus();
+  void NotifyWindowShow();
+  void NotifyWindowHide();
   void NotifyWindowMaximize();
   void NotifyWindowUnmaximize();
   void NotifyWindowMinimize();
@@ -205,6 +219,8 @@ class NativeWindow : public base::SupportsUserData,
   void NotifyWindowMove();
   void NotifyWindowResize();
   void NotifyWindowMoved();
+  void NotifyWindowScrollTouchBegin();
+  void NotifyWindowScrollTouchEnd();
   void NotifyWindowEnterFullScreen();
   void NotifyWindowLeaveFullScreen();
   void NotifyWindowEnterHtmlFullScreen();
@@ -265,6 +281,9 @@ class NativeWindow : public base::SupportsUserData,
   void BeforeUnloadDialogCancelled() override;
   bool OnMessageReceived(const IPC::Message& message) override;
 
+  // Parse hex color like "#FFF" or "#EFEFEF"
+  SkColor ParseHexColor(const std::string& name);
+
  private:
   // Schedule a notification unresponsive event.
   void ScheduleUnresponsiveEvent(int ms);

atom/browser/native_window_mac.h

@@ -42,12 +42,22 @@ class NativeWindowMac : public NativeWindow {
   bool IsMinimized() override;
   void SetFullScreen(bool fullscreen) override;
   bool IsFullscreen() const override;
-  void SetBounds(const gfx::Rect& bounds) override;
+  void SetBounds(const gfx::Rect& bounds, bool animate = false) override;
   gfx::Rect GetBounds() override;
   void SetContentSizeConstraints(
       const extensions::SizeConstraints& size_constraints) override;
   void SetResizable(bool resizable) override;
   bool IsResizable() override;
+  void SetMovable(bool movable) override;
+  bool IsMovable() override;
+  void SetMinimizable(bool minimizable) override;
+  bool IsMinimizable() override;
+  void SetMaximizable(bool maximizable) override;
+  bool IsMaximizable() override;
+  void SetFullScreenable(bool fullscreenable) override;
+  bool IsFullScreenable() override;
+  void SetClosable(bool closable) override;
+  bool IsClosable() override;
   void SetAlwaysOnTop(bool top) override;
   bool IsAlwaysOnTop() override;
   void Center() override;
@@ -58,6 +68,8 @@ class NativeWindowMac : public NativeWindow {
   void SetKiosk(bool kiosk) override;
   bool IsKiosk() override;
   void SetBackgroundColor(const std::string& color_name) override;
+  void SetHasShadow(bool has_shadow) override;
+  bool HasShadow() override;
   void SetRepresentedFilename(const std::string& filename) override;
   std::string GetRepresentedFilename() override;
   void SetDocumentEdited(bool edited) override;
@@ -65,6 +77,7 @@ class NativeWindowMac : public NativeWindow {
   void SetIgnoreMouseEvents(bool ignore) override;
   bool HasModalDialog() override;
   gfx::NativeWindow GetNativeWindow() override;
+  gfx::AcceleratedWidget GetAcceleratedWidget() override;
   void SetProgressBar(double progress) override;
   void SetOverlayIcon(const gfx::Image& overlay,
                       const std::string& description) override;
@@ -78,6 +91,10 @@ class NativeWindowMac : public NativeWindow {
     UpdateDraggableRegionViews(draggable_regions_);
   }
 
+  bool should_hide_native_toolbar_in_fullscreen() const {
+    return should_hide_native_toolbar_in_fullscreen_;
+  }
+
  protected:
   // NativeWindow:
   void HandleKeyboardEvent(
@@ -103,9 +120,16 @@ class NativeWindowMac : public NativeWindow {
   // whehter we can drag.
   void UpdateDraggableRegionViews(const std::vector<DraggableRegion>& regions);
 
+  // Set the attribute of NSWindow while work around a bug of zo0m button.
+  void SetStyleMask(bool on, NSUInteger flag);
+  void SetCollectionBehavior(bool on, NSUInteger flag);
+
   base::scoped_nsobject<AtomNSWindow> window_;
   base::scoped_nsobject<AtomNSWindowDelegate> window_delegate_;
 
+  // Event monitor for scroll wheel event.
+  id wheel_event_monitor_;
+
   // The view that will fill the whole frameless window.
   base::scoped_nsobject<FullSizeContentView> content_view_;
 
@@ -118,6 +142,8 @@ class NativeWindowMac : public NativeWindow {
   // The presentation options before entering kiosk mode.
   NSApplicationPresentationOptions kiosk_options_;
 
+  bool should_hide_native_toolbar_in_fullscreen_;
+
   DISALLOW_COPY_AND_ASSIGN(NativeWindowMac);
 };
 

atom/browser/native_window_mac.mm

@@ -79,6 +79,21 @@ bool ScopedDisableResize::disable_resize_ = false;
   return self;
 }
 
+- (void)windowDidChangeOcclusionState:(NSNotification *)notification {
+  // notification.object is the window that changed its state.
+  // It's safe to use self.window instead if you don't assign one delegate to many windows
+  NSWindow *window = notification.object;
+
+  // check occlusion binary flag
+  if (window.occlusionState & NSWindowOcclusionStateVisible)   {
+     // The app is visible
+     shell_->NotifyWindowShow();
+   } else {
+     // The app is not visible
+     shell_->NotifyWindowHide();
+   }
+}
+
 - (void)windowDidBecomeMain:(NSNotification*)notification {
   content::WebContents* web_contents = shell_->web_contents();
   if (!web_contents)
@@ -176,8 +191,27 @@ bool ScopedDisableResize::disable_resize_ = false;
   return YES;
 }
 
+- (void)windowWillEnterFullScreen:(NSNotification*)notification {
+  // Hide the native toolbar before entering fullscreen, so there is no visual
+  // artifacts.
+  if (shell_->should_hide_native_toolbar_in_fullscreen()) {
+    NSWindow* window = shell_->GetNativeWindow();
+    [window setToolbar:nil];
+  }
+}
+
 - (void)windowDidEnterFullScreen:(NSNotification*)notification {
   shell_->NotifyWindowEnterFullScreen();
+
+  // Restore the native toolbar immediately after entering fullscreen, if we do
+  // this before leaving fullscreen, traffic light buttons will be jumping.
+  if (shell_->should_hide_native_toolbar_in_fullscreen()) {
+    NSWindow* window = shell_->GetNativeWindow();
+    base::scoped_nsobject<NSToolbar> toolbar(
+        [[NSToolbar alloc] initWithIdentifier:@"titlebarStylingToolbar"]);
+    [toolbar setShowsBaselineSeparator:NO];
+    [window setToolbar:toolbar];
+  }
 }
 
 - (void)windowDidExitFullScreen:(NSNotification*)notification {
@@ -334,7 +368,8 @@ NativeWindowMac::NativeWindowMac(
     const mate::Dictionary& options)
     : NativeWindow(web_contents, options),
       is_kiosk_(false),
-      attention_request_id_(0) {
+      attention_request_id_(0),
+      should_hide_native_toolbar_in_fullscreen_(false) {
   int width = 800, height = 600;
   options.Get(options::kWidth, &width);
   options.Get(options::kHeight, &height);
@@ -349,6 +384,15 @@ NativeWindowMac::NativeWindowMac(
   bool resizable = true;
   options.Get(options::kResizable, &resizable);
 
+  bool minimizable = true;
+  options.Get(options::kMinimizable, &minimizable);
+
+  bool maximizable = true;
+  options.Get(options::kMaximizable, &maximizable);
+
+  bool closable = true;
+  options.Get(options::kClosable, &closable);
+
   // New title bar styles are available in Yosemite or newer
   std::string titleBarStyle;
   if (base::mac::IsOSYosemiteOrLater())
@@ -365,8 +409,13 @@ NativeWindowMac::NativeWindowMac(
     useStandardWindow = false;
   }
 
-  NSUInteger styleMask = NSTitledWindowMask | NSClosableWindowMask |
-                         NSMiniaturizableWindowMask;
+  NSUInteger styleMask = NSTitledWindowMask;
+  if (minimizable) {
+    styleMask |= NSMiniaturizableWindowMask;
+  }
+  if (closable) {
+    styleMask |= NSClosableWindowMask;
+  }
   if (!useStandardWindow || transparent() || !has_frame()) {
     styleMask |= NSTexturedBackgroundWindowMask;
   }
@@ -377,6 +426,12 @@ NativeWindowMac::NativeWindowMac(
     styleMask |= NSFullSizeContentViewWindowMask;
     styleMask |= NSUnifiedTitleAndToolbarWindowMask;
   }
+  // We capture this because we need to access the option later when
+  // entering/exiting fullscreen and since the options dict is only passed to
+  // the constructor but not stored, let’s store this option this way.
+  if (titleBarStyle == "hidden-inset") {
+    should_hide_native_toolbar_in_fullscreen_ = true;
+  }
 
   window_.reset([[AtomNSWindow alloc]
       initWithContentRect:cocoa_bounds
@@ -392,7 +447,7 @@ NativeWindowMac::NativeWindowMac(
   if (transparent()) {
     // Make window has transparent background.
     [window_ setOpaque:NO];
-    [window_ setHasShadow:NO];
+    // Setting the background color to clear will also hide the shadow.
     [window_ setBackgroundColor:[NSColor clearColor]];
   }
 
@@ -442,22 +497,41 @@ NativeWindowMac::NativeWindowMac(
   options.Get(options::kDisableAutoHideCursor, &disableAutoHideCursor);
   [window_ setDisableAutoHideCursor:disableAutoHideCursor];
 
-  // Disable fullscreen button when 'fullscreen' is specified to false.
-  bool fullscreen;
-  if (!(options.Get(options::kFullscreen, &fullscreen) &&
-        !fullscreen)) {
-    NSUInteger collectionBehavior = [window_ collectionBehavior];
-    collectionBehavior |= NSWindowCollectionBehaviorFullScreenPrimary;
-    [window_ setCollectionBehavior:collectionBehavior];
-  }
+  // Disable zoom button if window is not resizable.
+  if (!maximizable)
+    SetMaximizable(false);
 
   NSView* view = inspectable_web_contents()->GetView()->GetNativeView();
   [view setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
 
+  // Use an NSEvent monitor to listen for the wheel event.
+  BOOL __block began = NO;
+  wheel_event_monitor_ = [NSEvent
+    addLocalMonitorForEventsMatchingMask:NSScrollWheelMask
+    handler:^(NSEvent* event) {
+      if ([[event window] windowNumber] != [window_ windowNumber])
+        return event;
+
+      if (!web_contents)
+        return event;
+
+      if (!began && (([event phase] == NSEventPhaseMayBegin) ||
+                     ([event phase] == NSEventPhaseBegan))) {
+        this->NotifyWindowScrollTouchBegin();
+        began = YES;
+      } else if (began && (([event phase] == NSEventPhaseEnded) ||
+                           ([event phase] == NSEventPhaseCancelled))) {
+        this->NotifyWindowScrollTouchEnd();
+        began = NO;
+      }
+      return event;
+  }];
+
   InstallView();
 }
 
 NativeWindowMac::~NativeWindowMac() {
+  [NSEvent removeMonitor:wheel_event_monitor_];
   Observe(nullptr);
 }
 
@@ -514,7 +588,16 @@ void NativeWindowMac::Unmaximize() {
 }
 
 bool NativeWindowMac::IsMaximized() {
-  return [window_ isZoomed];
+  if (([window_ styleMask] & NSResizableWindowMask) != 0) {
+    return [window_ isZoomed];
+  } else {
+    NSRect rectScreen = [[NSScreen mainScreen] visibleFrame];
+    NSRect rectWindow = [window_ frame];
+    return (rectScreen.origin.x == rectWindow.origin.x &&
+            rectScreen.origin.y == rectWindow.origin.y &&
+            rectScreen.size.width == rectWindow.size.width &&
+            rectScreen.size.height == rectWindow.size.height);
+  }
 }
 
 void NativeWindowMac::Minimize() {
@@ -545,7 +628,7 @@ bool NativeWindowMac::IsFullscreen() const {
   return [window_ styleMask] & NSFullScreenWindowMask;
 }
 
-void NativeWindowMac::SetBounds(const gfx::Rect& bounds) {
+void NativeWindowMac::SetBounds(const gfx::Rect& bounds, bool animate) {
   NSRect cocoa_bounds = NSMakeRect(bounds.x(), 0,
                                    bounds.width(),
                                    bounds.height());
@@ -554,7 +637,7 @@ void NativeWindowMac::SetBounds(const gfx::Rect& bounds) {
   cocoa_bounds.origin.y =
       NSHeight([screen frame]) - bounds.height() - bounds.y();
 
-  [window_ setFrame:cocoa_bounds display:YES];
+  [window_ setFrame:cocoa_bounds display:YES animate:animate];
 }
 
 gfx::Rect NativeWindowMac::GetBounds() {
@@ -595,19 +678,58 @@ void NativeWindowMac::SetResizable(bool resizable) {
   // Change styleMask for frameless causes the window to change size, so we have
   // to explicitly disables that.
   ScopedDisableResize disable_resize;
-  if (resizable) {
-    [[window_ standardWindowButton:NSWindowZoomButton] setEnabled:YES];
-    [window_ setStyleMask:[window_ styleMask] | NSResizableWindowMask];
-  } else {
-    [[window_ standardWindowButton:NSWindowZoomButton] setEnabled:NO];
-    [window_ setStyleMask:[window_ styleMask] & (~NSResizableWindowMask)];
-  }
+  SetStyleMask(resizable, NSResizableWindowMask);
 }
 
 bool NativeWindowMac::IsResizable() {
   return [window_ styleMask] & NSResizableWindowMask;
 }
 
+void NativeWindowMac::SetMovable(bool movable) {
+  [window_ setMovable:movable];
+}
+
+bool NativeWindowMac::IsMovable() {
+  return [window_ isMovable];
+}
+
+void NativeWindowMac::SetMinimizable(bool minimizable) {
+  SetStyleMask(minimizable, NSMiniaturizableWindowMask);
+}
+
+bool NativeWindowMac::IsMinimizable() {
+  return [window_ styleMask] & NSMiniaturizableWindowMask;
+}
+
+void NativeWindowMac::SetMaximizable(bool maximizable) {
+  [[window_ standardWindowButton:NSWindowZoomButton] setEnabled:maximizable];
+}
+
+bool NativeWindowMac::IsMaximizable() {
+  return [[window_ standardWindowButton:NSWindowZoomButton] isEnabled];
+}
+
+void NativeWindowMac::SetFullScreenable(bool fullscreenable) {
+  SetCollectionBehavior(
+      fullscreenable, NSWindowCollectionBehaviorFullScreenPrimary);
+  // On EL Capitan this flag is required to hide fullscreen button.
+  SetCollectionBehavior(
+      !fullscreenable, NSWindowCollectionBehaviorFullScreenAuxiliary);
+}
+
+bool NativeWindowMac::IsFullScreenable() {
+  NSUInteger collectionBehavior = [window_ collectionBehavior];
+  return collectionBehavior & NSWindowCollectionBehaviorFullScreenPrimary;
+}
+
+void NativeWindowMac::SetClosable(bool closable) {
+  SetStyleMask(closable, NSClosableWindowMask);
+}
+
+bool NativeWindowMac::IsClosable() {
+  return [window_ styleMask] & NSClosableWindowMask;
+}
+
 void NativeWindowMac::SetAlwaysOnTop(bool top) {
   [window_ setLevel:(top ? NSFloatingWindowLevel : NSNormalWindowLevel)];
 }
@@ -670,6 +792,20 @@ bool NativeWindowMac::IsKiosk() {
 }
 
 void NativeWindowMac::SetBackgroundColor(const std::string& color_name) {
+  SkColor background_color = NativeWindow::ParseHexColor(color_name);
+  NSColor *color = [NSColor colorWithCalibratedRed:SkColorGetR(background_color)
+    green:SkColorGetG(background_color)
+    blue:SkColorGetB(background_color)
+    alpha:SkColorGetA(background_color)/255.0f];
+  [window_ setBackgroundColor:color];
+}
+
+void NativeWindowMac::SetHasShadow(bool has_shadow) {
+  [window_ setHasShadow:has_shadow];
+}
+
+bool NativeWindowMac::HasShadow() {
+  return [window_ hasShadow];
 }
 
 void NativeWindowMac::SetRepresentedFilename(const std::string& filename) {
@@ -700,6 +836,10 @@ gfx::NativeWindow NativeWindowMac::GetNativeWindow() {
   return window_;
 }
 
+gfx::AcceleratedWidget NativeWindowMac::GetAcceleratedWidget() {
+  return inspectable_web_contents()->GetView()->GetNativeView();
+}
+
 void NativeWindowMac::SetProgressBar(double progress) {
   NSDockTile* dock_tile = [NSApp dockTile];
 
@@ -750,13 +890,7 @@ void NativeWindowMac::ShowDefinitionForSelection() {
 }
 
 void NativeWindowMac::SetVisibleOnAllWorkspaces(bool visible) {
-  NSUInteger collectionBehavior = [window_ collectionBehavior];
-  if (visible) {
-    collectionBehavior |= NSWindowCollectionBehaviorCanJoinAllSpaces;
-  } else {
-    collectionBehavior &= ~NSWindowCollectionBehaviorCanJoinAllSpaces;
-  }
-  [window_ setCollectionBehavior:collectionBehavior];
+  SetCollectionBehavior(visible, NSWindowCollectionBehaviorCanJoinAllSpaces);
 }
 
 bool NativeWindowMac::IsVisibleOnAllWorkspaces() {
@@ -772,12 +906,15 @@ void NativeWindowMac::HandleKeyboardEvent(
     return;
 
   BOOL handled = [[NSApp mainMenu] performKeyEquivalent:event.os_event];
-  if (!handled && event.os_event.window != window_.get()) {
-    // The event comes from detached devtools view, and it has already been
-    if (!handled && (event.os_event.modifierFlags & NSCommandKeyMask) &&
-        (event.os_event.keyCode == 50  /* ~ key */)) {
-      // Handle the cmd+~ shortcut.
-      Focus(true);
+  if (!handled && event.os_event.window) {
+    // Handle the cmd+~ shortcut.
+    if ((event.os_event.modifierFlags & NSCommandKeyMask) /* cmd */ &&
+        (event.os_event.keyCode == 50  /* ~ */)) {
+      if (event.os_event.modifierFlags & NSShiftKeyMask) {
+        [NSApp sendAction:@selector(_cycleWindowsReversed:) to:nil from:nil];
+      } else {
+        [NSApp sendAction:@selector(_cycleWindows:) to:nil from:nil];
+      }
     }
   }
 }
@@ -913,6 +1050,30 @@ void NativeWindowMac::UpdateDraggableRegionViews(
   [window_ setMovableByWindowBackground:YES];
 }
 
+void NativeWindowMac::SetStyleMask(bool on, NSUInteger flag) {
+  bool zoom_button_enabled = IsMaximizable();
+  if (on)
+    [window_ setStyleMask:[window_ styleMask] | flag];
+  else
+    [window_ setStyleMask:[window_ styleMask] & (~flag)];
+  // Change style mask will make the zoom button revert to default, probably
+  // a bug of Cocoa or OS X.
+  if (!zoom_button_enabled)
+    SetMaximizable(false);
+}
+
+void NativeWindowMac::SetCollectionBehavior(bool on, NSUInteger flag) {
+  bool zoom_button_enabled = IsMaximizable();
+  if (on)
+    [window_ setCollectionBehavior:[window_ collectionBehavior] | flag];
+  else
+    [window_ setCollectionBehavior:[window_ collectionBehavior] & (~flag)];
+  // Change collectionBehavior will make the zoom button revert to default,
+  // probably a bug of Cocoa or OS X.
+  if (!zoom_button_enabled)
+    SetMaximizable(false);
+}
+
 // static
 NativeWindow* NativeWindow::Create(
     brightray::InspectableWebContents* inspectable_web_contents,

atom/browser/native_window_observer.h

@@ -42,6 +42,12 @@ class NativeWindowObserver {
   // Called when window gains focus.
   virtual void OnWindowFocus() {}
 
+  // Called when window is shown.
+  virtual void OnWindowShow() {}
+
+  // Called when window is hidden.
+  virtual void OnWindowHide() {}
+
   // Called when window state changed.
   virtual void OnWindowMaximize() {}
   virtual void OnWindowUnmaximize() {}
@@ -50,6 +56,8 @@ class NativeWindowObserver {
   virtual void OnWindowResize() {}
   virtual void OnWindowMove() {}
   virtual void OnWindowMoved() {}
+  virtual void OnWindowScrollTouchBegin() {}
+  virtual void OnWindowScrollTouchEnd() {}
   virtual void OnWindowEnterFullScreen() {}
   virtual void OnWindowLeaveFullScreen() {}
   virtual void OnWindowEnterHtmlFullScreen() {}

atom/browser/native_window_views.cc

@@ -59,13 +59,19 @@ const int kMenuBarHeight = 20;
 const int kMenuBarHeight = 25;
 #endif
 
-bool IsAltKey(const content::NativeWebKeyboardEvent& event) {
-#if defined(USE_X11)
-  // 164 and 165 represent VK_LALT and VK_RALT.
-  return event.windowsKeyCode == 164 || event.windowsKeyCode == 165;
-#else
-  return event.windowsKeyCode == ui::VKEY_MENU;
+#if defined(OS_WIN)
+void FlipWindowStyle(HWND handle, bool on, DWORD flag) {
+  DWORD style = ::GetWindowLong(handle, GWL_STYLE);
+  if (on)
+    style |= flag;
+  else
+    style &= ~flag;
+  ::SetWindowLong(handle, GWL_STYLE, style);
+}
 #endif
+
+bool IsAltKey(const content::NativeWebKeyboardEvent& event) {
+  return event.windowsKeyCode == ui::VKEY_MENU;
 }
 
 bool IsAltModifier(const content::NativeWebKeyboardEvent& event) {
@@ -78,29 +84,6 @@ bool IsAltModifier(const content::NativeWebKeyboardEvent& event) {
          (modifiers == (Modifiers::AltKey | Modifiers::IsRight));
 }
 
-SkColor ParseHexColor(const std::string& name) {
-  SkColor result = 0xFF000000;
-  unsigned value = 0;
-  auto color = name.substr(1);
-  unsigned length = color.size();
-  if (length != 3 && length != 6)
-    return result;
-  for (unsigned i = 0; i < length; ++i) {
-    if (!base::IsHexDigit(color[i]))
-      return result;
-    value <<= 4;
-    value |= (color[i] < 'A' ? color[i] - '0' : (color[i] - 'A' + 10) & 0xF);
-  }
-  if (length == 6) {
-    result |= value;
-    return result;
-  }
-  result |= (value & 0xF00) << 12 | (value & 0xF00) << 8
-      | (value & 0xF0) << 8 | (value & 0xF0) << 4
-      | (value & 0xF) << 4 | (value & 0xF);
-  return result;
-}
-
 class NativeWindowClientView : public views::ClientView {
  public:
   NativeWindowClientView(views::Widget* widget,
@@ -131,7 +114,11 @@ NativeWindowViews::NativeWindowViews(
       menu_bar_alt_pressed_(false),
       keyboard_event_handler_(new views::UnhandledKeyboardEventHandler),
       use_content_size_(false),
-      resizable_(true) {
+      movable_(true),
+      resizable_(true),
+      maximizable_(true),
+      minimizable_(true),
+      fullscreenable_(true) {
   options.Get(options::kTitle, &title_);
   options.Get(options::kAutoHideMenuBar, &menu_bar_autohide_);
 
@@ -139,6 +126,8 @@ NativeWindowViews::NativeWindowViews(
   // On Windows we rely on the CanResize() to indicate whether window can be
   // resized, and it should be set before window is created.
   options.Get(options::kResizable, &resizable_);
+  options.Get(options::kMinimizable, &minimizable_);
+  options.Get(options::kMaximizable, &maximizable_);
 #endif
 
   if (enable_larger_than_screen())
@@ -167,6 +156,11 @@ NativeWindowViews::NativeWindowViews(
   if (transparent())
     params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
 
+  // The given window is most likely not rectangular since it uses
+  // transparency and has no standard frame, don't show a shadow for it.
+  if (transparent() && !has_frame())
+    params.shadow_type = views::Widget::InitParams::SHADOW_TYPE_NONE;
+
 #if defined(OS_WIN)
   params.native_widget =
       new views::DesktopNativeWidgetAura(window_.get());
@@ -238,14 +232,18 @@ NativeWindowViews::NativeWindowViews(
     last_window_state_ = ui::SHOW_STATE_FULLSCREEN;
   else
     last_window_state_ = ui::SHOW_STATE_NORMAL;
-
   last_normal_size_ = gfx::Size(widget_size_);
 
   if (!has_frame()) {
     // Set Window style so that we get a minimize and maximize animation when
     // frameless.
-    DWORD frame_style = WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX |
-                        WS_CAPTION;
+    DWORD frame_style = WS_CAPTION;
+    if (resizable_)
+      frame_style |= WS_THICKFRAME;
+    if (minimizable_)
+      frame_style |= WS_MINIMIZEBOX;
+    if (maximizable_)
+      frame_style |= WS_MAXIMIZEBOX;
     // We should not show a frame for transparent window.
     if (transparent())
       frame_style &= ~(WS_THICKFRAME | WS_CAPTION);
@@ -267,11 +265,6 @@ NativeWindowViews::NativeWindowViews(
     window_->FrameTypeChanged();
   }
 
-  // The given window is most likely not rectangular since it uses
-  // transparency and has no standard frame, don't show a shadow for it.
-  if (transparent() && !has_frame())
-    wm::SetShadowType(GetNativeWindow(), wm::SHADOW_TYPE_NONE);
-
   gfx::Size size = bounds.size();
   if (has_frame() &&
       options.Get(options::kUseContentSize, &use_content_size_) &&
@@ -308,14 +301,35 @@ bool NativeWindowViews::IsFocused() {
 
 void NativeWindowViews::Show() {
   window_->native_widget_private()->ShowWithWindowState(GetRestoredState());
+
+  NotifyWindowShow();
+
+#if defined(USE_X11)
+  if (global_menu_bar_)
+    global_menu_bar_->OnWindowMapped();
+#endif
 }
 
 void NativeWindowViews::ShowInactive() {
   window_->ShowInactive();
+
+  NotifyWindowShow();
+
+#if defined(USE_X11)
+  if (global_menu_bar_)
+    global_menu_bar_->OnWindowMapped();
+#endif
 }
 
 void NativeWindowViews::Hide() {
   window_->Hide();
+
+  NotifyWindowHide();
+
+#if defined(USE_X11)
+  if (global_menu_bar_)
+    global_menu_bar_->OnWindowUnmapped();
+#endif
 }
 
 bool NativeWindowViews::IsVisible() {
@@ -355,6 +369,9 @@ bool NativeWindowViews::IsMinimized() {
 }
 
 void NativeWindowViews::SetFullScreen(bool fullscreen) {
+  if (!IsFullScreenable())
+    return;
+
 #if defined(OS_WIN)
   // There is no native fullscreen state on Windows.
   if (fullscreen) {
@@ -380,7 +397,8 @@ bool NativeWindowViews::IsFullscreen() const {
   return window_->IsFullscreen();
 }
 
-void NativeWindowViews::SetBounds(const gfx::Rect& bounds) {
+void NativeWindowViews::SetBounds(const gfx::Rect& bounds,
+    bool animate = false) {
 #if defined(USE_X11)
   // On Linux the minimum and maximum size should be updated with window size
   // when window is not resizable.
@@ -426,15 +444,8 @@ void NativeWindowViews::SetContentSizeConstraints(
 
 void NativeWindowViews::SetResizable(bool resizable) {
 #if defined(OS_WIN)
-  // WS_MAXIMIZEBOX => Maximize button
-  // WS_MINIMIZEBOX => Minimize button
-  // WS_THICKFRAME => Resize handle
-  DWORD style = ::GetWindowLong(GetAcceleratedWidget(), GWL_STYLE);
-  if (resizable)
-    style |= WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_THICKFRAME;
-  else
-    style = (style & ~(WS_MAXIMIZEBOX | WS_THICKFRAME)) | WS_MINIMIZEBOX;
-  ::SetWindowLong(GetAcceleratedWidget(), GWL_STYLE, style);
+  if (!transparent())
+    FlipWindowStyle(GetAcceleratedWidget(), resizable, WS_THICKFRAME);
 #elif defined(USE_X11)
   if (resizable != resizable_) {
     // On Linux there is no "resizable" property of a window, we have to set
@@ -455,7 +466,88 @@ void NativeWindowViews::SetResizable(bool resizable) {
 }
 
 bool NativeWindowViews::IsResizable() {
-  return resizable_;
+#if defined(OS_WIN)
+  return ::GetWindowLong(GetAcceleratedWidget(), GWL_STYLE) & WS_THICKFRAME;
+#else
+  return CanResize();
+#endif
+}
+
+void NativeWindowViews::SetMovable(bool movable) {
+  movable_ = movable;
+}
+
+bool NativeWindowViews::IsMovable() {
+#if defined(OS_WIN)
+  return movable_;
+#else
+  return true;  // Not implemented on Linux.
+#endif
+}
+
+void NativeWindowViews::SetMinimizable(bool minimizable) {
+#if defined(OS_WIN)
+  FlipWindowStyle(GetAcceleratedWidget(), minimizable, WS_MINIMIZEBOX);
+#endif
+  minimizable_ = minimizable;
+}
+
+bool NativeWindowViews::IsMinimizable() {
+#if defined(OS_WIN)
+  return ::GetWindowLong(GetAcceleratedWidget(), GWL_STYLE) & WS_MINIMIZEBOX;
+#else
+  return true;  // Not implemented on Linux.
+#endif
+}
+
+void NativeWindowViews::SetMaximizable(bool maximizable) {
+#if defined(OS_WIN)
+  FlipWindowStyle(GetAcceleratedWidget(), maximizable, WS_MAXIMIZEBOX);
+#endif
+  maximizable_ = maximizable;
+}
+
+bool NativeWindowViews::IsMaximizable() {
+#if defined(OS_WIN)
+  return ::GetWindowLong(GetAcceleratedWidget(), GWL_STYLE) & WS_MAXIMIZEBOX;
+#else
+  return true;  // Not implemented on Linux.
+#endif
+}
+
+void NativeWindowViews::SetFullScreenable(bool fullscreenable) {
+  fullscreenable_ = fullscreenable;
+}
+
+bool NativeWindowViews::IsFullScreenable() {
+  return fullscreenable_;
+}
+
+void NativeWindowViews::SetClosable(bool closable) {
+#if defined(OS_WIN)
+  HMENU menu = GetSystemMenu(GetAcceleratedWidget(), false);
+  if (closable) {
+    EnableMenuItem(menu, SC_CLOSE, MF_BYCOMMAND | MF_ENABLED);
+  } else {
+    EnableMenuItem(menu, SC_CLOSE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
+  }
+#endif
+}
+
+bool NativeWindowViews::IsClosable() {
+#if defined(OS_WIN)
+  HMENU menu = GetSystemMenu(GetAcceleratedWidget(), false);
+  MENUITEMINFO info;
+  memset(&info, 0, sizeof(info));
+  info.cbSize = sizeof(info);
+  info.fMask = MIIM_STATE;
+  if (!GetMenuItemInfo(menu, SC_CLOSE, false, &info)) {
+    return false;
+  }
+  return !(info.fState & MFS_DISABLED);
+#elif defined(USE_X11)
+  return true;
+#endif
 }
 
 void NativeWindowViews::SetAlwaysOnTop(bool top) {
@@ -522,7 +614,7 @@ bool NativeWindowViews::IsKiosk() {
 
 void NativeWindowViews::SetBackgroundColor(const std::string& color_name) {
   // web views' background color.
-  SkColor background_color = ParseHexColor(color_name);
+  SkColor background_color = NativeWindow::ParseHexColor(color_name);
   set_background(views::Background::CreateSolidBackground(background_color));
 
 #if defined(OS_WIN)
@@ -535,6 +627,16 @@ void NativeWindowViews::SetBackgroundColor(const std::string& color_name) {
 #endif
 }
 
+void NativeWindowViews::SetHasShadow(bool has_shadow) {
+  wm::SetShadowType(
+      GetNativeWindow(),
+      has_shadow ? wm::SHADOW_TYPE_RECTANGULAR : wm::SHADOW_TYPE_NONE);
+}
+
+bool NativeWindowViews::HasShadow() {
+  return wm::GetShadowType(GetNativeWindow()) != wm::SHADOW_TYPE_NONE;
+}
+
 void NativeWindowViews::SetMenu(ui::MenuModel* menu_model) {
   if (menu_model == nullptr) {
     // Remove accelerators
@@ -715,11 +817,15 @@ bool NativeWindowViews::CanResize() const {
 }
 
 bool NativeWindowViews::CanMaximize() const {
-  return resizable_;
+  return resizable_ && maximizable_;
 }
 
 bool NativeWindowViews::CanMinimize() const {
+#if defined(OS_WIN)
+  return minimizable_;
+#elif defined(USE_X11)
   return true;
+#endif
 }
 
 base::string16 NativeWindowViews::GetWindowTitle() const {

atom/browser/native_window_views.h

@@ -61,13 +61,23 @@ class NativeWindowViews : public NativeWindow,
   bool IsMinimized() override;
   void SetFullScreen(bool fullscreen) override;
   bool IsFullscreen() const override;
-  void SetBounds(const gfx::Rect& bounds) override;
+  void SetBounds(const gfx::Rect& bounds, bool animate) override;
   gfx::Rect GetBounds() override;
   gfx::Size GetContentSize() override;
   void SetContentSizeConstraints(
       const extensions::SizeConstraints& size_constraints) override;
   void SetResizable(bool resizable) override;
   bool IsResizable() override;
+  void SetMovable(bool movable) override;
+  bool IsMovable() override;
+  void SetMinimizable(bool minimizable) override;
+  bool IsMinimizable() override;
+  void SetMaximizable(bool maximizable) override;
+  bool IsMaximizable() override;
+  void SetFullScreenable(bool fullscreenable) override;
+  bool IsFullScreenable() override;
+  void SetClosable(bool closable) override;
+  bool IsClosable() override;
   void SetAlwaysOnTop(bool top) override;
   bool IsAlwaysOnTop() override;
   void Center() override;
@@ -78,6 +88,8 @@ class NativeWindowViews : public NativeWindow,
   void SetKiosk(bool kiosk) override;
   bool IsKiosk() override;
   void SetBackgroundColor(const std::string& color_name) override;
+  void SetHasShadow(bool has_shadow) override;
+  bool HasShadow() override;
   void SetMenu(ui::MenuModel* menu_model) override;
   gfx::NativeWindow GetNativeWindow() override;
   void SetOverlayIcon(const gfx::Image& overlay,
@@ -90,7 +102,7 @@ class NativeWindowViews : public NativeWindow,
   void SetVisibleOnAllWorkspaces(bool visible) override;
   bool IsVisibleOnAllWorkspaces() override;
 
-  gfx::AcceleratedWidget GetAcceleratedWidget();
+  gfx::AcceleratedWidget GetAcceleratedWidget() override;
 
   views::Widget* widget() const { return window_.get(); }
 
@@ -196,7 +208,11 @@ class NativeWindowViews : public NativeWindow,
   accelerator_util::AcceleratorTable accelerator_table_;
 
   bool use_content_size_;
+  bool movable_;
   bool resizable_;
+  bool maximizable_;
+  bool minimizable_;
+  bool fullscreenable_;
   std::string title_;
   gfx::Size widget_size_;
 

atom/browser/native_window_views_win.cc

@@ -84,29 +84,23 @@ bool NativeWindowViews::PreHandleMSG(
   NotifyWindowMessage(message, w_param, l_param);
 
   switch (message) {
-    // Screen readers send WM_GETOBJECT in order to get the accessibility
-    // object, so take this opportunity to push Chromium into accessible
-    // mode if it isn't already, always say we didn't handle the message
-    // because we still want Chromium to handle returning the actual
-    // accessibility object.
-    case WM_GETOBJECT: {
-      const DWORD obj_id = static_cast<DWORD>(l_param);
-      if (obj_id == OBJID_CLIENT) {
-        const auto axState = content::BrowserAccessibilityState::GetInstance();
-        if (axState && !axState->IsAccessibleBrowser())
-          axState->OnScreenReaderDetected();
-      }
-      return false;
-    }
     case WM_COMMAND:
       // Handle thumbar button click message.
       if (HIWORD(w_param) == THBN_CLICKED)
         return taskbar_host_.HandleThumbarButtonEvent(LOWORD(w_param));
       return false;
+
     case WM_SIZE:
       // Handle window state change.
       HandleSizeEvent(w_param, l_param);
       return false;
+
+    case WM_MOVING: {
+      if (!movable_)
+        ::GetWindowRect(GetAcceleratedWidget(), (LPRECT)l_param);
+      return false;
+    }
+
     default:
       return false;
   }

atom/browser/net/atom_network_delegate.cc

@@ -75,6 +75,10 @@ void ToDictionary(base::DictionaryValue* details, net::URLRequest* request) {
   details->SetString("resourceType",
                      info ? ResourceTypeToString(info->GetResourceType())
                           : "other");
+  scoped_ptr<base::ListValue> list(new base::ListValue);
+  GetUploadData(list.get(), request);
+  if (!list->empty())
+    details->Set("uploadData", list.Pass());
 }
 
 void ToDictionary(base::DictionaryValue* details,
@@ -154,6 +158,7 @@ void ReadFromResponseObject(const base::DictionaryValue& response,
                             net::HttpRequestHeaders* headers) {
   const base::DictionaryValue* dict;
   if (response.GetDictionary("requestHeaders", &dict)) {
+    headers->Clear();
     for (base::DictionaryValue::Iterator it(*dict);
          !it.IsAtEnd();
          it.Advance()) {
@@ -185,28 +190,6 @@ void ReadFromResponseObject(const base::DictionaryValue& response,
   }
 }
 
-// Deal with the results of Listener.
-template<typename T>
-void OnListenerResultInIO(const net::CompletionCallback& callback,
-                          T out,
-                          scoped_ptr<base::DictionaryValue> response) {
-  ReadFromResponseObject(*response.get(), out);
-
-  bool cancel = false;
-  response->GetBoolean("cancel", &cancel);
-  callback.Run(cancel ? net::ERR_BLOCKED_BY_CLIENT : net::OK);
-}
-
-template<typename T>
-void OnListenerResultInUI(const net::CompletionCallback& callback,
-                          T out,
-                          const base::DictionaryValue& response) {
-  scoped_ptr<base::DictionaryValue> copy = response.CreateDeepCopy();
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(OnListenerResultInIO<T>, callback, out, base::Passed(&copy)));
-}
-
 }  // namespace
 
 AtomNetworkDelegate::AtomNetworkDelegate() {
@@ -309,13 +292,13 @@ void AtomNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
 }
 
 void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
+  // OnCompleted may happen before other events.
+  callbacks_.erase(request->identifier());
+
   if (request->status().status() == net::URLRequestStatus::FAILED ||
       request->status().status() == net::URLRequestStatus::CANCELED) {
     // Error event.
-    if (ContainsKey(simple_listeners_, kOnErrorOccurred))
-      OnErrorOccurred(request);
-    else
-      brightray::NetworkDelegate::OnCompleted(request, started);
+    OnErrorOccurred(request, started);
     return;
   } else if (request->response_headers() &&
              net::HttpResponseHeaders::IsRedirectResponseCode(
@@ -334,7 +317,17 @@ void AtomNetworkDelegate::OnCompleted(net::URLRequest* request, bool started) {
                     request->was_cached());
 }
 
-void AtomNetworkDelegate::OnErrorOccurred(net::URLRequest* request) {
+void AtomNetworkDelegate::OnURLRequestDestroyed(net::URLRequest* request) {
+  callbacks_.erase(request->identifier());
+}
+
+void AtomNetworkDelegate::OnErrorOccurred(
+    net::URLRequest* request, bool started) {
+  if (!ContainsKey(simple_listeners_, kOnErrorOccurred)) {
+    brightray::NetworkDelegate::OnCompleted(request, started);
+    return;
+  }
+
   HandleSimpleEvent(kOnErrorOccurred, request, request->was_cached(),
                     request->status());
 }
@@ -353,8 +346,12 @@ int AtomNetworkDelegate::HandleResponseEvent(
   scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue);
   FillDetailsObject(details.get(), request, args...);
 
+  // The |request| could be destroyed before the |callback| is called.
+  callbacks_[request->identifier()] = callback;
+
   ResponseCallback response =
-      base::Bind(OnListenerResultInUI<Out>, callback, out);
+      base::Bind(&AtomNetworkDelegate::OnListenerResultInUI<Out>,
+                 base::Unretained(this), request->identifier(), out);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(RunResponseListener, info.listener, base::Passed(&details),
@@ -377,4 +374,28 @@ void AtomNetworkDelegate::HandleSimpleEvent(
       base::Bind(RunSimpleListener, info.listener, base::Passed(&details)));
 }
 
+template<typename T>
+void AtomNetworkDelegate::OnListenerResultInIO(
+    uint64_t id, T out, scoped_ptr<base::DictionaryValue> response) {
+  // The request has been destroyed.
+  if (!ContainsKey(callbacks_, id))
+    return;
+
+  ReadFromResponseObject(*response.get(), out);
+
+  bool cancel = false;
+  response->GetBoolean("cancel", &cancel);
+  callbacks_[id].Run(cancel ? net::ERR_BLOCKED_BY_CLIENT : net::OK);
+}
+
+template<typename T>
+void AtomNetworkDelegate::OnListenerResultInUI(
+    uint64_t id, T out, const base::DictionaryValue& response) {
+  scoped_ptr<base::DictionaryValue> copy = response.CreateDeepCopy();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&AtomNetworkDelegate::OnListenerResultInIO<T>,
+                 base::Unretained(this),  id, out, base::Passed(&copy)));
+}
+
 }  // namespace atom

atom/browser/net/atom_network_delegate.h

@@ -85,10 +85,11 @@ class AtomNetworkDelegate : public brightray::NetworkDelegate {
                         const GURL& new_location) override;
   void OnResponseStarted(net::URLRequest* request) override;
   void OnCompleted(net::URLRequest* request, bool started) override;
-
-  void OnErrorOccurred(net::URLRequest* request);
+  void OnURLRequestDestroyed(net::URLRequest* request) override;
 
  private:
+  void OnErrorOccurred(net::URLRequest* request, bool started);
+
   template<typename...Args>
   void HandleSimpleEvent(SimpleEvent type,
                          net::URLRequest* request,
@@ -100,8 +101,17 @@ class AtomNetworkDelegate : public brightray::NetworkDelegate {
                           Out out,
                           Args... args);
 
+  // Deal with the results of Listener.
+  template<typename T>
+  void OnListenerResultInIO(
+      uint64_t id, T out, scoped_ptr<base::DictionaryValue> response);
+  template<typename T>
+  void OnListenerResultInUI(
+      uint64_t id, T out, const base::DictionaryValue& response);
+
   std::map<SimpleEvent, SimpleListenerInfo> simple_listeners_;
-  std::map<ResponseEvent, ResponseListenerInfo> response_listeners_;;
+  std::map<ResponseEvent, ResponseListenerInfo> response_listeners_;
+  std::map<uint64_t, net::CompletionCallback> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomNetworkDelegate);
 };

atom/browser/net/url_request_fetch_job.cc

@@ -205,7 +205,7 @@ bool URLRequestFetchJob::ReadRawData(net::IOBuffer* dest,
 }
 
 bool URLRequestFetchJob::GetMimeType(std::string* mime_type) const {
-  if (!response_info_)
+  if (!response_info_ || !response_info_->headers)
     return false;
 
   return response_info_->headers->GetMimeType(mime_type);
@@ -217,7 +217,7 @@ void URLRequestFetchJob::GetResponseInfo(net::HttpResponseInfo* info) {
 }
 
 int URLRequestFetchJob::GetResponseCode() const {
-  if (!response_info_)
+  if (!response_info_ || !response_info_->headers)
     return -1;
 
   return response_info_->headers->response_code();

atom/browser/resources/mac/Info.plist

@@ -17,13 +17,13 @@
   <key>CFBundleIconFile</key>
   <string>atom.icns</string>
   <key>CFBundleVersion</key>
-  <string>0.36.1</string>
+  <string>0.36.11</string>
   <key>CFBundleShortVersionString</key>
-  <string>0.36.1</string>
+  <string>0.36.11</string>
   <key>LSApplicationCategoryType</key>
   <string>public.app-category.developer-tools</string>
   <key>LSMinimumSystemVersion</key>
-  <string>10.8.0</string>
+  <string>10.9.0</string>
   <key>NSMainNibFile</key>
   <string>MainMenu</string>
   <key>NSPrincipalClass</key>

atom/browser/resources/win/atom.rc

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

atom/browser/ui/accelerator_util.cc

@@ -9,7 +9,7 @@
 #include <string>
 #include <vector>
 
-#include "atom/common/keyboad_util.h"
+#include "atom/common/keyboard_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ -18,13 +18,12 @@
 
 namespace accelerator_util {
 
-bool StringToAccelerator(const std::string& description,
+bool StringToAccelerator(const std::string& shortcut,
                          ui::Accelerator* accelerator) {
-  if (!base::IsStringASCII(description)) {
+  if (!base::IsStringASCII(shortcut)) {
     LOG(ERROR) << "The accelerator string can only contain ASCII characters";
     return false;
   }
-  std::string shortcut(base::ToLowerASCII(description));
 
   std::vector<std::string> tokens = base::SplitString(
      shortcut, "+", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
@@ -33,95 +32,35 @@ bool StringToAccelerator(const std::string& description,
   int modifiers = ui::EF_NONE;
   ui::KeyboardCode key = ui::VKEY_UNKNOWN;
   for (size_t i = 0; i < tokens.size(); i++) {
-    // We use straight comparing instead of map because the accelerator tends
-    // to be correct and usually only uses few special tokens.
-    if (tokens[i].size() == 1) {
-      bool shifted = false;
-      key = atom::KeyboardCodeFromCharCode(tokens[i][0], &shifted);
-      if (shifted)
+    bool shifted = false;
+    ui::KeyboardCode code = atom::KeyboardCodeFromStr(tokens[i], &shifted);
+    if (shifted)
+      modifiers |= ui::EF_SHIFT_DOWN;
+    switch (code) {
+      // The token can be a modifier.
+      case ui::VKEY_SHIFT:
         modifiers |= ui::EF_SHIFT_DOWN;
-    } else if (tokens[i] == "ctrl" || tokens[i] == "control") {
-      modifiers |= ui::EF_CONTROL_DOWN;
-    } else if (tokens[i] == "super") {
-      modifiers |= ui::EF_COMMAND_DOWN;
-#if defined(OS_MACOSX)
-    } else if (tokens[i] == "cmd" || tokens[i] == "command") {
-      modifiers |= ui::EF_COMMAND_DOWN;
-#endif
-    } else if (tokens[i] == "commandorcontrol" || tokens[i] == "cmdorctrl") {
-#if defined(OS_MACOSX)
-      modifiers |= ui::EF_COMMAND_DOWN;
-#else
-      modifiers |= ui::EF_CONTROL_DOWN;
-#endif
-    } else if (tokens[i] == "alt") {
-      modifiers |= ui::EF_ALT_DOWN;
-    } else if (tokens[i] == "shift") {
-      modifiers |= ui::EF_SHIFT_DOWN;
-    } else if (tokens[i] == "plus") {
-      modifiers |= ui::EF_SHIFT_DOWN;
-      key = ui::VKEY_OEM_PLUS;
-    } else if (tokens[i] == "tab") {
-      key = ui::VKEY_TAB;
-    } else if (tokens[i] == "space") {
-      key = ui::VKEY_SPACE;
-    } else if (tokens[i] == "backspace") {
-      key = ui::VKEY_BACK;
-    } else if (tokens[i] == "delete") {
-      key = ui::VKEY_DELETE;
-    } else if (tokens[i] == "insert") {
-      key = ui::VKEY_INSERT;
-    } else if (tokens[i] == "enter" || tokens[i] == "return") {
-      key = ui::VKEY_RETURN;
-    } else if (tokens[i] == "up") {
-      key = ui::VKEY_UP;
-    } else if (tokens[i] == "down") {
-      key = ui::VKEY_DOWN;
-    } else if (tokens[i] == "left") {
-      key = ui::VKEY_LEFT;
-    } else if (tokens[i] == "right") {
-      key = ui::VKEY_RIGHT;
-    } else if (tokens[i] == "home") {
-      key = ui::VKEY_HOME;
-    } else if (tokens[i] == "end") {
-      key = ui::VKEY_END;
-    } else if (tokens[i] == "pageup") {
-      key = ui::VKEY_PRIOR;
-    } else if (tokens[i] == "pagedown") {
-      key = ui::VKEY_NEXT;
-    } else if (tokens[i] == "esc" || tokens[i] == "escape") {
-      key = ui::VKEY_ESCAPE;
-    } else if (tokens[i] == "volumemute") {
-      key = ui::VKEY_VOLUME_MUTE;
-    } else if (tokens[i] == "volumeup") {
-      key = ui::VKEY_VOLUME_UP;
-    } else if (tokens[i] == "volumedown") {
-      key = ui::VKEY_VOLUME_DOWN;
-    } else if (tokens[i] == "medianexttrack") {
-      key = ui::VKEY_MEDIA_NEXT_TRACK;
-    } else if (tokens[i] == "mediaprevioustrack") {
-      key = ui::VKEY_MEDIA_PREV_TRACK;
-    } else if (tokens[i] == "mediastop") {
-      key = ui::VKEY_MEDIA_STOP;
-    } else if (tokens[i] == "mediaplaypause") {
-      key = ui::VKEY_MEDIA_PLAY_PAUSE;
-    } else if (tokens[i].size() > 1 && tokens[i][0] == 'f') {
-      // F1 - F24.
-      int n;
-      if (base::StringToInt(tokens[i].c_str() + 1, &n) && n > 0 && n < 25) {
-        key = static_cast<ui::KeyboardCode>(ui::VKEY_F1 + n - 1);
-      } else {
-        LOG(WARNING) << tokens[i] << "is not available on keyboard";
-        return false;
-      }
-    } else {
-      LOG(WARNING) << "Invalid accelerator token: " << tokens[i];
-      return false;
+        break;
+      case ui::VKEY_CONTROL:
+        modifiers |= ui::EF_CONTROL_DOWN;
+        break;
+      case ui::VKEY_MENU:
+        modifiers |= ui::EF_ALT_DOWN;
+        break;
+      case ui::VKEY_COMMAND:
+        modifiers |= ui::EF_COMMAND_DOWN;
+        break;
+      case ui::VKEY_ALTGR:
+        modifiers |= ui::EF_ALTGR_DOWN;
+        break;
+      // Or it is a normal key.
+      default:
+        key = code;
     }
   }
 
   if (key == ui::VKEY_UNKNOWN) {
-    LOG(WARNING) << "The accelerator doesn't contain a valid key";
+    LOG(WARNING) << shortcut << " doesn't contain a valid key";
     return false;
   }
 

atom/browser/ui/cocoa/atom_menu_controller.mm

@@ -32,9 +32,12 @@ Role kRolesMap[] = {
   { @selector(cut:), "cut" },
   { @selector(copy:), "copy" },
   { @selector(paste:), "paste" },
+  { @selector(delete:), "delete" },
+  { @selector(pasteAndMatchStyle:), "paste-and-match-style" },
   { @selector(selectAll:), "selectall" },
   { @selector(performMiniaturize:), "minimize" },
   { @selector(performClose:), "close" },
+  { @selector(performZoom:), "zoom" },
 };
 
 }  // namespace
@@ -148,10 +151,11 @@ Role kRolesMap[] = {
 
     // Set submenu's role.
     base::string16 role = model->GetRoleAt(index);
-    if (role == base::ASCIIToUTF16("window"))
+    if (role == base::ASCIIToUTF16("window") && [submenu numberOfItems])
       [NSApp setWindowsMenu:submenu];
     else if (role == base::ASCIIToUTF16("help"))
       [NSApp setHelpMenu:submenu];
+
     if (role == base::ASCIIToUTF16("services"))
       [NSApp setServicesMenu:submenu];
   } else {

atom/browser/ui/file_dialog_mac.mm

@@ -34,7 +34,13 @@ void SetAllowedFileTypes(NSSavePanel* dialog, const Filters& filters) {
       [file_type_set addObject:base::mac::CFToNSCast(ext_cf.get())];
     }
   }
-  [dialog setAllowedFileTypes:[file_type_set allObjects]];
+
+  // Passing empty array to setAllowedFileTypes will cause exception.
+  NSArray* file_types = nil;
+  if ([file_type_set count])
+    file_types = [file_type_set allObjects];
+
+  [dialog setAllowedFileTypes:file_types];
 }
 
 void SetupDialog(NSSavePanel* dialog,

atom/browser/ui/file_dialog_win.cc

@@ -262,30 +262,7 @@ bool ShowSaveDialog(atom::NativeWindow* parent_window,
   if (FAILED(hr))
     return false;
 
-  std::string file_name = base::WideToUTF8(std::wstring(buffer));
-
-  // Append extension according to selected filter.
-  if (!filters.empty()) {
-    UINT filter_index = 1;
-    save_dialog.GetPtr()->GetFileTypeIndex(&filter_index);
-    const Filter& filter = filters[filter_index - 1];
-
-    bool matched = false;
-    for (size_t i = 0; i < filter.second.size(); ++i) {
-      if (filter.second[i] == "*" ||
-          base::EndsWith(
-            file_name, filter.second[i],
-            base::CompareCase::INSENSITIVE_ASCII)) {
-        matched = true;
-        break;;
-      }
-    }
-
-    if (!matched && !filter.second.empty())
-      file_name += ("." + filter.second[0]);
-  }
-
-  *path = base::FilePath(base::UTF8ToUTF16(file_name));
+  *path = base::FilePath(buffer);
   return true;
 }
 

atom/browser/ui/message_box.h

@@ -38,6 +38,7 @@ int ShowMessageBox(NativeWindow* parent_window,
                    MessageBoxType type,
                    const std::vector<std::string>& buttons,
                    int cancel_id,
+                   int default_id,
                    int options,
                    const std::string& title,
                    const std::string& message,
@@ -47,6 +48,7 @@ int ShowMessageBox(NativeWindow* parent_window,
 void ShowMessageBox(NativeWindow* parent_window,
                     MessageBoxType type,
                     const std::vector<std::string>& buttons,
+                    int default_id,
                     int cancel_id,
                     int options,
                     const std::string& title,

atom/browser/ui/message_box_gtk.cc

@@ -29,6 +29,7 @@ class GtkMessageBox {
   GtkMessageBox(NativeWindow* parent_window,
                 MessageBoxType type,
                 const std::vector<std::string>& buttons,
+                int default_id,
                 int cancel_id,
                 const std::string& title,
                 const std::string& message,
@@ -60,9 +61,10 @@ class GtkMessageBox {
 
     // Add buttons.
     for (size_t i = 0; i < buttons.size(); ++i) {
-      gtk_dialog_add_button(GTK_DIALOG(dialog_),
-                            TranslateToStock(i, buttons[i]),
-                            i);
+      GtkWidget* button = gtk_dialog_add_button(
+          GTK_DIALOG(dialog_), TranslateToStock(i, buttons[i]), i);
+      if (static_cast<int>(i) == default_id)
+        gtk_widget_grab_focus(button);
     }
 
     // Parent window.
@@ -161,19 +163,21 @@ void GtkMessageBox::OnResponseDialog(GtkWidget* widget, int response) {
 int ShowMessageBox(NativeWindow* parent,
                    MessageBoxType type,
                    const std::vector<std::string>& buttons,
+                   int default_id,
                    int cancel_id,
                    int options,
                    const std::string& title,
                    const std::string& message,
                    const std::string& detail,
                    const gfx::ImageSkia& icon) {
-  return GtkMessageBox(parent, type, buttons, cancel_id, title, message, detail,
-                       icon).RunSynchronous();
+  return GtkMessageBox(parent, type, buttons, default_id, cancel_id,
+                       title, message, detail, icon).RunSynchronous();
 }
 
 void ShowMessageBox(NativeWindow* parent,
                     MessageBoxType type,
                     const std::vector<std::string>& buttons,
+                    int default_id,
                     int cancel_id,
                     int options,
                     const std::string& title,
@@ -181,13 +185,13 @@ void ShowMessageBox(NativeWindow* parent,
                     const std::string& detail,
                     const gfx::ImageSkia& icon,
                     const MessageBoxCallback& callback) {
-  (new GtkMessageBox(parent, type, buttons, cancel_id, title, message, detail,
-                     icon))->RunAsynchronous(callback);
+  (new GtkMessageBox(parent, type, buttons, default_id, cancel_id,
+                     title, message, detail, icon))->RunAsynchronous(callback);
 }
 
 void ShowErrorBox(const base::string16& title, const base::string16& content) {
   if (Browser::Get()->is_ready()) {
-    GtkMessageBox(nullptr, MESSAGE_BOX_TYPE_ERROR, { "OK" }, 0, "Error",
+    GtkMessageBox(nullptr, MESSAGE_BOX_TYPE_ERROR, { "OK" }, -1, 0, "Error",
                   base::UTF16ToUTF8(title).c_str(),
                   base::UTF16ToUTF8(content).c_str(),
                   gfx::ImageSkia()).RunSynchronous();

atom/browser/ui/message_box_mac.mm

@@ -8,7 +8,9 @@
 
 #include "atom/browser/native_window.h"
 #include "base/callback.h"
+#include "base/mac/mac_util.h"
 #include "base/strings/sys_string_conversions.h"
+#include "skia/ext/skia_utils_mac.h"
 
 @interface ModalDelegate : NSObject {
  @private
@@ -54,9 +56,11 @@ namespace {
 NSAlert* CreateNSAlert(NativeWindow* parent_window,
                        MessageBoxType type,
                        const std::vector<std::string>& buttons,
+                       int default_id,
                        const std::string& title,
                        const std::string& message,
-                       const std::string& detail) {
+                       const std::string& detail,
+                       const gfx::ImageSkia& icon) {
   // Ignore the title; it's the window title on other platforms and ignorable.
   NSAlert* alert = [[NSAlert alloc] init];
   [alert setMessageText:base::SysUTF8ToNSString(message)];
@@ -82,6 +86,21 @@ NSAlert* CreateNSAlert(NativeWindow* parent_window,
     [button setTag:i];
   }
 
+  NSArray* ns_buttons = [alert buttons];
+  if (default_id >= 0 && default_id < static_cast<int>([ns_buttons count])) {
+    // Focus the button at default_id if the user opted to do so.
+    // The first button added gets set as the default selected.
+    // So remove that default, and make the requested button the default.
+    [[ns_buttons objectAtIndex:0] setKeyEquivalent:@""];
+    [[ns_buttons objectAtIndex:default_id] setKeyEquivalent:@"\r"];
+  }
+
+  if (!icon.isNull()) {
+    NSImage* image = gfx::SkBitmapToNSImageWithColorSpace(
+        *icon.bitmap(), base::mac::GetGenericRGBColorSpace());
+    [alert setIcon:image];
+  }
+
   return alert;
 }
 
@@ -94,6 +113,7 @@ void SetReturnCode(int* ret_code, int result) {
 int ShowMessageBox(NativeWindow* parent_window,
                    MessageBoxType type,
                    const std::vector<std::string>& buttons,
+                   int default_id,
                    int cancel_id,
                    int options,
                    const std::string& title,
@@ -101,7 +121,8 @@ int ShowMessageBox(NativeWindow* parent_window,
                    const std::string& detail,
                    const gfx::ImageSkia& icon) {
   NSAlert* alert = CreateNSAlert(
-      parent_window, type, buttons, title, message, detail);
+      parent_window, type, buttons, default_id, title, message,
+      detail, icon);
 
   // Use runModal for synchronous alert without parent, since we don't have a
   // window to wait for.
@@ -127,6 +148,7 @@ int ShowMessageBox(NativeWindow* parent_window,
 void ShowMessageBox(NativeWindow* parent_window,
                     MessageBoxType type,
                     const std::vector<std::string>& buttons,
+                    int default_id,
                     int cancel_id,
                     int options,
                     const std::string& title,
@@ -135,7 +157,8 @@ void ShowMessageBox(NativeWindow* parent_window,
                     const gfx::ImageSkia& icon,
                     const MessageBoxCallback& callback) {
   NSAlert* alert = CreateNSAlert(
-      parent_window, type, buttons, title, message, detail);
+      parent_window, type, buttons, default_id, title, message,
+      detail, icon);
   ModalDelegate* delegate = [[ModalDelegate alloc] initWithCallback:callback
                                                            andAlert:alert
                                                        callEndModal:false];

atom/browser/ui/message_box_win.cc

@@ -72,6 +72,7 @@ void MapToCommonID(const std::vector<base::string16>& buttons,
 int ShowMessageBoxUTF16(HWND parent,
                         MessageBoxType type,
                         const std::vector<base::string16>& buttons,
+                        int default_id,
                         int cancel_id,
                         int options,
                         const base::string16& title,
@@ -88,6 +89,9 @@ int ShowMessageBoxUTF16(HWND parent,
   config.hInstance  = GetModuleHandle(NULL);
   config.dwFlags    = flags;
 
+  if (default_id > 0)
+    config.nDefaultButton = kIDStart + default_id;
+
   // TaskDialogIndirect doesn't allow empty name, if we set empty title it
   // will show "electron.exe" in title.
   base::string16 app_name = base::UTF8ToUTF16(Browser::Get()->GetName());
@@ -156,6 +160,7 @@ void RunMessageBoxInNewThread(base::Thread* thread,
                               NativeWindow* parent,
                               MessageBoxType type,
                               const std::vector<std::string>& buttons,
+                              int default_id,
                               int cancel_id,
                               int options,
                               const std::string& title,
@@ -163,8 +168,8 @@ void RunMessageBoxInNewThread(base::Thread* thread,
                               const std::string& detail,
                               const gfx::ImageSkia& icon,
                               const MessageBoxCallback& callback) {
-  int result = ShowMessageBox(parent, type, buttons, cancel_id, options, title,
-                              message, detail, icon);
+  int result = ShowMessageBox(parent, type, buttons, default_id,
+                              cancel_id, options, title, message, detail, icon);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE, base::Bind(callback, result));
   content::BrowserThread::DeleteSoon(
@@ -176,6 +181,7 @@ void RunMessageBoxInNewThread(base::Thread* thread,
 int ShowMessageBox(NativeWindow* parent,
                    MessageBoxType type,
                    const std::vector<std::string>& buttons,
+                   int default_id,
                    int cancel_id,
                    int options,
                    const std::string& title,
@@ -194,6 +200,7 @@ int ShowMessageBox(NativeWindow* parent,
   return ShowMessageBoxUTF16(hwnd_parent,
                              type,
                              utf16_buttons,
+                             default_id,
                              cancel_id,
                              options,
                              base::UTF8ToUTF16(title),
@@ -205,6 +212,7 @@ int ShowMessageBox(NativeWindow* parent,
 void ShowMessageBox(NativeWindow* parent,
                     MessageBoxType type,
                     const std::vector<std::string>& buttons,
+                    int default_id,
                     int cancel_id,
                     int options,
                     const std::string& title,
@@ -224,13 +232,13 @@ void ShowMessageBox(NativeWindow* parent,
   unretained->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&RunMessageBoxInNewThread, base::Unretained(unretained),
-                 parent, type, buttons, cancel_id, options, title, message,
-                 detail, icon, callback));
+                 parent, type, buttons, default_id, cancel_id, options, title,
+                 message, detail, icon, callback));
 }
 
 void ShowErrorBox(const base::string16& title, const base::string16& content) {
-  ShowMessageBoxUTF16(NULL, MESSAGE_BOX_TYPE_ERROR, {}, 0, 0, L"Error", title,
-                      content, gfx::ImageSkia());
+  ShowMessageBoxUTF16(NULL, MESSAGE_BOX_TYPE_ERROR, {}, -1, 0, 0, L"Error",
+                      title, content, gfx::ImageSkia());
 }
 
 }  // namespace atom

atom/browser/ui/tray_icon_cocoa.mm

@@ -92,7 +92,7 @@ const CGFloat kVerticalTitleMargin = 2;
 
   // Make use of NSImageView to draw the image, which can correctly draw
   // template image under dark menu bar.
-  if (highlight && alternateImage_ &&
+  if (inMouseEventSequence_ && alternateImage_ &&
       [image_view_ image] != alternateImage_.get()) {
     [image_view_ setImage:alternateImage_];
   } else if ([image_view_ image] != image_.get()) {
@@ -281,14 +281,14 @@ const CGFloat kVerticalTitleMargin = 2;
 
 - (void)draggingEnded:(id <NSDraggingInfo>)sender {
   trayIcon_->NotifyDragEnded();
+
+  if (NSPointInRect([sender draggingLocation], self.frame)) {
+    trayIcon_->NotifyDrop();
+    [self handleDrop:sender];
+  }
 }
 
-- (BOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender {
-  trayIcon_->NotifyDrop();
-  return YES;
-}
-
-- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender {
+- (BOOL)handleDrop:(id <NSDraggingInfo>)sender {
   NSPasteboard* pboard = [sender draggingPasteboard];
 
   if ([[pboard types] containsObject:NSFilenamesPboardType]) {
@@ -302,6 +302,14 @@ const CGFloat kVerticalTitleMargin = 2;
   return NO;
 }
 
+- (BOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender {
+  return YES;
+}
+
+- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender {
+  return YES;
+}
+
 - (BOOL)shouldHighlight {
   if (isHighlightEnable_ && forceHighlight_)
     return true;