Bump v0.10.2.

Fixes https://github.com/atom/atom/issues/1589.

.gitignore

@@ -1,10 +1,7 @@
 .DS_Store
-atom-shell.zip
-version
 /build/
 /dist/
 /frameworks/
-/node/
 /out/
 /vendor/brightray/vendor/download/
 /vendor/python_26/

.gitmodules

@@ -4,9 +4,12 @@
 [submodule "vendor/node"]
 	path = vendor/node
   url = https://github.com/atom/node.git
-[submodule "vendor/gyp"]
-	path = vendor/gyp
-	url = https://github.com/svn2github/gyp.git
 [submodule "vendor/depot_tools"]
 	path = vendor/depot_tools
 	url = https://chromium.googlesource.com/chromium/tools/depot_tools.git
+[submodule "vendor/apm"]
+	path = vendor/apm
+	url = https://github.com/atom/apm.git
+[submodule "vendor/breakpad"]
+	path = vendor/breakpad
+	url = https://github.com/atom/chromium-breakpad.git

README.md

@@ -1,18 +1,19 @@
 # Atom Shell
 
-Experimental native layer for the [Atom](https://github.com/github/atom).
+Native layer for the [Atom editor](https://github.com/atom/atom).
 
-## Development
+## Features
 
-### One-time setup
+* Write desktop applications with web techniques
+* Support built-in and third-party modules of node.js
+* Support native node.js modules
+* Extended built-in modules for desktop programming
+* JavaScript on browser side
+* Easy API for cross-process communication
 
-    $ script/bootstrap
+## Usage & Development
 
-### Building
-
-    $ script/build
-
-This will build the app into the `build` directory.
+See the docs [here](https://github.com/atom/atom-shell/tree/master/docs).
 
 ## License
 

app/atom_main.cc

@@ -2,27 +2,124 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "app/atom_main.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(OS_WIN)
+#include <stdio.h>
+#include <io.h>
+#include <fcntl.h>
+
+#include <windows.h>
+#include <shellapi.h>
+
+#include "app/atom_main_delegate.h"
+#include "base/environment.h"
+#include "common/crash_reporter/win/crash_service_main.h"
+#include "content/public/app/startup_helper_win.h"
+#include "sandbox/win/src/sandbox_types.h"
+#elif defined(OS_LINUX)  // defined(OS_WIN)
+#include "app/atom_main_delegate.h"  // NOLINT
 #include "content/public/app/content_main.h"
+#else  // defined(OS_LINUX)
+#include "app/atom_library_main.h"
+#endif  // defined(OS_MACOSX)
+
+// Declaration of node::Start.
+namespace node {
+int Start(int argc, char *argv[]);
+}
 
 #if defined(OS_WIN)
 
-#include "app/atom_main_delegate.h"
-#include "content/public/app/startup_helper_win.h"
-#include "sandbox/win/src/sandbox_types.h"
+int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
+  int argc = 0;
+  wchar_t** wargv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
+
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+
+  // Make output work in console if we are not in cygiwn.
+  std::string os;
+  if (env->GetVar("OS", &os) && os != "cygwin") {
+    AttachConsole(ATTACH_PARENT_PROCESS);
+
+    FILE* dontcare;
+    freopen_s(&dontcare, "CON", "w", stdout);
+    freopen_s(&dontcare, "CON", "w", stderr);
+    freopen_s(&dontcare, "CON", "r", stdin);
+  }
+
+  std::string node_indicator, crash_service_indicator;
+  if (env->GetVar("ATOM_SHELL_INTERNAL_RUN_AS_NODE", &node_indicator) &&
+      node_indicator == "1") {
+    // Convert argv to to UTF8
+    char** argv = new char*[argc];
+    for (int i = 0; i < argc; i++) {
+      // Compute the size of the required buffer
+      DWORD size = WideCharToMultiByte(CP_UTF8,
+                                       0,
+                                       wargv[i],
+                                       -1,
+                                       NULL,
+                                       0,
+                                       NULL,
+                                       NULL);
+      if (size == 0) {
+        // This should never happen.
+        fprintf(stderr, "Could not convert arguments to utf8.");
+        exit(1);
+      }
+      // Do the actual conversion
+      argv[i] = new char[size];
+      DWORD result = WideCharToMultiByte(CP_UTF8,
+                                         0,
+                                         wargv[i],
+                                         -1,
+                                         argv[i],
+                                         size,
+                                         NULL,
+                                         NULL);
+      if (result == 0) {
+        // This should never happen.
+        fprintf(stderr, "Could not convert arguments to utf8.");
+        exit(1);
+      }
+    }
+    // Now that conversion is done, we can finally start.
+    return node::Start(argc, argv);
+  } else if (env->GetVar("ATOM_SHELL_INTERNAL_CRASH_SERVICE",
+                         &crash_service_indicator) &&
+      crash_service_indicator == "1") {
+    return crash_service::Main(cmd);
+  }
 
-int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t*, int) {
   sandbox::SandboxInterfaceInfo sandbox_info = {0};
   content::InitializeSandboxInfo(&sandbox_info);
   atom::AtomMainDelegate delegate;
   return content::ContentMain(instance, &sandbox_info, &delegate);
 }
 
-#else
-
-#include "app/atom_library_main.h"
+#elif defined(OS_LINUX)  // defined(OS_WIN)
 
 int main(int argc, const char* argv[]) {
+  char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
+  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0)
+    return node::Start(argc, const_cast<char**>(argv));
+
+  atom::AtomMainDelegate delegate;
+  return content::ContentMain(argc, argv, &delegate);
+}
+
+#else  // defined(OS_LINUX)
+
+int main(int argc, const char* argv[]) {
+  char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
+  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0)
+    return node::Start(argc, const_cast<char**>(argv));
+
   return AtomMain(argc, argv);
 }
 
-#endif  // OS_WIN
+#endif  // defined(OS_MACOSX)

app/atom_main.h

@@ -0,0 +1,5 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/public/app/content_main.h"

app/atom_main_delegate.cc

@@ -5,10 +5,13 @@
 #include "app/atom_main_delegate.h"
 
 #include "base/command_line.h"
+#include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "browser/atom_browser_client.h"
 #include "content/public/common/content_switches.h"
 #include "renderer/atom_renderer_client.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "base/path_service.h"
 
 namespace atom {
 
@@ -21,28 +24,71 @@ AtomMainDelegate::~AtomMainDelegate() {
 bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
   // Disable logging out to debug.log on Windows
 #if defined(OS_WIN)
-  logging::InitLogging(
-      L"debug.log",
+  logging::LoggingSettings settings;
 #if defined(DEBUG)
-      logging::LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG ,
+  settings.logging_dest = logging::LOG_TO_ALL;
+  settings.log_file = L"debug.log";
+  settings.lock_log = logging::LOCK_LOG_FILE;
+  settings.delete_old = logging::DELETE_OLD_LOG_FILE;
 #else
-      logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
-#endif  // defined(NDEBUG)
-      logging::LOCK_LOG_FILE,
-      logging::DELETE_OLD_LOG_FILE,
-      logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
-  logging::SetLogItems(true, false, true, false);
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+#endif
+  settings.dcheck_state =
+      logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
+  logging::InitLogging(settings);
 #endif  // defined(OS_WIN)
 
+  // Logging with pid and timestamp.
+  logging::SetLogItems(true, false, true, false);
+
+  // Enable convient stack printing.
+#if defined(DEBUG) && defined(OS_LINUX)
+  base::debug::EnableInProcessStackDumping();
+#endif
+
   return brightray::MainDelegate::BasicStartupComplete(exit_code);
 }
 
 void AtomMainDelegate::PreSandboxStartup() {
-  brightray::MainDelegate::PreSandboxStartup();
+#if defined(OS_MACOSX)
+  OverrideChildProcessPath();
+  OverrideFrameworkBundlePath();
+#endif
+  InitializeResourceBundle();
+
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  std::string process_type = command_line->GetSwitchValueASCII(
+      switches::kProcessType);
+
+  // Only append arguments for browser process.
+  if (!process_type.empty())
+    return;
+
+  // Add a flag to mark the start of switches added by atom-shell.
+  command_line->AppendSwitch("atom-shell-switches-start");
 
   // Disable renderer sandbox for most of node's functions.
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
   command_line->AppendSwitch(switches::kNoSandbox);
+
+  // Disable accelerated compositing since it caused a lot of troubles (black
+  // devtools, screen flashes) and needed lots of effort to make it right.
+  command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
+
+  // Add a flag to mark the end of switches added by atom-shell.
+  command_line->AppendSwitch("atom-shell-switches-end");
+}
+
+void AtomMainDelegate::InitializeResourceBundle() {
+  base::FilePath path;
+#if defined(OS_MACOSX)
+  path = GetResourcesPakFilePath();
+#else
+  base::FilePath pak_dir;
+  PathService::Get(base::DIR_MODULE, &pak_dir);
+  path = pak_dir.Append(FILE_PATH_LITERAL("content_shell.pak"));
+#endif
+
+  ui::ResourceBundle::InitSharedInstanceWithPakPath(path);
 }
 
 content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {

app/atom_main_delegate.h

@@ -17,6 +17,13 @@ class AtomMainDelegate : public brightray::MainDelegate {
  protected:
   virtual bool BasicStartupComplete(int* exit_code) OVERRIDE;
   virtual void PreSandboxStartup() OVERRIDE;
+  virtual void InitializeResourceBundle();
+
+#if defined(OS_MACOSX)
+  virtual base::FilePath GetResourcesPakFilePath();
+  virtual void OverrideChildProcessPath();
+  virtual void OverrideFrameworkBundlePath();
+#endif
 
  private:
   virtual content::ContentBrowserClient* CreateContentBrowserClient() OVERRIDE;

app/atom_main_delegate_mac.mm

@@ -0,0 +1,48 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "app/atom_main_delegate.h"
+
+#import "base/mac/bundle_locations.h"
+#import "base/mac/foundation_util.h"
+#import "base/mac/mac_util.h"
+#include "base/command_line.h"
+#include "base/path_service.h"
+#include "base/strings/sys_string_conversions.h"
+#include "content/public/common/content_paths.h"
+#include "content/public/common/content_switches.h"
+#include "vendor/brightray/common/application_info.h"
+#include "vendor/brightray/common/mac/main_application_bundle.h"
+
+namespace atom {
+
+namespace {
+
+base::FilePath GetFrameworksPath() {
+  return brightray::MainApplicationBundlePath().Append("Contents")
+                                               .Append("Frameworks");
+}
+
+}  // namespace
+
+base::FilePath AtomMainDelegate::GetResourcesPakFilePath() {
+  NSString* path = [base::mac::FrameworkBundle()
+      pathForResource:@"content_shell" ofType:@"pak"];
+  return base::mac::NSStringToFilePath(path);
+}
+
+void AtomMainDelegate::OverrideFrameworkBundlePath() {
+  base::mac::SetOverrideFrameworkBundlePath(
+      GetFrameworksPath().Append("Atom Framework.framework"));
+}
+
+void AtomMainDelegate::OverrideChildProcessPath() {
+  base::FilePath helper_path = GetFrameworksPath().Append("Atom Helper.app")
+                                                  .Append("Contents")
+                                                  .Append("MacOS")
+                                                  .Append("Atom Helper");
+  PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
+}
+
+}  // namespace atom

atom.gyp

@@ -2,67 +2,73 @@
   'variables': {
     'project_name': 'atom',
     'product_name': 'Atom',
+    'framework_name': 'Atom Framework',
     'app_sources': [
       'app/atom_main.cc',
+      'app/atom_main.h',
     ],
     'bundle_sources': [
-      'browser/mac/atom.icns',
+      'browser/resources/mac/atom.icns',
     ],
     'coffee_sources': [
       'browser/api/lib/app.coffee',
       'browser/api/lib/atom-delegate.coffee',
       'browser/api/lib/auto-updater.coffee',
       'browser/api/lib/browser-window.coffee',
-      'browser/api/lib/crash-reporter.coffee',
       'browser/api/lib/dialog.coffee',
       'browser/api/lib/ipc.coffee',
       'browser/api/lib/menu.coffee',
       'browser/api/lib/menu-item.coffee',
-      'browser/atom/atom.coffee',
-      'browser/atom/objects-registry.coffee',
-      'browser/atom/rpc-server.coffee',
+      'browser/api/lib/power-monitor.coffee',
+      'browser/api/lib/protocol.coffee',
+      'browser/lib/init.coffee',
+      'browser/lib/objects-registry.coffee',
+      'browser/lib/rpc-server.coffee',
       'common/api/lib/callbacks-registry.coffee',
       'common/api/lib/clipboard.coffee',
+      'common/api/lib/crash-reporter.coffee',
       'common/api/lib/id-weak-map.coffee',
+      'common/api/lib/screen.coffee',
       'common/api/lib/shell.coffee',
+      'common/lib/init.coffee',
+      'renderer/lib/init.coffee',
       'renderer/api/lib/ipc.coffee',
       'renderer/api/lib/remote.coffee',
     ],
     'lib_sources': [
       'app/atom_main_delegate.cc',
       'app/atom_main_delegate.h',
-      'browser/accelerator_util.cc',
-      'browser/accelerator_util.h',
-      'browser/accelerator_util_mac.mm',
-      'browser/accelerator_util_win.cc',
+      'app/atom_main_delegate_mac.mm',
       'browser/api/atom_api_app.cc',
       'browser/api/atom_api_app.h',
       'browser/api/atom_api_auto_updater.cc',
       'browser/api/atom_api_auto_updater.h',
       'browser/api/atom_api_browser_ipc.cc',
       'browser/api/atom_api_browser_ipc.h',
-      'browser/api/atom_api_crash_reporter.h',
-      'browser/api/atom_api_crash_reporter.cc',
       'browser/api/atom_api_dialog.cc',
       'browser/api/atom_api_dialog.h',
       'browser/api/atom_api_event.cc',
       'browser/api/atom_api_event.h',
-      'browser/api/atom_api_event_emitter.cc',
-      'browser/api/atom_api_event_emitter.h',
       'browser/api/atom_api_menu.cc',
       'browser/api/atom_api_menu.h',
+      'browser/api/atom_api_menu_gtk.cc',
+      'browser/api/atom_api_menu_gtk.h',
       'browser/api/atom_api_menu_mac.h',
       'browser/api/atom_api_menu_mac.mm',
       'browser/api/atom_api_menu_win.cc',
       'browser/api/atom_api_menu_win.h',
+      'browser/api/atom_api_power_monitor.cc',
+      'browser/api/atom_api_power_monitor.h',
+      'browser/api/atom_api_protocol.cc',
+      'browser/api/atom_api_protocol.h',
       'browser/api/atom_api_window.cc',
       'browser/api/atom_api_window.h',
       'browser/api/atom_browser_bindings.cc',
       'browser/api/atom_browser_bindings.h',
       'browser/auto_updater.cc',
       'browser/auto_updater.h',
-      'browser/auto_updater_delegate.cc',
       'browser/auto_updater_delegate.h',
+      'browser/auto_updater_linux.cc',
       'browser/auto_updater_mac.mm',
       'browser/auto_updater_win.cc',
       'browser/atom_application_mac.h',
@@ -76,37 +82,62 @@
       'browser/atom_browser_main_parts.cc',
       'browser/atom_browser_main_parts.h',
       'browser/atom_browser_main_parts_mac.mm',
-      'browser/atom_event_processing_window.h',
-      'browser/atom_event_processing_window.mm',
       'browser/atom_javascript_dialog_manager.cc',
       'browser/atom_javascript_dialog_manager.h',
       'browser/browser.cc',
       'browser/browser.h',
+      'browser/browser_linux.cc',
       'browser/browser_mac.mm',
       'browser/browser_win.cc',
       'browser/browser_observer.h',
-      'browser/crash_reporter.h',
-      'browser/crash_reporter_mac.mm',
-      'browser/crash_reporter_win.cc',
-      'browser/file_dialog.h',
-      'browser/file_dialog_mac.mm',
-      'browser/file_dialog_win.cc',
-      'browser/media/media_capture_devices_dispatcher.cc',
-      'browser/media/media_capture_devices_dispatcher.h',
-      'browser/media/media_stream_devices_controller.cc',
-      'browser/media/media_stream_devices_controller.h',
-      'browser/message_box.h',
-      'browser/message_box_mac.mm',
-      'browser/message_box_win.cc',
+      'browser/devtools_delegate.cc',
+      'browser/devtools_delegate.h',
       'browser/native_window.cc',
       'browser/native_window.h',
+      'browser/native_window_gtk.cc',
+      'browser/native_window_gtk.h',
       'browser/native_window_mac.h',
       'browser/native_window_mac.mm',
       'browser/native_window_win.cc',
       'browser/native_window_win.h',
       'browser/native_window_observer.h',
-      'browser/nsalert_synchronous_sheet.h',
-      'browser/nsalert_synchronous_sheet.mm',
+      'browser/net/adapter_request_job.cc',
+      'browser/net/adapter_request_job.h',
+      'browser/net/atom_url_request_context_getter.cc',
+      'browser/net/atom_url_request_context_getter.h',
+      'browser/net/atom_url_request_job_factory.cc',
+      'browser/net/atom_url_request_job_factory.h',
+      'browser/net/url_request_string_job.cc',
+      'browser/net/url_request_string_job.h',
+      'browser/ui/accelerator_util.cc',
+      'browser/ui/accelerator_util.h',
+      'browser/ui/accelerator_util_gtk.cc',
+      'browser/ui/accelerator_util_mac.mm',
+      'browser/ui/accelerator_util_win.cc',
+      'browser/ui/cocoa/atom_menu_controller.h',
+      'browser/ui/cocoa/atom_menu_controller.mm',
+      'browser/ui/cocoa/event_processing_window.h',
+      'browser/ui/cocoa/event_processing_window.mm',
+      'browser/ui/cocoa/nsalert_synchronous_sheet.h',
+      'browser/ui/cocoa/nsalert_synchronous_sheet.mm',
+      'browser/ui/file_dialog.h',
+      'browser/ui/file_dialog_gtk.cc',
+      'browser/ui/file_dialog_mac.mm',
+      'browser/ui/file_dialog_win.cc',
+      'browser/ui/gtk/gtk_custom_menu.cc',
+      'browser/ui/gtk/gtk_custom_menu.h',
+      'browser/ui/gtk/gtk_custom_menu_item.cc',
+      'browser/ui/gtk/gtk_custom_menu_item.h',
+      'browser/ui/gtk/gtk_window_util.cc',
+      'browser/ui/gtk/gtk_window_util.h',
+      'browser/ui/message_box.h',
+      'browser/ui/message_box_gtk.cc',
+      'browser/ui/message_box_mac.mm',
+      'browser/ui/message_box_win.cc',
+      'browser/ui/win/menu_2.cc',
+      'browser/ui/win/menu_2.h',
+      'browser/ui/win/native_menu_win.cc',
+      'browser/ui/win/native_menu_win.h',
       'browser/window_list.cc',
       'browser/window_list.h',
       'browser/window_list_observer.h',
@@ -114,9 +145,14 @@
       'common/api/api_messages.h',
       'common/api/atom_api_clipboard.cc',
       'common/api/atom_api_clipboard.h',
-      'common/api/atom_api_idle_gc.cc',
+      'common/api/atom_api_crash_reporter.cc',
+      'common/api/atom_api_crash_reporter.h',
+      'common/api/atom_api_event_emitter.cc',
+      'common/api/atom_api_event_emitter.h',
       'common/api/atom_api_id_weak_map.cc',
       'common/api/atom_api_id_weak_map.h',
+      'common/api/atom_api_screen.cc',
+      'common/api/atom_api_screen.h',
       'common/api/atom_api_shell.cc',
       'common/api/atom_api_shell.h',
       'common/api/atom_api_v8_util.cc',
@@ -126,8 +162,27 @@
       'common/api/atom_extensions.h',
       'common/api/object_life_monitor.cc',
       'common/api/object_life_monitor.h',
+      'common/crash_reporter/crash_reporter.cc',
+      'common/crash_reporter/crash_reporter.h',
+      'common/crash_reporter/crash_reporter_linux.cc',
+      'common/crash_reporter/crash_reporter_linux.h',
+      'common/crash_reporter/crash_reporter_mac.h',
+      'common/crash_reporter/crash_reporter_mac.mm',
+      'common/crash_reporter/crash_reporter_win.cc',
+      'common/crash_reporter/crash_reporter_win.h',
+      'common/crash_reporter/linux/crash_dump_handler.cc',
+      'common/crash_reporter/linux/crash_dump_handler.h',
+      'common/crash_reporter/win/crash_service.cc',
+      'common/crash_reporter/win/crash_service.h',
+      'common/crash_reporter/win/crash_service_main.cc',
+      'common/crash_reporter/win/crash_service_main.h',
+      'common/draggable_region.cc',
+      'common/draggable_region.h',
+      'common/linux/application_info.cc',
       'common/node_bindings.cc',
       'common/node_bindings.h',
+      'common/node_bindings_linux.cc',
+      'common/node_bindings_linux.h',
       'common/node_bindings_mac.cc',
       'common/node_bindings_mac.h',
       'common/node_bindings_win.cc',
@@ -135,10 +190,15 @@
       'common/options_switches.cc',
       'common/options_switches.h',
       'common/platform_util.h',
+      'common/platform_util_linux.cc',
       'common/platform_util_mac.mm',
       'common/platform_util_win.cc',
-      'common/v8_value_converter_impl.cc',
-      'common/v8_value_converter_impl.h',
+      'common/swap_or_assign.h',
+      'common/v8/node_common.h',
+      'common/v8/scoped_persistent.h',
+      'common/v8/native_type_conversions.h',
+      'common/v8/v8_value_converter.cc',
+      'common/v8/v8_value_converter.h',
       'renderer/api/atom_api_renderer_ipc.cc',
       'renderer/api/atom_api_renderer_ipc.h',
       'renderer/api/atom_renderer_bindings.cc',
@@ -155,22 +215,13 @@
     'conditions': [
       ['OS=="win"', {
         'app_sources': [
-          'app/win/resource.h',
-          'app/win/atom.rc',
+          'browser/resources/win/resource.h',
+          'browser/resources/win/atom.ico',
+          'browser/resources/win/atom.rc',
           '<(libchromiumcontent_src_dir)/content/app/startup_helper_win.cc',
         ],
       }],  # OS=="win"
     ],
-    'fix_framework_link_command': [
-      'install_name_tool',
-      '-change',
-      '@loader_path/../Frameworks/Sparkle.framework/Versions/A/Sparkle',
-      '@rpath/Sparkle.framework/Versions/A/Sparkle',
-      '-change',
-      '@executable_path/../Frameworks/Quincy.framework/Versions/A/Quincy',
-      '@rpath/Quincy.framework/Versions/A/Quincy',
-      '${BUILT_PRODUCTS_DIR}/${EXECUTABLE_PATH}'
-    ],
     'atom_source_root': '<!(python tools/atom_source_root.py)',
   },
   'target_defaults': {
@@ -183,9 +234,8 @@
     ],
     'configurations': {
       'Debug': {
-        'defines': [
-          'DEBUG',
-        ],
+        'defines': [ 'DEBUG' ],
+        'cflags': [ '-g', '-O0' ],
       },
     },
   },
@@ -215,7 +265,7 @@
             '<(project_name)_helper',
           ],
           'xcode_settings': {
-            'INFOPLIST_FILE': 'browser/mac/Info.plist',
+            'INFOPLIST_FILE': 'browser/resources/mac/Info.plist',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@executable_path/../Frameworks',
             ],
@@ -228,9 +278,10 @@
               'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Frameworks',
               'files': [
                 '<(PRODUCT_DIR)/<(product_name) Helper.app',
-                '<(PRODUCT_DIR)/<(product_name).framework',
-                'frameworks/Sparkle.framework',
-                'frameworks/Quincy.framework',
+                '<(PRODUCT_DIR)/<(framework_name).framework',
+                'frameworks/Squirrel.framework',
+                'frameworks/ReactiveCocoa.framework',
+                'frameworks/Mantle.framework',
               ],
             },
             {
@@ -239,21 +290,8 @@
                 'browser/default_app',
               ],
             },
-            {
-              # Copy node binary for worker process support.
-              'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources',
-              'files': [
-                'node/node',
-              ],
-            },
           ],
           'postbuilds': [
-            {
-              'postbuild_name': 'Fix Framework Link',
-              'action': [
-                '<@(fix_framework_link_command)',
-              ],
-            },
             {
               # This postbuid step is responsible for creating the following
               # helpers:
@@ -278,6 +316,7 @@
               'destination': '<(PRODUCT_DIR)',
               'files': [
                 '<(libchromiumcontent_library_dir)/chromiumcontent.dll',
+                '<(libchromiumcontent_library_dir)/ffmpegsumo.dll',
                 '<(libchromiumcontent_library_dir)/icudt.dll',
                 '<(libchromiumcontent_library_dir)/libGLESv2.dll',
                 '<(libchromiumcontent_resources_dir)/content_shell.pak',
@@ -289,22 +328,34 @@
                 'browser/default_app',
               ]
             },
+          ],
+        }],  # OS=="win"
+        ['OS=="linux"', {
+          'copies': [
             {
-              'destination': '<(PRODUCT_DIR)/resources',
+              'destination': '<(PRODUCT_DIR)',
               'files': [
-                'node/node.exe',
+                '<(libchromiumcontent_library_dir)/libchromiumcontent.so',
+                '<(libchromiumcontent_library_dir)/libffmpegsumo.so',
+                '<(libchromiumcontent_resources_dir)/content_shell.pak',
+              ],
+            },
+            {
+              'destination': '<(PRODUCT_DIR)/resources/browser',
+              'files': [
+                'browser/default_app',
               ]
             },
           ],
-        }],  # OS=="win"
+        }],  # OS=="linux"
       ],
-    },
+    },  # target <(project_name)
     {
       'target_name': '<(project_name)_lib',
       'type': 'static_library',
       'dependencies': [
         'vendor/brightray/brightray.gyp:brightray',
-        'vendor/node/node.gyp:node',
+        'vendor/node/node.gyp:node_lib',
       ],
       'sources': [
         '<@(lib_sources)',
@@ -312,6 +363,15 @@
       'include_dirs': [
         '.',
         'vendor',
+        'vendor/brightray',
+        # Include directories for uv and node.
+        'vendor/node/src',
+        'vendor/node/deps/http_parser',
+        'vendor/node/deps/uv/include',
+        # The `node.h` is using `#include"v8.h"`.
+        'vendor/brightray/vendor/download/libchromiumcontent/src/v8/include',
+        # The `node.h` is using `#include"ares.h"`.
+        'vendor/node/deps/cares/include',
       ],
       'direct_dependent_settings': {
         'include_dirs': [
@@ -327,12 +387,45 @@
             'libraries': [
               '-limm32.lib',
               '-loleacc.lib',
+              '-lComdlg32.lib',
+              '-lWininet.lib',
               '<(atom_source_root)/<(libchromiumcontent_library_dir)/chromiumviews.lib',
             ],
           },
-        }],
+          'dependencies': [
+            'vendor/breakpad/breakpad.gyp:breakpad_handler',
+            'vendor/breakpad/breakpad.gyp:breakpad_sender',
+          ],
+        }],  # OS=="win"
+        ['OS=="mac"', {
+          'dependencies': [
+            'vendor/breakpad/breakpad.gyp:breakpad',
+          ],
+        }],  # OS=="mac"
+        ['OS=="linux"', {
+          'link_settings': {
+            'ldflags': [
+              # Make binary search for libraries under current directory, so we
+              # don't have to manually set $LD_LIBRARY_PATH:
+              # http://serverfault.com/questions/279068/cant-find-so-in-the-same-directory-as-the-executable
+              '-rpath \$$ORIGIN',
+              # Make native module dynamic loading work.
+              '-rdynamic',
+            ],
+          },
+          # Required settings of using breakpad.
+          'include_dirs': [
+            'vendor/breakpad/src',
+          ],
+          'cflags': [
+            '-Wno-empty-body',
+          ],
+          'dependencies': [
+            'vendor/breakpad/breakpad.gyp:breakpad_client',
+          ],
+        }],  # OS=="linux"
       ],
-    },
+    },  # target <(product_name)_lib
     {
       'target_name': 'generated_sources',
       'type': 'none',
@@ -357,8 +450,7 @@
                 '<(RULE_INPUT_PATH)',
                 '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
               ],
-            }],  # OS=="mac"
-            ['OS=="win"', {
+            },{  # OS=="mac"
               'outputs': [
                 '<(PRODUCT_DIR)/resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
               ],
@@ -368,18 +460,74 @@
                 '<(RULE_INPUT_PATH)',
                 '<(PRODUCT_DIR)/resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
               ],
-            }],  # OS=="win"
+            }],  # OS=="win" or OS=="linux"
           ],
         },
       ],
-    },
+    },  # target generated_sources
+    {
+      'target_name': '<(project_name)_dump_symbols',
+      'type': 'none',
+      'dependencies': [
+        '<(project_name)',
+      ],
+      'conditions': [
+        ['OS=="mac"', {
+          'dependencies': [
+            'vendor/breakpad/breakpad.gyp:dump_syms',
+          ],
+          'actions': [
+            {
+              'action_name': 'Dump Symbols',
+              'inputs': [
+                '<(PRODUCT_DIR)/<(product_name).app/Contents/MacOS/<(product_name)',
+              ],
+              'outputs': [
+                '<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
+              ],
+              'action': [
+                'python',
+                'tools/mac/generate_breakpad_symbols.py',
+                '--build-dir=<(PRODUCT_DIR)',
+                '--binary=<(PRODUCT_DIR)/<(product_name).app/Contents/MacOS/<(product_name)',
+                '--symbols-dir=<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
+                '--libchromiumcontent-dir=<(libchromiumcontent_library_dir)',
+                '--clear',
+                '--jobs=16',
+              ],
+            },
+          ],
+        }],  # OS=="mac"
+        ['OS=="win"', {
+          'actions': [
+            {
+              'action_name': 'Dump Symbols',
+              'inputs': [
+                '<(PRODUCT_DIR)/<(project_name).exe',
+              ],
+              'outputs': [
+                '<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
+              ],
+              'action': [
+                'python',
+                'tools/win/generate_breakpad_symbols.py',
+                '--symbols-dir=<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
+                '--jobs=16',
+                '<(PRODUCT_DIR)',
+                '<(libchromiumcontent_library_dir)',
+              ],
+            },
+          ],
+        }],  # OS=="win"
+      ],
+    },  # target <(project_name>_dump_symbols
   ],
   'conditions': [
     ['OS=="mac"', {
       'targets': [
         {
           'target_name': '<(project_name)_framework',
-          'product_name': '<(product_name)',
+          'product_name': '<(framework_name)',
           'type': 'shared_library',
           'dependencies': [
             '<(project_name)_lib',
@@ -398,20 +546,22 @@
           'link_settings': {
             'libraries': [
               '$(SDKROOT)/System/Library/Frameworks/Carbon.framework',
-              'frameworks/Sparkle.framework',
-              'frameworks/Quincy.framework',
+              'frameworks/Squirrel.framework',
+              'frameworks/ReactiveCocoa.framework',
+              'frameworks/Mantle.framework',
             ],
           },
           'mac_bundle': 1,
           'mac_bundle_resources': [
-            'browser/mac/MainMenu.xib',
+            'common/resources/mac/MainMenu.xib',
             '<(libchromiumcontent_resources_dir)/content_shell.pak',
           ],
           'xcode_settings': {
+            'INFOPLIST_FILE': 'common/resources/mac/Info.plist',
             'LIBRARY_SEARCH_PATHS': [
               '<(libchromiumcontent_library_dir)',
             ],
-            'LD_DYLIB_INSTALL_NAME': '@rpath/<(product_name).framework/<(product_name)',
+            'LD_DYLIB_INSTALL_NAME': '@rpath/<(framework_name).framework/<(framework_name)',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@loader_path/Libraries',
             ],
@@ -421,25 +571,26 @@
           },
           'copies': [
             {
-              'destination': '<(PRODUCT_DIR)/<(product_name).framework/Versions/A/Libraries',
+              'destination': '<(PRODUCT_DIR)/<(framework_name).framework/Versions/A/Libraries',
               'files': [
                 '<(libchromiumcontent_library_dir)/ffmpegsumo.so',
                 '<(libchromiumcontent_library_dir)/libchromiumcontent.dylib',
               ],
             },
-          ],
-          'postbuilds': [
             {
-              'postbuild_name': 'Fix Framework Link',
-              'action': [
-                '<@(fix_framework_link_command)',
+              'destination': '<(PRODUCT_DIR)/<(framework_name).framework/Versions/A/Resources',
+              'files': [
+                '<(PRODUCT_DIR)/Inspector',
+                '<(PRODUCT_DIR)/crash_report_sender.app',
               ],
             },
+          ],
+          'postbuilds': [
             {
               'postbuild_name': 'Add symlinks for framework subdirectories',
               'action': [
                 'tools/mac/create-framework-subdir-symlinks.sh',
-                '<(product_name)',
+                '<(framework_name)',
                 'Libraries',
                 'Frameworks',
               ],
@@ -461,21 +612,45 @@
           ],
           'mac_bundle': 1,
           'xcode_settings': {
-            'INFOPLIST_FILE': 'renderer/mac/Info.plist',
+            'INFOPLIST_FILE': 'renderer/resources/mac/Info.plist',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@executable_path/../../..',
             ],
           },
-          'postbuilds': [
-            {
-              'postbuild_name': 'Fix Framework Link',
-              'action': [
-                '<@(fix_framework_link_command)',
-              ],
-            },
-          ],
         },  # target helper
       ],
     }],  # OS==Mac
+    ['OS=="win"', {
+      'targets': [
+        {
+          'target_name': 'generate_node_lib',
+          'type': 'none',
+          'dependencies': [
+            '<(project_name)',
+          ],
+          'actions': [
+            {
+              'action_name': 'Create node.lib',
+              'inputs': [
+                '<(PRODUCT_DIR)/atom.lib',
+                '<(libchromiumcontent_library_dir)/chromiumcontent.dll.lib',
+              ],
+              'outputs': [
+                '<(PRODUCT_DIR)/node.lib',
+              ],
+              'action': [
+                'lib.exe',
+                '/nologo',
+                # We can't use <(_outputs) here because that escapes the
+                # backslash in the path, which confuses lib.exe.
+                '/OUT:<(PRODUCT_DIR)\\node.lib',
+                '<@(_inputs)',
+              ],
+              'msvs_cygwin_shell': 0,
+            },
+          ],
+        },  # target generate_node_lib
+      ],
+    }],  # OS==win
   ],
 }

browser/accelerator_util.cc

@@ -1,91 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/accelerator_util.h"
-
-#include <string>
-
-#include "base/string_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
-#include "ui/base/accelerators/accelerator.h"
-
-namespace accelerator_util {
-
-namespace {
-
-// For Mac, we convert "Ctrl" to "Command" and "MacCtrl" to "Ctrl". Other
-// platforms leave the shortcut untouched.
-std::string NormalizeShortcutSuggestion(const std::string& suggestion) {
-#if !defined(OS_MACOSX)
-  return suggestion;
-#endif
-
-  std::string key;
-  std::vector<std::string> tokens;
-  base::SplitString(suggestion, '+', &tokens);
-  for (size_t i = 0; i < tokens.size(); i++) {
-    if (tokens[i] == "Ctrl")
-      tokens[i] = "Command";
-    else if (tokens[i] == "MacCtrl")
-      tokens[i] = "Ctrl";
-  }
-  return JoinString(tokens, '+');
-}
-
-}  // namespace
-
-bool StringToAccelerator(const std::string& description,
-                         ui::Accelerator* accelerator) {
-  std::string shortcut(NormalizeShortcutSuggestion(description));
-
-  std::vector<std::string> tokens;
-  base::SplitString(shortcut, '+', &tokens);
-  if (tokens.size() < 2 || tokens.size() > 4) {
-    LOG(WARNING) << "Invalid accelerator description: " << description;
-    return false;
-  }
-
-  // Now, parse it into an accelerator.
-  int modifiers = ui::EF_NONE;
-  ui::KeyboardCode key = ui::VKEY_UNKNOWN;
-  for (size_t i = 0; i < tokens.size(); i++) {
-    if (tokens[i] == "Ctrl") {
-      modifiers |= ui::EF_CONTROL_DOWN;
-    } else if (tokens[i] == "Command") {
-      modifiers |= ui::EF_COMMAND_DOWN;
-    } else if (tokens[i] == "Alt") {
-      modifiers |= ui::EF_ALT_DOWN;
-    } else if (tokens[i] == "Shift") {
-      modifiers |= ui::EF_SHIFT_DOWN;
-    } else if (tokens[i].size() == 1) {
-      if (key != ui::VKEY_UNKNOWN) {
-        // Multiple key assignments.
-        key = ui::VKEY_UNKNOWN;
-        break;
-      }
-      if (tokens[i][0] >= 'A' && tokens[i][0] <= 'Z') {
-        key = static_cast<ui::KeyboardCode>(ui::VKEY_A + (tokens[i][0] - 'A'));
-      } else if (tokens[i][0] >= '0' && tokens[i][0] <= '9') {
-        key = static_cast<ui::KeyboardCode>(ui::VKEY_0 + (tokens[i][0] - '0'));
-      } else if (tokens[i][0] >= '+' && tokens[i][0] <= '.') {
-        key = static_cast<ui::KeyboardCode>(
-            ui::VKEY_OEM_PLUS + (tokens[i][0] - '+'));
-      } else {
-        LOG(WARNING) << "Invalid accelerator character: " << tokens[i];
-        key = ui::VKEY_UNKNOWN;
-        break;
-      }
-    } else {
-      LOG(WARNING) << "Invalid accelerator token: " << tokens[i];
-      return false;
-    }
-  }
-
-  *accelerator = ui::Accelerator(key, modifiers);
-  SetPlatformAccelerator(accelerator);
-  return true;
-}
-
-}  // namespace accelerator_util

browser/api/atom_api_app.cc

@@ -7,7 +7,9 @@
 #include "base/values.h"
 #include "base/command_line.h"
 #include "browser/browser.h"
-#include "vendor/node/src/node.h"
+#include "common/v8/native_type_conversions.h"
+
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -47,103 +49,132 @@ void App::OnWillFinishLaunching() {
 }
 
 void App::OnFinishLaunching() {
-  Emit("finish-launching");
+  Emit("ready");
 }
 
 // static
-v8::Handle<v8::Value> App::New(const v8::Arguments &args) {
-  v8::HandleScope scope;
+void App::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::HandleScope scope(args.GetIsolate());
 
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
 
   new App(args.This());
-
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> App::Quit(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
+void App::Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Browser::Get()->Quit();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::Exit(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
+void App::Exit(const v8::FunctionCallbackInfo<v8::Value>& args) {
   exit(args[0]->IntegerValue());
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::Terminate(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
+void App::Terminate(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Browser::Get()->Terminate();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::Focus(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
+void App::Focus(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Browser::Get()->Focus();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::GetVersion(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  std::string version(Browser::Get()->GetVersion());
-
-  return v8::String::New(version.data(), version.size());
+void App::GetVersion(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  args.GetReturnValue().Set(ToV8Value(Browser::Get()->GetVersion()));
 }
 
 // static
-v8::Handle<v8::Value> App::AppendSwitch(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  if (!args[0]->IsString())
+void App::SetVersion(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string version;
+  if (!FromV8Arguments(args, &version))
+    return node::ThrowError("Bad argument");
+
+  Browser::Get()->SetVersion(version);
+}
+
+// static
+void App::GetName(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  return args.GetReturnValue().Set(ToV8Value(Browser::Get()->GetName()));
+}
+
+// static
+void App::SetName(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string name;
+  if (!FromV8Arguments(args, &name))
+    return node::ThrowError("Bad argument");
+
+  Browser::Get()->SetName(name);
+}
+
+// static
+void App::AppendSwitch(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string switch_string;
+  if (!FromV8Arguments(args, &switch_string))
     return node::ThrowError("Bad argument");
 
-  std::string switch_string(*v8::String::Utf8Value(args[0]));
   if (args.Length() == 1) {
     CommandLine::ForCurrentProcess()->AppendSwitch(switch_string);
   } else {
-    std::string value(*v8::String::Utf8Value(args[1]));
+    std::string value = FromV8Value(args[1]);
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switch_string, value);
   }
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::AppendArgument(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  if (!args[0]->IsString())
+void App::AppendArgument(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string value;
+  if (!FromV8Arguments(args, &value))
     return node::ThrowError("Bad argument");
 
-  std::string value(*v8::String::Utf8Value(args[0]));
   CommandLine::ForCurrentProcess()->AppendArg(value);
-
-  return v8::Undefined();
 }
 
+#if defined(OS_MACOSX)
+
+// static
+void App::DockBounce(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string type;
+  if (!FromV8Arguments(args, &type))
+    return node::ThrowError("Bad argument");
+
+  int request_id = -1;
+
+  if (type == "critical")
+    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_CRITICAL);
+  else if (type == "informational")
+    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_INFORMATIONAL);
+  else
+    return node::ThrowTypeError("Invalid bounce type");
+
+  args.GetReturnValue().Set(request_id);
+}
+
+// static
+void App::DockCancelBounce(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Browser::Get()->DockCancelBounce(FromV8Value(args[0]));
+}
+
+// static
+void App::DockSetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Browser::Get()->DockSetBadgeText(FromV8Value(args[0]));
+}
+
+// static
+void App::DockGetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string text(Browser::Get()->DockGetBadgeText());
+  args.GetReturnValue().Set(ToV8Value(text));
+}
+
+#endif  // defined(OS_MACOSX)
+
 // static
 void App::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
-
-  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(App::New);
+  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(v8::String::NewSymbol("Application"));
 
@@ -152,11 +183,21 @@ void App::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "terminate", Terminate);
   NODE_SET_PROTOTYPE_METHOD(t, "focus", Focus);
   NODE_SET_PROTOTYPE_METHOD(t, "getVersion", GetVersion);
+  NODE_SET_PROTOTYPE_METHOD(t, "setVersion", SetVersion);
+  NODE_SET_PROTOTYPE_METHOD(t, "getName", GetName);
+  NODE_SET_PROTOTYPE_METHOD(t, "setName", SetName);
 
   target->Set(v8::String::NewSymbol("Application"), t->GetFunction());
 
   NODE_SET_METHOD(target, "appendSwitch", AppendSwitch);
   NODE_SET_METHOD(target, "appendArgument", AppendArgument);
+
+#if defined(OS_MACOSX)
+  NODE_SET_METHOD(target, "dockBounce", DockBounce);
+  NODE_SET_METHOD(target, "dockCancelBounce", DockCancelBounce);
+  NODE_SET_METHOD(target, "dockSetBadgeText", DockSetBadgeText);
+  NODE_SET_METHOD(target, "dockGetBadgeText", DockGetBadgeText);
+#endif  // defined(OS_MACOSX)
 }
 
 }  // namespace api

browser/api/atom_api_app.h

@@ -6,8 +6,8 @@
 #define ATOM_BROWSER_API_ATOM_API_APP_H_
 
 #include "base/compiler_specific.h"
-#include "browser/api/atom_api_event_emitter.h"
 #include "browser/browser_observer.h"
+#include "common/api/atom_api_event_emitter.h"
 
 namespace atom {
 
@@ -33,15 +33,25 @@ class App : public EventEmitter,
   virtual void OnFinishLaunching() OVERRIDE;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments &args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> Quit(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Exit(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Terminate(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Focus(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetVersion(const v8::Arguments &args);
-  static v8::Handle<v8::Value> AppendSwitch(const v8::Arguments &args);
-  static v8::Handle<v8::Value> AppendArgument(const v8::Arguments &args);
+  static void Quit(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Exit(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Terminate(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Focus(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetVersion(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetVersion(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetName(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetName(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AppendSwitch(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void AppendArgument(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+#if defined(OS_MACOSX)
+  static void DockBounce(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DockCancelBounce(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DockSetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DockGetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args);
+#endif  // defined(OS_MACOSX)
 
   DISALLOW_COPY_AND_ASSIGN(App);
 };

browser/api/atom_api_auto_updater.cc

@@ -4,8 +4,12 @@
 
 #include "browser/api/atom_api_auto_updater.h"
 
+#include "base/time/time.h"
 #include "base/values.h"
 #include "browser/auto_updater.h"
+#include "common/v8/native_type_conversions.h"
+
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -14,117 +18,82 @@ namespace api {
 AutoUpdater::AutoUpdater(v8::Handle<v8::Object> wrapper)
     : EventEmitter(wrapper) {
   auto_updater::AutoUpdater::SetDelegate(this);
-  auto_updater::AutoUpdater::Init();
 }
 
 AutoUpdater::~AutoUpdater() {
   auto_updater::AutoUpdater::SetDelegate(NULL);
 }
 
-void AutoUpdater::WillInstallUpdate(const std::string& version,
-                                    const base::Closure& install) {
-  continue_update_ = install;
-
+void AutoUpdater::OnError(const std::string& error) {
   base::ListValue args;
-  args.AppendString(version);
-  bool prevent_default = Emit("will-install-update-raw", &args);
-
-  if (!prevent_default)
-    install.Run();
+  args.AppendString(error);
+  Emit("error", &args);
 }
 
-void AutoUpdater::ReadyForUpdateOnQuit(const std::string& version,
-                                       const base::Closure& quit_and_install) {
+void AutoUpdater::OnCheckingForUpdate() {
+  Emit("checking-for-update");
+}
+
+void AutoUpdater::OnUpdateAvailable() {
+  Emit("update-available");
+}
+
+void AutoUpdater::OnUpdateNotAvailable() {
+  Emit("update-not-available");
+}
+
+void AutoUpdater::OnUpdateDownloaded(const std::string& release_notes,
+                                     const std::string& release_name,
+                                     const base::Time& release_date,
+                                     const std::string& update_url,
+                                     const base::Closure& quit_and_install) {
   quit_and_install_ = quit_and_install;
 
   base::ListValue args;
-  args.AppendString(version);
-  Emit("ready-for-update-on-quit-raw", &args);
+  args.AppendString(release_notes);
+  args.AppendString(release_name);
+  args.AppendDouble(release_date.ToJsTime());
+  args.AppendString(update_url);
+  Emit("update-downloaded-raw", &args);
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::New(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
+void AutoUpdater::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
 
   new AutoUpdater(args.This());
-
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::SetFeedURL(const v8::Arguments &args) {
-  auto_updater::AutoUpdater::SetFeedURL(*v8::String::Utf8Value(args[0]));
-  return v8::Undefined();
+void AutoUpdater::SetFeedURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  auto_updater::AutoUpdater::SetFeedURL(FromV8Value(args[0]));
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::SetAutomaticallyChecksForUpdates(
-      const v8::Arguments &args) {
-  auto_updater::AutoUpdater::SetAutomaticallyChecksForUpdates(
-      args[0]->BooleanValue());
-  return v8::Undefined();
-}
-
-// static
-v8::Handle<v8::Value> AutoUpdater::SetAutomaticallyDownloadsUpdates(
-      const v8::Arguments &args) {
-  auto_updater::AutoUpdater::SetAutomaticallyDownloadsUpdates(
-      args[0]->BooleanValue());
-  return v8::Undefined();
-}
-
-// static
-v8::Handle<v8::Value> AutoUpdater::CheckForUpdates(const v8::Arguments &args) {
+void AutoUpdater::CheckForUpdates(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   auto_updater::AutoUpdater::CheckForUpdates();
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::CheckForUpdatesInBackground(
-      const v8::Arguments &args) {
-  auto_updater::AutoUpdater::CheckForUpdatesInBackground();
-  return v8::Undefined();
-}
-
-// static
-v8::Handle<v8::Value> AutoUpdater::ContinueUpdate(const v8::Arguments &args) {
+void AutoUpdater::QuitAndInstall(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   AutoUpdater* self = AutoUpdater::Unwrap<AutoUpdater>(args.This());
-  self->continue_update_.Run();
-  return v8::Undefined();
-}
 
-// static
-v8::Handle<v8::Value> AutoUpdater::QuitAndInstall(const v8::Arguments &args) {
-  AutoUpdater* self = AutoUpdater::Unwrap<AutoUpdater>(args.This());
-  self->quit_and_install_.Run();
-  return v8::Undefined();
+  if (!self->quit_and_install_.is_null())
+    self->quit_and_install_.Run();
 }
 
 // static
 void AutoUpdater::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
-
   v8::Local<v8::FunctionTemplate> t(
       v8::FunctionTemplate::New(AutoUpdater::New));
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(v8::String::NewSymbol("AutoUpdater"));
 
   NODE_SET_PROTOTYPE_METHOD(t, "setFeedUrl", SetFeedURL);
-  NODE_SET_PROTOTYPE_METHOD(t,
-                            "setAutomaticallyChecksForUpdates",
-                            SetAutomaticallyChecksForUpdates);
-  NODE_SET_PROTOTYPE_METHOD(t,
-                            "setAutomaticallyDownloadsUpdates",
-                            SetAutomaticallyDownloadsUpdates);
   NODE_SET_PROTOTYPE_METHOD(t, "checkForUpdates", CheckForUpdates);
-  NODE_SET_PROTOTYPE_METHOD(t,
-                            "checkForUpdatesInBackground",
-                            CheckForUpdatesInBackground);
-
-  NODE_SET_PROTOTYPE_METHOD(t, "continueUpdate", ContinueUpdate);
   NODE_SET_PROTOTYPE_METHOD(t, "quitAndInstall", QuitAndInstall);
 
   target->Set(v8::String::NewSymbol("AutoUpdater"), t->GetFunction());

browser/api/atom_api_auto_updater.h

@@ -7,8 +7,8 @@
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
-#include "browser/api/atom_api_event_emitter.h"
 #include "browser/auto_updater_delegate.h"
+#include "common/api/atom_api_event_emitter.h"
 
 namespace atom {
 
@@ -24,28 +24,27 @@ class AutoUpdater : public EventEmitter,
  protected:
   explicit AutoUpdater(v8::Handle<v8::Object> wrapper);
 
-  virtual void WillInstallUpdate(const std::string& version,
-                                 const base::Closure& install) OVERRIDE;
-  virtual void ReadyForUpdateOnQuit(
-      const std::string& version,
+  // AutoUpdaterDelegate implementations.
+  virtual void OnError(const std::string& error) OVERRIDE;
+  virtual void OnCheckingForUpdate() OVERRIDE;
+  virtual void OnUpdateAvailable() OVERRIDE;
+  virtual void OnUpdateNotAvailable() OVERRIDE;
+  virtual void OnUpdateDownloaded(
+      const std::string& release_notes,
+      const std::string& release_name,
+      const base::Time& release_date,
+      const std::string& update_url,
       const base::Closure& quit_and_install) OVERRIDE;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments &args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> SetFeedURL(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetAutomaticallyChecksForUpdates(
-      const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetAutomaticallyDownloadsUpdates(
-      const v8::Arguments &args);
-  static v8::Handle<v8::Value> CheckForUpdates(const v8::Arguments &args);
-  static v8::Handle<v8::Value> CheckForUpdatesInBackground(
-      const v8::Arguments &args);
+  static void SetFeedURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CheckForUpdates(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> ContinueUpdate(const v8::Arguments &args);
-  static v8::Handle<v8::Value> QuitAndInstall(const v8::Arguments &args);
+  static void ContinueUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void QuitAndInstall(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  base::Closure continue_update_;
   base::Closure quit_and_install_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoUpdater);

browser/api/atom_api_browser_ipc.cc

@@ -4,59 +4,41 @@
 
 #include "browser/api/atom_api_browser_ipc.h"
 
-#include "base/values.h"
 #include "common/api/api_messages.h"
-#include "common/v8_value_converter_impl.h"
+#include "common/v8/node_common.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/render_view_host.h"
-#include "vendor/node/src/node.h"
-#include "vendor/node/src/node_internals.h"
 
 using content::RenderViewHost;
-using content::V8ValueConverter;
 
 namespace atom {
 
 namespace api {
 
 // static
-v8::Handle<v8::Value> BrowserIPC::Send(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  if (!args[0]->IsString() || !args[1]->IsNumber() || !args[2]->IsNumber())
+void BrowserIPC::Send(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  string16 channel;
+  int process_id, routing_id;
+  scoped_ptr<base::Value> arguments;
+  if (!FromV8Arguments(args, &channel, &process_id, &routing_id, &arguments))
     return node::ThrowTypeError("Bad argument");
 
-  std::string channel(*v8::String::Utf8Value(args[0]));
-  int process_id = args[1]->IntegerValue();
-  int routing_id = args[2]->IntegerValue();
+  DCHECK(arguments && arguments->IsType(base::Value::TYPE_LIST));
 
   RenderViewHost* render_view_host(RenderViewHost::FromID(
       process_id, routing_id));
   if (!render_view_host)
     return node::ThrowError("Invalid render view host");
 
-  // Convert Arguments to Array, so we can use V8ValueConverter to convert it
-  // to ListValue.
-  v8::Local<v8::Array> v8_args = v8::Array::New(args.Length() - 3);
-  for (int i = 0; i < args.Length() - 3; ++i)
-    v8_args->Set(i, args[i + 3]);
-
-  scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
-  scoped_ptr<base::Value> arguments(
-      converter->FromV8Value(v8_args, v8::Context::GetCurrent()));
-
-  DCHECK(arguments && arguments->IsType(base::Value::TYPE_LIST));
-
-  render_view_host->Send(new AtomViewMsg_Message(
+  args.GetReturnValue().Set(render_view_host->Send(new AtomViewMsg_Message(
       routing_id,
       channel,
-      *static_cast<base::ListValue*>(arguments.get())));
-
-  return v8::Undefined();
+      *static_cast<base::ListValue*>(arguments.get()))));
 }
 
 // static
 void BrowserIPC::Initialize(v8::Handle<v8::Object> target) {
-  node::SetMethod(target, "send", Send);
+  NODE_SET_METHOD(target, "send", Send);
 }
 
 }  // namespace api

browser/api/atom_api_browser_ipc.h

@@ -17,7 +17,7 @@ class BrowserIPC {
   static void Initialize(v8::Handle<v8::Object> target);
 
  private:
-  static v8::Handle<v8::Value> Send(const v8::Arguments &args);
+  static void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BrowserIPC);
 };

browser/api/atom_api_crash_reporter.cc

@@ -1,47 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/api/atom_api_crash_reporter.h"
-
-#include "browser/crash_reporter.h"
-#include "vendor/node/src/node.h"
-#include "vendor/node/src/node_internals.h"
-
-namespace atom {
-
-namespace api {
-
-// static
-v8::Handle<v8::Value> CrashReporter::SetCompanyName(const v8::Arguments &args) {
-  std::string name(*v8::String::Utf8Value(args[0]));
-  crash_reporter::CrashReporter::SetCompanyName(name);
-  return v8::Undefined();
-}
-
-// static
-v8::Handle<v8::Value> CrashReporter::SetSubmissionURL(
-    const v8::Arguments &args) {
-  std::string url(*v8::String::Utf8Value(args[0]));
-  crash_reporter::CrashReporter::SetSubmissionURL(url);
-  return v8::Undefined();
-}
-
-// static
-v8::Handle<v8::Value> CrashReporter::SetAutoSubmit(const v8::Arguments &args) {
-  crash_reporter::CrashReporter::SetAutoSubmit(args[0]->BooleanValue());
-  return v8::Undefined();
-}
-
-// static
-void CrashReporter::Initialize(v8::Handle<v8::Object> target) {
-  node::SetMethod(target, "setCompanyName", SetCompanyName);
-  node::SetMethod(target, "setSubmissionUrl", SetSubmissionURL);
-  node::SetMethod(target, "setAutoSubmit", SetAutoSubmit);
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-NODE_MODULE(atom_browser_crash_reporter, atom::api::CrashReporter::Initialize)

browser/api/atom_api_dialog.cc

@@ -4,14 +4,12 @@
 
 #include "browser/api/atom_api_dialog.h"
 
-#include <string>
-
-#include "base/utf_string_conversions.h"
-#include "base/values.h"
-#include "browser/api/atom_api_window.h"
-#include "browser/file_dialog.h"
-#include "browser/message_box.h"
+#include "base/bind.h"
 #include "browser/native_window.h"
+#include "browser/ui/file_dialog.h"
+#include "browser/ui/message_box.h"
+#include "common/v8/node_common.h"
+#include "common/v8/native_type_conversions.h"
 
 namespace atom {
 
@@ -19,19 +17,25 @@ namespace api {
 
 namespace {
 
-base::FilePath V8ValueToFilePath(v8::Handle<v8::Value> path) {
-  std::string path_string(*v8::String::Utf8Value(path));
-  return base::FilePath::FromUTF8Unsafe(path_string);
+template<typename T>
+void CallV8Function(const RefCountedV8Function& callback, T arg) {
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+
+  v8::Handle<v8::Value> value = ToV8Value(arg);
+  callback->NewHandle(node_isolate)->Call(
+      v8::Context::GetCurrent()->Global(), 1, &value);
 }
 
-v8::Handle<v8::Value> FilePathToV8Value(const base::FilePath path) {
-  std::string path_string(path.AsUTF8Unsafe());
-  return v8::String::New(path_string.data(), path_string.size());
+template<typename T>
+void CallV8Function2(const RefCountedV8Function& callback, bool result, T arg) {
+  if (result)
+    return CallV8Function<T>(callback, arg);
+  else
+    return CallV8Function<void*>(callback, NULL);
 }
 
 void Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
-
   NODE_SET_METHOD(target, "showMessageBox", ShowMessageBox);
   NODE_SET_METHOD(target, "showOpenDialog", ShowOpenDialog);
   NODE_SET_METHOD(target, "showSaveDialog", ShowSaveDialog);
@@ -39,87 +43,95 @@ void Initialize(v8::Handle<v8::Object> target) {
 
 }  // namespace
 
-v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  if (!args[0]->IsNumber() ||  // type
-      !args[1]->IsArray() ||   // buttons
-      !args[2]->IsString() ||  // title
-      !args[3]->IsString() ||  // message
-      !args[4]->IsString())    // detail
-    return node::ThrowTypeError("Bad argument");
-
-  NativeWindow* native_window = NULL;
-  if (args[5]->IsObject()) {
-    Window* window = Window::Unwrap<Window>(args[5]->ToObject());
-    if (!window || !window->window())
-      return node::ThrowError("Invalid window");
-
-    native_window = window->window();
-  }
-
-  MessageBoxType type = (MessageBoxType)(args[0]->IntegerValue());
-
+void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  int type;
   std::vector<std::string> buttons;
-  v8::Handle<v8::Array> v8_buttons = v8::Handle<v8::Array>::Cast(args[1]);
-  for (uint32_t i = 0; i < v8_buttons->Length(); ++i)
-    buttons.push_back(*v8::String::Utf8Value(v8_buttons->Get(i)));
-
-  std::string title(*v8::String::Utf8Value(args[2]));
-  std::string message(*v8::String::Utf8Value(args[3]));
-  std::string detail(*v8::String::Utf8Value(args[4]));
-
-  int chosen = atom::ShowMessageBox(
-      native_window, type, buttons, title, message, detail);
-  return scope.Close(v8::Integer::New(chosen));
-}
-
-v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  if (!args[0]->IsString() ||  // title
-      !args[1]->IsString() ||  // default_path
-      !args[2]->IsNumber())    // properties
+  std::string title, message, detail;
+  if (!FromV8Arguments(args, &type, &buttons, &title, &message, &detail))
     return node::ThrowTypeError("Bad argument");
 
-  std::string title(*v8::String::Utf8Value(args[0]));
-  base::FilePath default_path(V8ValueToFilePath(args[1]));
-  int properties = args[2]->IntegerValue();
+  NativeWindow* native_window = FromV8Value(args[5]);
 
-  std::vector<base::FilePath> paths;
-  if (!file_dialog::ShowOpenDialog(title, default_path, properties, &paths))
-    return v8::Undefined();
-
-  v8::Handle<v8::Array> result = v8::Array::New(paths.size());
-  for (size_t i = 0; i < paths.size(); ++i)
-    result->Set(i, FilePathToV8Value(paths[i]));
-
-  return scope.Close(result);
+  if (!args[6]->IsFunction()) {
+    int chosen = atom::ShowMessageBox(
+        native_window,
+        (MessageBoxType)type,
+        buttons,
+        title,
+        message,
+        detail);
+    args.GetReturnValue().Set(chosen);
+  } else {
+    RefCountedV8Function callback = FromV8Value(args[6]);
+    atom::ShowMessageBox(
+        native_window,
+        (MessageBoxType)type,
+        buttons,
+        title,
+        message,
+        detail,
+        base::Bind(&CallV8Function<int>, callback));
+  }
 }
 
-v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  if (!args[0]->IsObject() ||  // window
-      !args[1]->IsString() ||  // title
-      !args[2]->IsString())    // default_path
+void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string title;
+  base::FilePath default_path;
+  int properties;
+  if (!FromV8Arguments(args, &title, &default_path, &properties))
     return node::ThrowTypeError("Bad argument");
 
-  Window* window = Window::Unwrap<Window>(args[0]->ToObject());
-  if (!window || !window->window())
-    return node::ThrowError("Invalid window");
+  NativeWindow* native_window = FromV8Value(args[3]);
 
-  std::string title(*v8::String::Utf8Value(args[1]));
-  base::FilePath default_path(V8ValueToFilePath(args[2]));
+  if (!args[4]->IsFunction()) {
+    std::vector<base::FilePath> paths;
+    if (!file_dialog::ShowOpenDialog(native_window,
+                                     title,
+                                     default_path,
+                                     properties,
+                                     &paths))
+      return;
 
-  base::FilePath path;
-  if (!file_dialog::ShowSaveDialog(window->window(),
-                                   title,
-                                   default_path,
-                                   &path))
-    return v8::Undefined();
+    v8::Handle<v8::Array> result = v8::Array::New(paths.size());
+    for (size_t i = 0; i < paths.size(); ++i)
+      result->Set(i, ToV8Value(paths[i]));
 
-  return scope.Close(FilePathToV8Value(path));
+    args.GetReturnValue().Set(result);
+  } else {
+    RefCountedV8Function callback = FromV8Value(args[4]);
+    file_dialog::ShowOpenDialog(
+        native_window,
+        title,
+        default_path,
+        properties,
+        base::Bind(&CallV8Function2<const std::vector<base::FilePath>&>,
+                   callback));
+  }
+}
+
+void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string title;
+  base::FilePath default_path;
+  if (!FromV8Arguments(args, &title, &default_path))
+    return node::ThrowTypeError("Bad argument");
+
+  NativeWindow* native_window = FromV8Value(args[2]);
+
+  if (!args[3]->IsFunction()) {
+    base::FilePath path;
+    if (file_dialog::ShowSaveDialog(native_window,
+                                    title,
+                                    default_path,
+                                    &path))
+      args.GetReturnValue().Set(ToV8Value(path));
+  } else {
+    RefCountedV8Function callback = FromV8Value(args[3]);
+    file_dialog::ShowSaveDialog(
+        native_window,
+        title,
+        default_path,
+        base::Bind(&CallV8Function2<const base::FilePath&>, callback));
+  }
 }
 
 }  // namespace api

browser/api/atom_api_dialog.h

@@ -11,9 +11,9 @@ namespace atom {
 
 namespace api {
 
-v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments &args);
-v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments &args);
-v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments &args);
+void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args);
+void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
+void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 }  // namespace api
 

browser/api/atom_api_event.cc

@@ -4,56 +4,95 @@
 
 #include "browser/api/atom_api_event.h"
 
-using node::node_isolate;
+#include "browser/native_window.h"
+#include "common/api/api_messages.h"
+#include "common/v8/node_common.h"
+#include "common/v8/native_type_conversions.h"
 
 namespace atom {
 
 namespace api {
 
-v8::Persistent<v8::FunctionTemplate> Event::constructor_template_;
+ScopedPersistent<v8::Function> Event::constructor_template_;
 
 Event::Event()
-    : prevent_default_(false) {
+    : sender_(NULL),
+      message_(NULL),
+      prevent_default_(false) {
 }
 
 Event::~Event() {
+  if (sender_ != NULL)
+    sender_->RemoveObserver(this);
 }
 
 // static
 v8::Handle<v8::Object> Event::CreateV8Object() {
-  v8::HandleScope scope;
-
   if (constructor_template_.IsEmpty()) {
     v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
-    constructor_template_ = v8::Persistent<v8::FunctionTemplate>::New(
-        node_isolate, t);
-    constructor_template_->InstanceTemplate()->SetInternalFieldCount(1);
-    constructor_template_->SetClassName(v8::String::NewSymbol("Event"));
+    t->InstanceTemplate()->SetInternalFieldCount(1);
+    t->SetClassName(v8::String::NewSymbol("Event"));
 
     NODE_SET_PROTOTYPE_METHOD(t, "preventDefault", PreventDefault);
+    NODE_SET_PROTOTYPE_METHOD(t, "sendReply", SendReply);
+    NODE_SET_PROTOTYPE_METHOD(t, "destroy", Destroy);
+
+    constructor_template_.reset(t->GetFunction());
   }
 
-  v8::Handle<v8::Object> v8_event =
-      constructor_template_->GetFunction()->NewInstance(0, NULL);
-
-  return scope.Close(v8_event);
+  v8::Handle<v8::Function> t = constructor_template_.NewHandle(node_isolate);
+  return t->NewInstance(0, NULL);
 }
 
-v8::Handle<v8::Value> Event::New(const v8::Arguments &args) {
+void Event::SetSenderAndMessage(NativeWindow* sender, IPC::Message* message) {
+  DCHECK(!sender_);
+  DCHECK(!message_);
+  sender_ = sender;
+  message_ = message;
+
+  sender_->AddObserver(this);
+}
+
+void Event::OnWindowClosed() {
+  sender_ = NULL;
+  message_ = NULL;
+}
+
+// static
+void Event::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Event* event = new Event;
   event->Wrap(args.This());
-
-  return args.This();
 }
 
-v8::Handle<v8::Value> Event::PreventDefault(const v8::Arguments &args) {
+// static
+void Event::PreventDefault(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Event* event = Unwrap<Event>(args.This());
   if (event == NULL)
     return node::ThrowError("Event is already destroyed");
 
   event->prevent_default_ = true;
+}
 
-  return v8::Undefined();
+// static
+void Event::SendReply(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Event* event = Unwrap<Event>(args.This());
+  if (event == NULL)
+    return node::ThrowError("Event is already destroyed");
+
+  if (event->message_ == NULL || event->sender_ == NULL)
+    return node::ThrowError("Can only send reply to synchronous events");
+
+  string16 json = FromV8Value(args[0]);
+
+  AtomViewHostMsg_Message_Sync::WriteReplyParams(event->message_, json);
+  event->sender_->Send(event->message_);
+
+  delete event;
+}
+
+// static
+void Event::Destroy(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  delete Unwrap<Event>(args.This());
 }
 
 }  // namespace api

browser/api/atom_api_event.h

@@ -6,21 +6,32 @@
 #define ATOM_BROWSER_ATOM_API_EVENT_H_
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/strings/string16.h"
+#include "browser/native_window_observer.h"
+#include "common/v8/scoped_persistent.h"
 #include "vendor/node/src/node_object_wrap.h"
 
+namespace IPC {
+class Message;
+}
+
 namespace atom {
 
+class NativeWindow;
+
 namespace api {
 
-class Event : public node::ObjectWrap {
+class Event : public node::ObjectWrap,
+              public NativeWindowObserver {
  public:
   virtual ~Event();
 
   // Create a V8 Event object.
   static v8::Handle<v8::Object> CreateV8Object();
 
-  // Accessor to return handle_, this follows Google C++ Style.
-  v8::Persistent<v8::Object>& handle() { return handle_; }
+  // Pass the sender and message to be replied.
+  void SetSenderAndMessage(NativeWindow* sender, IPC::Message* message);
 
   // Whether event.preventDefault() is called.
   bool prevent_default() const { return prevent_default_; }
@@ -28,11 +39,21 @@ class Event : public node::ObjectWrap {
  protected:
   Event();
 
- private:
-  static v8::Handle<v8::Value> New(const v8::Arguments &args);
-  static v8::Handle<v8::Value> PreventDefault(const v8::Arguments &args);
+  // NativeWindowObserver implementations:
+  virtual void OnWindowClosed() OVERRIDE;
 
-  static v8::Persistent<v8::FunctionTemplate> constructor_template_;
+ private:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void PreventDefault(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SendReply(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static ScopedPersistent<v8::Function> constructor_template_;
+
+  // Replyer for the synchronous messages.
+  NativeWindow* sender_;
+  IPC::Message* message_;
 
   bool prevent_default_;
 

browser/api/atom_api_menu.cc

@@ -4,8 +4,9 @@
 
 #include "browser/api/atom_api_menu.h"
 
-#include "browser/accelerator_util.h"
-#include "browser/api/atom_api_window.h"
+#include "browser/ui/accelerator_util.h"
+#include "common/v8/node_common.h"
+#include "common/v8/native_type_conversions.h"
 
 #define UNWRAP_MEMNU_AND_CHECK \
   Menu* self = ObjectWrap::Unwrap<Menu>(args.This()); \
@@ -18,23 +19,13 @@ namespace api {
 
 namespace {
 
-// Converts a V8 value to a string16.
-string16 V8ValueToUTF16(v8::Handle<v8::Value> value) {
-  v8::String::Value s(value);
-  return string16(reinterpret_cast<const char16*>(*s), s.length());
-}
-
-// Converts string16 to V8 String.
-v8::Handle<v8::Value> UTF16ToV8Value(const string16& s) {
-  return v8::String::New(reinterpret_cast<const uint16_t*>(s.data()), s.size());
-}
-
 // Call method of delegate object.
 v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
                                    v8::Handle<v8::Object> menu,
                                    const char* method,
                                    int command_id) {
-  v8::HandleScope scope;
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Handle<v8::Value> delegate = menu->Get(v8::String::New("delegate"));
   if (!delegate->IsObject())
@@ -47,7 +38,7 @@ v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
 
   v8::Handle<v8::Value> argv = v8::Integer::New(command_id);
 
-  return scope.Close(
+  return handle_scope.Close(
       function->Call(v8::Context::GetCurrent()->Global(), 1, &argv));
 }
 
@@ -62,38 +53,42 @@ Menu::~Menu() {
 }
 
 bool Menu::IsCommandIdChecked(int command_id) const {
-  v8::HandleScope scope;
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::False(),
-                      handle(),
+                      const_cast<Menu*>(this)->handle(),
                       "isCommandIdChecked",
                       command_id)->BooleanValue();
 }
 
 bool Menu::IsCommandIdEnabled(int command_id) const {
-  v8::HandleScope scope;
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::True(),
-                      handle(),
+                      const_cast<Menu*>(this)->handle(),
                       "isCommandIdEnabled",
                       command_id)->BooleanValue();
 }
 
 bool Menu::IsCommandIdVisible(int command_id) const {
-  v8::HandleScope scope;
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::True(),
-                      handle(),
+                      const_cast<Menu*>(this)->handle(),
                       "isCommandIdVisible",
                       command_id)->BooleanValue();
 }
 
 bool Menu::GetAcceleratorForCommandId(int command_id,
                                       ui::Accelerator* accelerator) {
-  v8::HandleScope scope;
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
   v8::Handle<v8::Value> shortcut = CallDelegate(v8::Undefined(),
                                                 handle(),
                                                 "getAcceleratorForCommandId",
                                                 command_id);
   if (shortcut->IsString()) {
-    std::string shortcut_str(*v8::String::Utf8Value(shortcut));
+    std::string shortcut_str = FromV8Value(shortcut);
     return accelerator_util::StringToAccelerator(shortcut_str, accelerator);
   }
 
@@ -101,251 +96,224 @@ bool Menu::GetAcceleratorForCommandId(int command_id,
 }
 
 bool Menu::IsItemForCommandIdDynamic(int command_id) const {
-  v8::HandleScope scope;
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::False(),
-                      handle(),
+                      const_cast<Menu*>(this)->handle(),
                       "isItemForCommandIdDynamic",
                       command_id)->BooleanValue();
 }
 
 string16 Menu::GetLabelForCommandId(int command_id) const {
-  v8::HandleScope scope;
-  return V8ValueToUTF16(CallDelegate(v8::False(),
-                                     handle(),
-                                     "getLabelForCommandId",
-                                     command_id));
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+  return FromV8Value(CallDelegate(v8::False(),
+                                  const_cast<Menu*>(this)->handle(),
+                                  "getLabelForCommandId",
+                                  command_id));
 }
 
 string16 Menu::GetSublabelForCommandId(int command_id) const {
-  v8::HandleScope scope;
-  return V8ValueToUTF16(CallDelegate(v8::False(),
-                                     handle(),
-                                     "getSubLabelForCommandId",
-                                     command_id));
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+  return FromV8Value(CallDelegate(v8::False(),
+                                  const_cast<Menu*>(this)->handle(),
+                                  "getSubLabelForCommandId",
+                                  command_id));
 }
 
 void Menu::ExecuteCommand(int command_id, int event_flags) {
-  v8::HandleScope scope;
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
   CallDelegate(v8::False(), handle(), "executeCommand", command_id);
 }
 
 // static
-v8::Handle<v8::Value> Menu::New(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
+void Menu::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
 
   Menu::Create(args.This());
-
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertItem(const v8::Arguments &args) {
+void Menu::InsertItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
-  if (!args[0]->IsNumber() || !args[1]->IsNumber() || !args[2]->IsString())
+  int index, command_id;
+  string16 label;
+  if (!FromV8Arguments(args, &index, &command_id, &label))
     return node::ThrowTypeError("Bad argument");
 
-  int index = args[0]->IntegerValue();
-
   if (index < 0)
-    self->model_->AddItem(args[1]->IntegerValue(), V8ValueToUTF16(args[2]));
+    self->model_->AddItem(command_id, label);
   else
-    self->model_->InsertItemAt(
-        index, args[1]->IntegerValue(), V8ValueToUTF16(args[2]));
-
-  return v8::Undefined();
+    self->model_->InsertItemAt(index, command_id, label);
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertCheckItem(const v8::Arguments &args) {
+void Menu::InsertCheckItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
-  if (!args[0]->IsNumber() || !args[1]->IsNumber() || !args[2]->IsString())
+  int index, command_id;
+  string16 label;
+  if (!FromV8Arguments(args, &index, &command_id, &label))
     return node::ThrowTypeError("Bad argument");
 
-  int index = args[0]->IntegerValue();
-  int command_id = args[1]->IntegerValue();
-
   if (index < 0)
-    self->model_->AddCheckItem(command_id, V8ValueToUTF16(args[2]));
+    self->model_->AddCheckItem(command_id, label);
   else
-    self->model_->InsertCheckItemAt(index, command_id, V8ValueToUTF16(args[2]));
-
-  return v8::Undefined();
+    self->model_->InsertCheckItemAt(index, command_id, label);
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertRadioItem(const v8::Arguments &args) {
+void Menu::InsertRadioItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
-  if (!args[0]->IsNumber() ||
-      !args[1]->IsNumber() ||
-      !args[2]->IsString() ||
-      !args[3]->IsNumber())
+  int index, command_id, group_id;
+  string16 label;
+  if (!FromV8Arguments(args, &index, &command_id, &label, &group_id))
     return node::ThrowTypeError("Bad argument");
 
-  int index = args[0]->IntegerValue();
-  int command_id = args[1]->IntegerValue();
-  int group_id = args[3]->IntegerValue();
-
   if (index < 0)
-    self->model_->AddRadioItem(command_id, V8ValueToUTF16(args[2]), group_id);
+    self->model_->AddRadioItem(command_id, label, group_id);
   else
-    self->model_->InsertRadioItemAt(
-        index, command_id, V8ValueToUTF16(args[2]), group_id);
-
-  return v8::Undefined();
+    self->model_->InsertRadioItemAt(index, command_id, label, group_id);
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertSeparator(const v8::Arguments &args) {
+void Menu::InsertSeparator(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
-  if (!args[0]->IsNumber())
+  int index;
+  if (!FromV8Arguments(args, &index))
     return node::ThrowTypeError("Bad argument");
 
-  int index = args[0]->IntegerValue();
-
   if (index < 0)
     self->model_->AddSeparator(ui::NORMAL_SEPARATOR);
   else
     self->model_->InsertSeparatorAt(index, ui::NORMAL_SEPARATOR);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertSubMenu(const v8::Arguments &args) {
+void Menu::InsertSubMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
-  if (!args[0]->IsNumber() ||
-      !args[1]->IsNumber() ||
-      !args[2]->IsString() ||
-      !args[3]->IsObject())
+  int index, command_id;
+  string16 label;
+  if (!FromV8Arguments(args, &index, &command_id, &label))
     return node::ThrowTypeError("Bad argument");
 
   Menu* submenu = ObjectWrap::Unwrap<Menu>(args[3]->ToObject());
   if (!submenu)
     return node::ThrowTypeError("The submenu is already destroyed");
 
-  int index = args[0]->IntegerValue();
-  int command_id = args[1]->IntegerValue();
-
   if (index < 0)
-    self->model_->AddSubMenu(
-        command_id, V8ValueToUTF16(args[2]), submenu->model_.get());
+    self->model_->AddSubMenu(command_id, label, submenu->model_.get());
   else
     self->model_->InsertSubMenuAt(
-        index, command_id, V8ValueToUTF16(args[2]), submenu->model_.get());
-
-  return v8::Undefined();
+        index, command_id, label, submenu->model_.get());
 }
 
 // static
-v8::Handle<v8::Value> Menu::SetIcon(const v8::Arguments &args) {
+void Menu::SetIcon(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
-  if (!args[0]->IsNumber() || !args[1]->IsString())
+  int index;
+  base::FilePath path;
+  if (!FromV8Arguments(args, &index, &path))
     return node::ThrowTypeError("Bad argument");
 
   // FIXME use webkit_glue's image decoder here.
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::SetSublabel(const v8::Arguments &args) {
+void Menu::SetSublabel(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
-  if (!args[0]->IsNumber() || !args[1]->IsString())
+  int index;
+  string16 label;
+  if (!FromV8Arguments(args, &index, &label))
     return node::ThrowTypeError("Bad argument");
 
-  self->model_->SetSublabel(args[0]->IntegerValue(), V8ValueToUTF16(args[1]));
-
-  return v8::Undefined();
+  self->model_->SetSublabel(index, label);
 }
 
 // static
-v8::Handle<v8::Value> Menu::Clear(const v8::Arguments &args) {
+void Menu::Clear(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-
   self->model_->Clear();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetIndexOfCommandId(const v8::Arguments &args) {
+void Menu::GetIndexOfCommandId(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
-  return v8::Integer::New(self->model_->GetIndexOfCommandId(index));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(self->model_->GetIndexOfCommandId(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetItemCount(const v8::Arguments &args) {
+void Menu::GetItemCount(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  return v8::Integer::New(self->model_->GetItemCount());
+  args.GetReturnValue().Set(self->model_->GetItemCount());
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetCommandIdAt(const v8::Arguments &args) {
+void Menu::GetCommandIdAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
-  return v8::Integer::New(self->model_->GetCommandIdAt(index));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(self->model_->GetCommandIdAt(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetLabelAt(const v8::Arguments &args) {
+void Menu::GetLabelAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
-  return UTF16ToV8Value(self->model_->GetLabelAt(index));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(ToV8Value(self->model_->GetLabelAt(index)));
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetSublabelAt(const v8::Arguments &args) {
+void Menu::GetSublabelAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
-  return UTF16ToV8Value(self->model_->GetSublabelAt(index));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(ToV8Value(self->model_->GetSublabelAt(index)));
 }
 
 // static
-v8::Handle<v8::Value> Menu::IsItemCheckedAt(const v8::Arguments &args) {
+void Menu::IsItemCheckedAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
-  return v8::Boolean::New(self->model_->IsItemCheckedAt(index));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(self->model_->IsItemCheckedAt(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::IsEnabledAt(const v8::Arguments &args) {
+void Menu::IsEnabledAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  return v8::Boolean::New(self->model_->IsEnabledAt(args[0]->IntegerValue()));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(self->model_->IsEnabledAt(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::IsVisibleAt(const v8::Arguments &args) {
+void Menu::IsVisibleAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  return v8::Boolean::New(self->model_->IsVisibleAt(args[0]->IntegerValue()));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(self->model_->IsVisibleAt(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::Popup(const v8::Arguments &args) {
+void Menu::Popup(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
-  Window* window = Window::Unwrap<Window>(args[0]->ToObject());
-  if (!window)
-    return node::ThrowTypeError("Invalid window");
+  atom::NativeWindow* window;
+  if (!FromV8Arguments(args, &window))
+    return node::ThrowTypeError("Bad argument");
 
-  self->Popup(window->window());
-  return v8::Undefined();
+  self->Popup(window);
 }
 
 // static
 void Menu::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
-
   v8::Local<v8::FunctionTemplate> t(v8::FunctionTemplate::New(Menu::New));
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(v8::String::NewSymbol("Menu"));
@@ -372,6 +340,10 @@ void Menu::Initialize(v8::Handle<v8::Object> target) {
 
   NODE_SET_PROTOTYPE_METHOD(t, "popup", Popup);
 
+#if defined(OS_WIN) || defined(TOOLKIT_GTK)
+  NODE_SET_PROTOTYPE_METHOD(t, "attachToWindow", AttachToWindow);
+#endif
+
   target->Set(v8::String::NewSymbol("Menu"), t->GetFunction());
 
 #if defined(OS_MACOSX)

browser/api/atom_api_menu.h

@@ -6,7 +6,7 @@
 #define ATOM_BROWSER_API_ATOM_API_MENU_H_
 
 #include "base/memory/scoped_ptr.h"
-#include "browser/api/atom_api_event_emitter.h"
+#include "common/api/atom_api_event_emitter.h"
 #include "ui/base/models/simple_menu_model.h"
 
 namespace atom {
@@ -44,34 +44,38 @@ class Menu : public EventEmitter,
   scoped_ptr<ui::SimpleMenuModel> model_;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments &args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> InsertItem(const v8::Arguments &args);
-  static v8::Handle<v8::Value> InsertCheckItem(const v8::Arguments &args);
-  static v8::Handle<v8::Value> InsertRadioItem(const v8::Arguments &args);
-  static v8::Handle<v8::Value> InsertSeparator(const v8::Arguments &args);
-  static v8::Handle<v8::Value> InsertSubMenu(const v8::Arguments &args);
+  static void InsertItem(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InsertCheckItem(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InsertRadioItem(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InsertSeparator(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InsertSubMenu(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> SetIcon(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetSublabel(const v8::Arguments &args);
+  static void SetIcon(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetSublabel(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> Clear(const v8::Arguments &args);
+  static void Clear(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> GetIndexOfCommandId(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetItemCount(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetCommandIdAt(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetLabelAt(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetSublabelAt(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsItemCheckedAt(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsEnabledAt(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsVisibleAt(const v8::Arguments &args);
+  static void GetIndexOfCommandId(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetItemCount(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetCommandIdAt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetLabelAt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetSublabelAt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsItemCheckedAt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsEnabledAt(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsVisibleAt(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> Popup(const v8::Arguments &args);
+  static void Popup(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-#if defined(OS_MACOSX)
-  static v8::Handle<v8::Value> SetApplicationMenu(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SendActionToFirstResponder(
-      const v8::Arguments &args);
+#if defined(OS_WIN) || defined(TOOLKIT_GTK)
+  static void AttachToWindow(const v8::FunctionCallbackInfo<v8::Value>& args);
+#elif defined(OS_MACOSX)
+  static void SetApplicationMenu(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SendActionToFirstResponder(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(Menu);

browser/api/atom_api_menu_gtk.cc

@@ -0,0 +1,32 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/api/atom_api_menu_gtk.h"
+
+namespace atom {
+
+namespace api {
+
+MenuGtk::MenuGtk(v8::Handle<v8::Object> wrapper)
+    : Menu(wrapper) {
+}
+
+MenuGtk::~MenuGtk() {
+}
+
+void MenuGtk::Popup(NativeWindow* native_window) {
+}
+
+// static
+void Menu::AttachToWindow(const v8::FunctionCallbackInfo<v8::Value>& args) {
+}
+
+// static
+Menu* Menu::Create(v8::Handle<v8::Object> wrapper) {
+  return new MenuGtk(wrapper);
+}
+
+}  // namespace api
+
+}  // namespace atom

browser/api/atom_api_menu_gtk.h

@@ -0,0 +1,30 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_
+#define ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_
+
+#include "browser/api/atom_api_menu.h"
+
+namespace atom {
+
+namespace api {
+
+class MenuGtk : public Menu {
+ public:
+  explicit MenuGtk(v8::Handle<v8::Object> wrapper);
+  virtual ~MenuGtk();
+
+ protected:
+  virtual void Popup(NativeWindow* window) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MenuGtk);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_

browser/api/atom_api_menu_mac.h

@@ -7,7 +7,7 @@
 
 #include "browser/api/atom_api_menu.h"
 
-#import "chrome/browser/ui/cocoa/menu_controller.h"
+#import "browser/ui/cocoa/atom_menu_controller.h"
 
 namespace atom {
 
@@ -21,16 +21,11 @@ class MenuMac : public Menu {
  protected:
   virtual void Popup(NativeWindow* window) OVERRIDE;
 
-  scoped_nsobject<MenuController> menu_controller_;
+  base::scoped_nsobject<AtomMenuController> menu_controller_;
 
  private:
   friend class Menu;
 
-  // The MenuController doesn't set title for menus, however it's required by
-  // application menu to show submenus correctly, fix it by iterating all
-  // submenus and set their titles.
-  static void FixMenuTitles(NSMenu* menu);
-
   // Fake sending an action from the application menu.
   static void SendActionToFirstResponder(const std::string& action);
 

browser/api/atom_api_menu_mac.mm

@@ -4,10 +4,12 @@
 
 #import "browser/api/atom_api_menu_mac.h"
 
-#include "base/message_loop.h"
 #include "base/mac/scoped_sending_event.h"
+#include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "browser/native_window.h"
+#include "common/v8/node_common.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 
@@ -23,9 +25,8 @@ MenuMac::~MenuMac() {
 }
 
 void MenuMac::Popup(NativeWindow* native_window) {
-  scoped_nsobject<MenuController> menu_controller(
-      [[MenuController alloc] initWithModel:model_.get()
-                     useWithPopUpButtonCell:NO]);
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:model_.get()]);
 
   NSWindow* window = native_window->GetNativeWindow();
   content::WebContents* web_contents = native_window->GetWebContents();
@@ -46,7 +47,8 @@ void MenuMac::Popup(NativeWindow* native_window) {
 
   {
     // Make sure events can be pumped while the menu is up.
-    MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
+    base::MessageLoop::ScopedNestableTaskAllower allow(
+        base::MessageLoop::current());
 
     // One of the events that could be pumped is |window.close()|.
     // User-initiated event-tracking loops protect against this by
@@ -62,22 +64,6 @@ void MenuMac::Popup(NativeWindow* native_window) {
   }
 }
 
-// static
-void MenuMac::FixMenuTitles(NSMenu* menu) {
-  int size = [menu numberOfItems];
-  for (int i = 0; i < size; ++i) {
-    NSMenuItem* item = [menu itemAtIndex:i];
-    if ([item hasSubmenu]) {
-      NSString* title = [item title];
-      NSMenu* submenu = [item submenu];
-      [submenu setTitle:title];
-
-      if ([title isEqualToString:@"Window"] && [submenu numberOfItems] > 0)
-        [NSApp setWindowsMenu:submenu];
-    }
-  }
-}
-
 // static
 void MenuMac::SendActionToFirstResponder(const std::string& action) {
   SEL selector = NSSelectorFromString(base::SysUTF8ToNSString(action));
@@ -87,9 +73,7 @@ void MenuMac::SendActionToFirstResponder(const std::string& action) {
 }
 
 // static
-v8::Handle<v8::Value> Menu::SetApplicationMenu(const v8::Arguments &args) {
-  v8::HandleScope scope;
-
+void Menu::SetApplicationMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (!args[0]->IsObject())
     return node::ThrowTypeError("Bad argument");
 
@@ -97,30 +81,22 @@ v8::Handle<v8::Value> Menu::SetApplicationMenu(const v8::Arguments &args) {
   if (!menu)
     return node::ThrowError("Menu is destroyed");
 
-  scoped_nsobject<MenuController> menu_controller(
-      [[MenuController alloc] initWithModel:menu->model_.get()
-                     useWithPopUpButtonCell:NO]);
-  MenuMac::FixMenuTitles([menu_controller menu]);
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:menu->model_.get()]);
   [NSApp setMainMenu:[menu_controller menu]];
 
   // Ensure the menu_controller_ is destroyed after main menu is set.
   menu_controller.swap(menu->menu_controller_);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::SendActionToFirstResponder(
-    const v8::Arguments &args) {
-  v8::HandleScope scope;
-
-  if (!args[0]->IsString())
+void Menu::SendActionToFirstResponder(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string action;
+  if (!FromV8Arguments(args, &action))
     return node::ThrowTypeError("Bad argument");
 
-  std::string action(*v8::String::Utf8Value(args[0]));
   MenuMac::SendActionToFirstResponder(action);
-
-  return v8::Undefined();
 }
 
 // static

browser/api/atom_api_menu_win.cc

@@ -4,6 +4,14 @@
 
 #include "browser/api/atom_api_menu_win.h"
 
+#include "browser/native_window_win.h"
+#include "browser/ui/win/menu_2.h"
+#include "common/v8/native_type_conversions.h"
+#include "ui/gfx/point.h"
+#include "ui/gfx/screen.h"
+
+#include "common/v8/node_common.h"
+
 namespace atom {
 
 namespace api {
@@ -16,6 +24,22 @@ MenuWin::~MenuWin() {
 }
 
 void MenuWin::Popup(NativeWindow* native_window) {
+  gfx::Point cursor = gfx::Screen::GetNativeScreen()->GetCursorScreenPoint();
+  menu_.reset(new atom::Menu2(model_.get()));
+  menu_->RunContextMenuAt(cursor);
+}
+
+// static
+void Menu::AttachToWindow(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Menu* self = ObjectWrap::Unwrap<Menu>(args.This());
+  if (self == NULL)
+    return node::ThrowError("Menu is already destroyed");
+
+  NativeWindow* native_window;
+  if (!FromV8Arguments(args, &native_window))
+    return node::ThrowTypeError("Bad argument");
+
+  static_cast<NativeWindowWin*>(native_window)->SetMenu(self->model_.get());
 }
 
 // static

browser/api/atom_api_menu_win.h

@@ -9,6 +9,8 @@
 
 namespace atom {
 
+class Menu2;
+
 namespace api {
 
 class MenuWin : public Menu {
@@ -20,6 +22,8 @@ class MenuWin : public Menu {
   virtual void Popup(NativeWindow* window) OVERRIDE;
 
  private:
+  scoped_ptr<atom::Menu2> menu_;
+
   DISALLOW_COPY_AND_ASSIGN(MenuWin);
 };
 

browser/api/atom_api_power_monitor.cc

@@ -0,0 +1,67 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/api/atom_api_power_monitor.h"
+
+#include "base/power_monitor/power_monitor.h"
+#include "base/power_monitor/power_monitor_device_source.h"
+
+#include "common/v8/node_common.h"
+
+namespace atom {
+
+namespace api {
+
+PowerMonitor::PowerMonitor(v8::Handle<v8::Object> wrapper)
+    : EventEmitter(wrapper) {
+  base::PowerMonitor::Get()->AddObserver(this);
+}
+
+PowerMonitor::~PowerMonitor() {
+  base::PowerMonitor::Get()->RemoveObserver(this);
+}
+
+void PowerMonitor::OnPowerStateChange(bool on_battery_power) {
+  if (on_battery_power)
+    Emit("on-battery");
+  else
+    Emit("on-ac");
+}
+
+void PowerMonitor::OnSuspend() {
+  Emit("suspend");
+}
+
+void PowerMonitor::OnResume() {
+  Emit("resume");
+}
+
+// static
+void PowerMonitor::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  if (!args.IsConstructCall())
+    return node::ThrowError("Require constructor call");
+
+  new PowerMonitor(args.This());
+}
+
+// static
+void PowerMonitor::Initialize(v8::Handle<v8::Object> target) {
+#if defined(OS_MACOSX)
+  base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
+#endif
+
+  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(
+      PowerMonitor::New);
+  t->InstanceTemplate()->SetInternalFieldCount(1);
+  t->SetClassName(v8::String::NewSymbol("PowerMonitor"));
+
+  target->Set(v8::String::NewSymbol("PowerMonitor"), t->GetFunction());
+}
+
+
+}  // namespace api
+
+}  // namespace atom
+
+NODE_MODULE(atom_browser_power_monitor, atom::api::PowerMonitor::Initialize)

browser/api/atom_api_power_monitor.h

@@ -0,0 +1,40 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
+#define ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
+
+#include "base/compiler_specific.h"
+#include "base/power_monitor/power_observer.h"
+#include "common/api/atom_api_event_emitter.h"
+
+namespace atom {
+
+namespace api {
+
+class PowerMonitor : public EventEmitter,
+                     public base::PowerObserver {
+ public:
+  virtual ~PowerMonitor();
+
+  static void Initialize(v8::Handle<v8::Object> target);
+
+ protected:
+  explicit PowerMonitor(v8::Handle<v8::Object> wrapper);
+
+  virtual void OnPowerStateChange(bool on_battery_power) OVERRIDE;
+  virtual void OnSuspend() OVERRIDE;
+  virtual void OnResume() OVERRIDE;
+
+ private:
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_

browser/api/atom_api_protocol.cc

@@ -0,0 +1,386 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/api/atom_api_protocol.h"
+
+#include "base/stl_util.h"
+#include "browser/atom_browser_context.h"
+#include "browser/net/adapter_request_job.h"
+#include "browser/net/atom_url_request_context_getter.h"
+#include "browser/net/atom_url_request_job_factory.h"
+#include "common/v8/native_type_conversions.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/url_request/url_request_context.h"
+
+#include "common/v8/node_common.h"
+
+namespace atom {
+
+namespace api {
+
+typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
+
+namespace {
+
+// The protocol module object.
+ScopedPersistent<v8::Object> g_protocol_object;
+
+// Registered protocol handlers.
+typedef std::map<std::string, RefCountedV8Function> HandlersMap;
+static HandlersMap g_handlers;
+
+static const char* kEarlyUseProtocolError = "This method can only be used"
+    "after the application has finished launching.";
+
+// Emit an event for the protocol module.
+void EmitEventInUI(const std::string& event, const std::string& parameter) {
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+
+  v8::Handle<v8::Value> argv[] = {
+      ToV8Value(event),
+      ToV8Value(parameter),
+  };
+  node::MakeCallback(g_protocol_object.NewHandle(node_isolate),
+                     "emit", 2, argv);
+}
+
+// Convert the URLRequest object to V8 object.
+v8::Handle<v8::Object> ConvertURLRequestToV8Object(
+    const net::URLRequest* request) {
+  v8::Local<v8::Object> obj = v8::Object::New();
+  obj->Set(ToV8Value("method"), ToV8Value(request->method()));
+  obj->Set(ToV8Value("url"), ToV8Value(request->url().spec()));
+  obj->Set(ToV8Value("referrer"), ToV8Value(request->referrer()));
+  return obj;
+}
+
+// Get the job factory.
+AtomURLRequestJobFactory* GetRequestJobFactory() {
+  return AtomBrowserContext::Get()->url_request_context_getter()->job_factory();
+}
+
+class CustomProtocolRequestJob : public AdapterRequestJob {
+ public:
+  CustomProtocolRequestJob(ProtocolHandler* protocol_handler,
+                           net::URLRequest* request,
+                           net::NetworkDelegate* network_delegate)
+      : AdapterRequestJob(protocol_handler, request, network_delegate) {
+  }
+
+  // AdapterRequestJob:
+  virtual void GetJobTypeInUI() OVERRIDE {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+    v8::Locker locker(node_isolate);
+    v8::HandleScope handle_scope(node_isolate);
+
+    // Call the JS handler.
+    v8::Handle<v8::Value> argv[] = {
+      ConvertURLRequestToV8Object(request()),
+    };
+    RefCountedV8Function callback = g_handlers[request()->url().scheme()];
+    v8::Handle<v8::Value> result = callback->NewHandle(node_isolate)->Call(
+        v8::Context::GetCurrent()->Global(), 1, argv);
+
+    // Determine the type of the job we are going to create.
+    if (result->IsString()) {
+      std::string data = FromV8Value(result);
+      content::BrowserThread::PostTask(
+          content::BrowserThread::IO,
+          FROM_HERE,
+          base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
+                     GetWeakPtr(),
+                     "text/plain",
+                     "UTF-8",
+                     data));
+      return;
+    } else if (result->IsObject()) {
+      v8::Handle<v8::Object> obj = result->ToObject();
+      std::string name = FromV8Value(obj->GetConstructorName());
+      if (name == "RequestStringJob") {
+        std::string mime_type = FromV8Value(obj->Get(
+            v8::String::New("mimeType")));
+        std::string charset = FromV8Value(obj->Get(v8::String::New("charset")));
+        std::string data = FromV8Value(obj->Get(v8::String::New("data")));
+
+        content::BrowserThread::PostTask(
+            content::BrowserThread::IO,
+            FROM_HERE,
+            base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
+                       GetWeakPtr(),
+                       mime_type,
+                       charset,
+                       data));
+        return;
+      } else if (name == "RequestFileJob") {
+        base::FilePath path = FromV8Value(obj->Get(v8::String::New("path")));
+
+        content::BrowserThread::PostTask(
+            content::BrowserThread::IO,
+            FROM_HERE,
+            base::Bind(&AdapterRequestJob::CreateFileJobAndStart,
+                       GetWeakPtr(),
+                       path));
+        return;
+      }
+    }
+
+    // Try the default protocol handler if we have.
+    if (default_protocol_handler()) {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::IO,
+          FROM_HERE,
+          base::Bind(&AdapterRequestJob::CreateJobFromProtocolHandlerAndStart,
+                     GetWeakPtr()));
+      return;
+    }
+
+    // Fallback to the not implemented error.
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&AdapterRequestJob::CreateErrorJobAndStart,
+                   GetWeakPtr(),
+                   net::ERR_NOT_IMPLEMENTED));
+  }
+};
+
+// Always return the same CustomProtocolRequestJob for all requests, because
+// the content API needs the ProtocolHandler to return a job immediately, and
+// getting the real job from the JS requires asynchronous calls, so we have
+// to create an adapter job first.
+// Users can also pass an extra ProtocolHandler as the fallback one when
+// registered handler doesn't want to deal with the request.
+class CustomProtocolHandler : public ProtocolHandler {
+ public:
+  explicit CustomProtocolHandler(ProtocolHandler* protocol_handler = NULL)
+      : protocol_handler_(protocol_handler) {
+  }
+
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    return new CustomProtocolRequestJob(protocol_handler_.get(),
+                                        request,
+                                        network_delegate);
+  }
+
+  ProtocolHandler* ReleaseDefaultProtocolHandler() {
+    return protocol_handler_.release();
+  }
+
+  ProtocolHandler* original_handler() { return protocol_handler_.get(); }
+
+ private:
+  scoped_ptr<ProtocolHandler> protocol_handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
+};
+
+}  // namespace
+
+// static
+void Protocol::RegisterProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string scheme;
+  RefCountedV8Function callback;
+  if (!FromV8Arguments(args, &scheme, &callback))
+    return node::ThrowTypeError("Bad argument");
+
+  if (g_handlers.find(scheme) != g_handlers.end() ||
+      GetRequestJobFactory()->IsHandledProtocol(scheme))
+    return node::ThrowError("The scheme is already registered");
+
+  if (AtomBrowserContext::Get()->url_request_context_getter() == NULL)
+    return node::ThrowError(kEarlyUseProtocolError);
+
+  // Store the handler in a map.
+  g_handlers[scheme] = callback;
+
+  content::BrowserThread::PostTask(content::BrowserThread::IO,
+                                   FROM_HERE,
+                                   base::Bind(&RegisterProtocolInIO, scheme));
+}
+
+// static
+void Protocol::UnregisterProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string scheme;
+  if (!FromV8Arguments(args, &scheme))
+    return node::ThrowTypeError("Bad argument");
+
+  if (AtomBrowserContext::Get()->url_request_context_getter() == NULL)
+    return node::ThrowError(kEarlyUseProtocolError);
+
+  // Erase the handler from map.
+  HandlersMap::iterator it(g_handlers.find(scheme));
+  if (it == g_handlers.end())
+    return node::ThrowError("The scheme has not been registered");
+  g_handlers.erase(it);
+
+  content::BrowserThread::PostTask(content::BrowserThread::IO,
+                                   FROM_HERE,
+                                   base::Bind(&UnregisterProtocolInIO, scheme));
+}
+
+// static
+void Protocol::IsHandledProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string scheme;
+  if (!FromV8Arguments(args, &scheme))
+    return node::ThrowTypeError("Bad argument");
+
+  args.GetReturnValue().Set(GetRequestJobFactory()->IsHandledProtocol(scheme));
+}
+
+// static
+void Protocol::InterceptProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string scheme;
+  RefCountedV8Function callback;
+  if (!FromV8Arguments(args, &scheme, &callback))
+    return node::ThrowTypeError("Bad argument");
+
+  if (!GetRequestJobFactory()->HasProtocolHandler(scheme))
+    return node::ThrowError("Cannot intercept procotol");
+
+  if (ContainsKey(g_handlers, scheme))
+    return node::ThrowError("Cannot intercept custom procotols");
+
+  if (AtomBrowserContext::Get()->url_request_context_getter() == NULL)
+    return node::ThrowError(kEarlyUseProtocolError);
+
+  // Store the handler in a map.
+  g_handlers[scheme] = callback;
+
+  content::BrowserThread::PostTask(content::BrowserThread::IO,
+                                   FROM_HERE,
+                                   base::Bind(&InterceptProtocolInIO, scheme));
+}
+
+// static
+void Protocol::UninterceptProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string scheme;
+  if (!FromV8Arguments(args, &scheme))
+    return node::ThrowTypeError("Bad argument");
+
+  if (AtomBrowserContext::Get()->url_request_context_getter() == NULL)
+    return node::ThrowError(kEarlyUseProtocolError);
+
+  // Erase the handler from map.
+  HandlersMap::iterator it(g_handlers.find(scheme));
+  if (it == g_handlers.end())
+    return node::ThrowError("The scheme has not been registered");
+  g_handlers.erase(it);
+
+  content::BrowserThread::PostTask(content::BrowserThread::IO,
+                                   FROM_HERE,
+                                   base::Bind(&UninterceptProtocolInIO,
+                                              scheme));
+}
+
+// static
+void Protocol::RegisterProtocolInIO(const std::string& scheme) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  AtomURLRequestJobFactory* job_factory(GetRequestJobFactory());
+  job_factory->SetProtocolHandler(scheme, new CustomProtocolHandler);
+
+  content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                   FROM_HERE,
+                                   base::Bind(&EmitEventInUI,
+                                              "registered",
+                                              scheme));
+}
+
+// static
+void Protocol::UnregisterProtocolInIO(const std::string& scheme) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  AtomURLRequestJobFactory* job_factory(GetRequestJobFactory());
+  job_factory->SetProtocolHandler(scheme, NULL);
+
+  content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                   FROM_HERE,
+                                   base::Bind(&EmitEventInUI,
+                                              "unregistered",
+                                              scheme));
+}
+
+// static
+void Protocol::InterceptProtocolInIO(const std::string& scheme) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  AtomURLRequestJobFactory* job_factory(GetRequestJobFactory());
+  ProtocolHandler* original_handler = job_factory->GetProtocolHandler(scheme);
+  if (original_handler == NULL) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&EmitEventInUI,
+                   "error",
+                   "There is no protocol handler to intercpet"));
+    return;
+  }
+
+  job_factory->ReplaceProtocol(scheme,
+                               new CustomProtocolHandler(original_handler));
+
+  content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                   FROM_HERE,
+                                   base::Bind(&EmitEventInUI,
+                                              "intercepted",
+                                              scheme));
+}
+
+// static
+void Protocol::UninterceptProtocolInIO(const std::string& scheme) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  AtomURLRequestJobFactory* job_factory(GetRequestJobFactory());
+
+  // Check if the protocol handler is intercepted.
+  CustomProtocolHandler* handler = static_cast<CustomProtocolHandler*>(
+      job_factory->GetProtocolHandler(scheme));
+  if (handler->original_handler() == NULL) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&EmitEventInUI,
+                   "error",
+                   "The protocol is not intercpeted"));
+    return;
+  }
+
+  // Reset the protocol handler to the orignal one and delete current
+  // protocol handler.
+  ProtocolHandler* original_handler = handler->ReleaseDefaultProtocolHandler();
+  delete job_factory->ReplaceProtocol(scheme, original_handler);
+
+  content::BrowserThread::PostTask(content::BrowserThread::UI,
+                                   FROM_HERE,
+                                   base::Bind(&EmitEventInUI,
+                                              "unintercepted",
+                                              scheme));
+}
+
+// static
+void Protocol::Initialize(v8::Handle<v8::Object> target) {
+  // Remember the protocol object, used for emitting event later.
+  g_protocol_object.reset(target);
+
+  // Make sure the job factory has been created.
+  AtomBrowserContext::Get()->url_request_context_getter()->
+      GetURLRequestContext();
+
+  NODE_SET_METHOD(target, "registerProtocol", RegisterProtocol);
+  NODE_SET_METHOD(target, "unregisterProtocol", UnregisterProtocol);
+  NODE_SET_METHOD(target, "isHandledProtocol", IsHandledProtocol);
+  NODE_SET_METHOD(target, "interceptProtocol", InterceptProtocol);
+  NODE_SET_METHOD(target, "uninterceptProtocol", UninterceptProtocol);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+NODE_MODULE(atom_browser_protocol, atom::api::Protocol::Initialize)

browser/api/atom_api_protocol.h

@@ -0,0 +1,47 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
+#define ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
+
+#include <string>
+#include <map>
+
+#include "base/basictypes.h"
+#include "v8/include/v8.h"
+
+namespace atom {
+
+namespace api {
+
+class Protocol {
+ public:
+  static void Initialize(v8::Handle<v8::Object> target);
+
+ private:
+  static void RegisterProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void UnregisterProtocol(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsHandledProtocol(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void InterceptProtocol(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void UninterceptProtocol(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void RegisterProtocolInIO(const std::string& scheme);
+  static void UnregisterProtocolInIO(const std::string& scheme);
+
+  static void InterceptProtocolInIO(const std::string& scheme);
+  static void UninterceptProtocolInIO(const std::string& scheme);
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(Protocol);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_

browser/api/atom_api_window.cc

@@ -4,17 +4,19 @@
 
 #include "browser/api/atom_api_window.h"
 
-#include "base/values.h"
+#include "base/bind.h"
+#include "base/process/kill.h"
 #include "browser/native_window.h"
-#include "common/v8_value_converter_impl.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/render_process_host.h"
 #include "ui/gfx/point.h"
-#include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
-using content::V8ValueConverter;
+#include "common/v8/node_common.h"
+#include "vendor/node/src/node_buffer.h"
+
 using content::NavigationController;
 using node::ObjectWrap;
 
@@ -27,15 +29,6 @@ namespace atom {
 
 namespace api {
 
-namespace {
-
-// Converts string16 to V8 String.
-v8::Handle<v8::String> UTF16ToV8String(const string16& s) {
-  return v8::String::New(reinterpret_cast<const uint16_t*>(s.data()), s.size());
-}
-
-}  // namespace
-
 Window::Window(v8::Handle<v8::Object> wrapper, base::DictionaryValue* options)
     : EventEmitter(wrapper),
       window_(NativeWindow::Create(options)) {
@@ -56,6 +49,12 @@ void Window::OnPageTitleUpdated(bool* prevent_default,
   *prevent_default = Emit("page-title-updated", &args);
 }
 
+void Window::OnLoadingStateChanged(bool is_loading) {
+  base::ListValue args;
+  args.AppendBoolean(is_loading);
+  Emit("loading-state-changed", &args);
+}
+
 void Window::WillCloseWindow(bool* prevent_default) {
   *prevent_default = Emit("close");
 }
@@ -63,8 +62,9 @@ void Window::WillCloseWindow(bool* prevent_default) {
 void Window::OnWindowClosed() {
   Emit("closed");
 
-  // Free memory immediately when window is closed.
-  delete this;
+  // Free memory when native window is closed, the delete is delayed so other
+  // observers would not get a invalid pointer of NativeWindow.
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void Window::OnWindowBlur() {
@@ -79,578 +79,557 @@ void Window::OnRendererResponsive() {
   Emit("responsive");
 }
 
+void Window::OnRenderViewDeleted(int process_id, int routing_id) {
+  base::ListValue args;
+  args.AppendInteger(process_id);
+  args.AppendInteger(routing_id);
+  Emit("render-view-deleted", &args);
+}
+
 void Window::OnRendererCrashed() {
   Emit("crashed");
 }
 
-// static
-v8::Handle<v8::Value> Window::New(const v8::Arguments &args) {
-  v8::HandleScope scope;
+void Window::OnCapturePageDone(const RefCountedV8Function& callback,
+                               const std::vector<unsigned char>& data) {
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
 
+  v8::Local<v8::Value> buffer = node::Buffer::New(
+      reinterpret_cast<const char*>(data.data()),
+      data.size());
+  callback->NewHandle(node_isolate)->Call(
+      v8::Context::GetCurrent()->Global(), 1, &buffer);
+}
+
+// static
+void Window::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
 
-  if (!args[0]->IsObject())
-    return node::ThrowTypeError("Need options creating Window");
-
-  scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
-  scoped_ptr<base::Value> options(
-      converter->FromV8Value(args[0], v8::Context::GetCurrent()));
+  scoped_ptr<base::Value> options;
+  if (!FromV8Arguments(args, &options))
+    return node::ThrowTypeError("Bad argument");
 
   if (!options || !options->IsType(base::Value::TYPE_DICTIONARY))
-    return node::ThrowTypeError("Invalid options");
+    return node::ThrowTypeError("Options must be dictionary");
 
   new Window(args.This(), static_cast<base::DictionaryValue*>(options.get()));
 
-  return args.This();
+  // Give js code a chance to do initialization.
+  node::MakeCallback(args.This(), "_init", 0, NULL);
 }
 
 // static
-v8::Handle<v8::Value> Window::Destroy(const v8::Arguments &args) {
+void Window::Destroy(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
+  base::ProcessHandle handle = self->window_->GetRenderProcessHandle();
   delete self;
 
-  return v8::Undefined();
+  // Make sure the renderer process is terminated, it could happen that the
+  // renderer process became a zombie.
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(base::IgnoreResult(base::KillProcess), handle, 0, false),
+      base::TimeDelta::FromMilliseconds(5000));
 }
 
 // static
-v8::Handle<v8::Value> Window::Close(const v8::Arguments &args) {
+void Window::Close(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Close();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Focus(const v8::Arguments &args) {
+void Window::Focus(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Focus(args[0]->IsBoolean() ? args[0]->BooleanValue(): true);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsFocused(const v8::Arguments &args) {
+void Window::IsFocused(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-  return v8::Boolean::New(self->window_->IsFocused());
+  args.GetReturnValue().Set(self->window_->IsFocused());
 }
 
 // static
-v8::Handle<v8::Value> Window::Show(const v8::Arguments &args) {
+void Window::Show(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Show();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Hide(const v8::Arguments &args) {
+void Window::Hide(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Hide();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Maximize(const v8::Arguments &args) {
+void Window::IsVisible(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
+  return args.GetReturnValue().Set(self->window_->IsVisible());
+}
 
+// static
+void Window::Maximize(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  UNWRAP_WINDOW_AND_CHECK;
   self->window_->Maximize();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Unmaximize(const v8::Arguments &args) {
+void Window::Unmaximize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Unmaximize();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Minimize(const v8::Arguments &args) {
+void Window::Minimize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Minimize();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Restore(const v8::Arguments &args) {
+void Window::Restore(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Restore();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::SetFullscreen(const v8::Arguments &args) {
+void Window::SetFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1 || !args[0]->IsBoolean())
+  bool fs;
+  if (!FromV8Arguments(args, &fs))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetFullscreen(args[0]->BooleanValue());
 
-  return v8::Undefined();
+  self->window_->SetFullscreen(fs);
 }
 
 // static
-v8::Handle<v8::Value> Window::IsFullscreen(const v8::Arguments &args) {
+void Window::IsFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  return v8::Boolean::New(self->window_->IsFullscreen());
+  args.GetReturnValue().Set(self->window_->IsFullscreen());
 }
 
 // static
-v8::Handle<v8::Value> Window::SetSize(const v8::Arguments &args) {
+void Window::SetSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 2)
+  int width, height;
+  if (!FromV8Arguments(args, &width, &height))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetSize(
-      gfx::Size(args[0]->IntegerValue(), args[1]->IntegerValue()));
 
-  return v8::Undefined();
+  self->window_->SetSize(gfx::Size(width, height));
 }
 
 // static
-v8::Handle<v8::Value> Window::GetSize(const v8::Arguments &args) {
+void Window::GetSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Size size = self->window_->GetSize();
   v8::Handle<v8::Array> ret = v8::Array::New(2);
-  ret->Set(0, v8::Integer::New(size.width()));
-  ret->Set(1, v8::Integer::New(size.height()));
+  ret->Set(0, ToV8Value(size.width()));
+  ret->Set(1, ToV8Value(size.height()));
 
-  return ret;
+  args.GetReturnValue().Set(ret);
 }
 
 // static
-v8::Handle<v8::Value> Window::SetMinimumSize(const v8::Arguments &args) {
+void Window::SetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 2)
+  int width, height;
+  if (!FromV8Arguments(args, &width, &height))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetMinimumSize(
-      gfx::Size(args[0]->IntegerValue(), args[1]->IntegerValue()));
 
-  return v8::Undefined();
+  self->window_->SetMinimumSize(gfx::Size(width, height));
 }
 
 // static
-v8::Handle<v8::Value> Window::GetMinimumSize(const v8::Arguments &args) {
+void Window::GetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Size size = self->window_->GetMinimumSize();
   v8::Handle<v8::Array> ret = v8::Array::New(2);
-  ret->Set(0, v8::Integer::New(size.width()));
-  ret->Set(1, v8::Integer::New(size.height()));
+  ret->Set(0, ToV8Value(size.width()));
+  ret->Set(1, ToV8Value(size.height()));
 
-  return ret;
+  args.GetReturnValue().Set(ret);
 }
 
 // static
-v8::Handle<v8::Value> Window::SetMaximumSize(const v8::Arguments &args) {
+void Window::SetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 2)
+  int width, height;
+  if (!FromV8Arguments(args, &width, &height))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetMaximumSize(
-      gfx::Size(args[0]->IntegerValue(), args[1]->IntegerValue()));
 
-  return v8::Undefined();
+  self->window_->SetMaximumSize(gfx::Size(width, height));
 }
 
 // static
-v8::Handle<v8::Value> Window::GetMaximumSize(const v8::Arguments &args) {
+void Window::GetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Size size = self->window_->GetMaximumSize();
   v8::Handle<v8::Array> ret = v8::Array::New(2);
-  ret->Set(0, v8::Integer::New(size.width()));
-  ret->Set(1, v8::Integer::New(size.height()));
+  ret->Set(0, ToV8Value(size.width()));
+  ret->Set(1, ToV8Value(size.height()));
 
-  return ret;
+  args.GetReturnValue().Set(ret);
 }
 
 // static
-v8::Handle<v8::Value> Window::SetResizable(const v8::Arguments &args) {
+void Window::SetResizable(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1 || !args[0]->IsBoolean())
+  bool resizable;
+  if (!FromV8Arguments(args, &resizable))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetResizable(args[0]->BooleanValue());
 
-  return v8::Undefined();
+  self->window_->SetResizable(resizable);
 }
 
 // static
-v8::Handle<v8::Value> Window::IsResizable(const v8::Arguments &args) {
+void Window::IsResizable(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  return v8::Boolean::New(self->window_->IsResizable());
+  args.GetReturnValue().Set(self->window_->IsResizable());
 }
 
 // static
-v8::Handle<v8::Value> Window::SetAlwaysOnTop(const v8::Arguments &args) {
+void Window::SetAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1 || !args[0]->IsBoolean())
+  bool top;
+  if (!FromV8Arguments(args, &top))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetAlwaysOnTop(args[0]->BooleanValue());
 
-  return v8::Undefined();
+  self->window_->SetAlwaysOnTop(top);
 }
 
 // static
-v8::Handle<v8::Value> Window::IsAlwaysOnTop(const v8::Arguments &args) {
+void Window::IsAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  return v8::Boolean::New(self->window_->IsAlwaysOnTop());
+  args.GetReturnValue().Set(self->window_->IsAlwaysOnTop());
 }
 
 // static
-v8::Handle<v8::Value> Window::Center(const v8::Arguments &args) {
+void Window::Center(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Center();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::SetPosition(const v8::Arguments &args) {
+void Window::SetPosition(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 2)
+  int x, y;
+  if (!FromV8Arguments(args, &x, &y))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetPosition(
-      gfx::Point(args[0]->IntegerValue(), args[1]->IntegerValue()));
 
-  return v8::Undefined();
+  self->window_->SetPosition(gfx::Point(x, y));
 }
 
 // static
-v8::Handle<v8::Value> Window::GetPosition(const v8::Arguments &args) {
+void Window::GetPosition(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Point pos = self->window_->GetPosition();
   v8::Handle<v8::Array> ret = v8::Array::New(2);
-  ret->Set(0, v8::Integer::New(pos.x()));
-  ret->Set(1, v8::Integer::New(pos.y()));
+  ret->Set(0, ToV8Value(pos.x()));
+  ret->Set(1, ToV8Value(pos.y()));
 
-  return ret;
+  args.GetReturnValue().Set(ret);
 }
 
 // static
-v8::Handle<v8::Value> Window::SetTitle(const v8::Arguments &args) {
+void Window::SetTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1 || !args[0]->IsString())
+  std::string title;
+  if (!FromV8Arguments(args, &title))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetTitle(*v8::String::Utf8Value(args[0]));
 
-  return v8::Undefined();
+  self->window_->SetTitle(title);
 }
 
 // static
-v8::Handle<v8::Value> Window::GetTitle(const v8::Arguments &args) {
+void Window::GetTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  std::string title = self->window_->GetTitle();
-
-  return v8::String::New(title.c_str(), title.size());
+  args.GetReturnValue().Set(ToV8Value(self->window_->GetTitle()));
 }
 
 // static
-v8::Handle<v8::Value> Window::FlashFrame(const v8::Arguments &args) {
+void Window::FlashFrame(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->FlashFrame(
       args[0]->IsBoolean() ? args[0]->BooleanValue(): true);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::SetKiosk(const v8::Arguments &args) {
+void Window::SetKiosk(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1 || !args[0]->IsBoolean())
+  bool kiosk;
+  if (!FromV8Arguments(args, &kiosk))
     return node::ThrowTypeError("Bad argument");
-  self->window_->SetKiosk(args[0]->BooleanValue());
 
-  return v8::Undefined();
+  self->window_->SetKiosk(kiosk);
 }
 
 // static
-v8::Handle<v8::Value> Window::IsKiosk(const v8::Arguments &args) {
+void Window::IsKiosk(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  return v8::Boolean::New(self->window_->IsKiosk());
+  args.GetReturnValue().Set(self->window_->IsKiosk());
 }
 
 // static
-v8::Handle<v8::Value> Window::OpenDevTools(const v8::Arguments &args) {
+void Window::OpenDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->OpenDevTools();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::CloseDevTools(const v8::Arguments &args) {
+void Window::CloseDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->CloseDevTools();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::InspectElement(const v8::Arguments& args) {
+void Window::IsDevToolsOpened(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  self->window_->InspectElement(args[0]->IntegerValue(),
-                                args[1]->IntegerValue());
-
-  return v8::Undefined();
+  args.GetReturnValue().Set(self->window_->IsDevToolsOpened());
 }
 
 // static
-v8::Handle<v8::Value> Window::FocusOnWebView(const v8::Arguments &args) {
+void Window::InspectElement(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
+  int x, y;
+  if (!FromV8Arguments(args, &x, &y))
+    return node::ThrowTypeError("Bad argument");
+
+  self->window_->InspectElement(x, y);
+}
+
+// static
+void Window::DebugDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  UNWRAP_WINDOW_AND_CHECK;
+  self->window_->DebugDevTools();
+}
+
+// static
+void Window::FocusOnWebView(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  UNWRAP_WINDOW_AND_CHECK;
   self->window_->FocusOnWebView();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::BlurWebView(const v8::Arguments &args) {
+void Window::BlurWebView(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->BlurWebView();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::RestartHangMonitorTimeout(
-    const v8::Arguments &args) {
+void Window::IsWebViewFocused(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  self->window_->RestartHangMonitorTimeout();
-
-  return v8::Undefined();
+  args.GetReturnValue().Set(self->window_->IsWebViewFocused());
 }
 
 // static
-v8::Handle<v8::Value> Window::GetPageTitle(const v8::Arguments &args) {
+void Window::CapturePage(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  string16 title = self->window_->GetWebContents()->GetTitle();
+  gfx::Rect rect;
+  RefCountedV8Function callback;
+  if (!FromV8Arguments(args, &rect, &callback) &&
+      !FromV8Arguments(args, &callback))
+    return node::ThrowTypeError("Bad argument");
 
-  return UTF16ToV8String(title);
+  self->window_->CapturePage(rect, base::Bind(&Window::OnCapturePageDone,
+                                              base::Unretained(self),
+                                              callback));
 }
 
 // static
-v8::Handle<v8::Value> Window::IsLoading(const v8::Arguments &args) {
+void Window::GetPageTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  return v8::Boolean::New(self->window_->GetWebContents()->IsLoading());
+  args.GetReturnValue().Set(ToV8Value(
+      self->window_->GetWebContents()->GetTitle()));
 }
 
 // static
-v8::Handle<v8::Value> Window::IsWaitingForResponse(const v8::Arguments &args) {
+void Window::IsLoading(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
+  args.GetReturnValue().Set(self->window_->GetWebContents()->IsLoading());
+}
 
-  return v8::Boolean::New(
+// static
+void Window::IsWaitingForResponse(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  UNWRAP_WINDOW_AND_CHECK;
+  args.GetReturnValue().Set(
       self->window_->GetWebContents()->IsWaitingForResponse());
 }
 
 // static
-v8::Handle<v8::Value> Window::Stop(const v8::Arguments &args) {
+void Window::Stop(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->GetWebContents()->Stop();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetRoutingID(const v8::Arguments &args) {
+void Window::GetRoutingID(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  return v8::Integer::New(self->window_->GetWebContents()->GetRoutingID());
+  args.GetReturnValue().Set(self->window_->GetWebContents()->GetRoutingID());
 }
 
 // static
-v8::Handle<v8::Value> Window::GetProcessID(const v8::Arguments &args) {
+void Window::GetProcessID(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  return v8::Integer::New(
+  args.GetReturnValue().Set(
       self->window_->GetWebContents()->GetRenderProcessHost()->GetID());
 }
 
 // static
-v8::Handle<v8::Value> Window::IsCrashed(const v8::Arguments &args) {
+void Window::IsCrashed(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
-  return v8::Boolean::New(self->window_->GetWebContents()->IsCrashed());
+  args.GetReturnValue().Set(self->window_->GetWebContents()->IsCrashed());
 }
 
 // static
-v8::Handle<v8::Value> Window::LoadURL(const v8::Arguments &args) {
+void Window::LoadURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1 || !args[0]->IsString())
+  GURL url;
+  if (!FromV8Arguments(args, &url))
     return node::ThrowTypeError("Bad argument");
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
-  controller.LoadURL(GURL(*v8::String::Utf8Value(args[0])),
-                     content::Referrer(),
-                     content::PAGE_TRANSITION_AUTO_TOPLEVEL,
-                     std::string());
 
-  return v8::Undefined();
+  content::NavigationController::LoadURLParams params(url);
+  params.transition_type = content::PAGE_TRANSITION_TYPED;
+  params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
+  controller.LoadURLWithParams(params);
 }
 
 // static
-v8::Handle<v8::Value> Window::GetURL(const v8::Arguments &args) {
+void Window::GetURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
-  std::string url;
+  GURL url;
   if (controller.GetActiveEntry())
-    url = controller.GetActiveEntry()->GetVirtualURL().spec();
+    url = controller.GetActiveEntry()->GetVirtualURL();
 
-  return v8::String::New(url.c_str(), url.size());
+  args.GetReturnValue().Set(ToV8Value(url));
 }
 
 // static
-v8::Handle<v8::Value> Window::CanGoBack(const v8::Arguments &args) {
+void Window::CanGoBack(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
 
-  return v8::Boolean::New(controller.CanGoBack());
+  args.GetReturnValue().Set(controller.CanGoBack());
 }
 
 // static
-v8::Handle<v8::Value> Window::CanGoForward(const v8::Arguments &args) {
+void Window::CanGoForward(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
 
-  return v8::Boolean::New(controller.CanGoForward());
+  args.GetReturnValue().Set(controller.CanGoForward());
 }
 
 // static
-v8::Handle<v8::Value> Window::CanGoToOffset(const v8::Arguments &args) {
+void Window::CanGoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1)
+  int offset;
+  if (!FromV8Arguments(args, &offset))
     return node::ThrowTypeError("Bad argument");
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
-  int offset = args[0]->IntegerValue();
 
-  return v8::Boolean::New(controller.CanGoToOffset(offset));
+  args.GetReturnValue().Set(controller.CanGoToOffset(offset));
 }
 
 // static
-v8::Handle<v8::Value> Window::GoBack(const v8::Arguments &args) {
+void Window::GoBack(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.GoBack();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GoForward(const v8::Arguments &args) {
+void Window::GoForward(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.GoForward();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GoToIndex(const v8::Arguments &args) {
+void Window::GoToIndex(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1)
+  int index;
+  if (!FromV8Arguments(args, &index))
     return node::ThrowTypeError("Bad argument");
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
-  controller.GoToIndex(args[0]->IntegerValue());
-
-  return v8::Undefined();
+  controller.GoToIndex(index);
 }
 
 // static
-v8::Handle<v8::Value> Window::GoToOffset(const v8::Arguments &args) {
+void Window::GoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  if (args.Length() < 1)
+  int offset;
+  if (!FromV8Arguments(args, &offset))
     return node::ThrowTypeError("Bad argument");
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
-  controller.GoToOffset(args[0]->IntegerValue());
-
-  return v8::Undefined();
+  controller.GoToOffset(offset);
 }
 
 // static
-v8::Handle<v8::Value> Window::Reload(const v8::Arguments &args) {
+void Window::Reload(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.Reload(args[0]->IsBoolean() ? args[0]->BooleanValue(): false);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::ReloadIgnoringCache(const v8::Arguments &args) {
+void Window::ReloadIgnoringCache(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.ReloadIgnoringCache(
       args[0]->IsBoolean() ? args[0]->BooleanValue(): false);
-
-  return v8::Undefined();
 }
 
 // static
 void Window::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
-
   v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(Window::New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(v8::String::NewSymbol("BrowserWindow"));
@@ -661,6 +640,7 @@ void Window::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "isFocused", IsFocused);
   NODE_SET_PROTOTYPE_METHOD(t, "show", Show);
   NODE_SET_PROTOTYPE_METHOD(t, "hide", Hide);
+  NODE_SET_PROTOTYPE_METHOD(t, "isVisible", IsVisible);
   NODE_SET_PROTOTYPE_METHOD(t, "maximize", Maximize);
   NODE_SET_PROTOTYPE_METHOD(t, "unmaximize", Unmaximize);
   NODE_SET_PROTOTYPE_METHOD(t, "minimize", Minimize);
@@ -687,12 +667,13 @@ void Window::Initialize(v8::Handle<v8::Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "isKiosk", IsKiosk);
   NODE_SET_PROTOTYPE_METHOD(t, "openDevTools", OpenDevTools);
   NODE_SET_PROTOTYPE_METHOD(t, "closeDevTools", CloseDevTools);
+  NODE_SET_PROTOTYPE_METHOD(t, "isDevToolsOpened", IsDevToolsOpened);
   NODE_SET_PROTOTYPE_METHOD(t, "inspectElement", InspectElement);
+  NODE_SET_PROTOTYPE_METHOD(t, "debugDevTools", DebugDevTools);
   NODE_SET_PROTOTYPE_METHOD(t, "focusOnWebView", FocusOnWebView);
   NODE_SET_PROTOTYPE_METHOD(t, "blurWebView", BlurWebView);
-  NODE_SET_PROTOTYPE_METHOD(t,
-                            "restartHangMonitorTimeout",
-                            RestartHangMonitorTimeout);
+  NODE_SET_PROTOTYPE_METHOD(t, "isWebViewFocused", IsWebViewFocused);
+  NODE_SET_PROTOTYPE_METHOD(t, "capturePage", CapturePage);
 
   NODE_SET_PROTOTYPE_METHOD(t, "getPageTitle", GetPageTitle);
   NODE_SET_PROTOTYPE_METHOD(t, "isLoading", IsLoading);

browser/api/atom_api_window.h

@@ -5,9 +5,12 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_WINDOW_H_
 #define ATOM_BROWSER_API_ATOM_API_WINDOW_H_
 
+#include <vector>
+
 #include "base/memory/scoped_ptr.h"
-#include "browser/api/atom_api_event_emitter.h"
 #include "browser/native_window_observer.h"
+#include "common/api/atom_api_event_emitter.h"
+#include "common/v8/scoped_persistent.h"
 
 namespace base {
 class DictionaryValue;
@@ -35,76 +38,87 @@ class Window : public EventEmitter,
   // Implementations of NativeWindowObserver.
   virtual void OnPageTitleUpdated(bool* prevent_default,
                                   const std::string& title) OVERRIDE;
+  virtual void OnLoadingStateChanged(bool is_loading) OVERRIDE;
   virtual void WillCloseWindow(bool* prevent_default) OVERRIDE;
   virtual void OnWindowClosed() OVERRIDE;
   virtual void OnWindowBlur() OVERRIDE;
   virtual void OnRendererUnresponsive() OVERRIDE;
   virtual void OnRendererResponsive() OVERRIDE;
+  virtual void OnRenderViewDeleted(int process_id, int routing_id) OVERRIDE;
   virtual void OnRendererCrashed() OVERRIDE;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Destroy(const v8::Arguments &args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // APIs for NativeWindow.
-  static v8::Handle<v8::Value> Close(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Focus(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsFocused(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Show(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Hide(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Maximize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Unmaximize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Minimize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Restore(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetFullscreen(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsFullscreen(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetSize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetSize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetMinimumSize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetMinimumSize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetMaximumSize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetMaximumSize(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetResizable(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsResizable(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetAlwaysOnTop(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsAlwaysOnTop(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Center(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetPosition(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetPosition(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetTitle(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetTitle(const v8::Arguments &args);
-  static v8::Handle<v8::Value> FlashFrame(const v8::Arguments &args);
-  static v8::Handle<v8::Value> SetKiosk(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsKiosk(const v8::Arguments &args);
-  static v8::Handle<v8::Value> OpenDevTools(const v8::Arguments &args);
-  static v8::Handle<v8::Value> CloseDevTools(const v8::Arguments &args);
-  static v8::Handle<v8::Value> InspectElement(const v8::Arguments &args);
-  static v8::Handle<v8::Value> FocusOnWebView(const v8::Arguments &args);
-  static v8::Handle<v8::Value> BlurWebView(const v8::Arguments &args);
-  static v8::Handle<v8::Value> RestartHangMonitorTimeout(
-      const v8::Arguments &args);
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Focus(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsFocused(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Show(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Hide(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsVisible(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Maximize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Unmaximize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Minimize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Restore(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetResizable(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsResizable(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Center(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetPosition(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPosition(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FlashFrame(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetKiosk(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsKiosk(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void OpenDevTools(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CloseDevTools(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsDevToolsOpened(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void InspectElement(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DebugDevTools(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FocusOnWebView(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void BlurWebView(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsWebViewFocused(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CapturePage(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // APIs for WebContents.
-  static v8::Handle<v8::Value> GetPageTitle(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsLoading(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsWaitingForResponse(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Stop(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetRoutingID(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetProcessID(const v8::Arguments &args);
-  static v8::Handle<v8::Value> IsCrashed(const v8::Arguments &args);
+  static void GetPageTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsLoading(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsWaitingForResponse(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetRoutingID(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetProcessID(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void IsCrashed(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // APIs for NavigationController.
-  static v8::Handle<v8::Value> LoadURL(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GetURL(const v8::Arguments &args);
-  static v8::Handle<v8::Value> CanGoBack(const v8::Arguments &args);
-  static v8::Handle<v8::Value> CanGoForward(const v8::Arguments &args);
-  static v8::Handle<v8::Value> CanGoToOffset(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GoBack(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GoForward(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GoToIndex(const v8::Arguments &args);
-  static v8::Handle<v8::Value> GoToOffset(const v8::Arguments &args);
-  static v8::Handle<v8::Value> Reload(const v8::Arguments &args);
-  static v8::Handle<v8::Value> ReloadIgnoringCache(const v8::Arguments &args);
+  static void LoadURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CanGoBack(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CanGoForward(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CanGoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GoBack(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GoForward(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GoToIndex(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Reload(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void ReloadIgnoringCache(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // Called when capturePage is done.
+  void OnCapturePageDone(const RefCountedV8Function& callback,
+                         const std::vector<unsigned char>& data);
 
   scoped_ptr<NativeWindow> window_;
 

browser/api/atom_browser_bindings.cc

@@ -7,14 +7,11 @@
 #include <vector>
 
 #include "base/logging.h"
-#include "base/values.h"
-#include "common/v8_value_converter_impl.h"
+#include "browser/api/atom_api_event.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/browser_thread.h"
-#include "vendor/node/src/node.h"
-#include "vendor/node/src/node_internals.h"
 
-using content::V8ValueConverter;
-using node::node_isolate;
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -24,72 +21,60 @@ AtomBrowserBindings::AtomBrowserBindings() {
 AtomBrowserBindings::~AtomBrowserBindings() {
 }
 
-void AtomBrowserBindings::AfterLoad() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
-  v8::HandleScope scope;
-
-  v8::Handle<v8::Object> global = node::g_context->Global();
-  v8::Handle<v8::Object> atom =
-      global->Get(v8::String::New("__atom"))->ToObject();
-  DCHECK(!atom.IsEmpty());
-
-  browser_main_parts_ = v8::Persistent<v8::Object>::New(
-      node_isolate,
-      atom->Get(v8::String::New("browserMainParts"))->ToObject());
-  DCHECK(!browser_main_parts_.IsEmpty());
-}
-
 void AtomBrowserBindings::OnRendererMessage(int process_id,
                                             int routing_id,
-                                            const std::string& channel,
+                                            const string16& channel,
                                             const base::ListValue& args) {
-  v8::HandleScope scope;
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
 
-  v8::Handle<v8::Context> context = v8::Context::GetCurrent();
-
-  scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
+  scoped_ptr<V8ValueConverter> converter(new V8ValueConverter);
 
   // process.emit(channel, 'message', process_id, routing_id);
   std::vector<v8::Handle<v8::Value>> arguments;
   arguments.reserve(3 + args.GetSize());
-  arguments.push_back(v8::String::New(channel.c_str(), channel.size()));
+  arguments.push_back(ToV8Value(channel));
   const base::Value* value;
   if (args.Get(0, &value))
-    arguments.push_back(converter->ToV8Value(value, context));
+    arguments.push_back(converter->ToV8Value(value, global_env->context()));
   arguments.push_back(v8::Integer::New(process_id));
   arguments.push_back(v8::Integer::New(routing_id));
 
   for (size_t i = 1; i < args.GetSize(); i++) {
     const base::Value* value;
     if (args.Get(i, &value))
-      arguments.push_back(converter->ToV8Value(value, context));
+      arguments.push_back(converter->ToV8Value(value, global_env->context()));
   }
 
-  node::MakeCallback(node::process, "emit", arguments.size(), &arguments[0]);
+  node::MakeCallback(global_env->process_object(),
+                     "emit",
+                     arguments.size(),
+                     &arguments[0]);
 }
 
 void AtomBrowserBindings::OnRendererMessageSync(
     int process_id,
     int routing_id,
-    const std::string& channel,
+    const string16& channel,
     const base::ListValue& args,
-    base::DictionaryValue* result) {
-  v8::HandleScope scope;
+    NativeWindow* sender,
+    IPC::Message* message) {
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
 
-  v8::Handle<v8::Context> context = v8::Context::GetCurrent();
+  scoped_ptr<V8ValueConverter> converter(new V8ValueConverter);
 
-  scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
-
-  v8::Handle<v8::Object> event = v8::Object::New();
+  // Create the event object.
+  v8::Handle<v8::Object> event = api::Event::CreateV8Object();
+  api::Event::Unwrap<api::Event>(event)->SetSenderAndMessage(sender, message);
 
   // process.emit(channel, 'sync-message', event, process_id, routing_id);
   std::vector<v8::Handle<v8::Value>> arguments;
   arguments.reserve(3 + args.GetSize());
-  arguments.push_back(v8::String::New(channel.c_str(), channel.size()));
+  arguments.push_back(ToV8Value(channel));
   const base::Value* value;
   if (args.Get(0, &value))
-    arguments.push_back(converter->ToV8Value(value, context));
+    arguments.push_back(converter->ToV8Value(value, global_env->context()));
   arguments.push_back(event);
   arguments.push_back(v8::Integer::New(process_id));
   arguments.push_back(v8::Integer::New(routing_id));
@@ -97,15 +82,13 @@ void AtomBrowserBindings::OnRendererMessageSync(
   for (size_t i = 1; i < args.GetSize(); i++) {
     const base::Value* value;
     if (args.Get(i, &value))
-      arguments.push_back(converter->ToV8Value(value, context));
+      arguments.push_back(converter->ToV8Value(value, global_env->context()));
   }
 
-  node::MakeCallback(node::process, "emit", arguments.size(), &arguments[0]);
-
-  scoped_ptr<base::Value> base_event(converter->FromV8Value(event, context));
-  DCHECK(base_event && base_event->IsType(base::Value::TYPE_DICTIONARY));
-
-  result->Swap(static_cast<base::DictionaryValue*>(base_event.get()));
+  node::MakeCallback(global_env->process_object(),
+                     "emit",
+                     arguments.size(),
+                     &arguments[0]);
 }
 
 }  // namespace atom

browser/api/atom_browser_bindings.h

@@ -5,46 +5,42 @@
 #ifndef ATOM_BROWSER_API_ATOM_BROWSER_BINDINGS_
 #define ATOM_BROWSER_API_ATOM_BROWSER_BINDINGS_
 
-#include <string>
-
+#include "base/strings/string16.h"
 #include "common/api/atom_bindings.h"
+#include "common/v8/scoped_persistent.h"
 
 namespace base {
-class DictionaryValue;
 class ListValue;
 }
 
+namespace IPC {
+class Message;
+}
+
 namespace atom {
 
+class NativeWindow;
+
 class AtomBrowserBindings : public AtomBindings {
  public:
   AtomBrowserBindings();
   virtual ~AtomBrowserBindings();
 
-  // Called when the node.js main script has been loaded.
-  virtual void AfterLoad();
-
   // Called when received a message from renderer.
   void OnRendererMessage(int process_id,
                          int routing_id,
-                         const std::string& channel,
+                         const string16& channel,
                          const base::ListValue& args);
 
   // Called when received a synchronous message from renderer.
   void OnRendererMessageSync(int process_id,
                              int routing_id,
-                             const std::string& channel,
+                             const string16& channel,
                              const base::ListValue& args,
-                             base::DictionaryValue* result);
-
-  // The require('atom').browserMainParts object.
-  v8::Handle<v8::Object> browser_main_parts() {
-    return browser_main_parts_;
-  }
+                             NativeWindow* sender,
+                             IPC::Message* message);
 
  private:
-  v8::Persistent<v8::Object> browser_main_parts_;
-
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserBindings);
 };
 

browser/api/lib/app.coffee

@@ -1,6 +1,7 @@
-bindings = process.atomBinding 'app'
 EventEmitter = require('events').EventEmitter
 
+bindings = process.atomBinding 'app'
+
 Application = bindings.Application
 Application::__proto__ = EventEmitter.prototype
 
@@ -9,9 +10,25 @@ app = new Application
 app.getHomeDir = ->
   process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
 
+app.setApplicationMenu = (menu) ->
+  require('menu').setApplicationMenu menu
+
+app.getApplicationMenu = ->
+  require('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
+
+# Support old event name.
+app.once 'ready', -> app.emit 'finish-launching'
+
 # Only one App object pemitted.
 module.exports = app

browser/api/lib/atom-delegate.coffee

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

browser/api/lib/auto-updater.coffee

@@ -4,9 +4,22 @@ EventEmitter = require('events').EventEmitter
 AutoUpdater::__proto__ = EventEmitter.prototype
 
 autoUpdater = new AutoUpdater
-autoUpdater.on 'will-install-update-raw', (event, version) ->
-  @emit 'will-install-update', event, version, => @continueUpdate()
-autoUpdater.on 'ready-for-update-on-quit-raw', (event, version) ->
-  @emit 'ready-for-update-on-quit', event, version, => @quitAndInstall()
+autoUpdater.on 'update-downloaded-raw', (args...) ->
+  args[3] = new Date(args[3])  # releaseDate
+  @emit 'update-downloaded', args..., => @quitAndInstall()
+
+autoUpdater.quitAndInstall = ->
+  # If we don't have any window then quitAndInstall immediately.
+  BrowserWindow = require 'browser-window'
+  windows = BrowserWindow.getAllWindows()
+  if windows.length is 0
+    AutoUpdater::quitAndInstall.call this
+    return
+
+  # Do the restart after all windows have been closed.
+  app = require 'app'
+  app.removeAllListeners 'window-all-closed'
+  app.once 'window-all-closed', AutoUpdater::quitAndInstall.bind(this)
+  win.close() for win in windows
 
 module.exports = autoUpdater

browser/api/lib/browser-window.coffee

@@ -1,28 +1,57 @@
 EventEmitter = require('events').EventEmitter
-v8Util = process.atomBinding 'v8_util'
-objectsRegistry = require '../../atom/objects-registry.js'
+IDWeakMap = require 'id-weak-map'
+app = require 'app'
 
 BrowserWindow = process.atomBinding('window').BrowserWindow
 BrowserWindow::__proto__ = EventEmitter.prototype
 
+# Store all created windows in the weak map.
+BrowserWindow.windows = new IDWeakMap
+
+BrowserWindow::_init = ->
+  # Simulate the application menu on platforms other than OS X.
+  if process.platform isnt 'darwin'
+    menu = app.getApplicationMenu()
+    @setMenu menu if menu?
+
+  # Remember the window.
+  id = BrowserWindow.windows.add this
+
+  # Remove the window from weak map immediately when it's destroyed, since we
+  # could be iterating windows before GC happended.
+  @once 'destroyed', ->
+    BrowserWindow.windows.remove id if BrowserWindow.windows.has id
+
+  # Tell the rpc server that a render view has been deleted and we need to
+  # release all objects owned by it.
+  @on 'render-view-deleted', (event, processId, routingId) ->
+    process.emit 'ATOM_BROWSER_RELEASE_RENDER_VIEW', processId, routingId
+
 BrowserWindow::toggleDevTools = ->
-  opened = v8Util.getHiddenValue this, 'devtoolsOpened'
-  if opened
-    @closeDevTools()
-    v8Util.setHiddenValue this, 'devtoolsOpened', false
-  else
-    @openDevTools()
-    v8Util.setHiddenValue this, 'devtoolsOpened', true
+  if @isDevToolsOpened() then @closeDevTools() else @openDevTools()
 
 BrowserWindow::restart = ->
   @loadUrl(@getUrl())
 
+BrowserWindow::setMenu = (menu) ->
+  if process.platform is 'darwin'
+    throw new Error('BrowserWindow.setMenu is not available on OS X')
+
+  throw new TypeError('Invalid menu') unless menu?.constructor?.name is 'Menu'
+
+  @menu = menu  # Keep a reference of menu in case of GC.
+  @menu.attachToWindow this
+
+BrowserWindow.getAllWindows = ->
+  windows = BrowserWindow.windows
+  windows.get key for key in windows.keys()
+
 BrowserWindow.getFocusedWindow = ->
-  windows = objectsRegistry.getAllWindows()
+  windows = BrowserWindow.getAllWindows()
   return window for window in windows when window.isFocused()
 
 BrowserWindow.fromProcessIdAndRoutingId = (processId, routingId) ->
-  windows = objectsRegistry.getAllWindows()
+  windows = BrowserWindow.getAllWindows()
   return window for window in windows when window.getProcessId() == processId and
                                            window.getRoutingId() == routingId
 

browser/api/lib/crash-reporter.coffee

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

browser/api/lib/dialog.coffee

@@ -1,4 +1,5 @@
 binding = process.atomBinding 'dialog'
+v8Util = process.atomBinding 'v8_util'
 BrowserWindow = require 'browser-window'
 
 fileDialogProperties =
@@ -7,48 +8,71 @@ fileDialogProperties =
 messageBoxTypes = ['none', 'info', 'warning']
 
 module.exports =
-  showOpenDialog: (options) ->
-    options = title: 'Open', properties: ['openFile'] unless options?
-    options.properties = options.properties ? ['openFile']
+  showOpenDialog: (window, options, callback) ->
+    unless window?.constructor is BrowserWindow
+      # Shift.
+      callback = options
+      options = window
+      window = null
+
+    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.title ? ''
-    options.defaultPath = options.defaultPath ? ''
+    options.title ?= ''
+    options.defaultPath ?= ''
 
-    binding.showOpenDialog options.title, options.defaultPath, properties
+    binding.showOpenDialog String(options.title),
+                           String(options.defaultPath),
+                           properties,
+                           window,
+                           callback
 
-  showSaveDialog: (window, options) ->
-    throw new TypeError('Invalid window') unless window?.constructor is BrowserWindow
-    options = title: 'Save' unless options?
-
-    options.title = options.title ? ''
-    options.defaultPath = options.defaultPath ? ''
-
-    binding.showSaveDialog window, options.title, options.defaultPath
-
-  showMessageBox: (window, options) ->
-    if window? and window.constructor isnt BrowserWindow
+  showSaveDialog: (window, options, callback) ->
+    unless window?.constructor is BrowserWindow
+      # Shift.
+      callback = options
       options = window
       window = null
 
-    options = type: 'none' unless options?
-    options.type = options.type ? 'none'
+    options ?= title: 'Save'
+    options.title ?= ''
+    options.defaultPath ?= ''
+
+    binding.showSaveDialog String(options.title),
+                           String(options.defaultPath),
+                           window,
+                           callback
+
+  showMessageBox: (window, options, callback) ->
+    unless window?.constructor is BrowserWindow
+      # Shift.
+      callback = options
+      options = window
+      window = null
+
+    options ?= type: 'none'
+    options.type ?= 'none'
     options.type = messageBoxTypes.indexOf options.type
     throw new TypeError('Invalid message box type') unless options.type > -1
 
     throw new TypeError('Buttons need to be array') unless Array.isArray options.buttons
 
-    options.title = options.title ? ''
-    options.message = options.message ? ''
-    options.detail = options.detail ? ''
+    options.title ?= ''
+    options.message ?= ''
+    options.detail ?= ''
 
     binding.showMessageBox options.type,
                            options.buttons,
                            String(options.title),
                            String(options.message),
                            String(options.detail),
-                           window
+                           window,
+                           callback
+
+# Mark standard asynchronous functions.
+v8Util.setHiddenValue f, 'asynchronous', true for k, f of module.exports

browser/api/lib/ipc.coffee

@@ -5,17 +5,23 @@ sendWrap = (channel, processId, routingId, args...) ->
   BrowserWindow = require 'browser-window'
   if processId?.constructor is BrowserWindow
     window = processId
+    args = [routingId, args...]
     processId = window.getProcessId()
     routingId = window.getRoutingId()
 
-  send channel, processId, routingId, args...
+  send channel, processId, routingId, [args...]
 
 class Ipc extends EventEmitter
   constructor: ->
     process.on 'ATOM_INTERNAL_MESSAGE', (args...) =>
       @emit(args...)
-    process.on 'ATOM_INTERNAL_MESSAGE_SYNC', (args...) =>
-      @emit(args...)
+    process.on 'ATOM_INTERNAL_MESSAGE_SYNC', (channel, event, args...) =>
+      set = (value) -> event.sendReply JSON.stringify(value)
+
+      Object.defineProperty event, 'returnValue', {set}
+      Object.defineProperty event, 'result', {set}
+
+      @emit(channel, event, args...)
 
   send: (processId, routingId, args...) ->
     @sendChannel(processId, routingId, 'message', args...)

browser/api/lib/menu-item.coffee

@@ -1,3 +1,5 @@
+BrowserWindow = require 'browser-window'
+
 nextCommandId = 0
 
 class MenuItem
@@ -6,7 +8,7 @@ class MenuItem
   constructor: (options) ->
     Menu = require 'menu'
 
-    {click, selector, @type, @label, @sublabel, @accelerator, @enabled, @visible, @checked, @groupId, @submenu} = options
+    {click, @selector, @type, @label, @sublabel, @accelerator, @enabled, @visible, @checked, @groupId, @submenu} = options
 
     @type = 'submenu' if not @type? and @submenu?
     throw new Error('Invalid submenu') if @type is 'submenu' and @submenu?.constructor isnt Menu
@@ -14,16 +16,20 @@ class MenuItem
     @type = @type ? 'normal'
     @label = @label ? ''
     @sublabel = @sublabel ? ''
+    @accelerator = @accelerator ? null
     @enabled = @enabled ? true
     @visible = @visible ? true
+    @checked = @checked ? false
+    @groupId = @groupId ? null
+    @submenu = @submenu ? null
 
     throw new Error('Unknown menu type') if MenuItem.types.indexOf(@type) is -1
 
     @commandId = ++nextCommandId
-    @click = ->
+    @click = =>
       if typeof click is 'function'
-        click()
-      else if typeof selector is 'string'
-        Menu.sendActionToFirstResponder selector
+        click this, BrowserWindow.getFocusedWindow()
+      else if typeof @selector is 'string'
+        Menu.sendActionToFirstResponder @selector
 
 module.exports = MenuItem

browser/api/lib/menu.coffee

@@ -1,5 +1,5 @@
-EventEmitter = require('events').EventEmitter
 BrowserWindow = require 'browser-window'
+EventEmitter = require('events').EventEmitter
 MenuItem = require 'menu-item'
 
 bindings = process.atomBinding 'menu'
@@ -28,19 +28,32 @@ Menu::insert = (pos, item) ->
 
   @setSublabel pos, item.sublabel if item.sublabel?
 
-  unless @items?
-    @items = {}
+  unless @delegate?
+    @commandsMap = {}
+    @items = []
     @delegate =
-      isCommandIdChecked: (commandId) => @items[commandId]?.checked
-      isCommandIdEnabled: (commandId) => @items[commandId]?.enabled
-      isCommandIdVisible: (commandId) => @items[commandId]?.visible
-      getAcceleratorForCommandId: (commandId) => @items[commandId]?.accelerator
-      executeCommand: (commandId) => @items[commandId]?.click()
-  @items[item.commandId] = item
+      isCommandIdChecked: (commandId) => @commandsMap[commandId]?.checked
+      isCommandIdEnabled: (commandId) => @commandsMap[commandId]?.enabled
+      isCommandIdVisible: (commandId) => @commandsMap[commandId]?.visible
+      getAcceleratorForCommandId: (commandId) => @commandsMap[commandId]?.accelerator
+      executeCommand: (commandId) =>
+        activeItem = @commandsMap[commandId]
+        activeItem.click() if activeItem?
+  @items.splice pos, 0, item
+  @commandsMap[item.commandId] = item
 
+applicationMenu = null
 Menu.setApplicationMenu = (menu) ->
   throw new TypeError('Invalid menu') unless menu?.constructor is Menu
-  bindings.setApplicationMenu menu
+  applicationMenu = menu  # Keep a reference.
+
+  if process.platform is 'darwin'
+    bindings.setApplicationMenu menu
+  else
+    windows = BrowserWindow.getAllWindows()
+    w.setMenu menu for w in windows
+
+Menu.getApplicationMenu = -> applicationMenu
 
 Menu.sendActionToFirstResponder = bindings.sendActionToFirstResponder
 
@@ -52,7 +65,10 @@ Menu.buildFromTemplate = (template) ->
     throw new TypeError('Invalid template for MenuItem') unless typeof item is 'object'
 
     item.submenu = Menu.buildFromTemplate item.submenu if item.submenu?
-    menu.append new MenuItem(item)
+    menuItem = new MenuItem(item)
+    menuItem[key] = value for key, value of item when not menuItem[key]?
+
+    menu.append menuItem
 
   menu
 

browser/api/lib/power-monitor.coffee

@@ -0,0 +1,7 @@
+bindings = process.atomBinding 'power_monitor'
+EventEmitter = require('events').EventEmitter
+
+PowerMonitor = bindings.PowerMonitor
+PowerMonitor::__proto__ = EventEmitter.prototype
+
+module.exports = new PowerMonitor

browser/api/lib/protocol.coffee

@@ -0,0 +1,20 @@
+protocol = process.atomBinding 'protocol'
+EventEmitter = require('events').EventEmitter
+
+protocol[key] = value for key, value of EventEmitter.prototype
+
+protocol.RequestStringJob =
+class RequestStringJob
+  constructor: ({mimeType, charset, data}) ->
+    if typeof data isnt 'string' and not data instanceof Buffer
+      throw new TypeError('Data should be string or Buffer')
+
+    @mimeType = mimeType ? 'text/plain'
+    @charset = charset ? 'UTF-8'
+    @data = String data
+
+protocol.RequestFileJob =
+class RequestFileJob
+  constructor: (@path) ->
+
+module.exports = protocol

browser/atom/atom.coffee

@@ -1,60 +0,0 @@
-fs = require 'fs'
-path = require 'path'
-
-# Redirect node's console to use our own implementations, since node can not
-# handle output when running as GUI program.
-if process.platform is 'win32'
-  console.log = console.error = console.warn = process.log
-  process.stdout.write = process.stderr.write = process.log
-
-# Enable idle gc.
-process.atomBinding('idle_gc').start()
-
-# Provide default Content API implementations.
-atom = {}
-
-atom.browserMainParts =
-  preMainMessageLoopRun: ->
-    # This is the start of the whole application, usually we should initialize
-    # the main window here.
-
-# Store atom object in global scope, apps can just override methods of it to
-# implement various logics.
-global.__atom = atom
-
-# Add browser/api/lib to require's search paths,
-# which contains javascript part of Atom's built-in libraries.  
-globalPaths = require('module').globalPaths
-globalPaths.push path.join process.resourcesPath, 'browser', 'api', 'lib'
-
-# And also common/api/lib
-globalPaths.push path.join process.resourcesPath, 'common', 'api', 'lib'
-
-# Don't quit on fatal error.
-process.on 'uncaughtException', (error) ->
-  # Show error in GUI.
-  message = error.stack ? "#{error.name}: #{error.message}"
-  require('dialog').showMessageBox
-      type: 'warning'
-      title: 'An javascript error occured in the browser'
-      message: 'uncaughtException'
-      detail: message
-      buttons: ['OK']
-
-# Load the RPC server.
-require './rpc-server.js'
-
-# Now we try to load app's package.json.
-packageJson = null
-
-packagePath = path.join process.resourcesPath, 'app'
-try
-  # First we try to load process.resourcesPath/app
-  packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
-catch error
-  # If not found then we load browser/default_app
-  packagePath = path.join process.resourcesPath, 'browser', 'default_app'
-  packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
-
-# Finally load app's main.js and transfer control to C++.
-require path.join(packagePath, packageJson.main)

browser/atom/objects-registry.coffee

@@ -1,88 +0,0 @@
-BrowserWindow = require 'browser-window'
-IDWeakMap = require 'id-weak-map'
-v8Util = process.atomBinding 'v8_util'
-
-class ObjectsStore
-  @stores = {}
-
-  constructor: ->
-    @nextId = 1
-    @objects = []
-
-  getNextId: ->
-    ++@nextId
-
-  add: (obj) ->
-    id = @getNextId()
-    @objects[id] = obj
-    id
-
-  has: (id) ->
-    @objects[id]?
-
-  remove: (id) ->
-    throw new Error("Invalid key #{id} for ObjectsStore") unless @has id
-    delete @objects[id]
-
-  get: (id) ->
-    throw new Error("Invalid key #{id} for ObjectsStore") unless @has id
-    @objects[id]
-
-  @forRenderView: (processId, routingId) ->
-    key = "#{processId}_#{routingId}"
-    @stores[key] = new ObjectsStore unless @stores[key]?
-    @stores[key]
-
-  @releaseForRenderView: (processId, routingId) ->
-    key = "#{processId}_#{routingId}"
-    delete @stores[key]
-
-# Objects in weak map will be not referenced (so we won't leak memory), and
-# every object created in browser will have a unique id in weak map.
-objectsWeakMap = new IDWeakMap
-objectsWeakMap.add = (obj) ->
-  id = IDWeakMap::add.call this, obj
-  v8Util.setHiddenValue obj, 'atomId', id
-  id
-
-windowsWeakMap = new IDWeakMap
-
-process.on 'ATOM_BROWSER_INTERNAL_NEW', (obj) ->
-  # It's possible that user created a object in browser side and then want to
-  # get it in renderer via remote.getObject. So we must add every native object
-  # created in browser to the weak map even it may not be referenced by the
-  # renderer.
-  objectsWeakMap.add obj
-
-  # Also remember all windows.
-  if obj.constructor is BrowserWindow
-    id = windowsWeakMap.add obj
-    obj.on 'destroyed', ->
-      windowsWeakMap.remove id
-
-exports.add = (processId, routingId, obj) ->
-  # Some native objects may already been added to objectsWeakMap, be care not
-  # to add it twice.
-  objectsWeakMap.add obj unless v8Util.getHiddenValue obj, 'atomId'
-  id = v8Util.getHiddenValue obj, 'atomId'
-
-  # Store and reference the object, then return the storeId which points to
-  # where the object is stored. The caller can later dereference the object
-  # with the storeId.
-  store = ObjectsStore.forRenderView processId, routingId
-  storeId = store.add obj
-
-  [id, storeId]
-
-exports.get = (id) ->
-  objectsWeakMap.get id
-
-exports.getAllWindows = () ->
-  keys = windowsWeakMap.keys()
-  windowsWeakMap.get key for key in keys
-
-exports.remove = (processId, routingId, storeId) ->
-  ObjectsStore.forRenderView(processId, routingId).remove storeId
-
-exports.clear = (processId, routingId) ->
-  ObjectsStore.releaseForRenderView processId, routingId

browser/atom_browser_client.cc

@@ -4,18 +4,51 @@
 
 #include "browser/atom_browser_client.h"
 
+#include "base/command_line.h"
+#include "browser/atom_browser_context.h"
 #include "browser/atom_browser_main_parts.h"
-#include "browser/media/media_capture_devices_dispatcher.h"
-#include "webkit/glue/webpreferences.h"
+#include "browser/native_window.h"
+#include "browser/net/atom_url_request_context_getter.h"
+#include "browser/window_list.h"
+#include "common/options_switches.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/site_instance.h"
+#include "content/public/browser/web_contents.h"
+#include "webkit/common/webpreferences.h"
 
 namespace atom {
 
-AtomBrowserClient::AtomBrowserClient() {
+namespace {
+
+struct FindByProcessId {
+  explicit FindByProcessId(int child_process_id)
+      : child_process_id_(child_process_id) {
+  }
+
+  bool operator() (NativeWindow* const window) {
+    int id = window->GetWebContents()->GetRenderProcessHost()->GetID();
+    return id == child_process_id_;
+  }
+
+  int child_process_id_;
+};
+
+}  // namespace
+
+AtomBrowserClient::AtomBrowserClient()
+    : dying_render_process_(NULL) {
 }
 
 AtomBrowserClient::~AtomBrowserClient() {
 }
 
+net::URLRequestContextGetter* AtomBrowserClient::CreateRequestContext(
+    content::BrowserContext* browser_context,
+    content::ProtocolHandlerMap* protocol_handlers) {
+  return static_cast<AtomBrowserContext*>(browser_context)->
+      CreateRequestContext(protocol_handlers);
+}
+
 void AtomBrowserClient::OverrideWebkitPrefs(
     content::RenderViewHost* render_view_host,
     const GURL& url,
@@ -38,16 +71,46 @@ void AtomBrowserClient::OverrideWebkitPrefs(
   prefs->allow_running_insecure_content = true;
 }
 
-content::MediaObserver* AtomBrowserClient::GetMediaObserver() {
-  return MediaCaptureDevicesDispatcher::GetInstance();
-}
-
 bool AtomBrowserClient::ShouldSwapProcessesForNavigation(
     content::SiteInstance* site_instance,
     const GURL& current_url,
     const GURL& new_url) {
-  // Restart renderer process if navigating to the same url.
-  return current_url == new_url;
+  if (site_instance->HasProcess())
+    dying_render_process_ = site_instance->GetProcess();
+
+  // Restart renderer process for all navigations.
+  return true;
+}
+
+void AtomBrowserClient::AppendExtraCommandLineSwitches(
+    CommandLine* command_line,
+    int child_process_id) {
+  WindowList* list = WindowList::GetInstance();
+  NativeWindow* window = NULL;
+
+  // Find the owner of this child process.
+  WindowList::const_iterator iter = std::find_if(
+      list->begin(), list->end(), FindByProcessId(child_process_id));
+  if (iter != list->end())
+    window = *iter;
+
+  // If the render process is a newly started one, which means the window still
+  // uses the old going-to-be-swapped render process, then we try to find the
+  // window from the swapped render process.
+  if (window == NULL && dying_render_process_ != NULL) {
+    child_process_id = dying_render_process_->GetID();
+    WindowList::const_iterator iter = std::find_if(
+        list->begin(), list->end(), FindByProcessId(child_process_id));
+    if (iter != list->end())
+      window = *iter;
+  }
+
+  // Append --node-integration to renderer process.
+  if (window != NULL)
+    command_line->AppendSwitchASCII(switches::kNodeIntegration,
+                                    window->node_integration());
+
+  dying_render_process_ = NULL;
 }
 
 brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(

browser/atom_browser_client.h

@@ -15,19 +15,26 @@ class AtomBrowserClient : public brightray::BrowserClient {
   virtual ~AtomBrowserClient();
 
  protected:
+  net::URLRequestContextGetter* CreateRequestContext(
+      content::BrowserContext* browser_context,
+      content::ProtocolHandlerMap* protocol_handlers) OVERRIDE;
   virtual void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
                                    const GURL& url,
                                    WebPreferences* prefs) OVERRIDE;
-  virtual content::MediaObserver* GetMediaObserver() OVERRIDE;
   virtual bool ShouldSwapProcessesForNavigation(
       content::SiteInstance* site_instance,
       const GURL& current_url,
       const GURL& new_url) OVERRIDE;
+  virtual void AppendExtraCommandLineSwitches(CommandLine* command_line,
+                                              int child_process_id) OVERRIDE;
 
  private:
   virtual brightray::BrowserMainParts* OverrideCreateBrowserMainParts(
       const content::MainFunctionParams&) OVERRIDE;
 
+  // The render process which would be swapped out soon.
+  content::RenderProcessHost* dying_render_process_;
+
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
 };
 

browser/atom_browser_context.cc

@@ -5,15 +5,74 @@
 #include "browser/atom_browser_context.h"
 
 #include "browser/atom_browser_main_parts.h"
+#include "browser/net/atom_url_request_context_getter.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/resource_context.h"
+#include "vendor/brightray/browser/network_delegate.h"
 
 namespace atom {
 
-AtomBrowserContext::AtomBrowserContext() {
+using content::BrowserThread;
+
+class AtomResourceContext : public content::ResourceContext {
+ public:
+  AtomResourceContext() : getter_(NULL) {}
+
+  void set_url_request_context_getter(AtomURLRequestContextGetter* getter) {
+    getter_ = getter;
+  }
+
+ protected:
+  virtual net::HostResolver* GetHostResolver() OVERRIDE {
+    DCHECK(getter_);
+    return getter_->host_resolver();
+  }
+
+  virtual net::URLRequestContext* GetRequestContext() OVERRIDE {
+    DCHECK(getter_);
+    return getter_->GetURLRequestContext();
+  }
+
+  virtual bool AllowMicAccess(const GURL& origin) OVERRIDE {
+    return true;
+  }
+
+  virtual bool AllowCameraAccess(const GURL& origin) OVERRIDE {
+    return true;
+  }
+
+ private:
+  AtomURLRequestContextGetter* getter_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomResourceContext);
+};
+
+AtomBrowserContext::AtomBrowserContext()
+    : resource_context_(new AtomResourceContext) {
 }
 
 AtomBrowserContext::~AtomBrowserContext() {
 }
 
+AtomURLRequestContextGetter* AtomBrowserContext::CreateRequestContext(
+    content::ProtocolHandlerMap* protocol_handlers) {
+  DCHECK(!url_request_getter_);
+  url_request_getter_ = new AtomURLRequestContextGetter(
+      GetPath(),
+      BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::IO),
+      BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::FILE),
+      base::Bind(&AtomBrowserContext::CreateNetworkDelegate,
+                 base::Unretained(this)),
+      protocol_handlers);
+
+  resource_context_->set_url_request_context_getter(url_request_getter_.get());
+  return url_request_getter_.get();
+}
+
+content::ResourceContext* AtomBrowserContext::GetResourceContext() {
+  return resource_context_.get();
+}
+
 // static
 AtomBrowserContext* AtomBrowserContext::Get() {
   return static_cast<AtomBrowserContext*>(

browser/atom_browser_context.h

@@ -10,14 +10,34 @@
 
 namespace atom {
 
+class AtomResourceContext;
+class AtomURLRequestContextGetter;
+
 class AtomBrowserContext : public brightray::BrowserContext {
  public:
   AtomBrowserContext();
   virtual ~AtomBrowserContext();
 
+  // Returns the browser context singleton.
   static AtomBrowserContext* Get();
 
+  // Creates or returns the request context.
+  AtomURLRequestContextGetter* CreateRequestContext(
+      content::ProtocolHandlerMap*);
+
+  AtomURLRequestContextGetter* url_request_context_getter() const {
+    DCHECK(url_request_getter_);
+    return url_request_getter_.get();
+  }
+
+ protected:
+  // content::BrowserContext implementations:
+  virtual content::ResourceContext* GetResourceContext() OVERRIDE;
+
  private:
+  scoped_ptr<AtomResourceContext> resource_context_;
+  scoped_refptr<AtomURLRequestContextGetter> url_request_getter_;
+
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
 };
 

browser/atom_browser_main_parts.cc

@@ -9,8 +9,13 @@
 #include "browser/atom_browser_context.h"
 #include "browser/browser.h"
 #include "common/node_bindings.h"
-#include "vendor/node/src/node.h"
-#include "vendor/node/src/node_internals.h"
+#include "net/proxy/proxy_resolver_v8.h"
+
+#if defined(OS_WIN)
+#include "ui/gfx/win/dpi.h"
+#endif
+
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -43,33 +48,34 @@ void AtomBrowserMainParts::PostEarlyInitialization() {
 
   node_bindings_->Initialize();
 
+  v8::V8::Initialize();
+
+  // Create context.
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+  v8::Local<v8::Context> context = v8::Context::New(node_isolate);
+
+  // Create the global environment.
+  global_env = node_bindings_->CreateEnvironment(context);
+
   // Wrap whole process in one global context.
-  node::g_context->Enter();
+  context->Enter();
 
-  atom_bindings_->BindTo(node::process);
-
-  node_bindings_->Load();
-
-  atom_bindings_->AfterLoad();
+  // Add atom-shell extended APIs.
+  atom_bindings_->BindTo(global_env->process_object());
 }
 
 void AtomBrowserMainParts::PreMainMessageLoopRun() {
-  node_bindings_->PrepareMessageLoop();
-
   brightray::BrowserMainParts::PreMainMessageLoopRun();
 
-  {
-    v8::HandleScope scope;
-    v8::Context::Scope context_scope(node::g_context);
-
-    v8::Handle<v8::Value> args;
-    node::MakeCallback(atom_bindings_->browser_main_parts(),
-                       "preMainMessageLoopRun",
-                       0, &args);
-  }
-
+  node_bindings_->PrepareMessageLoop();
   node_bindings_->RunMessageLoop();
 
+  // Make sure the url request job factory is created before the
+  // will-finish-launching event.
+  static_cast<content::BrowserContext*>(AtomBrowserContext::Get())->
+      GetRequestContext();
+
 #if !defined(OS_MACOSX)
   // The corresponding call in OS X is in AtomApplicationDelegate.
   Browser::Get()->WillFinishLaunching();
@@ -77,4 +83,19 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
 #endif
 }
 
+int AtomBrowserMainParts::PreCreateThreads() {
+  // Note that we are overriding the PreCreateThreads of brightray, since we
+  // are integrating node in browser, we can just be sure that an V8 instance
+  // would be prepared, while the ProxyResolverV8::CreateIsolate() would
+  // try to create a V8 isolate, which messed everything on Windows, so we
+  // have to override and call RememberDefaultIsolate on Windows instead.
+  net::ProxyResolverV8::RememberDefaultIsolate();
+
+#if defined(OS_WIN)
+  gfx::EnableHighDPISupport();
+#endif
+
+  return 0;
+}
+
 }  // namespace atom

browser/atom_browser_main_parts.h

@@ -30,6 +30,7 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   // Implementations of content::BrowserMainParts.
   virtual void PostEarlyInitialization() OVERRIDE;
   virtual void PreMainMessageLoopRun() OVERRIDE;
+  virtual int PreCreateThreads() OVERRIDE;
 #if defined(OS_MACOSX)
   virtual void PreMainMessageLoopStart() OVERRIDE;
   virtual void PostDestroyThreads() OVERRIDE;

browser/atom_browser_main_parts_mac.mm

@@ -4,9 +4,11 @@
 
 #include "browser/atom_browser_main_parts.h"
 
-#import "base/mac/bundle_locations.h"
+#include "base/files/file_path.h"
+#import "base/mac/foundation_util.h"
 #import "browser/atom_application_mac.h"
 #import "browser/atom_application_delegate_mac.h"
+#import "vendor/brightray/common/mac/main_application_bundle.h"
 
 namespace atom {
 
@@ -17,10 +19,14 @@ void AtomBrowserMainParts::PreMainMessageLoopStart() {
   AtomApplicationDelegate* delegate = [AtomApplicationDelegate alloc];
   [NSApp setDelegate:delegate];
 
-  auto infoDictionary = base::mac::OuterBundle().infoDictionary;
-
-  NSString *mainNibName = [infoDictionary objectForKey:@"NSMainNibFile"];
-  auto mainNib = [[NSNib alloc] initWithNibNamed:mainNibName bundle:base::mac::FrameworkBundle()];
+  base::FilePath frameworkPath = brightray::MainApplicationBundlePath()
+      .Append("Contents")
+      .Append("Frameworks")
+      .Append("Atom Framework.framework");
+  NSBundle* frameworkBundle = [NSBundle
+       bundleWithPath:base::mac::FilePathToNSString(frameworkPath)];
+  NSNib* mainNib = [[NSNib alloc] initWithNibNamed:@"MainMenu"
+                                            bundle:frameworkBundle];
   [mainNib instantiateWithOwner:application topLevelObjects:nil];
   [mainNib release];
 

browser/atom_javascript_dialog_manager.cc

@@ -4,7 +4,7 @@
 
 #include "browser/atom_javascript_dialog_manager.h"
 
-#include "base/utf_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
 
 namespace atom {
 

browser/atom_javascript_dialog_manager.h

@@ -26,7 +26,9 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
       const string16& message_text,
       bool is_reload,
       const DialogClosedCallback& callback) OVERRIDE;
-  virtual void ResetJavaScriptState(
+  virtual void CancelActiveAndPendingDialogs(
+      content::WebContents* web_contents) OVERRIDE {}
+  virtual void WebContentsDestroyed(
       content::WebContents* web_contents) OVERRIDE {}
 };
 

browser/auto_updater.h

@@ -19,13 +19,8 @@ class AutoUpdater {
   static AutoUpdaterDelegate* GetDelegate();
   static void SetDelegate(AutoUpdaterDelegate* delegate);
 
-  static void Init();
-
   static void SetFeedURL(const std::string& url);
-  static void SetAutomaticallyChecksForUpdates(bool yes);
-  static void SetAutomaticallyDownloadsUpdates(bool yes);
   static void CheckForUpdates();
-  static void CheckForUpdatesInBackground();
 
  private:
   static AutoUpdaterDelegate* delegate_;

browser/auto_updater_delegate.cc

@@ -1,21 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/auto_updater_delegate.h"
-
-#include "base/callback.h"
-
-namespace auto_updater {
-
-void AutoUpdaterDelegate::WillInstallUpdate(const std::string& version,
-                                            const base::Closure& install) {
-  install.Run();
-}
-
-void AutoUpdaterDelegate::ReadyForUpdateOnQuit(
-    const std::string& version,
-    const base::Closure& quit_and_install) {
-}
-
-}  // namespace auto_updater

browser/auto_updater_delegate.h

@@ -9,17 +9,32 @@
 
 #include "base/callback_forward.h"
 
+namespace base {
+class Time;
+}
+
 namespace auto_updater {
 
 class AutoUpdaterDelegate {
  public:
-  // The application is going to relaunch to install update.
-  virtual void WillInstallUpdate(const std::string& version,
-                                 const base::Closure& install);
+  // An error happened.
+  virtual void OnError(const std::string& error) {}
 
-  // User has chosen to update on quit.
-  virtual void ReadyForUpdateOnQuit(const std::string& version,
-                                    const base::Closure& quit_and_install);
+  // Checking to see if there is an update
+  virtual void OnCheckingForUpdate() {}
+
+  // There is an update available and it is being downloaded
+  virtual void OnUpdateAvailable() {}
+
+  // There is no available update.
+  virtual void OnUpdateNotAvailable() {}
+
+  // There is a new update which has been downloaded.
+  virtual void OnUpdateDownloaded(const std::string& release_notes,
+                                  const std::string& release_name,
+                                  const base::Time& release_date,
+                                  const std::string& update_url,
+                                  const base::Closure& quit_and_install) {}
 
  protected:
   virtual ~AutoUpdaterDelegate() {}

browser/auto_updater_linux.cc

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

browser/auto_updater_mac.mm

@@ -4,106 +4,89 @@
 
 #include "browser/auto_updater.h"
 
-// Sparkle's headers are throwing compilation warnings, supress them.
-#pragma GCC diagnostic ignored "-Wmissing-method-return-type"
-#import <Sparkle/Sparkle.h>
+#import <ReactiveCocoa/RACCommand.h>
+#import <ReactiveCocoa/RACSignal.h>
+#import <ReactiveCocoa/NSObject+RACPropertySubscribing.h>
+#import <Squirrel/Squirrel.h>
 
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
 #include "base/strings/sys_string_conversions.h"
 #include "browser/auto_updater_delegate.h"
 
-using auto_updater::AutoUpdaterDelegate;
+#include <iostream>
+
+namespace auto_updater {
 
 namespace {
 
-struct NSInvocationDeleter {
-  inline void operator()(NSInvocation* invocation) const {
-    [invocation release];
-  }
-};
+// The gloal SQRLUpdater object.
+SQRLUpdater* g_updater = nil;
 
-typedef scoped_ptr<NSInvocation, NSInvocationDeleter> ScopedNSInvocation;
-
-// We are passing the NSInvocation as scoped_ptr, because we want to make sure
-// whether or not the callback is called, the NSInvocation should alwasy be
-// released, the only way to ensure it is to use scoped_ptr.
-void CallNSInvocation(ScopedNSInvocation invocation) {
-  [invocation.get() invoke];
+void RelaunchToInstallUpdate() {
+  [[g_updater relaunchToInstallUpdate] subscribeError:^(NSError* error) {
+    AutoUpdaterDelegate* delegate = AutoUpdater::GetDelegate();
+    if (delegate)
+      delegate->OnError(base::SysNSStringToUTF8(error.localizedDescription));
+  }];
 }
 
 }  // namespace
 
-@interface SUUpdaterDelegate : NSObject {
-}
-@end
-
-@implementation SUUpdaterDelegate
-
-- (BOOL)updater:(SUUpdater*)updater
-        shouldPostponeRelaunchForUpdate:(SUAppcastItem*)update
-        untilInvoking:(NSInvocation*)invocation {
-  AutoUpdaterDelegate* delegate = auto_updater::AutoUpdater::GetDelegate();
-  if (!delegate)
-    return NO;
-
-  std::string version(base::SysNSStringToUTF8([update versionString]));
-  ScopedNSInvocation invocation_ptr([invocation retain]);
-  delegate->WillInstallUpdate(
-      version,
-      base::Bind(&CallNSInvocation, base::Passed(invocation_ptr.Pass())));
-
-  return YES;
-}
-
-- (void)updater:(SUUpdater*)updater
-        willInstallUpdateOnQuit:(SUAppcastItem*)update
-        immediateInstallationInvocation:(NSInvocation*)invocation {
-  AutoUpdaterDelegate* delegate = auto_updater::AutoUpdater::GetDelegate();
-  if (!delegate)
-    return;
-
-  std::string version(base::SysNSStringToUTF8([update versionString]));
-  ScopedNSInvocation invocation_ptr([invocation retain]);
-  delegate->ReadyForUpdateOnQuit(
-      version,
-      base::Bind(&CallNSInvocation, base::Passed(invocation_ptr.Pass())));
-}
-
-@end
-
-namespace auto_updater {
-
 // static
-void AutoUpdater::Init() {
-  SUUpdaterDelegate* delegate = [[SUUpdaterDelegate alloc] init];
-  [[SUUpdater sharedUpdater] setDelegate:delegate];
-}
+void AutoUpdater::SetFeedURL(const std::string& feed) {
+  if (g_updater == nil) {
+    // Initialize the SQRLUpdater.
+    NSURL* url = [NSURL URLWithString:base::SysUTF8ToNSString(feed)];
+    NSURLRequest* urlRequest = [NSURLRequest requestWithURL:url];
+    g_updater = [[SQRLUpdater alloc] initWithUpdateRequest:urlRequest];
 
-// static
-void AutoUpdater::SetFeedURL(const std::string& url) {
-  NSString* url_str(base::SysUTF8ToNSString(url));
-  [[SUUpdater sharedUpdater] setFeedURL:[NSURL URLWithString:url_str]];
-}
+    AutoUpdaterDelegate* delegate = GetDelegate();
+    if (!delegate)
+      return;
 
-// static
-void AutoUpdater::SetAutomaticallyChecksForUpdates(bool yes) {
-  [[SUUpdater sharedUpdater] setAutomaticallyChecksForUpdates:yes];
-}
-
-// static
-void AutoUpdater::SetAutomaticallyDownloadsUpdates(bool yes) {
-  [[SUUpdater sharedUpdater] setAutomaticallyDownloadsUpdates:yes];
+    [[g_updater rac_valuesForKeyPath:@"state" observer:g_updater]
+      subscribeNext:^(NSNumber *stateNumber) {
+        int state = [stateNumber integerValue];
+        if (state == SQRLUpdaterStateCheckingForUpdate) {
+          delegate->OnCheckingForUpdate();
+        } else if (state == SQRLUpdaterStateDownloadingUpdate) {
+          delegate->OnUpdateAvailable();
+        }
+    }];
+  }
 }
 
 // static
 void AutoUpdater::CheckForUpdates() {
-  [[SUUpdater sharedUpdater] checkForUpdates:nil];
-}
+  AutoUpdaterDelegate* delegate = GetDelegate();
+  if (!delegate)
+    return;
 
-// static
-void AutoUpdater::CheckForUpdatesInBackground() {
-  [[SUUpdater sharedUpdater] checkForUpdatesInBackground];
+  [[[[g_updater.checkForUpdatesCommand
+      execute:nil]
+      // Send a `nil` after everything...
+      concat:[RACSignal return:nil]]
+      // But only take the first value. If an update is sent, we'll get that.
+      // Otherwise, we'll get our inserted `nil` value.
+      take:1]
+      subscribeNext:^(SQRLDownloadedUpdate *downloadedUpdate) {
+        if (downloadedUpdate) {
+          SQRLUpdate* update = downloadedUpdate.update;
+          // There is a new update that has been downloaded.
+          delegate->OnUpdateDownloaded(
+            base::SysNSStringToUTF8(update.releaseNotes),
+            base::SysNSStringToUTF8(update.releaseName),
+            base::Time::FromDoubleT(update.releaseDate.timeIntervalSince1970),
+            base::SysNSStringToUTF8(update.updateURL.absoluteString),
+            base::Bind(RelaunchToInstallUpdate));
+        } else {
+          // When the completed event is sent with no update, then we know there
+          // is no update available.
+          delegate->OnUpdateNotAvailable();
+        }
+      } error:^(NSError *error) {
+        delegate->OnError(base::SysNSStringToUTF8(error.localizedDescription));
+      }];
 }
-
 }  // namespace auto_updater

browser/auto_updater_win.cc

@@ -6,28 +6,12 @@
 
 namespace auto_updater {
 
-// static
-void AutoUpdater::Init() {
-}
-
 // static
 void AutoUpdater::SetFeedURL(const std::string& url) {
 }
 
-// static
-void AutoUpdater::SetAutomaticallyChecksForUpdates(bool yes) {
-}
-
-// static
-void AutoUpdater::SetAutomaticallyDownloadsUpdates(bool yes) {
-}
-
 // static
 void AutoUpdater::CheckForUpdates() {
 }
 
-// static
-void AutoUpdater::CheckForUpdatesInBackground() {
-}
-
 }  // namespace auto_updater

browser/browser.cc

@@ -33,6 +33,34 @@ void Browser::Quit() {
   window_list->CloseAllWindows();
 }
 
+std::string Browser::GetVersion() const {
+  if (version_override_.empty()) {
+    std::string version = GetExecutableFileVersion();
+    if (!version.empty())
+      return version;
+  }
+
+  return version_override_;
+}
+
+void Browser::SetVersion(const std::string& version) {
+  version_override_ = version;
+}
+
+std::string Browser::GetName() const {
+  if (name_override_.empty()) {
+    std::string name = GetExecutableFileProductName();
+    if (!name.empty())
+      return name;
+  }
+
+  return name_override_;
+}
+
+void Browser::SetName(const std::string& name) {
+  name_override_ = name;
+}
+
 bool Browser::OpenFile(const std::string& file_path) {
   bool prevent_default = false;
   FOR_EACH_OBSERVER(BrowserObserver,

browser/browser.h

@@ -31,7 +31,30 @@ class Browser : public WindowListObserver {
   void Focus();
 
   // Returns the version of the executable (or bundle).
-  std::string GetVersion();
+  std::string GetVersion() const;
+
+  // Overrides the application version.
+  void SetVersion(const std::string& version);
+
+  // Returns the application's name, default is just Atom-Shell.
+  std::string GetName() const;
+
+  // Overrides the application name.
+  void SetName(const std::string& name);
+
+#if defined(OS_MACOSX)
+  // Bounce the dock icon.
+  enum BounceType {
+    BOUNCE_CRITICAL = 0,
+    BOUNCE_INFORMATIONAL = 10,
+  };
+  int DockBounce(BounceType type);
+  void DockCancelBounce(int request_id);
+
+  // Set/Get dock's badge text.
+  void DockSetBadgeText(const std::string& label);
+  std::string DockGetBadgeText();
+#endif  // defined(OS_MACOSX)
 
   // Tell the application to open a file.
   bool OpenFile(const std::string& file_path);
@@ -54,6 +77,12 @@ class Browser : public WindowListObserver {
   bool is_quiting() const { return is_quiting_; }
 
  protected:
+  // Returns the version of application bundle or executable file.
+  std::string GetExecutableFileVersion() const;
+
+  // Returns the name of application bundle or executable file.
+  std::string GetExecutableFileProductName() const;
+
   // Send the will-quit message and then terminate the application.
   void NotifyAndTerminate();
 
@@ -70,6 +99,9 @@ class Browser : public WindowListObserver {
   // Observers of the browser.
   ObserverList<BrowserObserver> observers_;
 
+  std::string version_override_;
+  std::string name_override_;
+
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 

browser/browser_linux.cc

@@ -0,0 +1,44 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/browser.h"
+
+#include <stdlib.h>
+
+#include "browser/native_window.h"
+#include "browser/window_list.h"
+#include "common/atom_version.h"
+
+namespace atom {
+
+void Browser::Terminate() {
+  is_quiting_ = true;
+  exit(0);
+}
+
+void Browser::Focus() {
+  // Focus on the first visible window.
+  WindowList* list = WindowList::GetInstance();
+  for (WindowList::iterator iter = list->begin(); iter != list->end(); ++iter) {
+    NativeWindow* window = *iter;
+    if (window->IsVisible()) {
+      window->Focus(true);
+      break;
+    }
+  }
+}
+
+std::string Browser::GetExecutableFileVersion() const {
+  return ATOM_VERSION_STRING;
+}
+
+std::string Browser::GetExecutableFileProductName() const {
+  return "Atom-Shell";
+}
+
+void Browser::CancelQuit() {
+  // No way to cancel quit on Linux.
+}
+
+}  // namespace atom

browser/browser_mac.mm

@@ -19,14 +19,38 @@ void Browser::Focus() {
   [[AtomApplication sharedApplication] activateIgnoringOtherApps:YES];
 }
 
-std::string Browser::GetVersion() {
+std::string Browser::GetExecutableFileVersion() const {
   NSDictionary* infoDictionary = base::mac::OuterBundle().infoDictionary;
   NSString *version = [infoDictionary objectForKey:@"CFBundleVersion"];
   return base::SysNSStringToUTF8(version);
 }
 
+std::string Browser::GetExecutableFileProductName() const {
+  NSDictionary* infoDictionary = base::mac::OuterBundle().infoDictionary;
+  NSString *version = [infoDictionary objectForKey:@"CFBundleName"];
+  return base::SysNSStringToUTF8(version);
+}
+
 void Browser::CancelQuit() {
   [[AtomApplication sharedApplication] replyToApplicationShouldTerminate:NO];
 }
 
+int Browser::DockBounce(BounceType type) {
+  return [[AtomApplication sharedApplication] requestUserAttention:type];
+}
+
+void Browser::DockCancelBounce(int rid) {
+  [[AtomApplication sharedApplication] cancelUserAttentionRequest:rid];
+}
+
+void Browser::DockSetBadgeText(const std::string& label) {
+  NSDockTile *tile = [[AtomApplication sharedApplication] dockTile];
+  [tile setBadgeLabel:base::SysUTF8ToNSString(label)];
+}
+
+std::string Browser::DockGetBadgeText() {
+  NSDockTile *tile = [[AtomApplication sharedApplication] dockTile];
+  return base::SysNSStringToUTF8([tile badgeLabel]);
+}
+
 }  // namespace atom

browser/browser_win.cc

@@ -12,6 +12,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
+#include "common/atom_version.h"
 
 namespace atom {
 
@@ -43,7 +44,7 @@ void Browser::Focus() {
   EnumWindows(&WindowsEnumerationHandler, reinterpret_cast<LPARAM>(&pid));
 }
 
-std::string Browser::GetVersion() {
+std::string Browser::GetExecutableFileVersion() const {
   base::FilePath path;
   if (PathService::Get(base::FILE_EXE, &path)) {
     scoped_ptr<FileVersionInfo> version_info(
@@ -51,7 +52,18 @@ std::string Browser::GetVersion() {
     return UTF16ToUTF8(version_info->product_version());
   }
 
-  return "";
+  return ATOM_VERSION_STRING;
+}
+
+std::string Browser::GetExecutableFileProductName() const {
+  base::FilePath path;
+  if (PathService::Get(base::FILE_EXE, &path)) {
+    scoped_ptr<FileVersionInfo> version_info(
+        FileVersionInfo::CreateFileVersionInfo(path));
+    return UTF16ToUTF8(version_info->product_name());
+  }
+
+  return "Atom-Shell";
 }
 
 void Browser::CancelQuit() {

browser/crash_reporter.h

@@ -1,26 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_CRASH_REPORTER_H_
-#define ATOM_BROWSER_CRASH_REPORTER_H_
-
-#include <string>
-
-#include "base/basictypes.h"
-
-namespace crash_reporter {
-
-class CrashReporter {
- public:
-  static void SetCompanyName(const std::string& name);
-  static void SetSubmissionURL(const std::string& url);
-  static void SetAutoSubmit(bool yes);
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(CrashReporter);
-};
-
-}  // namespace crash_reporter
-
-#endif  // ATOM_BROWSER_CRASH_REPORTER_H_

browser/crash_reporter_mac.mm

@@ -1,31 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/crash_reporter.h"
-
-#import <Quincy/BWQuincyManager.h>
-
-#include "base/strings/sys_string_conversions.h"
-
-namespace crash_reporter {
-
-// static
-void CrashReporter::SetCompanyName(const std::string& name) {
-  BWQuincyManager *manager = [BWQuincyManager sharedQuincyManager];
-  [manager setCompanyName:base::SysUTF8ToNSString(name)];
-}
-
-// static
-void CrashReporter::SetSubmissionURL(const std::string& url) {
-  BWQuincyManager *manager = [BWQuincyManager sharedQuincyManager];
-  [manager setSubmissionURL:base::SysUTF8ToNSString(url)];
-}
-
-// static
-void CrashReporter::SetAutoSubmit(bool yes) {
-  BWQuincyManager *manager = [BWQuincyManager sharedQuincyManager];
-  [manager setAutoSubmitCrashReport:yes];
-}
-
-}  // namespace crash_reporter

browser/crash_reporter_win.cc

@@ -1,22 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/crash_reporter.h"
-
-namespace crash_reporter {
-
-// static
-void CrashReporter::SetCompanyName(const std::string& name) {
-}
-
-// static
-void CrashReporter::SetSubmissionURL(const std::string& url) {
-}
-
-// static
-void CrashReporter::SetAutoSubmit(bool yes) {
-}
-
-}  // namespace crash_reporter
-

browser/default_app/default_app.js

@@ -1,6 +1,5 @@
 var app = require('app');
 var dialog = require('dialog');
-var delegate = require('atom-delegate');
 var ipc = require('ipc');
 var Menu = require('menu');
 var MenuItem = require('menu-item');
@@ -18,7 +17,7 @@ app.on('open-url', function(event, url) {
   dialog.showMessageBox({message: url, buttons: ['OK']});
 });
 
-app.on('finish-launching', function() {
+app.on('ready', function() {
   app.commandLine.appendSwitch('js-flags', '--harmony_collections');
 
   mainWindow = new BrowserWindow({ width: 800, height: 600 });
@@ -31,7 +30,6 @@ app.on('finish-launching', function() {
   });
 
   mainWindow.on('closed', function() {
-    console.log('closed');
     mainWindow = null;
   });
 
@@ -39,124 +37,165 @@ app.on('finish-launching', function() {
     console.log('unresponsive');
   });
 
-  var template = [
-    {
-      label: 'Atom Shell',
-      submenu: [
-        {
-          label: 'About Atom Shell',
-          selector: 'orderFrontStandardAboutPanel:'
-        },
-        {
-          type: 'separator'
-        },
-        {
-          label: 'Hide Atom Shell',
-          accelerator: 'Command+H',
-          selector: 'hide:'
-        },
-        {
-          label: 'Hide Others',
-          accelerator: 'Command+Shift+H',
-          selector: 'hideOtherApplications:'
-        },
-        {
-          label: 'Show All',
-          selector: 'unhideAllApplications:'
-        },
-        {
-          type: 'separator'
-        },
-        {
-          label: 'Quit',
-          accelerator: 'Command+Q',
-          click: function() { app.quit(); }
-        },
-      ]
-    },
-    {
-      label: 'Edit',
-      submenu: [
-        {
-          label: 'Undo',
-          accelerator: 'Command+Z',
-          selector: 'undo:'
-        },
-        {
-          label: 'Redo',
-          accelerator: 'Shift+Command+Z',
-          selector: 'redo:'
-        },
-        {
-          type: 'separator'
-        },
-        {
-          label: 'Cut',
-          accelerator: 'Command+X',
-          selector: 'cut:'
-        },
-        {
-          label: 'Copy',
-          accelerator: 'Command+C',
-          selector: 'copy:'
-        },
-        {
-          label: 'Paste',
-          accelerator: 'Command+V',
-          selector: 'paste:'
-        },
-        {
-          label: 'Select All',
-          accelerator: 'Command+A',
-          selector: 'selectAll:'
-        },
-      ]
-    },
-    {
-      label: 'View',
-      submenu: [
-        {
-          label: 'Reload',
-          accelerator: 'Command+R',
-          click: function() { BrowserWindow.getFocusedWindow().restart(); }
-        },
-        {
-          label: 'Enter Fullscreen',
-          click: function() { BrowserWindow.getFocusedWindow().setFullscreen(true); }
-        },
-        {
-          label: 'Toggle DevTools',
-          accelerator: 'Alt+Command+I',
-          click: function() { BrowserWindow.getFocusedWindow().toggleDevTools(); }
-        },
-      ]
-    },
-    {
-      label: 'Window',
-      submenu: [
-        {
-          label: 'Minimize',
-          accelerator: 'Command+M',
-          selector: 'performMiniaturize:'
-        },
-        {
-          label: 'Close',
-          accelerator: 'Command+W',
-          selector: 'performClose:'
-        },
-        {
-          type: 'separator'
-        },
-        {
-          label: 'Bring All to Front',
-          selector: 'arrangeInFront:'
-        },
-      ]
-    },
-  ];
+  if (process.platform == 'darwin') {
+    var template = [
+      {
+        label: 'Atom Shell',
+        submenu: [
+          {
+            label: 'About Atom Shell',
+            selector: 'orderFrontStandardAboutPanel:'
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Hide Atom Shell',
+            accelerator: 'Command+H',
+            selector: 'hide:'
+          },
+          {
+            label: 'Hide Others',
+            accelerator: 'Command+Shift+H',
+            selector: 'hideOtherApplications:'
+          },
+          {
+            label: 'Show All',
+            selector: 'unhideAllApplications:'
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Quit',
+            accelerator: 'Command+Q',
+            click: function() { app.quit(); }
+          },
+        ]
+      },
+      {
+        label: 'Edit',
+        submenu: [
+          {
+            label: 'Undo',
+            accelerator: 'Command+Z',
+            selector: 'undo:'
+          },
+          {
+            label: 'Redo',
+            accelerator: 'Shift+Command+Z',
+            selector: 'redo:'
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Cut',
+            accelerator: 'Command+X',
+            selector: 'cut:'
+          },
+          {
+            label: 'Copy',
+            accelerator: 'Command+C',
+            selector: 'copy:'
+          },
+          {
+            label: 'Paste',
+            accelerator: 'Command+V',
+            selector: 'paste:'
+          },
+          {
+            label: 'Select All',
+            accelerator: 'Command+A',
+            selector: 'selectAll:'
+          },
+        ]
+      },
+      {
+        label: 'View',
+        submenu: [
+          {
+            label: 'Reload',
+            accelerator: 'Command+R',
+            click: function() { BrowserWindow.getFocusedWindow().restart(); }
+          },
+          {
+            label: 'Enter Fullscreen',
+            click: function() { BrowserWindow.getFocusedWindow().setFullscreen(true); }
+          },
+          {
+            label: 'Toggle DevTools',
+            accelerator: 'Alt+Command+I',
+            click: function() { BrowserWindow.getFocusedWindow().toggleDevTools(); }
+          },
+        ]
+      },
+      {
+        label: 'Window',
+        submenu: [
+          {
+            label: 'Minimize',
+            accelerator: 'Command+M',
+            selector: 'performMiniaturize:'
+          },
+          {
+            label: 'Close',
+            accelerator: 'Command+W',
+            selector: 'performClose:'
+          },
+          {
+            type: 'separator'
+          },
+          {
+            label: 'Bring All to Front',
+            selector: 'arrangeInFront:'
+          },
+        ]
+      },
+    ];
 
-  menu = Menu.buildFromTemplate(template);
-  Menu.setApplicationMenu(menu);
+    menu = Menu.buildFromTemplate(template);
+    Menu.setApplicationMenu(menu);
+  } else {
+    var template = [
+      {
+        label: 'File',
+        submenu: [
+          {
+            label: 'Open',
+            accelerator: 'Command+O',
+          },
+          {
+            label: 'Close',
+            accelerator: 'Command+W',
+            click: function() { mainWindow.close(); }
+          },
+        ]
+      },
+      {
+        label: 'View',
+        submenu: [
+          {
+            label: 'Reload',
+            accelerator: 'Command+R',
+            click: function() { mainWindow.restart(); }
+          },
+          {
+            label: 'Enter Fullscreen',
+            click: function() { mainWindow.setFullscreen(true); }
+          },
+          {
+            label: 'Toggle DevTools',
+            accelerator: 'Alt+Command+I',
+            click: function() { mainWindow.toggleDevTools(); }
+          },
+        ]
+      },
+    ];
+
+    menu = Menu.buildFromTemplate(template);
+    mainWindow.setMenu(menu);
+  }
 
   ipc.on('message', function(processId, routingId, type) {
     if (type == 'menu')

browser/default_app/index.html

@@ -7,7 +7,6 @@
   This is the default mode of Atom Shell, please follow the instructions in
   wiki to get started.
   <script type="text/javascript" charset="utf-8">
-
     var ipc = require('ipc');
 
     window.addEventListener('contextmenu', function (e) {

browser/default_app/main.js

@@ -1,6 +1,14 @@
-var argv = require('optimist').argv;
-var dialog = require('dialog');
+var app = require('app');
 var path = require('path');
+var optimist = require('optimist');
+
+// Quit when all windows are closed and no other one is listening to this.
+app.on('window-all-closed', function() {
+  if (app.listeners('window-all-closed').length == 1)
+    app.quit();
+});
+
+var argv = optimist(process.argv.slice(1)).boolean('ci').argv;
 
 // Start the specified app if there is one specified in command line, otherwise
 // start the default app.
@@ -9,12 +17,16 @@ if (argv._.length > 0) {
     require(path.resolve(argv._[0]));
   } catch(e) {
     if (e.code == 'MODULE_NOT_FOUND') {
+      console.error(e.stack);
       console.error('Specified app is invalid');
       process.exit(1);
     } else {
       throw e;
     }
   }
+} else if (argv.version) {
+  console.log('v' + process.versions['atom-shell']);
+  process.exit(0);
 } else {
   require('./default_app.js');
 }

browser/default_app/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "atom",
+  "name": "atom-shell-default-app",
   "version": "0.1.0",
   "main": "main.js",
   "dependencies": {

browser/devtools_delegate.cc

@@ -0,0 +1,63 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/devtools_delegate.h"
+
+#include "base/values.h"
+#include "browser/native_window.h"
+#include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/devtools_client_host.h"
+#include "content/public/browser/devtools_http_handler.h"
+#include "content/public/browser/devtools_manager.h"
+#include "content/public/browser/web_contents.h"
+
+namespace atom {
+
+DevToolsDelegate::DevToolsDelegate(NativeWindow* window,
+                                   content::WebContents* target_web_contents)
+    : content::WebContentsObserver(window->GetWebContents()),
+      owner_window_(window) {
+  content::WebContents* web_contents = window->GetWebContents();
+
+  // Setup devtools.
+  devtools_agent_host_ = content::DevToolsAgentHost::GetOrCreateFor(
+      target_web_contents->GetRenderViewHost());
+  devtools_client_host_.reset(
+      content::DevToolsClientHost::CreateDevToolsFrontendHost(web_contents,
+                                                              this));
+  content::DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(
+      devtools_agent_host_.get(), devtools_client_host_.get());
+
+  // Go!
+  base::DictionaryValue options;
+  options.SetString("title", "DevTools Debugger");
+  window->InitFromOptions(&options);
+  web_contents->GetController().LoadURL(
+      GURL("chrome-devtools://devtools/devtools.html"),
+      content::Referrer(),
+      content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+      std::string());
+}
+
+DevToolsDelegate::~DevToolsDelegate() {
+}
+
+void DevToolsDelegate::DispatchOnEmbedder(const std::string& message) {
+}
+
+void DevToolsDelegate::InspectedContentsClosing() {
+  delete owner_window_;
+}
+
+void DevToolsDelegate::AboutToNavigateRenderView(
+      content::RenderViewHost* render_view_host) {
+  content::DevToolsClientHost::SetupDevToolsFrontendClient(
+      owner_window_->GetWebContents()->GetRenderViewHost());
+}
+
+void DevToolsDelegate::OnWindowClosed() {
+  delete owner_window_;
+}
+
+}  // namespace atom

browser/devtools_delegate.h

@@ -0,0 +1,53 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_DEVTOOLS_DELEGATE_H_
+#define ATOM_BROWSER_DEVTOOLS_DELEGATE_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "browser/native_window_observer.h"
+#include "content/public/browser/devtools_frontend_host_delegate.h"
+#include "content/public/browser/web_contents_observer.h"
+
+namespace content {
+class DevToolsAgentHost;
+class DevToolsClientHost;
+}
+
+namespace atom {
+
+class NativeWindow;
+
+class DevToolsDelegate : public content::DevToolsFrontendHostDelegate,
+                         public content::WebContentsObserver,
+                         public NativeWindowObserver {
+ public:
+  DevToolsDelegate(NativeWindow* window,
+                   content::WebContents* target_web_contents);
+  virtual ~DevToolsDelegate();
+
+ protected:
+  // Implementations of content::DevToolsFrontendHostDelegate.
+  virtual void DispatchOnEmbedder(const std::string& message) OVERRIDE;
+  virtual void InspectedContentsClosing() OVERRIDE;
+
+  // Implementations of content::WebContentsObserver.
+  virtual void AboutToNavigateRenderView(
+      content::RenderViewHost* render_view_host) OVERRIDE;
+
+  // Implementations of NativeWindowObserver.
+  virtual void OnWindowClosed() OVERRIDE;
+
+ private:
+  NativeWindow* owner_window_;
+
+  scoped_refptr<content::DevToolsAgentHost> devtools_agent_host_;
+  scoped_ptr<content::DevToolsClientHost> devtools_client_host_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_DEVTOOLS_DELEGATE_H_

browser/file_dialog.h

@@ -1,38 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BROWSER_FILE_DIALOG_H_
-#define BROWSER_FILE_DIALOG_H_
-
-#include <string>
-#include <vector>
-
-#include "base/files/file_path.h"
-
-namespace atom {
-class NativeWindow;
-}
-
-namespace file_dialog {
-
-enum FileDialogProperty {
-  FILE_DIALOG_OPEN_FILE        = 1,
-  FILE_DIALOG_OPEN_DIRECTORY   = 2,
-  FILE_DIALOG_MULTI_SELECTIONS = 4,
-  FILE_DIALOG_CREATE_DIRECTORY = 8,
-};
-
-bool ShowOpenDialog(const std::string& title,
-                    const base::FilePath& default_path,
-                    int properties,
-                    std::vector<base::FilePath>* paths);
-
-bool ShowSaveDialog(atom::NativeWindow* window,
-                    const std::string& title,
-                    const base::FilePath& default_path,
-                    base::FilePath* path);
-
-}  // namespace file_dialog
-
-#endif  // BROWSER_FILE_DIALOG_H_

browser/file_dialog_mac.mm

@@ -1,107 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/file_dialog.h"
-
-#import <Cocoa/Cocoa.h>
-#include <CoreServices/CoreServices.h>
-
-#include "base/file_util.h"
-#include "base/strings/sys_string_conversions.h"
-#include "browser/native_window.h"
-
-namespace file_dialog {
-
-namespace {
-
-void SetupDialog(NSSavePanel* dialog,
-                 const std::string& title,
-                 const base::FilePath& default_path) {
-  if (!title.empty())
-    [dialog setTitle:base::SysUTF8ToNSString(title)];
-
-  NSString* default_dir = nil;
-  NSString* default_filename = nil;
-  if (!default_path.empty()) {
-    if (file_util::DirectoryExists(default_path)) {
-      default_dir = base::SysUTF8ToNSString(default_path.value());
-    } else {
-      default_dir = base::SysUTF8ToNSString(default_path.DirName().value());
-      default_filename =
-          base::SysUTF8ToNSString(default_path.BaseName().value());
-    }
-  }
-
-  if (default_dir)
-    [dialog setDirectoryURL:[NSURL fileURLWithPath:default_dir]];
-  if (default_filename)
-    [dialog setNameFieldStringValue:default_filename];
-
-  [dialog setAllowsOtherFileTypes:YES];
-}
-
-}  // namespace
-
-bool ShowOpenDialog(const std::string& title,
-                    const base::FilePath& default_path,
-                    int properties,
-                    std::vector<base::FilePath>* paths) {
-  DCHECK(paths);
-  NSOpenPanel* dialog = [NSOpenPanel openPanel];
-
-  SetupDialog(dialog, title, default_path);
-
-  [dialog setCanChooseFiles:(properties & FILE_DIALOG_OPEN_FILE)];
-  if (properties & FILE_DIALOG_OPEN_DIRECTORY)
-    [dialog setCanChooseDirectories:YES];
-  if (properties & FILE_DIALOG_CREATE_DIRECTORY)
-    [dialog setCanCreateDirectories:YES];
-  if (properties & FILE_DIALOG_MULTI_SELECTIONS)
-    [dialog setAllowsMultipleSelection:YES];
-
-  if ([dialog runModal] == NSFileHandlingPanelCancelButton)
-    return false;
-
-  NSArray* urls = [dialog URLs];
-  for (NSURL* url in urls)
-    if ([url isFileURL])
-      paths->push_back(base::FilePath(base::SysNSStringToUTF8([url path])));
-
-  return true;
-}
-
-bool ShowSaveDialog(atom::NativeWindow* window,
-                    const std::string& title,
-                    const base::FilePath& default_path,
-                    base::FilePath* path) {
-  DCHECK(window);
-  DCHECK(path);
-  NSSavePanel* dialog = [NSSavePanel savePanel];
-
-  SetupDialog(dialog, title, default_path);
-
-  [dialog setCanSelectHiddenExtension:YES];
-
-  __block bool result = false;
-  __block base::FilePath ret_path;
-  [dialog beginSheetModalForWindow:window->GetNativeWindow()
-                 completionHandler:^(NSInteger chosen) {
-    if (chosen == NSFileHandlingPanelCancelButton ||
-        ![[dialog URL] isFileURL]) {
-      result = false;
-    } else {
-      result = true;
-      ret_path = base::FilePath(base::SysNSStringToUTF8([[dialog URL] path]));
-    }
-
-    [NSApp stopModal];
-  }];
-
-  [NSApp runModalForWindow:window->GetNativeWindow()];
-
-  *path = ret_path;
-  return result;
-}
-
-}  // namespace file_dialog

browser/file_dialog_win.cc

@@ -1,23 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/file_dialog.h"
-
-namespace file_dialog {
-
-bool ShowOpenDialog(const std::string& title,
-                    const base::FilePath& default_path,
-                    int properties,
-                    std::vector<base::FilePath>* paths) {
-  return false;
-}
-
-bool ShowSaveDialog(atom::NativeWindow* window,
-                    const std::string& title,
-                    const base::FilePath& default_path,
-                    base::FilePath* path) {
-  return false;
-}
-
-}  // namespace file_dialog

browser/lib/init.coffee

@@ -0,0 +1,80 @@
+fs   = require 'fs'
+path = require 'path'
+util = require 'util'
+
+# Expose information of current process.
+process.__atom_type = 'browser'
+process.resourcesPath = path.resolve process.argv[1], '..', '..', '..'
+
+# 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
+
+# Pick out switches appended by atom-shell.
+startMark = process.argv.indexOf '--atom-shell-switches-start'
+endMark = process.argv.indexOf '--atom-shell-switches-end'
+process.execArgv = process.argv.splice startMark, endMark - startMark + 1
+
+# Add browser/api/lib to require's search paths,
+# which contains javascript part of Atom's built-in libraries.
+globalPaths = require('module').globalPaths
+globalPaths.push path.join process.resourcesPath, 'browser', 'api', 'lib'
+
+# Do loading in next tick since we still need some initialize work before
+# native bindings can work.
+setImmediate ->
+  # Import common settings.
+  require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init.js')
+
+  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.
+    print = (args...) ->
+      process.log util.format(args...)
+    console.log = console.error = console.warn = print
+    process.stdout.write = process.stderr.write = print
+
+    # 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) ->
+    # Show error in GUI.
+    message = error.stack ? "#{error.name}: #{error.message}"
+    require('dialog').showMessageBox
+      type: 'warning'
+      title: 'An javascript error occured in the browser'
+      message: 'uncaughtException'
+      detail: message
+      buttons: ['OK']
+
+  # Load the RPC server.
+  require './rpc-server.js'
+
+  # Now we try to load app's package.json.
+  packageJson = null
+
+  packagePath = path.join process.resourcesPath, 'app'
+  try
+    # First we try to load process.resourcesPath/app
+    packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
+  catch error
+    # If not found then we load browser/default_app
+    packagePath = path.join process.resourcesPath, 'browser', 'default_app'
+    packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
+
+  # Set application's version.
+  app = require 'app'
+  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
+
+  # Finally load app's main.js and transfer control to C++.
+  require path.join(packagePath, packageJson.main)

browser/lib/objects-registry.coffee

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

browser/lib/rpc-server.coffee

@@ -38,40 +38,69 @@ errorToMeta = (error) ->
 
 # Convert array of meta data from renderer into array of real values.
 unwrapArgs = (processId, routingId, args) ->
-  args.map (meta) ->
+  metaToValue = (meta) ->
     switch meta.type
       when 'value' then meta.value
-      when 'object' then objectsRegistry.get meta.id
+      when 'remote-object' then objectsRegistry.get meta.id
+      when 'array' then unwrapArgs processId, routingId, meta.value
+      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'
+        rendererReleased = false
+        objectsRegistry.once "release-renderer-view-#{processId}-#{routingId}", ->
+          rendererReleased = true
+
         ret = ->
+          throw new Error('Calling a callback of released renderer view') if rendererReleased
           ipc.sendChannel processId, routingId, 'ATOM_RENDERER_CALLBACK', meta.id, valueToMeta(processId, routingId, arguments)
         v8Util.setDestructor ret, ->
+          return if rendererReleased
           ipc.sendChannel processId, routingId, 'ATOM_RENDERER_RELEASE_CALLBACK', meta.id
         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, processId, routingId, func, caller, args) ->
+  if v8Util.getHiddenValue(func, 'asynchronous') and typeof args[args.length - 1] isnt 'function'
+    args.push (ret) ->
+      event.returnValue = valueToMeta processId, routingId, ret
+    func.apply caller, args
+  else
+    ret = func.apply caller, args
+    event.returnValue = valueToMeta processId, routingId, ret
+
+# Send by BrowserWindow when its render view is deleted.
+process.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (processId, routingId) ->
+  objectsRegistry.clear processId, routingId
+
 ipc.on 'ATOM_BROWSER_REQUIRE', (event, processId, routingId, module) ->
   try
-    event.result = valueToMeta processId, routingId, require(module)
+    event.returnValue = valueToMeta processId, routingId, require(module)
   catch e
-    event.result = errorToMeta e
+    event.returnValue = errorToMeta e
 
 ipc.on 'ATOM_BROWSER_GLOBAL', (event, processId, routingId, name) ->
   try
-    event.result = valueToMeta processId, routingId, global[name]
+    event.returnValue = valueToMeta processId, routingId, global[name]
   catch e
-    event.result = errorToMeta e
-
-ipc.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (event, processId, routingId) ->
-  objectsRegistry.clear processId, routingId
+    event.returnValue = errorToMeta e
 
 ipc.on 'ATOM_BROWSER_CURRENT_WINDOW', (event, processId, routingId) ->
   try
     BrowserWindow = require 'browser-window'
     window = BrowserWindow.fromProcessIdAndRoutingId processId, routingId
-    event.result = valueToMeta processId, routingId, window
+    event.returnValue = valueToMeta processId, routingId, window
   catch e
-    event.result = errorToMeta e
+    event.returnValue = errorToMeta e
 
 ipc.on 'ATOM_BROWSER_CONSTRUCTOR', (event, processId, routingId, id, args) ->
   try
@@ -80,48 +109,50 @@ ipc.on 'ATOM_BROWSER_CONSTRUCTOR', (event, processId, routingId, id, args) ->
     # 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.result = valueToMeta processId, routingId, obj
+    event.returnValue = valueToMeta processId, routingId, obj
   catch e
-    event.result = errorToMeta e
+    event.returnValue = errorToMeta e
 
 ipc.on 'ATOM_BROWSER_FUNCTION_CALL', (event, processId, routingId, id, args) ->
   try
     args = unwrapArgs processId, routingId, args
     func = objectsRegistry.get id
-    ret = func.apply global, args
-    event.result = valueToMeta processId, routingId, ret
+    callFunction event, processId, routingId, func, global, args
   catch e
-    event.result = errorToMeta e
+    event.returnValue = errorToMeta e
+
+ipc.on 'ATOM_BROWSER_MEMBER_CONSTRUCTOR', (event, processId, routingId, id, method, args) ->
+  try
+    args = unwrapArgs processId, routingId, args
+    constructor = objectsRegistry.get(id)[method]
+    # Call new with array of arguments.
+    obj = new (Function::bind.apply(constructor, [null].concat(args)))
+    event.returnValue = valueToMeta processId, routingId, obj
+  catch e
+    event.returnValue = errorToMeta e
 
 ipc.on 'ATOM_BROWSER_MEMBER_CALL', (event, processId, routingId, id, method, args) ->
   try
     args = unwrapArgs processId, routingId, args
     obj = objectsRegistry.get id
-    ret = obj[method].apply(obj, args)
-    event.result = valueToMeta processId, routingId, ret
+    callFunction event, processId, routingId, obj[method], obj, args
   catch e
-    event.result = errorToMeta e
+    event.returnValue = errorToMeta e
 
 ipc.on 'ATOM_BROWSER_MEMBER_SET', (event, processId, routingId, id, name, value) ->
   try
     obj = objectsRegistry.get id
     obj[name] = value
+    event.returnValue = null
   catch e
-    event.result = errorToMeta e
+    event.returnValue = errorToMeta e
 
 ipc.on 'ATOM_BROWSER_MEMBER_GET', (event, processId, routingId, id, name) ->
   try
     obj = objectsRegistry.get id
-    event.result = valueToMeta processId, routingId, obj[name]
+    event.returnValue = valueToMeta processId, routingId, obj[name]
   catch e
-    event.result = errorToMeta e
-
-ipc.on 'ATOM_BROWSER_REFERENCE', (event, processId, routingId, id) ->
-  try
-    obj = objectsRegistry.get id
-    event.result = valueToMeta processId, routingId, obj
-  catch e
-    event.result = errorToMeta e
+    event.returnValue = errorToMeta e
 
 ipc.on 'ATOM_BROWSER_DEREFERENCE', (processId, routingId, storeId) ->
   objectsRegistry.remove processId, routingId, storeId

browser/media/media_capture_devices_dispatcher.cc

@@ -1,157 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/media/media_capture_devices_dispatcher.h"
-
-#include "base/prefs/pref_service.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/media_devices_monitor.h"
-#include "content/public/common/media_stream_request.h"
-
-using content::BrowserThread;
-using content::MediaStreamDevices;
-
-namespace {
-
-const content::MediaStreamDevice* FindDefaultDeviceWithId(
-    const content::MediaStreamDevices& devices,
-    const std::string& device_id) {
-  if (devices.empty())
-    return NULL;
-
-  content::MediaStreamDevices::const_iterator iter = devices.begin();
-  for (; iter != devices.end(); ++iter) {
-    if (iter->id == device_id) {
-      return &(*iter);
-    }
-  }
-
-  return &(*devices.begin());
-};
-
-}  // namespace
-
-
-MediaCaptureDevicesDispatcher* MediaCaptureDevicesDispatcher::GetInstance() {
-  return Singleton<MediaCaptureDevicesDispatcher>::get();
-}
-
-MediaCaptureDevicesDispatcher::MediaCaptureDevicesDispatcher()
-    : devices_enumerated_(false) {}
-
-MediaCaptureDevicesDispatcher::~MediaCaptureDevicesDispatcher() {}
-
-const MediaStreamDevices&
-MediaCaptureDevicesDispatcher::GetAudioCaptureDevices() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!devices_enumerated_) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&content::EnsureMonitorCaptureDevices));
-    devices_enumerated_ = true;
-  }
-  return audio_devices_;
-}
-
-const MediaStreamDevices&
-MediaCaptureDevicesDispatcher::GetVideoCaptureDevices() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!devices_enumerated_) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&content::EnsureMonitorCaptureDevices));
-    devices_enumerated_ = true;
-  }
-  return video_devices_;
-}
-
-void MediaCaptureDevicesDispatcher::GetRequestedDevice(
-    const std::string& requested_device_id,
-    bool audio,
-    bool video,
-    content::MediaStreamDevices* devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(audio || video);
-
-  if (audio) {
-    const content::MediaStreamDevices& audio_devices = GetAudioCaptureDevices();
-    const content::MediaStreamDevice* const device =
-        FindDefaultDeviceWithId(audio_devices, requested_device_id);
-    if (device)
-      devices->push_back(*device);
-  }
-  if (video) {
-    const content::MediaStreamDevices& video_devices = GetVideoCaptureDevices();
-    const content::MediaStreamDevice* const device =
-        FindDefaultDeviceWithId(video_devices, requested_device_id);
-    if (device)
-      devices->push_back(*device);
-  }
-}
-
-void MediaCaptureDevicesDispatcher::GetDefaultDevices(
-    bool audio,
-    bool video,
-    content::MediaStreamDevices* devices) {
-  if (audio) {
-    GetRequestedDevice(std::string(), true, false, devices);
-  }
-
-  if (video) {
-    GetRequestedDevice(std::string(), false, true, devices);
-  }
-}
-
-void MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged(
-    const content::MediaStreamDevices& devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&MediaCaptureDevicesDispatcher::UpdateAudioDevicesOnUIThread,
-                 base::Unretained(this), devices));
-}
-
-void MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged(
-    const content::MediaStreamDevices& devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&MediaCaptureDevicesDispatcher::UpdateVideoDevicesOnUIThread,
-                 base::Unretained(this), devices));
-}
-
-void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(
-    int render_process_id,
-    int render_view_id,
-    const content::MediaStreamDevice& device,
-    content::MediaRequestState state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(
-          &MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread,
-          base::Unretained(this), render_process_id, render_view_id, device,
-          state));
-}
-
-void MediaCaptureDevicesDispatcher::UpdateAudioDevicesOnUIThread(
-    const content::MediaStreamDevices& devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  devices_enumerated_ = true;
-  audio_devices_ = devices;
-}
-
-void MediaCaptureDevicesDispatcher::UpdateVideoDevicesOnUIThread(
-    const content::MediaStreamDevices& devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  devices_enumerated_ = true;
-  video_devices_ = devices;
-}
-
-void MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread(
-    int render_process_id,
-    int render_view_id,
-    const content::MediaStreamDevice& device,
-    content::MediaRequestState state) {
-}

browser/media/media_capture_devices_dispatcher.h

@@ -1,78 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_
-#define CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_
-
-#include "base/callback.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/singleton.h"
-#include "base/observer_list.h"
-#include "content/public/browser/media_observer.h"
-#include "content/public/common/media_stream_request.h"
-
-// This singleton is used to receive updates about media events from the content
-// layer.
-class MediaCaptureDevicesDispatcher : public content::MediaObserver {
- public:
-  static MediaCaptureDevicesDispatcher* GetInstance();
-
-  // Helper for picking the device that was requested for an OpenDevice request.
-  // If the device requested is not available it will revert to using the first
-  // available one instead or will return an empty list if no devices of the
-  // requested kind are present.
-  void GetRequestedDevice(const std::string& requested_device_id,
-                          bool audio,
-                          bool video,
-                          content::MediaStreamDevices* devices);
-  void GetDefaultDevices(bool audio,
-                         bool video,
-                         content::MediaStreamDevices* devices);
-
-  const content::MediaStreamDevices& GetAudioCaptureDevices();
-  const content::MediaStreamDevices& GetVideoCaptureDevices();
-
-  // Overridden from content::MediaObserver:
-  virtual void OnAudioCaptureDevicesChanged(
-      const content::MediaStreamDevices& devices) OVERRIDE;
-  virtual void OnVideoCaptureDevicesChanged(
-      const content::MediaStreamDevices& devices) OVERRIDE;
-  virtual void OnMediaRequestStateChanged(
-      int render_process_id,
-      int render_view_id,
-      const content::MediaStreamDevice& device,
-      content::MediaRequestState state) OVERRIDE;
-  virtual void OnAudioStreamPlayingChanged(
-      int render_process_id,
-      int render_view_id,
-      int stream_id,
-      bool playing) OVERRIDE {}
-
- private:
-  friend struct DefaultSingletonTraits<MediaCaptureDevicesDispatcher>;
-
-  MediaCaptureDevicesDispatcher();
-  virtual ~MediaCaptureDevicesDispatcher();
-
-  // Called by the MediaObserver() functions, executed on UI thread.
-  void UpdateAudioDevicesOnUIThread(const content::MediaStreamDevices& devices);
-  void UpdateVideoDevicesOnUIThread(const content::MediaStreamDevices& devices);
-  void UpdateMediaRequestStateOnUIThread(
-      int render_process_id,
-      int render_view_id,
-      const content::MediaStreamDevice& device,
-      content::MediaRequestState state);
-
-  // A list of cached audio capture devices.
-  content::MediaStreamDevices audio_devices_;
-
-  // A list of cached video capture devices.
-  content::MediaStreamDevices video_devices_;
-
-  // Flag to indicate if device enumeration has been done/doing.
-  // Only accessed on UI thread.
-  bool devices_enumerated_;
-};
-
-#endif  // CHROME_BROWSER_MEDIA_MEDIA_CAPTURE_DEVICES_DISPATCHER_H_

browser/media/media_stream_devices_controller.cc

@@ -1,86 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/media/media_stream_devices_controller.h"
-
-#include "base/values.h"
-#include "browser/media/media_capture_devices_dispatcher.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/common/media_stream_request.h"
-
-namespace atom {
-
-namespace {
-
-bool HasAnyAvailableDevice() {
-  const content::MediaStreamDevices& audio_devices =
-      MediaCaptureDevicesDispatcher::GetInstance()->GetAudioCaptureDevices();
-  const content::MediaStreamDevices& video_devices =
-      MediaCaptureDevicesDispatcher::GetInstance()->GetVideoCaptureDevices();
-
-  return !audio_devices.empty() || !video_devices.empty();
-};
-
-}  // namespace
-
-MediaStreamDevicesController::MediaStreamDevicesController(
-    const content::MediaStreamRequest& request,
-    const content::MediaResponseCallback& callback)
-    : request_(request),
-      callback_(callback),
-      microphone_requested_(
-          request_.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE),
-      webcam_requested_(
-          request_.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE) {
-}
-
-MediaStreamDevicesController::~MediaStreamDevicesController() {}
-
-bool MediaStreamDevicesController::TakeAction() {
-  // Deny the request if there is no device attached to the OS.
-  if (!HasAnyAvailableDevice()) {
-    Deny();
-    return true;
-  }
-
-  Accept();
-  return true;
-}
-
-void MediaStreamDevicesController::Accept() {
-  // Get the default devices for the request.
-  content::MediaStreamDevices devices;
-  if (microphone_requested_ || webcam_requested_) {
-    switch (request_.request_type) {
-      case content::MEDIA_OPEN_DEVICE:
-        // For open device request pick the desired device or fall back to the
-        // first available of the given type.
-        MediaCaptureDevicesDispatcher::GetInstance()->GetRequestedDevice(
-            request_.requested_device_id,
-            microphone_requested_,
-            webcam_requested_,
-            &devices);
-        break;
-      case content::MEDIA_DEVICE_ACCESS:
-      case content::MEDIA_GENERATE_STREAM:
-      case content::MEDIA_ENUMERATE_DEVICES:
-        // Get the default devices for the request.
-        MediaCaptureDevicesDispatcher::GetInstance()->
-            GetDefaultDevices(microphone_requested_,
-                              webcam_requested_,
-                              &devices);
-        break;
-    }
-  }
-
-  LOG(ERROR) << "Accept";
-  callback_.Run(devices, scoped_ptr<content::MediaStreamUI>());
-}
-
-void MediaStreamDevicesController::Deny() {
-  callback_.Run(content::MediaStreamDevices(),
-                scoped_ptr<content::MediaStreamUI>());
-}
-
-}  // namespace atom

browser/media/media_stream_devices_controller.h

@@ -1,46 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_MEDIA_MEDIA_STREAM_DEVICES_CONTROLLER_H_
-#define ATOM_BROWSER_MEDIA_MEDIA_STREAM_DEVICES_CONTROLLER_H_
-
-#include "content/public/browser/web_contents_delegate.h"
-
-namespace atom {
-
-class MediaStreamDevicesController {
- public:
-  MediaStreamDevicesController(const content::MediaStreamRequest& request,
-                               const content::MediaResponseCallback& callback);
-
-  virtual ~MediaStreamDevicesController();
-
-  // Public method to be called before creating the MediaStreamInfoBarDelegate.
-  // This function will check the content settings exceptions and take the
-  // corresponding action on exception which matches the request.
-  bool TakeAction();
-
-  // Public methods to be called by MediaStreamInfoBarDelegate;
-  bool has_audio() const { return microphone_requested_; }
-  bool has_video() const { return webcam_requested_; }
-  void Accept();
-  void Deny();
-
- private:
-  // The original request for access to devices.
-  const content::MediaStreamRequest request_;
-
-  // The callback that needs to be Run to notify WebRTC of whether access to
-  // audio/video devices was granted or not.
-  content::MediaResponseCallback callback_;
-
-  bool microphone_requested_;
-  bool webcam_requested_;
-
-  DISALLOW_COPY_AND_ASSIGN(MediaStreamDevicesController);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_MEDIA_MEDIA_STREAM_DEVICES_CONTROLLER_H_

browser/message_box_mac.mm

@@ -1,49 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "browser/message_box.h"
-
-#import <Cocoa/Cocoa.h>
-
-#include "base/strings/sys_string_conversions.h"
-#include "browser/native_window.h"
-#include "browser/nsalert_synchronous_sheet.h"
-
-namespace atom {
-
-int ShowMessageBox(NativeWindow* parent_window,
-                   MessageBoxType type,
-                   const std::vector<std::string>& buttons,
-                   const std::string& title,
-                   const std::string& message,
-                   const std::string& detail) {
-  // Ignore the title; it's the window title on other platforms and ignorable.
-  NSAlert* alert = [[[NSAlert alloc] init] autorelease];
-  [alert setMessageText:base::SysUTF8ToNSString(message)];
-  [alert setInformativeText:base::SysUTF8ToNSString(detail)];
-
-  switch (type) {
-    case MESSAGE_BOX_TYPE_INFORMATION:
-      [alert setAlertStyle:NSInformationalAlertStyle];
-      break;
-    case MESSAGE_BOX_TYPE_WARNING:
-      [alert setAlertStyle:NSWarningAlertStyle];
-      break;
-    default:
-      break;
-  }
-
-  for (size_t i = 0; i < buttons.size(); ++i) {
-    NSString* title = base::SysUTF8ToNSString(buttons[i]);
-    NSButton* button = [alert addButtonWithTitle:title];
-    [button setTag:i];
-  }
-
-  if (parent_window)
-    return [alert runModalSheetForWindow:parent_window->GetNativeWindow()];
-  else
-    return [alert runModal];
-}
-
-}  // namespace atom

browser/native_window.cc

@@ -6,8 +6,10 @@
 
 #include <string>
 
-#include "base/message_loop.h"
-#include "base/utf_string_conversions.h"
+#include "base/file_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "brightray/browser/inspectable_web_contents.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
@@ -15,7 +17,8 @@
 #include "browser/atom_browser_context.h"
 #include "browser/atom_browser_main_parts.h"
 #include "browser/atom_javascript_dialog_manager.h"
-#include "browser/media/media_stream_devices_controller.h"
+#include "browser/browser.h"
+#include "browser/devtools_delegate.h"
 #include "browser/window_list.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/invalidate_type.h"
@@ -25,12 +28,18 @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "content/public/common/renderer_preferences.h"
 #include "common/api/api_messages.h"
+#include "common/atom_version.h"
 #include "common/options_switches.h"
 #include "ipc/ipc_message_macros.h"
+#include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
+#include "vendor/brightray/browser/inspectable_web_contents_impl.h"
+#include "webkit/common/user_agent/user_agent_util.h"
 
 using content::NavigationEntry;
 
@@ -39,14 +48,36 @@ namespace atom {
 NativeWindow::NativeWindow(content::WebContents* web_contents,
                            base::DictionaryValue* options)
     : content::WebContentsObserver(web_contents),
+      has_frame_(true),
       is_closed_(false),
-      not_responding_(false),
+      node_integration_("all"),
+      has_dialog_attached_(false),
+      weak_factory_(this),
       inspectable_web_contents_(
           brightray::InspectableWebContents::Create(web_contents)) {
+  options->GetBoolean(switches::kFrame, &has_frame_);
+
+  // Read icon before window is created.
+  std::string icon;
+  if (options->GetString(switches::kIcon, &icon) && !SetIcon(icon))
+    LOG(ERROR) << "Failed to set icon to " << icon;
+
+  // Read iframe security before any navigation.
+  options->GetString(switches::kNodeIntegration, &node_integration_);
+
   web_contents->SetDelegate(this);
 
   WindowList::AddWindow(this);
 
+  // Override the user agent to contain application and atom-shell's version.
+  Browser* browser = Browser::Get();
+  std::string product_name = base::StringPrintf(
+      "%s/%s Atom-Shell/" ATOM_VERSION_STRING,
+      browser->GetName().c_str(),
+      browser->GetVersion().c_str());
+  web_contents->GetMutableRendererPrefs()->user_agent_override =
+      webkit_glue::BuildUserAgentFromProduct(product_name);
+
   // Get notified of title updated message.
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED,
       content::Source<content::WebContents>(web_contents));
@@ -130,6 +161,10 @@ void NativeWindow::InitFromOptions(base::DictionaryValue* options) {
     Show();
 }
 
+bool NativeWindow::HasModalDialog() {
+  return has_dialog_attached_;
+}
+
 void NativeWindow::OpenDevTools() {
   inspectable_web_contents()->ShowDevTools();
 }
@@ -138,6 +173,10 @@ void NativeWindow::CloseDevTools() {
   inspectable_web_contents()->GetView()->CloseDevTools();
 }
 
+bool NativeWindow::IsDevToolsOpened() {
+  return inspectable_web_contents()->IsDevToolsViewShowing();
+}
+
 void NativeWindow::InspectElement(int x, int y) {
   OpenDevTools();
   content::RenderViewHost* rvh = GetWebContents()->GetRenderViewHost();
@@ -146,6 +185,16 @@ void NativeWindow::InspectElement(int x, int y) {
   agent->InspectElement(x, y);
 }
 
+void NativeWindow::DebugDevTools() {
+  if (!IsDevToolsOpened())
+    return;
+
+  base::DictionaryValue options;
+  NativeWindow* window = NativeWindow::Create(&options);
+  window->devtools_delegate_.reset(new DevToolsDelegate(
+      window, GetDevToolsWebContents()));
+}
+
 void NativeWindow::FocusOnWebView() {
   GetWebContents()->GetRenderViewHost()->Focus();
 }
@@ -154,8 +203,45 @@ void NativeWindow::BlurWebView() {
   GetWebContents()->GetRenderViewHost()->Blur();
 }
 
-void NativeWindow::RestartHangMonitorTimeout() {
-  GetWebContents()->GetRenderViewHost()->RestartHangMonitorTimeout();
+bool NativeWindow::IsWebViewFocused() {
+  return GetWebContents()->GetRenderViewHost()->GetView()->HasFocus();
+}
+
+bool NativeWindow::SetIcon(const std::string& str_path) {
+  base::FilePath path = base::FilePath::FromUTF8Unsafe(str_path);
+
+  // Read the file from disk.
+  std::string file_contents;
+  if (path.empty() || !base::ReadFileToString(path, &file_contents))
+    return false;
+
+  // Decode the bitmap using WebKit's image decoder.
+  const unsigned char* data =
+      reinterpret_cast<const unsigned char*>(file_contents.data());
+  scoped_ptr<SkBitmap> decoded(new SkBitmap());
+  gfx::PNGCodec::Decode(data, file_contents.length(), decoded.get());
+  if (decoded->empty())
+    return false;  // Unable to decode.
+
+  icon_ = gfx::Image::CreateFrom1xBitmap(*decoded.release());
+  return true;
+}
+
+base::ProcessHandle NativeWindow::GetRenderProcessHandle() {
+  return GetWebContents()->GetRenderProcessHost()->GetHandle();
+}
+
+void NativeWindow::CapturePage(const gfx::Rect& rect,
+                               const CapturePageCallback& callback) {
+  gfx::Rect flipped_y_rect = rect;
+  flipped_y_rect.set_y(-rect.y());
+
+  GetWebContents()->GetRenderViewHost()->CopyFromBackingStore(
+      flipped_y_rect,
+      gfx::Size(),
+      base::Bind(&NativeWindow::OnCapturePageDone,
+                 weak_factory_.GetWeakPtr(),
+                 callback));
 }
 
 void NativeWindow::CloseWebContents() {
@@ -170,6 +256,22 @@ void NativeWindow::CloseWebContents() {
 
   content::WebContents* web_contents(GetWebContents());
 
+  // Assume the window is not responding if it doesn't cancel the close and is
+  // not closed in 500ms, in this way we can quickly show the unresponsive
+  // dialog when the window is busy executing some script withouth waiting for
+  // the unresponsive timeout.
+  if (!Browser::Get()->is_quiting() &&
+      window_unresposive_closure_.IsCancelled()) {
+    window_unresposive_closure_.Reset(
+        base::Bind(&NativeWindow::RendererUnresponsive,
+                   weak_factory_.GetWeakPtr(),
+                   web_contents));
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        window_unresposive_closure_.callback(),
+        base::TimeDelta::FromMilliseconds(500));
+  }
+
   if (web_contents->NeedToFireBeforeUnload())
     web_contents->GetRenderViewHost()->FirePageBeforeUnload(false);
   else
@@ -180,10 +282,25 @@ content::WebContents* NativeWindow::GetWebContents() const {
   return inspectable_web_contents_->GetWebContents();
 }
 
+content::WebContents* NativeWindow::GetDevToolsWebContents() const {
+  brightray::InspectableWebContentsImpl* inspectable_web_contents_impl =
+      static_cast<brightray::InspectableWebContentsImpl*>(
+          inspectable_web_contents());
+  return inspectable_web_contents_impl->devtools_web_contents();
+}
+
 void NativeWindow::NotifyWindowClosed() {
   if (is_closed_)
     return;
 
+  // The OnRenderViewDeleted is not called when the WebContents is destroyed
+  // directly (e.g. when closing the window), so we make sure it's always
+  // emitted to users by sending it before window is closed..
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
+                    OnRenderViewDeleted(
+                        GetWebContents()->GetRenderProcessHost()->GetID(),
+                        GetWebContents()->GetRoutingID()));
+
   is_closed_ = true;
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowClosed());
 
@@ -194,22 +311,28 @@ void NativeWindow::NotifyWindowBlur() {
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowBlur());
 }
 
-// Window opened by window.open.
-void NativeWindow::WebContentsCreated(
-    content::WebContents* source_contents,
-    int64 source_frame_id,
-    const string16& frame_name,
-    const GURL& target_url,
-    content::WebContents* new_contents) {
-  LOG(WARNING) << "Please use node-style Window API to create window, "
-                  "using window.open has very strict constrains.";
+// In atom-shell all reloads and navigations started by renderer process would
+// be redirected to this method, so we can have precise control of how we
+// would open the url (in our case, is to restart the renderer process). See
+// AtomRendererClient::ShouldFork for how this is done.
+content::WebContents* NativeWindow::OpenURLFromTab(
+    content::WebContents* source,
+    const content::OpenURLParams& params) {
+  if (params.disposition != CURRENT_TAB)
+      return NULL;
 
-  scoped_ptr<base::DictionaryValue> options(new base::DictionaryValue);
-  options->SetInteger(switches::kWidth, 800);
-  options->SetInteger(switches::kHeight, 600);
+  content::NavigationController::LoadURLParams load_url_params(params.url);
+  load_url_params.referrer = params.referrer;
+  load_url_params.transition_type = params.transition;
+  load_url_params.extra_headers = params.extra_headers;
+  load_url_params.should_replace_current_entry =
+      params.should_replace_current_entry;
+  load_url_params.is_renderer_initiated = params.is_renderer_initiated;
+  load_url_params.transferred_global_request_id =
+      params.transferred_global_request_id;
 
-  NativeWindow* window = Create(new_contents, options.get());
-  window->InitFromOptions(options.get());
+  source->GetController().LoadURLWithParams(load_url_params);
+  return source;
 }
 
 content::JavaScriptDialogManager* NativeWindow::GetJavaScriptDialogManager() {
@@ -226,6 +349,9 @@ void NativeWindow::BeforeUnloadFired(content::WebContents* tab,
 
   if (!proceed)
     WindowList::WindowCloseCancelled(this);
+
+  // When the "beforeunload" callback is fired the window is certainly live.
+  window_unresposive_closure_.Cancel();
 }
 
 void NativeWindow::RequestToLockMouse(content::WebContents* web_contents,
@@ -234,14 +360,6 @@ void NativeWindow::RequestToLockMouse(content::WebContents* web_contents,
   GetWebContents()->GotResponseToLockMouseRequest(true);
 }
 
-void NativeWindow::RequestMediaAccessPermission(
-      content::WebContents* web_contents,
-      const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback) {
-  MediaStreamDevicesController controller(request, callback);
-  controller.TakeAction();
-}
-
 bool NativeWindow::CanOverscrollContent() const {
   return false;
 }
@@ -254,6 +372,13 @@ void NativeWindow::DeactivateContents(content::WebContents* contents) {
   BlurWebView();
 }
 
+void NativeWindow::LoadingStateChanged(content::WebContents* source) {
+  bool is_loading = source->IsLoading();
+  FOR_EACH_OBSERVER(NativeWindowObserver,
+                    observers_,
+                    OnLoadingStateChanged(is_loading));
+}
+
 void NativeWindow::MoveContents(content::WebContents* source,
                                 const gfx::Rect& pos) {
   SetPosition(pos.origin());
@@ -269,6 +394,9 @@ void NativeWindow::CloseContents(content::WebContents* source) {
   CloseImmediately();
 
   NotifyWindowClosed();
+
+  // Do not sent "unresponsive" event after window is closed.
+  window_unresposive_closure_.Cancel();
 }
 
 bool NativeWindow::IsPopupOrPanel(const content::WebContents* source) const {
@@ -277,41 +405,48 @@ bool NativeWindow::IsPopupOrPanel(const content::WebContents* source) const {
 }
 
 void NativeWindow::RendererUnresponsive(content::WebContents* source) {
-  not_responding_ = true;
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&NativeWindow::RendererUnresponsiveDelayed,
-                 base::Unretained(this)),
-      base::TimeDelta::FromSeconds(1));
+  window_unresposive_closure_.Cancel();
+
+  if (!HasModalDialog())
+    FOR_EACH_OBSERVER(NativeWindowObserver,
+                      observers_,
+                      OnRendererUnresponsive());
 }
 
 void NativeWindow::RendererResponsive(content::WebContents* source) {
-  not_responding_ = false;
+  window_unresposive_closure_.Cancel();
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererResponsive());
 }
 
+void NativeWindow::RenderViewDeleted(content::RenderViewHost* rvh) {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
+                    OnRenderViewDeleted(rvh->GetProcess()->GetID(),
+                                        rvh->GetRoutingID()));
+}
+
+void NativeWindow::RenderProcessGone(base::TerminationStatus status) {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererCrashed());
+}
+
+void NativeWindow::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.
+}
+
 bool NativeWindow::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NativeWindow, message)
     IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
-    IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message_Sync, OnRendererMessageSync)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
+                                    OnRendererMessageSync)
+    IPC_MESSAGE_HANDLER(AtomViewHostMsg_UpdateDraggableRegions,
+                        UpdateDraggableRegions)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
-void NativeWindow::RenderViewGone(base::TerminationStatus status) {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererCrashed());
-}
-
-void NativeWindow::RendererUnresponsiveDelayed() {
-  if (not_responding_)
-    FOR_EACH_OBSERVER(NativeWindowObserver,
-                      observers_,
-                      OnRendererUnresponsive());
-}
-
 void NativeWindow::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
@@ -332,7 +467,16 @@ void NativeWindow::Observe(int type,
   }
 }
 
-void NativeWindow::OnRendererMessage(const std::string& channel,
+void NativeWindow::OnCapturePageDone(const CapturePageCallback& callback,
+                                     bool succeed,
+                                     const SkBitmap& bitmap) {
+  std::vector<unsigned char> data;
+  if (succeed)
+    gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, true, &data);
+  callback.Run(data);
+}
+
+void NativeWindow::OnRendererMessage(const string16& channel,
                                      const base::ListValue& args) {
   AtomBrowserMainParts::Get()->atom_bindings()->OnRendererMessage(
       GetWebContents()->GetRenderProcessHost()->GetID(),
@@ -341,15 +485,16 @@ void NativeWindow::OnRendererMessage(const std::string& channel,
       args);
 }
 
-void NativeWindow::OnRendererMessageSync(const std::string& channel,
+void NativeWindow::OnRendererMessageSync(const string16& channel,
                                          const base::ListValue& args,
-                                         base::DictionaryValue* result) {
+                                         IPC::Message* reply_msg) {
   AtomBrowserMainParts::Get()->atom_bindings()->OnRendererMessageSync(
       GetWebContents()->GetRenderProcessHost()->GetID(),
       GetWebContents()->GetRoutingID(),
       channel,
       args,
-      result);
+      this,
+      reply_msg);
 }
 
 }  // namespace atom

browser/native_window.h

@@ -6,14 +6,17 @@
 #define ATOM_BROWSER_NATIVE_WINDOW_H_
 
 #include "base/basictypes.h"
+#include "base/cancelable_callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "browser/native_window_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_observer.h"
-#include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "ui/gfx/image/image.h"
+#include "vendor/brightray/browser/default_web_contents_delegate.h"
 
 namespace base {
 class DictionaryValue;
@@ -35,14 +38,42 @@ class Rect;
 class Size;
 }
 
+namespace IPC {
+class Message;
+}
+
 namespace atom {
 
 class AtomJavaScriptDialogManager;
+class DevToolsDelegate;
+struct DraggableRegion;
 
-class NativeWindow : public content::WebContentsDelegate,
+class NativeWindow : public brightray::DefaultWebContentsDelegate,
                      public content::WebContentsObserver,
                      public content::NotificationObserver {
  public:
+  typedef base::Callback<void(const std::vector<unsigned char>& buffer)>
+      CapturePageCallback;
+
+  class DialogScope {
+   public:
+    explicit DialogScope(NativeWindow* window)
+        : window_(window) {
+      if (window_ != NULL)
+        window_->set_has_dialog_attached(true);
+    }
+
+    ~DialogScope() {
+      if (window_ != NULL)
+        window_->set_has_dialog_attached(false);
+    }
+
+   private:
+    NativeWindow* window_;
+
+    DISALLOW_COPY_AND_ASSIGN(DialogScope);
+  };
+
   virtual ~NativeWindow();
 
   // Create window with existing WebContents.
@@ -64,6 +95,7 @@ class NativeWindow : public content::WebContentsDelegate,
   virtual bool IsFocused() = 0;
   virtual void Show() = 0;
   virtual void Hide() = 0;
+  virtual bool IsVisible() = 0;
   virtual void Maximize() = 0;
   virtual void Unmaximize() = 0;
   virtual void Minimize() = 0;
@@ -88,15 +120,32 @@ class NativeWindow : public content::WebContentsDelegate,
   virtual void FlashFrame(bool flash) = 0;
   virtual void SetKiosk(bool kiosk) = 0;
   virtual bool IsKiosk() = 0;
+  virtual bool HasModalDialog();
   virtual gfx::NativeWindow GetNativeWindow() = 0;
 
   virtual bool IsClosed() const { return is_closed_; }
   virtual void OpenDevTools();
   virtual void CloseDevTools();
+  virtual bool IsDevToolsOpened();
   virtual void InspectElement(int x, int y);
+
+  // Creates a new window to debug the devtools.
+  virtual void DebugDevTools();
+
   virtual void FocusOnWebView();
   virtual void BlurWebView();
-  virtual void RestartHangMonitorTimeout();
+  virtual bool IsWebViewFocused();
+
+  virtual bool SetIcon(const std::string& path);
+
+  // Returns the process handle of render process, useful for killing the
+  // render process manually
+  virtual base::ProcessHandle GetRenderProcessHandle();
+
+  // Captures the page with |rect|, |callback| would be called when capturing is
+  // done.
+  virtual void CapturePage(const gfx::Rect& rect,
+                           const CapturePageCallback& callback);
 
   // The same with closing a tab in a real browser.
   //
@@ -104,6 +153,7 @@ class NativeWindow : public content::WebContentsDelegate,
   virtual void CloseWebContents();
 
   content::WebContents* GetWebContents() const;
+  content::WebContents* GetDevToolsWebContents() const;
 
   void AddObserver(NativeWindowObserver* obs) {
     observers_.AddObserver(obs);
@@ -113,6 +163,13 @@ class NativeWindow : public content::WebContentsDelegate,
     observers_.RemoveObserver(obs);
   }
 
+  bool has_frame() const { return has_frame_; }
+  std::string node_integration() const { return node_integration_; }
+
+  void set_has_dialog_attached(bool has_dialog_attached) {
+    has_dialog_attached_ = has_dialog_attached;
+  }
+
  protected:
   explicit NativeWindow(content::WebContents* web_contents,
                         base::DictionaryValue* options);
@@ -124,12 +181,14 @@ class NativeWindow : public content::WebContentsDelegate,
   void NotifyWindowClosed();
   void NotifyWindowBlur();
 
+  // Called when the window needs to update its draggable region.
+  virtual void UpdateDraggableRegions(
+      const std::vector<DraggableRegion>& regions) = 0;
+
   // Implementations of content::WebContentsDelegate.
-  virtual void WebContentsCreated(content::WebContents* source_contents,
-                                  int64 source_frame_id,
-                                  const string16& frame_name,
-                                  const GURL& target_url,
-                                  content::WebContents* new_contents) OVERRIDE;
+  virtual content::WebContents* OpenURLFromTab(
+      content::WebContents* source,
+      const content::OpenURLParams& params) OVERRIDE;
   virtual content::JavaScriptDialogManager*
       GetJavaScriptDialogManager() OVERRIDE;
   virtual void BeforeUnloadFired(content::WebContents* tab,
@@ -138,13 +197,10 @@ class NativeWindow : public content::WebContentsDelegate,
   virtual void RequestToLockMouse(content::WebContents* web_contents,
                                   bool user_gesture,
                                   bool last_unlocked_by_target) OVERRIDE;
-  virtual void RequestMediaAccessPermission(
-      content::WebContents* web_contents,
-      const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback) OVERRIDE;
   virtual bool CanOverscrollContent() const OVERRIDE;
   virtual void ActivateContents(content::WebContents* contents) OVERRIDE;
   virtual void DeactivateContents(content::WebContents* contents) OVERRIDE;
+  virtual void LoadingStateChanged(content::WebContents* source) OVERRIDE;
   virtual void MoveContents(content::WebContents* source,
                             const gfx::Rect& pos) OVERRIDE;
   virtual void CloseContents(content::WebContents* source) OVERRIDE;
@@ -154,23 +210,34 @@ class NativeWindow : public content::WebContentsDelegate,
   virtual void RendererResponsive(content::WebContents* source) OVERRIDE;
 
   // Implementations of content::WebContentsObserver.
-  virtual void RenderViewGone(base::TerminationStatus status) OVERRIDE;
+  virtual void RenderViewDeleted(content::RenderViewHost*) OVERRIDE;
+  virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
+  virtual void BeforeUnloadFired(const base::TimeTicks& proceed_time) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
-  // Implementations of content::NotificationObserver
+  // Implementations of content::NotificationObserver.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
- private:
-  void RendererUnresponsiveDelayed();
+  // Whether window has standard frame.
+  bool has_frame_;
 
-  void OnRendererMessage(const std::string& channel,
+  // Window icon.
+  gfx::Image icon_;
+
+ private:
+  // Called when CapturePage has done.
+  void OnCapturePageDone(const CapturePageCallback& callback,
+                         bool succeed,
+                         const SkBitmap& bitmap);
+
+  void OnRendererMessage(const string16& channel,
                          const base::ListValue& args);
 
-  void OnRendererMessageSync(const std::string& channel,
+  void OnRendererMessageSync(const string16& channel,
                              const base::ListValue& args,
-                             base::DictionaryValue* result);
+                             IPC::Message* reply_msg);
 
   // Notification manager.
   content::NotificationRegistrar registrar_;
@@ -181,9 +248,19 @@ class NativeWindow : public content::WebContentsDelegate,
   // The windows has been closed.
   bool is_closed_;
 
-  // The window is not responding.
-  bool not_responding_;
+  // The security token of iframe.
+  std::string node_integration_;
 
+  // There is a dialog that has been attached to window.
+  bool has_dialog_attached_;
+
+  // Closure that would be called when window is unresponsive when closing,
+  // it should be cancelled when we can prove that the window is responsive.
+  base::CancelableClosure window_unresposive_closure_;
+
+  base::WeakPtrFactory<NativeWindow> weak_factory_;
+
+  scoped_ptr<DevToolsDelegate> devtools_delegate_;
   scoped_ptr<AtomJavaScriptDialogManager> dialog_manager_;
   scoped_ptr<brightray::InspectableWebContents> inspectable_web_contents_;
 

browser/native_window_gtk.cc

@@ -0,0 +1,429 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "browser/native_window_gtk.h"
+
+#include "base/values.h"
+#include "browser/ui/gtk/gtk_window_util.h"
+#include "common/draggable_region.h"
+#include "common/options_switches.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_view.h"
+#include "content/public/common/renderer_preferences.h"
+#include "ui/base/x/x11_util.h"
+#include "ui/gfx/gtk_util.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/skia_utils_gtk.h"
+
+namespace atom {
+
+namespace {
+
+// Dividing GTK's cursor blink cycle time (in milliseconds) by this value yields
+// an appropriate value for content::RendererPreferences::caret_blink_interval.
+// This matches the logic in the WebKit GTK port.
+const double kGtkCursorBlinkCycleFactor = 2000.0;
+
+}  // namespace
+
+NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
+                                 base::DictionaryValue* options)
+    : NativeWindow(web_contents, options),
+      window_(GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL))),
+      state_(GDK_WINDOW_STATE_WITHDRAWN),
+      is_always_on_top_(false) {
+  gtk_container_add(GTK_CONTAINER(window_),
+                    GetWebContents()->GetView()->GetNativeView());
+
+  int width = 800, height = 600;
+  options->GetInteger(switches::kWidth, &width);
+  options->GetInteger(switches::kHeight, &height);
+  gtk_window_set_default_size(window_, width, height);
+
+  if (!icon_.IsEmpty())
+    gtk_window_set_icon(window_, icon_.ToGdkPixbuf());
+
+  // In some (older) versions of compiz, raising top-level windows when they
+  // are partially off-screen causes them to get snapped back on screen, not
+  // always even on the current virtual desktop.  If we are running under
+  // compiz, suppress such raises, as they are not necessary in compiz anyway.
+  if (ui::GuessWindowManager() == ui::WM_COMPIZ)
+    suppress_window_raise_ = true;
+
+  g_signal_connect(window_, "delete-event",
+                   G_CALLBACK(OnWindowDeleteEventThunk), this);
+  g_signal_connect(window_, "focus-out-event",
+                   G_CALLBACK(OnFocusOutThunk), this);
+
+  if (!has_frame_) {
+    gtk_window_set_decorated(window_, false);
+
+    g_signal_connect(window_, "motion-notify-event",
+                     G_CALLBACK(OnMouseMoveEventThunk), this);
+    g_signal_connect(window_, "button-press-event",
+                     G_CALLBACK(OnButtonPressThunk), this);
+  }
+
+  SetWebKitColorStyle();
+}
+
+NativeWindowGtk::~NativeWindowGtk() {
+  if (window_)
+    gtk_widget_destroy(GTK_WIDGET(window_));
+}
+
+void NativeWindowGtk::Close() {
+  CloseWebContents();
+}
+
+void NativeWindowGtk::CloseImmediately() {
+  gtk_widget_destroy(GTK_WIDGET(window_));
+  window_ = NULL;
+}
+
+void NativeWindowGtk::Move(const gfx::Rect& pos) {
+  gtk_window_move(window_, pos.x(), pos.y());
+  gtk_window_resize(window_, pos.width(), pos.height());
+}
+
+void NativeWindowGtk::Focus(bool focus) {
+  if (!IsVisible())
+    return;
+
+  if (focus)
+    gtk_window_present(window_);
+  else
+    gdk_window_lower(gtk_widget_get_window(GTK_WIDGET(window_)));
+}
+
+bool NativeWindowGtk::IsFocused() {
+  return gtk_window_is_active(window_);
+}
+
+void NativeWindowGtk::Show() {
+  gtk_widget_show_all(GTK_WIDGET(window_));
+}
+
+void NativeWindowGtk::Hide() {
+  gtk_widget_hide(GTK_WIDGET(window_));
+}
+
+bool NativeWindowGtk::IsVisible() {
+  return gtk_widget_get_visible(GTK_WIDGET(window_));
+}
+
+void NativeWindowGtk::Maximize() {
+  gtk_window_maximize(window_);
+}
+
+void NativeWindowGtk::Unmaximize() {
+  gtk_window_unmaximize(window_);
+}
+
+void NativeWindowGtk::Minimize() {
+  gtk_window_iconify(window_);
+}
+
+void NativeWindowGtk::Restore() {
+  gtk_window_present(window_);
+}
+
+void NativeWindowGtk::SetFullscreen(bool fullscreen) {
+  if (fullscreen)
+    gtk_window_fullscreen(window_);
+  else
+    gtk_window_unfullscreen(window_);
+}
+
+bool NativeWindowGtk::IsFullscreen() {
+  return state_ & GDK_WINDOW_STATE_FULLSCREEN;
+}
+
+void NativeWindowGtk::SetSize(const gfx::Size& size) {
+  gtk_window_resize(window_, size.width(), size.height());
+}
+
+gfx::Size NativeWindowGtk::GetSize() {
+  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
+
+  GdkRectangle frame_extents;
+  gdk_window_get_frame_extents(gdk_window, &frame_extents);
+
+  return gfx::Size(frame_extents.width, frame_extents.height);
+}
+
+void NativeWindowGtk::SetMinimumSize(const gfx::Size& size) {
+  minimum_size_ = size;
+
+  GdkGeometry geometry = { 0 };
+  geometry.min_width = size.width();
+  geometry.min_height = size.height();
+  int hints = GDK_HINT_POS | GDK_HINT_MIN_SIZE;
+  gtk_window_set_geometry_hints(
+      window_, GTK_WIDGET(window_), &geometry, (GdkWindowHints)hints);
+}
+
+gfx::Size NativeWindowGtk::GetMinimumSize() {
+  return minimum_size_;
+}
+
+void NativeWindowGtk::SetMaximumSize(const gfx::Size& size) {
+  maximum_size_ = size;
+
+  GdkGeometry geometry = { 0 };
+  geometry.max_width = size.width();
+  geometry.max_height = size.height();
+  int hints = GDK_HINT_POS | GDK_HINT_MAX_SIZE;
+  gtk_window_set_geometry_hints(
+      window_, GTK_WIDGET(window_), &geometry, (GdkWindowHints)hints);
+}
+
+gfx::Size NativeWindowGtk::GetMaximumSize() {
+  return maximum_size_;
+}
+
+void NativeWindowGtk::SetResizable(bool resizable) {
+  // Should request widget size after setting unresizable, otherwise the
+  // window will shrink to a very small size.
+  if (!IsResizable()) {
+    gint width, height;
+    gtk_window_get_size(window_, &width, &height);
+    gtk_widget_set_size_request(GTK_WIDGET(window_), width, height);
+  }
+
+  gtk_window_set_resizable(window_, resizable);
+}
+
+bool NativeWindowGtk::IsResizable() {
+  return gtk_window_get_resizable(window_);
+}
+
+void NativeWindowGtk::SetAlwaysOnTop(bool top) {
+  is_always_on_top_ = top;
+  gtk_window_set_keep_above(window_, top ? TRUE : FALSE);
+}
+
+bool NativeWindowGtk::IsAlwaysOnTop() {
+  return is_always_on_top_;
+}
+
+void NativeWindowGtk::Center() {
+  gtk_window_set_position(window_, GTK_WIN_POS_CENTER);
+}
+
+void NativeWindowGtk::SetPosition(const gfx::Point& position) {
+  gtk_window_move(window_, position.x(), position.y());
+}
+
+gfx::Point NativeWindowGtk::GetPosition() {
+  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
+
+  GdkRectangle frame_extents;
+  gdk_window_get_frame_extents(gdk_window, &frame_extents);
+
+  return gfx::Point(frame_extents.x, frame_extents.y);
+}
+
+void NativeWindowGtk::SetTitle(const std::string& title) {
+  gtk_window_set_title(window_, title.c_str());
+}
+
+std::string NativeWindowGtk::GetTitle() {
+  return gtk_window_get_title(window_);
+}
+
+void NativeWindowGtk::FlashFrame(bool flash) {
+  gtk_window_set_urgency_hint(window_, flash);
+}
+
+void NativeWindowGtk::SetKiosk(bool kiosk) {
+  SetFullscreen(kiosk);
+}
+
+bool NativeWindowGtk::IsKiosk() {
+  return IsFullscreen();
+}
+
+bool NativeWindowGtk::HasModalDialog() {
+  // FIXME(zcbenz): Implement me.
+  return false;
+}
+
+gfx::NativeWindow NativeWindowGtk::GetNativeWindow() {
+  return window_;
+}
+
+void NativeWindowGtk::UpdateDraggableRegions(
+    const std::vector<DraggableRegion>& regions) {
+  // Draggable region is not supported for non-frameless window.
+  if (has_frame_)
+    return;
+
+  SkRegion draggable_region;
+
+  // By default, the whole window is non-draggable. We need to explicitly
+  // include those draggable regions.
+  for (std::vector<DraggableRegion>::const_iterator iter =
+           regions.begin();
+       iter != regions.end(); ++iter) {
+    const DraggableRegion& region = *iter;
+    draggable_region.op(
+        region.bounds.x(),
+        region.bounds.y(),
+        region.bounds.right(),
+        region.bounds.bottom(),
+        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
+  }
+
+  draggable_region_ = draggable_region;
+}
+
+void NativeWindowGtk::SetWebKitColorStyle() {
+  content::RendererPreferences* prefs =
+      GetWebContents()->GetMutableRendererPrefs();
+  GtkStyle* frame_style = gtk_rc_get_style(GTK_WIDGET(window_));
+  prefs->focus_ring_color =
+      gfx::GdkColorToSkColor(frame_style->bg[GTK_STATE_SELECTED]);
+  prefs->thumb_active_color = SkColorSetRGB(244, 244, 244);
+  prefs->thumb_inactive_color = SkColorSetRGB(234, 234, 234);
+  prefs->track_color = SkColorSetRGB(211, 211, 211);
+
+  GtkWidget* url_entry = gtk_entry_new();
+  GtkStyle* entry_style = gtk_rc_get_style(url_entry);
+  prefs->active_selection_bg_color =
+      gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_SELECTED]);
+  prefs->active_selection_fg_color =
+      gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_SELECTED]);
+  prefs->inactive_selection_bg_color =
+      gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_ACTIVE]);
+  prefs->inactive_selection_fg_color =
+      gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_ACTIVE]);
+  gtk_widget_destroy(url_entry);
+
+  const base::TimeDelta cursor_blink_time = gfx::GetCursorBlinkCycle();
+  prefs->caret_blink_interval =
+      cursor_blink_time.InMilliseconds() ?
+      cursor_blink_time.InMilliseconds() / kGtkCursorBlinkCycleFactor :
+      0;
+}
+
+bool NativeWindowGtk::IsMaximized() const {
+  return state_ & GDK_WINDOW_STATE_MAXIMIZED;
+}
+
+bool NativeWindowGtk::GetWindowEdge(int x, int y, GdkWindowEdge* edge) {
+  if (has_frame_)
+    return false;
+
+  if (IsMaximized() || IsFullscreen())
+    return false;
+
+  return gtk_window_util::GetWindowEdge(GetSize(), 0, x, y, edge);
+}
+
+gboolean NativeWindowGtk::OnWindowDeleteEvent(GtkWidget* widget,
+                                              GdkEvent* event) {
+  Close();
+  return TRUE;
+}
+
+gboolean NativeWindowGtk::OnFocusOut(GtkWidget* window, GdkEventFocus*) {
+  NotifyWindowBlur();
+  return FALSE;
+}
+
+gboolean NativeWindowGtk::OnWindowState(GtkWidget* window,
+                                        GdkEventWindowState* event) {
+  state_ = event->new_window_state;
+  return FALSE;
+}
+
+gboolean NativeWindowGtk::OnMouseMoveEvent(GtkWidget* widget,
+                                           GdkEventMotion* event) {
+  if (!IsResizable())
+    return FALSE;
+
+  int win_x, win_y;
+  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
+  gdk_window_get_origin(gdk_window, &win_x, &win_y);
+  gfx::Point point(static_cast<int>(event->x_root - win_x),
+                   static_cast<int>(event->y_root - win_y));
+
+  // Update the cursor if we're on the custom frame border.
+  GdkWindowEdge edge;
+  bool has_hit_edge = GetWindowEdge(point.x(), point.y(), &edge);
+  GdkCursorType new_cursor = GDK_LAST_CURSOR;
+  if (has_hit_edge)
+    new_cursor = gtk_window_util::GdkWindowEdgeToGdkCursorType(edge);
+
+  GdkCursorType last_cursor = GDK_LAST_CURSOR;
+  if (frame_cursor_)
+    last_cursor = frame_cursor_->type;
+
+  if (last_cursor != new_cursor) {
+    frame_cursor_ = has_hit_edge ? gfx::GetCursor(new_cursor) : NULL;
+    gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)),
+                          frame_cursor_);
+  }
+  return FALSE;
+}
+
+gboolean NativeWindowGtk::OnButtonPress(GtkWidget* widget,
+                                        GdkEventButton* event) {
+  // Make the button press coordinate relative to the browser window.
+  int win_x, win_y;
+  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
+  gdk_window_get_origin(gdk_window, &win_x, &win_y);
+
+  bool resizable = IsResizable();
+  GdkWindowEdge edge;
+  gfx::Point point(static_cast<int>(event->x_root - win_x),
+                   static_cast<int>(event->y_root - win_y));
+  bool has_hit_edge = resizable && GetWindowEdge(point.x(), point.y(), &edge);
+  bool has_hit_titlebar = !draggable_region_.isEmpty() &&
+      draggable_region_.contains(event->x, event->y);
+
+  if (event->button == 1) {
+    if (GDK_BUTTON_PRESS == event->type) {
+      // Raise the window after a click on either the titlebar or the border to
+      // match the behavior of most window managers, unless that behavior has
+      // been suppressed.
+      if ((has_hit_titlebar || has_hit_edge) && !suppress_window_raise_)
+        gdk_window_raise(GTK_WIDGET(widget)->window);
+
+      if (has_hit_edge) {
+        gtk_window_begin_resize_drag(window_, edge, event->button,
+                                     static_cast<gint>(event->x_root),
+                                     static_cast<gint>(event->y_root),
+                                     event->time);
+        return TRUE;
+      } else if (has_hit_titlebar) {
+        return gtk_window_util::HandleTitleBarLeftMousePress(
+            window_, gfx::Rect(GetPosition(), GetSize()), event);
+      }
+    } else if (GDK_2BUTTON_PRESS == event->type) {
+      if (has_hit_titlebar && resizable) {
+        // Maximize/restore on double click.
+        if (IsMaximized())
+          gtk_window_unmaximize(window_);
+        else
+          gtk_window_maximize(window_);
+        return TRUE;
+      }
+    }
+  } else if (event->button == 2) {
+    if (has_hit_titlebar || has_hit_edge)
+      gdk_window_lower(gdk_window);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+// static
+NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
+                                   base::DictionaryValue* options) {
+  return new NativeWindowGtk(web_contents, options);
+}
+
+}  // namespace atom

browser/native_window_gtk.h

@@ -0,0 +1,109 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_NATIVE_WINDOW_GTK_H_
+#define ATOM_BROWSER_NATIVE_WINDOW_GTK_H_
+
+#include <gtk/gtk.h>
+
+#include "browser/native_window.h"
+#include "third_party/skia/include/core/SkRegion.h"
+#include "ui/base/gtk/gtk_signal.h"
+#include "ui/gfx/size.h"
+
+namespace atom {
+
+class NativeWindowGtk : public NativeWindow {
+ public:
+  explicit NativeWindowGtk(content::WebContents* web_contents,
+                           base::DictionaryValue* options);
+  virtual ~NativeWindowGtk();
+
+  // NativeWindow implementation.
+  virtual void Close() OVERRIDE;
+  virtual void CloseImmediately() OVERRIDE;
+  virtual void Move(const gfx::Rect& pos) OVERRIDE;
+  virtual void Focus(bool focus) OVERRIDE;
+  virtual bool IsFocused() OVERRIDE;
+  virtual void Show() OVERRIDE;
+  virtual void Hide() OVERRIDE;
+  virtual bool IsVisible() OVERRIDE;
+  virtual void Maximize() OVERRIDE;
+  virtual void Unmaximize() OVERRIDE;
+  virtual void Minimize() OVERRIDE;
+  virtual void Restore() OVERRIDE;
+  virtual void SetFullscreen(bool fullscreen) OVERRIDE;
+  virtual bool IsFullscreen() OVERRIDE;
+  virtual void SetSize(const gfx::Size& size) OVERRIDE;
+  virtual gfx::Size GetSize() OVERRIDE;
+  virtual void SetMinimumSize(const gfx::Size& size) OVERRIDE;
+  virtual gfx::Size GetMinimumSize() OVERRIDE;
+  virtual void SetMaximumSize(const gfx::Size& size) OVERRIDE;
+  virtual gfx::Size GetMaximumSize() OVERRIDE;
+  virtual void SetResizable(bool resizable) OVERRIDE;
+  virtual bool IsResizable() OVERRIDE;
+  virtual void SetAlwaysOnTop(bool top) OVERRIDE;
+  virtual bool IsAlwaysOnTop() OVERRIDE;
+  virtual void Center() OVERRIDE;
+  virtual void SetPosition(const gfx::Point& position) OVERRIDE;
+  virtual gfx::Point GetPosition() OVERRIDE;
+  virtual void SetTitle(const std::string& title) OVERRIDE;
+  virtual std::string GetTitle() OVERRIDE;
+  virtual void FlashFrame(bool flash) OVERRIDE;
+  virtual void SetKiosk(bool kiosk) OVERRIDE;
+  virtual bool IsKiosk() OVERRIDE;
+  virtual bool HasModalDialog() OVERRIDE;
+  virtual gfx::NativeWindow GetNativeWindow() OVERRIDE;
+
+ protected:
+  virtual void UpdateDraggableRegions(
+      const std::vector<DraggableRegion>& regions) OVERRIDE;
+
+ private:
+  // Set WebKit's style from current theme.
+  void SetWebKitColorStyle();
+
+  // Whether window is maximized.
+  bool IsMaximized() const;
+
+  // If the point (|x|, |y|) is within the resize border area of the window,
+  // returns true and sets |edge| to the appropriate GdkWindowEdge value.
+  // Otherwise, returns false.
+  bool GetWindowEdge(int x, int y, GdkWindowEdge* edge);
+
+  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnWindowDeleteEvent,
+                       GdkEvent*);
+  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnFocusOut, GdkEventFocus*);
+  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnWindowState,
+                       GdkEventWindowState*);
+  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnMouseMoveEvent,
+                       GdkEventMotion*);
+  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnButtonPress,
+                       GdkEventButton*);
+
+  GtkWindow* window_;
+
+  GdkWindowState state_;
+  bool is_always_on_top_;
+  gfx::Size minimum_size_;
+  gfx::Size maximum_size_;
+
+  // The region is treated as title bar, can be dragged to move
+  // and double clicked to maximize.
+  SkRegion draggable_region_;
+
+  // If true, don't call gdk_window_raise() when we get a click in the title
+  // bar or window border.  This is to work around a compiz bug.
+  bool suppress_window_raise_;
+
+  // The current window cursor.  We set it to a resize cursor when over the
+  // custom frame border.  We set it to NULL if we want the default cursor.
+  GdkCursor* frame_cursor_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeWindowGtk);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NATIVE_WINDOW_GTK_H_

browser/native_window_mac.h

@@ -10,6 +10,8 @@
 #include "base/memory/scoped_ptr.h"
 #include "browser/native_window.h"
 
+class SkRegion;
+
 namespace atom {
 
 class NativeWindowMac : public NativeWindow {
@@ -26,6 +28,7 @@ class NativeWindowMac : public NativeWindow {
   virtual bool IsFocused() OVERRIDE;
   virtual void Show() OVERRIDE;
   virtual void Hide() OVERRIDE;
+  virtual bool IsVisible() OVERRIDE;
   virtual void Maximize() OVERRIDE;
   virtual void Unmaximize() OVERRIDE;
   virtual void Minimize() OVERRIDE;
@@ -50,13 +53,28 @@ class NativeWindowMac : public NativeWindow {
   virtual void FlashFrame(bool flash) OVERRIDE;
   virtual void SetKiosk(bool kiosk) OVERRIDE;
   virtual bool IsKiosk() OVERRIDE;
+  virtual bool HasModalDialog() OVERRIDE;
   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE;
 
-  NSWindow*& window() { return window_; }
-
   void NotifyWindowBlur() { NativeWindow::NotifyWindowBlur(); }
 
+  // Returns true if |point| in local Cocoa coordinate system falls within
+  // the draggable region.
+  bool IsWithinDraggableRegion(NSPoint point) const;
+
+  // Called to handle a mouse event.
+  void HandleMouseEvent(NSEvent* event);
+
+  // Clip web view to rounded corner.
+  void ClipWebView();
+
+  NSWindow*& window() { return window_; }
+  SkRegion* draggable_region() const { return draggable_region_.get(); }
+
  protected:
+  virtual void UpdateDraggableRegions(
+      const std::vector<DraggableRegion>& regions) OVERRIDE;
+
   // Implementations of content::WebContentsDelegate.
   virtual void HandleKeyboardEvent(
       content::WebContents*,
@@ -65,6 +83,9 @@ class NativeWindowMac : public NativeWindow {
  private:
   void InstallView();
   void UninstallView();
+  void InstallDraggableRegionViews();
+  void UpdateDraggableRegionsForCustomDrag(
+      const std::vector<DraggableRegion>& regions);
 
   NSWindow* window_;
 
@@ -72,6 +93,18 @@ class NativeWindowMac : public NativeWindow {
 
   NSInteger attention_request_id_;  // identifier from requestUserAttention
 
+  // For system drag, the whole window is draggable and the non-draggable areas
+  // have to been explicitly excluded.
+  std::vector<gfx::Rect> system_drag_exclude_areas_;
+
+  // For custom drag, the whole window is non-draggable and the draggable region
+  // has to been explicitly provided.
+  scoped_ptr<SkRegion> draggable_region_;  // used in custom drag.
+
+  // Mouse location since the last mouse event, in screen coordinates. This is
+  // used in custom drag to compute the window movement.
+  NSPoint last_mouse_offset_;
+
   DISALLOW_COPY_AND_ASSIGN(NativeWindowMac);
 };
 

browser/native_window_mac.mm

@@ -11,17 +11,25 @@
 #define BASE_MAC_FOUNDATION_UTIL_H_
 
 #include "base/mac/mac_util.h"
+#include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/values.h"
-#import "browser/atom_event_processing_window.h"
+#import "browser/ui/cocoa/event_processing_window.h"
 #include "brightray/browser/inspectable_web_contents.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
+#include "common/draggable_region.h"
 #include "common/options_switches.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/render_view_host.h"
 
+static const CGFloat kAtomWindowCornerRadius = 4.0;
+
+@interface NSView (PrivateMethods)
+- (CGFloat)roundedCornerRadius;
+@end
+
 @interface AtomNSWindowDelegate : NSObject<NSWindowDelegate> {
  @private
   atom::NativeWindowMac* shell_;
@@ -41,6 +49,11 @@
   shell_->NotifyWindowBlur();
 }
 
+- (void)windowDidResize:(NSNotification*)otification {
+  if (!shell_->has_frame())
+    shell_->ClipWebView();
+}
+
 - (void)windowWillClose:(NSNotification*)notification {
   shell_->window() = nil;
   [self autorelease];
@@ -54,10 +67,17 @@
   return NO;
 }
 
+- (void)windowDidExitFullScreen:(NSNotification*)notification {
+  if (!shell_->has_frame()) {
+    NSWindow* window = shell_->GetNativeWindow();
+    [[window standardWindowButton:NSWindowFullScreenButton] setHidden:YES];
+  }
+}
+
 @end
 
-@interface AtomNSWindow : AtomEventProcessingWindow {
- @private
+@interface AtomNSWindow : EventProcessingWindow {
+ @protected
   atom::NativeWindowMac* shell_;
 }
 - (void)setShell:(atom::NativeWindowMac*)shell;
@@ -80,6 +100,41 @@
 
 @end
 
+@interface ControlRegionView : NSView {
+ @private
+  atom::NativeWindowMac* shellWindow_;  // Weak; owns self.
+}
+@end
+
+@implementation ControlRegionView
+
+- (id)initWithShellWindow:(atom::NativeWindowMac*)shellWindow {
+  if ((self = [super init]))
+    shellWindow_ = shellWindow;
+  return self;
+}
+
+- (BOOL)mouseDownCanMoveWindow {
+  return NO;
+}
+
+- (NSView*)hitTest:(NSPoint)aPoint {
+  if (!shellWindow_->IsWithinDraggableRegion(aPoint)) {
+    return nil;
+  }
+  return self;
+}
+
+- (void)mouseDown:(NSEvent*)event {
+  shellWindow_->HandleMouseEvent(event);
+}
+
+- (void)mouseDragged:(NSEvent*)event {
+  shellWindow_->HandleMouseEvent(event);
+}
+
+@end
+
 namespace atom {
 
 NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
@@ -87,27 +142,30 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
     : NativeWindow(web_contents, options),
       is_kiosk_(false),
       attention_request_id_(0) {
-  int width, height;
+  int width = 800, height = 600;
   options->GetInteger(switches::kWidth, &width);
   options->GetInteger(switches::kHeight, &height);
 
   NSRect main_screen_rect = [[[NSScreen screens] objectAtIndex:0] frame];
   NSRect cocoa_bounds = NSMakeRect(
-      (NSWidth(main_screen_rect) - width) / 2,
-      (NSHeight(main_screen_rect) - height) / 2,
+      round((NSWidth(main_screen_rect) - width) / 2) ,
+      round((NSHeight(main_screen_rect) - height) / 2),
       width,
       height);
-  NSUInteger style_mask = NSTitledWindowMask | NSClosableWindowMask |
-                          NSMiniaturizableWindowMask | NSResizableWindowMask |
-                          NSTexturedBackgroundWindowMask;
-  AtomNSWindow* atom_window = [[AtomNSWindow alloc]
+
+  AtomNSWindow* atomWindow;
+
+  atomWindow = [[AtomNSWindow alloc]
       initWithContentRect:cocoa_bounds
-                styleMask:style_mask
+                styleMask:NSTitledWindowMask | NSClosableWindowMask |
+                          NSMiniaturizableWindowMask | NSResizableWindowMask |
+                          NSTexturedBackgroundWindowMask
                   backing:NSBackingStoreBuffered
                     defer:YES];
-  [atom_window setShell:this];
 
-  window_ = atom_window;
+  [atomWindow setShell:this];
+  window_ = atomWindow;
+
   [window() setDelegate:[[AtomNSWindowDelegate alloc] initWithShell:this]];
 
   // Disable fullscreen button when 'fullscreen' is specified to false.
@@ -119,6 +177,9 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
     [window() setCollectionBehavior:collectionBehavior];
   }
 
+  NSView* view = inspectable_web_contents()->GetView()->GetNativeView();
+  [view setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
+
   InstallView();
 }
 
@@ -149,7 +210,10 @@ void NativeWindowMac::Move(const gfx::Rect& pos) {
 }
 
 void NativeWindowMac::Focus(bool focus) {
-  if (focus && [window() isVisible]) {
+  if (!IsVisible())
+    return;
+
+  if (focus) {
     [[NSApplication sharedApplication] activateIgnoringOtherApps:YES];
     [window() makeKeyAndOrderFront:nil];
   } else {
@@ -169,6 +233,10 @@ void NativeWindowMac::Hide() {
   [window() orderOut:nil];
 }
 
+bool NativeWindowMac::IsVisible() {
+  return [window() isVisible];
+}
+
 void NativeWindowMac::Maximize() {
   [window() zoom:nil];
 }
@@ -300,7 +368,7 @@ void NativeWindowMac::SetKiosk(bool kiosk) {
   if (kiosk) {
     NSApplicationPresentationOptions options =
         NSApplicationPresentationHideDock +
-        NSApplicationPresentationHideMenuBar + 
+        NSApplicationPresentationHideMenuBar +
         NSApplicationPresentationDisableAppleMenu +
         NSApplicationPresentationDisableProcessSwitching +
         NSApplicationPresentationDisableForceQuit +
@@ -320,10 +388,51 @@ bool NativeWindowMac::IsKiosk() {
   return is_kiosk_;
 }
 
+bool NativeWindowMac::HasModalDialog() {
+  return [window() attachedSheet] != nil;
+}
+
 gfx::NativeWindow NativeWindowMac::GetNativeWindow() {
   return window();
 }
 
+bool NativeWindowMac::IsWithinDraggableRegion(NSPoint point) const {
+  if (!draggable_region_)
+    return false;
+  NSView* webView = GetWebContents()->GetView()->GetNativeView();
+  NSInteger webViewHeight = NSHeight([webView bounds]);
+  // |draggable_region_| is stored in local platform-indepdent coordiate system
+  // while |point| is in local Cocoa coordinate system. Do the conversion
+  // to match these two.
+  return draggable_region_->contains(point.x, webViewHeight - point.y);
+}
+
+void NativeWindowMac::HandleMouseEvent(NSEvent* event) {
+  NSPoint current_mouse_location =
+      [window() convertBaseToScreen:[event locationInWindow]];
+
+  if ([event type] == NSLeftMouseDown) {
+    NSPoint frame_origin = [window() frame].origin;
+    last_mouse_offset_ = NSMakePoint(
+        frame_origin.x - current_mouse_location.x,
+        frame_origin.y - current_mouse_location.y);
+  } else if ([event type] == NSLeftMouseDragged) {
+    [window() setFrameOrigin:NSMakePoint(
+        current_mouse_location.x + last_mouse_offset_.x,
+        current_mouse_location.y + last_mouse_offset_.y)];
+  }
+}
+
+void NativeWindowMac::UpdateDraggableRegions(
+    const std::vector<DraggableRegion>& regions) {
+  // Draggable region is not supported for non-frameless window.
+  if (has_frame_)
+    return;
+
+  UpdateDraggableRegionsForCustomDrag(regions);
+  InstallDraggableRegionViews();
+}
+
 void NativeWindowMac::HandleKeyboardEvent(
     content::WebContents*,
     const content::NativeWebKeyboardEvent& event) {
@@ -331,24 +440,105 @@ void NativeWindowMac::HandleKeyboardEvent(
       event.type == content::NativeWebKeyboardEvent::Char)
     return;
 
-  AtomEventProcessingWindow* event_window =
-      static_cast<AtomEventProcessingWindow*>(window());
-  DCHECK([event_window isKindOfClass:[AtomEventProcessingWindow class]]);
+  EventProcessingWindow* event_window =
+      static_cast<EventProcessingWindow*>(window());
+  DCHECK([event_window isKindOfClass:[EventProcessingWindow class]]);
   [event_window redispatchKeyEvent:event.os_event];
 }
 
 void NativeWindowMac::InstallView() {
   NSView* view = inspectable_web_contents()->GetView()->GetNativeView();
-  [view setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
-  [view setFrame:[[window() contentView] bounds]];
-  [[window() contentView] addSubview:view];
+  if (has_frame_) {
+    [view setFrame:[[window() contentView] bounds]];
+    [[window() contentView] addSubview:view];
+  } else {
+    NSView* frameView = [[window() contentView] superview];
+    [view setFrame:[frameView bounds]];
+    [frameView addSubview:view];
+
+    ClipWebView();
+
+    [[window() standardWindowButton:NSWindowZoomButton] setHidden:YES];
+    [[window() standardWindowButton:NSWindowMiniaturizeButton] setHidden:YES];
+    [[window() standardWindowButton:NSWindowCloseButton] setHidden:YES];
+    [[window() standardWindowButton:NSWindowFullScreenButton] setHidden:YES];
+  }
 }
 
 void NativeWindowMac::UninstallView() {
-  NSView* view = GetWebContents()->GetView()->GetNativeView();
+  NSView* view = inspectable_web_contents()->GetView()->GetNativeView();
   [view removeFromSuperview];
 }
 
+void NativeWindowMac::ClipWebView() {
+  NSView* view = GetWebContents()->GetView()->GetNativeView();
+
+  view.wantsLayer = YES;
+  view.layer.masksToBounds = YES;
+  view.layer.cornerRadius = kAtomWindowCornerRadius;
+}
+
+void NativeWindowMac::InstallDraggableRegionViews() {
+  DCHECK(!has_frame_);
+
+  // All ControlRegionViews should be added as children of the WebContentsView,
+  // because WebContentsView will be removed and re-added when entering and
+  // leaving fullscreen mode.
+  NSView* webView = GetWebContents()->GetView()->GetNativeView();
+  NSInteger webViewHeight = NSHeight([webView bounds]);
+
+  // Remove all ControlRegionViews that are added last time.
+  // Note that [webView subviews] returns the view's mutable internal array and
+  // it should be copied to avoid mutating the original array while enumerating
+  // it.
+  base::scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
+  for (NSView* subview in subviews.get())
+    if ([subview isKindOfClass:[ControlRegionView class]])
+      [subview removeFromSuperview];
+
+  // Create and add ControlRegionView for each region that needs to be excluded
+  // from the dragging.
+  for (std::vector<gfx::Rect>::const_iterator iter =
+           system_drag_exclude_areas_.begin();
+       iter != system_drag_exclude_areas_.end();
+       ++iter) {
+    base::scoped_nsobject<NSView> controlRegion(
+        [[ControlRegionView alloc] initWithShellWindow:this]);
+    [controlRegion setFrame:NSMakeRect(iter->x(),
+                                       webViewHeight - iter->bottom(),
+                                       iter->width(),
+                                       iter->height())];
+    [webView addSubview:controlRegion];
+  }
+}
+
+void NativeWindowMac::UpdateDraggableRegionsForCustomDrag(
+    const std::vector<DraggableRegion>& regions) {
+  // We still need one ControlRegionView to cover the whole window such that
+  // mouse events could be captured.
+  NSView* web_view = GetWebContents()->GetView()->GetNativeView();
+  gfx::Rect window_bounds(
+      0, 0, NSWidth([web_view bounds]), NSHeight([web_view bounds]));
+  system_drag_exclude_areas_.clear();
+  system_drag_exclude_areas_.push_back(window_bounds);
+
+  // Aggregate the draggable areas and non-draggable areas such that hit test
+  // could be performed easily.
+  SkRegion* draggable_region = new SkRegion;
+  for (std::vector<DraggableRegion>::const_iterator iter = regions.begin();
+       iter != regions.end();
+       ++iter) {
+    const DraggableRegion& region = *iter;
+    draggable_region->op(
+        region.bounds.x(),
+        region.bounds.y(),
+        region.bounds.right(),
+        region.bounds.bottom(),
+        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
+  }
+  draggable_region_.reset(draggable_region);
+}
+
 // static
 NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
                                    base::DictionaryValue* options) {

browser/native_window_observer.h

@@ -17,6 +17,9 @@ class NativeWindowObserver {
   virtual void OnPageTitleUpdated(bool* prevent_default,
                                   const std::string& title) {}
 
+  // Called when the window is starting or is done loading a page.
+  virtual void OnLoadingStateChanged(bool is_loading) {}
+
   // Called when the window is gonna closed.
   virtual void WillCloseWindow(bool* prevent_default) {}
 
@@ -32,6 +35,9 @@ class NativeWindowObserver {
   // Called when renderer recovers.
   virtual void OnRendererResponsive() {}
 
+  // Called when a render view has been deleted.
+  virtual void OnRenderViewDeleted(int process_id, int routing_id) {}
+
   // Called when renderer has crashed.
   virtual void OnRendererCrashed() {}
 };

browser/native_window_win.cc

@@ -4,12 +4,24 @@
 
 #include "browser/native_window_win.h"
 
+#include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "browser/api/atom_api_menu.h"
+#include "browser/ui/win/menu_2.h"
+#include "browser/ui/win/native_menu_win.h"
+#include "common/draggable_region.h"
 #include "common/options_switches.h"
 #include "content/public/browser/native_web_keyboard_event.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_view.h"
+#include "ui/gfx/path.h"
+#include "ui/base/models/simple_menu_model.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/widget/widget.h"
+#include "ui/views/widget/native_widget_win.h"
 #include "ui/views/window/client_view.h"
 #include "ui/views/window/native_frame_view.h"
 
@@ -17,24 +29,52 @@ namespace atom {
 
 namespace {
 
+const int kResizeInsideBoundsSize = 5;
+const int kResizeAreaCornerSize = 16;
+
+// Wrapper of NativeWidgetWin to handle WM_MENUCOMMAND messages, which are
+// triggered by window menus.
+class MenuCommandNativeWidget : public views::NativeWidgetWin {
+ public:
+  explicit MenuCommandNativeWidget(NativeWindowWin* delegate)
+      : views::NativeWidgetWin(delegate->window()),
+        delegate_(delegate) {}
+  virtual ~MenuCommandNativeWidget() {}
+
+ protected:
+  virtual bool PreHandleMSG(UINT message,
+                            WPARAM w_param,
+                            LPARAM l_param,
+                            LRESULT* result) OVERRIDE {
+    if (message == WM_MENUCOMMAND) {
+      delegate_->OnMenuCommand(w_param, reinterpret_cast<HMENU>(l_param));
+      *result = 0;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+ private:
+  NativeWindowWin* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(MenuCommandNativeWidget);
+};
+
 class NativeWindowClientView : public views::ClientView {
  public:
   NativeWindowClientView(views::Widget* widget,
-                         views::View* contents_view,
-                         NativeWindowWin* shell)
-      : views::ClientView(widget, contents_view),
-        shell_(shell) {
+                         NativeWindowWin* contents_view)
+      : views::ClientView(widget, contents_view) {
   }
   virtual ~NativeWindowClientView() {}
 
   virtual bool CanClose() OVERRIDE {
-    shell_->CloseWebContents();
+    static_cast<NativeWindowWin*>(contents_view())->CloseWebContents();
     return false;
   }
 
  private:
-  NativeWindowWin* shell_;
-
   DISALLOW_COPY_AND_ASSIGN(NativeWindowClientView);
 };
 
@@ -60,6 +100,99 @@ class NativeWindowFrameView : public views::NativeFrameView {
   DISALLOW_COPY_AND_ASSIGN(NativeWindowFrameView);
 };
 
+class NativeWindowFramelessView : public views::NonClientFrameView {
+ public:
+  explicit NativeWindowFramelessView(views::Widget* frame,
+                                     NativeWindowWin* shell)
+      : frame_(frame),
+        shell_(shell) {
+  }
+  virtual ~NativeWindowFramelessView() {}
+
+  // views::NonClientFrameView implementations:
+  virtual gfx::Rect NativeWindowFramelessView::GetBoundsForClientView() const
+      OVERRIDE {
+    return bounds();
+  }
+
+  virtual gfx::Rect NativeWindowFramelessView::GetWindowBoundsForClientBounds(
+        const gfx::Rect& client_bounds) const OVERRIDE {
+    gfx::Rect window_bounds = client_bounds;
+    // Enforce minimum size (1, 1) in case that client_bounds is passed with
+    // empty size. This could occur when the frameless window is being
+    // initialized.
+    if (window_bounds.IsEmpty()) {
+      window_bounds.set_width(1);
+      window_bounds.set_height(1);
+    }
+    return window_bounds;
+  }
+
+  virtual int NonClientHitTest(const gfx::Point& point) OVERRIDE {
+    if (frame_->IsFullscreen())
+      return HTCLIENT;
+
+    // Check the frame first, as we allow a small area overlapping the contents
+    // to be used for resize handles.
+    bool can_ever_resize = frame_->widget_delegate() ?
+        frame_->widget_delegate()->CanResize() :
+        false;
+    // Don't allow overlapping resize handles when the window is maximized or
+    // fullscreen, as it can't be resized in those states.
+    int resize_border =
+        frame_->IsMaximized() || frame_->IsFullscreen() ? 0 :
+        kResizeInsideBoundsSize;
+    int frame_component = GetHTComponentForFrame(point,
+                                                 resize_border,
+                                                 resize_border,
+                                                 kResizeAreaCornerSize,
+                                                 kResizeAreaCornerSize,
+                                                 can_ever_resize);
+    if (frame_component != HTNOWHERE)
+      return frame_component;
+
+    // Check for possible draggable region in the client area for the frameless
+    // window.
+    if (shell_->draggable_region() &&
+        shell_->draggable_region()->contains(point.x(), point.y()))
+      return HTCAPTION;
+
+    int client_component = frame_->client_view()->NonClientHitTest(point);
+    if (client_component != HTNOWHERE)
+      return client_component;
+
+    // Caption is a safe default.
+    return HTCAPTION;
+  }
+
+  virtual void GetWindowMask(const gfx::Size& size,
+                             gfx::Path* window_mask) OVERRIDE {}
+  virtual void ResetWindowControls() OVERRIDE {}
+  virtual void UpdateWindowIcon() OVERRIDE {}
+  virtual void UpdateWindowTitle() OVERRIDE {}
+
+  // views::View implementations:
+  virtual gfx::Size NativeWindowFramelessView::GetPreferredSize() OVERRIDE {
+    gfx::Size pref = frame_->client_view()->GetPreferredSize();
+    gfx::Rect bounds(0, 0, pref.width(), pref.height());
+    return frame_->non_client_view()->GetWindowBoundsForClientBounds(
+        bounds).size();
+  }
+
+  virtual gfx::Size GetMinimumSize() OVERRIDE {
+    return shell_->GetMinimumSize();
+  }
+
+  virtual gfx::Size GetMaximumSize() OVERRIDE {
+    return shell_->GetMaximumSize();
+  }
+
+ private:
+  views::Widget* frame_;
+  NativeWindowWin* shell_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeWindowFramelessView);
+};
 
 }  // namespace
 
@@ -71,6 +204,8 @@ NativeWindowWin::NativeWindowWin(content::WebContents* web_contents,
       resizable_(true) {
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.delegate = this;
+  params.native_widget = new MenuCommandNativeWidget(this);
+  params.remove_standard_frame = !has_frame_;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   window_->set_frame_type(views::Widget::FRAME_TYPE_FORCE_NATIVE);
   window_->Init(params);
@@ -82,7 +217,10 @@ NativeWindowWin::NativeWindowWin(content::WebContents* web_contents,
   gfx::Size size(width, height);
   window_->CenterWindow(size);
 
+  window_->UpdateWindowIcon();
+
   web_view_->SetWebContents(web_contents);
+  OnViewWasResized();
 }
 
 NativeWindowWin::~NativeWindowWin() {
@@ -127,6 +265,10 @@ void NativeWindowWin::Unmaximize() {
   window_->Restore();
 }
 
+bool NativeWindowWin::IsVisible() {
+  return window_->IsVisible();
+}
+
 void NativeWindowWin::Minimize() {
   window_->Minimize();
 }
@@ -221,15 +363,91 @@ gfx::NativeWindow NativeWindowWin::GetNativeWindow() {
   return window_->GetNativeView();
 }
 
+void NativeWindowWin::OnMenuCommand(int position, HMENU menu) {
+  DCHECK(menu_);
+  menu_->wrapper()->OnMenuCommand(position, menu);
+}
+
+void NativeWindowWin::SetMenu(ui::MenuModel* menu_model) {
+  menu_.reset(new atom::Menu2(menu_model, true));
+  ::SetMenu(GetNativeWindow(), menu_->GetNativeMenu());
+  RegisterAccelerators();
+}
+
+void NativeWindowWin::UpdateDraggableRegions(
+    const std::vector<DraggableRegion>& regions) {
+  if (has_frame_)
+    return;
+
+  SkRegion* draggable_region = new SkRegion;
+
+  // By default, the whole window is non-draggable. We need to explicitly
+  // include those draggable regions.
+  for (std::vector<DraggableRegion>::const_iterator iter = regions.begin();
+       iter != regions.end(); ++iter) {
+    const DraggableRegion& region = *iter;
+    draggable_region->op(
+        region.bounds.x(),
+        region.bounds.y(),
+        region.bounds.right(),
+        region.bounds.bottom(),
+        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
+  }
+
+  draggable_region_.reset(draggable_region);
+  OnViewWasResized();
+}
+
 void NativeWindowWin::HandleKeyboardEvent(
     content::WebContents*,
     const content::NativeWebKeyboardEvent& event) {
+  if (event.type == WebKit::WebInputEvent::RawKeyDown) {
+    ui::Accelerator accelerator(
+        static_cast<ui::KeyboardCode>(event.windowsKeyCode),
+        content::GetModifiersFromNativeWebKeyboardEvent(event));
+
+    if (GetFocusManager()->ProcessAccelerator(accelerator)) {
+      return;
+    }
+  }
+
   // Any unhandled keyboard/character messages should be defproced.
   // This allows stuff like F10, etc to work correctly.
   DefWindowProc(event.os_event.hwnd, event.os_event.message,
                 event.os_event.wParam, event.os_event.lParam);
 }
 
+void NativeWindowWin::Layout() {
+  DCHECK(web_view_);
+  web_view_->SetBounds(0, 0, width(), height());
+  OnViewWasResized();
+}
+
+void NativeWindowWin::ViewHierarchyChanged(
+  const ViewHierarchyChangedDetails& details) {
+  if (details.is_add && details.child == this)
+    AddChildView(web_view_);
+}
+
+bool NativeWindowWin::AcceleratorPressed(
+    const ui::Accelerator& accelerator) {
+  if (ContainsKey(accelerator_table_, accelerator)) {
+    const MenuItem& item = accelerator_table_[accelerator];
+    item.model->ActivatedAt(item.position);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void NativeWindowWin::DeleteDelegate() {
+  // Do nothing, window is managed by users.
+}
+
+views::View* NativeWindowWin::GetInitiallyFocusedView() {
+  return web_view_;
+}
+
 bool NativeWindowWin::CanResize() const {
   return resizable_;
 }
@@ -246,8 +464,15 @@ bool NativeWindowWin::ShouldHandleSystemCommands() const {
   return true;
 }
 
-bool NativeWindowWin::ShouldShowWindowIcon() const {
-  return true;
+gfx::ImageSkia NativeWindowWin::GetWindowAppIcon() {
+  if (icon_.IsEmpty())
+    return gfx::ImageSkia();
+  else
+    return *icon_.ToImageSkia();
+}
+
+gfx::ImageSkia NativeWindowWin::GetWindowIcon() {
+  return GetWindowAppIcon();
 }
 
 views::Widget* NativeWindowWin::GetWidget() {
@@ -259,12 +484,83 @@ const views::Widget* NativeWindowWin::GetWidget() const {
 }
 
 views::ClientView* NativeWindowWin::CreateClientView(views::Widget* widget) {
-  return new NativeWindowClientView(widget, web_view_, this);
+  return new NativeWindowClientView(widget, this);
 }
 
 views::NonClientFrameView* NativeWindowWin::CreateNonClientFrameView(
     views::Widget* widget) {
-  return new NativeWindowFrameView(widget, this);
+  if (has_frame_)
+    return new NativeWindowFrameView(widget, this);
+
+  return new NativeWindowFramelessView(widget, this);
+}
+
+void NativeWindowWin::OnViewWasResized() {
+  // Set the window shape of the RWHV.
+  gfx::Size sz = web_view_->size();
+  int height = sz.height(), width = sz.width();
+  gfx::Path path;
+  path.addRect(0, 0, width, height);
+  SetWindowRgn(web_contents()->GetView()->GetNativeView(),
+               path.CreateNativeRegion(),
+               1);
+
+  SkRegion* rgn = new SkRegion;
+  if (!window_->IsFullscreen() && !window_->IsMaximized()) {
+    if (draggable_region())
+      rgn->op(*draggable_region(), SkRegion::kUnion_Op);
+
+    if (!has_frame_ && CanResize()) {
+      rgn->op(0, 0, width, kResizeInsideBoundsSize, SkRegion::kUnion_Op);
+      rgn->op(0, 0, kResizeInsideBoundsSize, height, SkRegion::kUnion_Op);
+      rgn->op(width - kResizeInsideBoundsSize, 0, width, height,
+          SkRegion::kUnion_Op);
+      rgn->op(0, height - kResizeInsideBoundsSize, width, height,
+          SkRegion::kUnion_Op);
+    }
+  }
+
+  content::WebContents* web_contents = GetWebContents();
+  if (web_contents->GetRenderViewHost()->GetView())
+    web_contents->GetRenderViewHost()->GetView()->SetClickthroughRegion(rgn);
+}
+
+void NativeWindowWin::RegisterAccelerators() {
+  views::FocusManager* focus_manager = GetFocusManager();
+  accelerator_table_.clear();
+  focus_manager->UnregisterAccelerators(this);
+
+  GenerateAcceleratorTable();
+  for (AcceleratorTable::const_iterator iter = accelerator_table_.begin();
+       iter != accelerator_table_.end(); ++iter) {
+    focus_manager->RegisterAccelerator(
+        iter->first, ui::AcceleratorManager::kNormalPriority, this);
+  }
+}
+
+void NativeWindowWin::GenerateAcceleratorTable() {
+  DCHECK(menu_);
+  ui::SimpleMenuModel* model = static_cast<ui::SimpleMenuModel*>(
+      menu_->model());
+  FillAcceleratorTable(&accelerator_table_, model);
+}
+
+void NativeWindowWin::FillAcceleratorTable(AcceleratorTable* table,
+                                           ui::MenuModel* model) {
+  int count = model->GetItemCount();
+  for (int i = 0; i < count; ++i) {
+    ui::MenuModel::ItemType type = model->GetTypeAt(i);
+    if (type == ui::MenuModel::TYPE_SUBMENU) {
+      ui::MenuModel* submodel = model->GetSubmenuModelAt(i);
+      FillAcceleratorTable(table, submodel);
+    } else {
+      ui::Accelerator accelerator;
+      if (model->GetAcceleratorAt(i, &accelerator)) {
+        MenuItem item = { i, model };
+        (*table)[accelerator] = item;
+      }
+    }
+  }
 }
 
 // static

browser/native_window_win.h

@@ -5,13 +5,16 @@
 #ifndef ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
 #define ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
 
-#include "base/string16.h"
-
 #include "base/memory/scoped_ptr.h"
+#include "base/strings/string16.h"
 #include "browser/native_window.h"
 #include "ui/gfx/size.h"
 #include "ui/views/widget/widget_delegate.h"
 
+namespace ui {
+class MenuModel;
+}
+
 namespace views {
 class WebView;
 class Widget;
@@ -19,8 +22,10 @@ class Widget;
 
 namespace atom {
 
+class Menu2;
+
 class NativeWindowWin : public NativeWindow,
-                        public views::WidgetDelegate {
+                        public views::WidgetDelegateView {
  public:
   explicit NativeWindowWin(content::WebContents* web_contents,
                            base::DictionaryValue* options);
@@ -34,6 +39,7 @@ class NativeWindowWin : public NativeWindow,
   virtual bool IsFocused() OVERRIDE;
   virtual void Show() OVERRIDE;
   virtual void Hide() OVERRIDE;
+  virtual bool IsVisible() OVERRIDE;
   virtual void Maximize() OVERRIDE;
   virtual void Unmaximize() OVERRIDE;
   virtual void Minimize() OVERRIDE;
@@ -60,18 +66,38 @@ class NativeWindowWin : public NativeWindow,
   virtual bool IsKiosk() OVERRIDE;
   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE;
 
+  void OnMenuCommand(int position, HMENU menu);
+
+  // Set the native window menu.
+  void SetMenu(ui::MenuModel* menu_model);
+
+  views::Widget* window() const { return window_.get(); }
+  SkRegion* draggable_region() { return draggable_region_.get(); }
+
  protected:
+  virtual void UpdateDraggableRegions(
+      const std::vector<DraggableRegion>& regions) OVERRIDE;
+
   // Overridden from content::WebContentsDelegate:
   virtual void HandleKeyboardEvent(
       content::WebContents*,
       const content::NativeWebKeyboardEvent&) OVERRIDE;
 
+  // Overridden from views::View:
+  virtual void Layout() OVERRIDE;
+  virtual void ViewHierarchyChanged(
+      const ViewHierarchyChangedDetails& details) OVERRIDE;
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
+
   // Overridden from views::WidgetDelegate:
+  virtual void DeleteDelegate() OVERRIDE;
+  virtual views::View* GetInitiallyFocusedView() OVERRIDE;
   virtual bool CanResize() const OVERRIDE;
   virtual bool CanMaximize() const OVERRIDE;
   virtual string16 GetWindowTitle() const OVERRIDE;
   virtual bool ShouldHandleSystemCommands() const OVERRIDE;
-  virtual bool ShouldShowWindowIcon() const OVERRIDE;
+  virtual gfx::ImageSkia GetWindowAppIcon() OVERRIDE;
+  virtual gfx::ImageSkia GetWindowIcon() OVERRIDE;
   virtual views::Widget* GetWidget() OVERRIDE;
   virtual const views::Widget* GetWidget() const OVERRIDE;
   virtual views::ClientView* CreateClientView(views::Widget* widget) OVERRIDE;
@@ -79,9 +105,32 @@ class NativeWindowWin : public NativeWindow,
       views::Widget* widget) OVERRIDE;
 
  private:
+  typedef struct { int position; ui::MenuModel* model; } MenuItem;
+  typedef std::map<ui::Accelerator, MenuItem> AcceleratorTable;
+
+  void OnViewWasResized();
+
+  // Register accelerators supported by the menu model.
+  void RegisterAccelerators();
+
+  // Generate a table that contains memu model's accelerators and command ids.
+  void GenerateAcceleratorTable();
+
+  // Helper to fill the accelerator table from the model.
+  void FillAcceleratorTable(AcceleratorTable* table,
+                            ui::MenuModel* model);
+
   scoped_ptr<views::Widget> window_;
   views::WebView* web_view_;  // managed by window_.
 
+  // The window menu.
+  scoped_ptr<atom::Menu2> menu_;
+
+  // Map from accelerator to menu item's command id.
+  AcceleratorTable accelerator_table_;
+
+  scoped_ptr<SkRegion> draggable_region_;
+
   bool resizable_;
   string16 title_;
   gfx::Size minimum_size_;