Bump v0.13.3.

Fixes atom/atom#2658.

.gitignore

@@ -1,7 +1,7 @@
 .DS_Store
 /build/
 /dist/
-/frameworks/
+/external_binaries/
 /out/
 /vendor/brightray/vendor/download/
 /vendor/python_26/

.gitmodules

@@ -1,15 +1,15 @@
 [submodule "vendor/brightray"]
 	path = vendor/brightray
-  url = https://github.com/brightray/brightray.git
+	url = https://github.com/brightray/brightray.git
 [submodule "vendor/node"]
 	path = vendor/node
-  url = https://github.com/atom/node.git
+	url = https://github.com/atom/node.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
+[submodule "vendor/native_mate"]
+	path = vendor/native_mate
+	url = https://github.com/zcbenz/native-mate.git

.travis.yml

@@ -0,0 +1,8 @@
+language: objective-c
+
+notifications:
+  email:
+    on_success: never
+    on_failure: change
+
+script: './script/cibuild'

LICENSE

@@ -1,28 +1,20 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Copyright (c) 2014 GitHub Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,20 +1,22 @@
-# Atom Shell
+# Atom Shell [![Build Status](https://travis-ci.org/atom/atom-shell.svg?branch=master)](https://travis-ci.org/atom/atom-shell)
 
-Native layer for the [Atom editor](https://github.com/atom/atom).
+The Atom Shell framework lets you write cross-platform desktop applications
+using JavaScript, HTML and CSS. It is based on [node.js](http://nodejs.org) and
+[Chromium](http://www.chromium.org) and is used in the [Atom
+editor](https://github.com/atom/atom).
 
-## Features
+## Downloads
 
-* 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
+Prebuilt binaries of atom-shell for Linux, Windows and Mac can be found on the
+[releases](https://github.com/atom/atom-shell/releases) page.
 
-## Usage & Development
+## Documentation
 
-See the docs [here](https://github.com/atom/atom-shell/tree/master/docs).
+Guides and the API reference are located in the
+[docs](https://github.com/atom/atom-shell/tree/master/docs) directory. It also
+contains documents describing how to build and contribute to atom-shell.
 
-## License
+## Community
 
-See the [`LICENSE`](LICENSE) file.
+There is an [`atom-shell` category on the Atom forums](http://discuss.atom.io/category/atom-shell)
+as well as an `#atom-shell` channel on Freenode.

atom.gyp

@@ -1,5 +1,8 @@
 {
   'variables': {
+    'includes': [
+      'vendor/native_mate/native_mate_files.gypi',
+    ],
     'project_name': 'atom',
     'product_name': 'Atom',
     'framework_name': 'Atom Framework',
@@ -21,6 +24,8 @@
       'atom/browser/api/lib/menu-item.coffee',
       'atom/browser/api/lib/power-monitor.coffee',
       'atom/browser/api/lib/protocol.coffee',
+      'atom/browser/api/lib/tray.coffee',
+      'atom/browser/api/lib/web-contents.coffee',
       'atom/browser/lib/init.coffee',
       'atom/browser/lib/objects-registry.coffee',
       'atom/browser/lib/rpc-server.coffee',
@@ -36,6 +41,7 @@
       'atom/renderer/lib/override.coffee',
       'atom/renderer/api/lib/ipc.coffee',
       'atom/renderer/api/lib/remote.coffee',
+      'atom/renderer/api/lib/web-view.coffee',
     ],
     'lib_sources': [
       'atom/app/atom_main_delegate.cc',
@@ -45,12 +51,7 @@
       'atom/browser/api/atom_api_app.h',
       'atom/browser/api/atom_api_auto_updater.cc',
       'atom/browser/api/atom_api_auto_updater.h',
-      'atom/browser/api/atom_api_browser_ipc.cc',
-      'atom/browser/api/atom_api_browser_ipc.h',
       'atom/browser/api/atom_api_dialog.cc',
-      'atom/browser/api/atom_api_dialog.h',
-      'atom/browser/api/atom_api_event.cc',
-      'atom/browser/api/atom_api_event.h',
       'atom/browser/api/atom_api_menu.cc',
       'atom/browser/api/atom_api_menu.h',
       'atom/browser/api/atom_api_menu_gtk.cc',
@@ -63,20 +64,22 @@
       'atom/browser/api/atom_api_power_monitor.h',
       'atom/browser/api/atom_api_protocol.cc',
       'atom/browser/api/atom_api_protocol.h',
+      'atom/browser/api/atom_api_tray.cc',
+      'atom/browser/api/atom_api_tray.h',
+      'atom/browser/api/atom_api_web_contents.cc',
+      'atom/browser/api/atom_api_web_contents.h',
       'atom/browser/api/atom_api_window.cc',
       'atom/browser/api/atom_api_window.h',
-      'atom/browser/api/atom_browser_bindings.cc',
-      'atom/browser/api/atom_browser_bindings.h',
+      'atom/browser/api/event.cc',
+      'atom/browser/api/event.h',
+      'atom/browser/api/event_emitter.cc',
+      'atom/browser/api/event_emitter.h',
       'atom/browser/auto_updater.cc',
       'atom/browser/auto_updater.h',
       'atom/browser/auto_updater_delegate.h',
       'atom/browser/auto_updater_linux.cc',
       'atom/browser/auto_updater_mac.mm',
       'atom/browser/auto_updater_win.cc',
-      'atom/browser/atom_application_mac.h',
-      'atom/browser/atom_application_mac.mm',
-      'atom/browser/atom_application_delegate_mac.h',
-      'atom/browser/atom_application_delegate_mac.mm',
       'atom/browser/atom_browser_client.cc',
       'atom/browser/atom_browser_client.h',
       'atom/browser/atom_browser_context.cc',
@@ -94,8 +97,10 @@
       'atom/browser/browser_observer.h',
       'atom/browser/devtools_delegate.cc',
       'atom/browser/devtools_delegate.h',
-      'atom/browser/devtools_web_contents_observer.cc',
-      'atom/browser/devtools_web_contents_observer.h',
+      'atom/browser/mac/atom_application.h',
+      'atom/browser/mac/atom_application.mm',
+      'atom/browser/mac/atom_application_delegate.h',
+      'atom/browser/mac/atom_application_delegate.mm',
       'atom/browser/native_window.cc',
       'atom/browser/native_window.h',
       'atom/browser/native_window_gtk.cc',
@@ -126,31 +131,41 @@
       'atom/browser/ui/file_dialog_gtk.cc',
       'atom/browser/ui/file_dialog_mac.mm',
       'atom/browser/ui/file_dialog_win.cc',
+      'atom/browser/ui/gtk/app_indicator_icon.cc',
+      'atom/browser/ui/gtk/app_indicator_icon.h',
+      'atom/browser/ui/gtk/status_icon.cc',
+      'atom/browser/ui/gtk/status_icon.h',
       'atom/browser/ui/message_box.h',
       'atom/browser/ui/message_box_gtk.cc',
       'atom/browser/ui/message_box_mac.mm',
       'atom/browser/ui/message_box_win.cc',
+      'atom/browser/ui/tray_icon.cc',
+      'atom/browser/ui/tray_icon.h',
+      'atom/browser/ui/tray_icon_gtk.cc',
+      'atom/browser/ui/tray_icon_cocoa.h',
+      'atom/browser/ui/tray_icon_cocoa.mm',
+      'atom/browser/ui/tray_icon_observer.h',
+      'atom/browser/ui/tray_icon_win.cc',
       'atom/browser/ui/win/menu_2.cc',
       'atom/browser/ui/win/menu_2.h',
       'atom/browser/ui/win/native_menu_win.cc',
       'atom/browser/ui/win/native_menu_win.h',
+      'atom/browser/ui/win/notify_icon_host.cc',
+      'atom/browser/ui/win/notify_icon_host.h',
+      'atom/browser/ui/win/notify_icon.cc',
+      'atom/browser/ui/win/notify_icon.h',
       'atom/browser/window_list.cc',
       'atom/browser/window_list.h',
       'atom/browser/window_list_observer.h',
       'atom/common/api/api_messages.cc',
       'atom/common/api/api_messages.h',
       'atom/common/api/atom_api_clipboard.cc',
-      'atom/common/api/atom_api_clipboard.h',
       'atom/common/api/atom_api_crash_reporter.cc',
-      'atom/common/api/atom_api_crash_reporter.h',
-      'atom/common/api/atom_api_event_emitter.cc',
-      'atom/common/api/atom_api_event_emitter.h',
       'atom/common/api/atom_api_id_weak_map.cc',
       'atom/common/api/atom_api_id_weak_map.h',
       'atom/common/api/atom_api_screen.cc',
       'atom/common/api/atom_api_screen.h',
       'atom/common/api/atom_api_shell.cc',
-      'atom/common/api/atom_api_shell.h',
       'atom/common/api/atom_api_v8_util.cc',
       'atom/common/api/atom_bindings.cc',
       'atom/common/api/atom_bindings.h',
@@ -158,6 +173,8 @@
       'atom/common/api/atom_extensions.h',
       'atom/common/api/object_life_monitor.cc',
       'atom/common/api/object_life_monitor.h',
+      'atom/common/browser_v8_locker.cc',
+      'atom/common/browser_v8_locker.h',
       'atom/common/crash_reporter/crash_reporter.cc',
       'atom/common/crash_reporter/crash_reporter.h',
       'atom/common/crash_reporter/crash_reporter_linux.cc',
@@ -175,6 +192,16 @@
       'atom/common/draggable_region.cc',
       'atom/common/draggable_region.h',
       'atom/common/linux/application_info.cc',
+      'atom/common/native_mate_converters/file_path_converter.h',
+      'atom/common/native_mate_converters/function_converter.h',
+      'atom/common/native_mate_converters/gurl_converter.h',
+      'atom/common/native_mate_converters/image_converter.cc',
+      'atom/common/native_mate_converters/image_converter.h',
+      'atom/common/native_mate_converters/string16_converter.h',
+      'atom/common/native_mate_converters/v8_value_converter.cc',
+      'atom/common/native_mate_converters/v8_value_converter.h',
+      'atom/common/native_mate_converters/value_converter.cc',
+      'atom/common/native_mate_converters/value_converter.h',
       'atom/common/node_bindings.cc',
       'atom/common/node_bindings.h',
       'atom/common/node_bindings_linux.cc',
@@ -183,22 +210,18 @@
       'atom/common/node_bindings_mac.h',
       'atom/common/node_bindings_win.cc',
       'atom/common/node_bindings_win.h',
+      'atom/common/node_includes.h',
       'atom/common/options_switches.cc',
       'atom/common/options_switches.h',
       'atom/common/platform_util.h',
       'atom/common/platform_util_linux.cc',
       'atom/common/platform_util_mac.mm',
       'atom/common/platform_util_win.cc',
-      'atom/common/swap_or_assign.h',
-      'atom/common/v8/node_common.h',
-      'atom/common/v8/scoped_persistent.h',
-      'atom/common/v8/native_type_conversions.h',
-      'atom/common/v8/v8_value_converter.cc',
-      'atom/common/v8/v8_value_converter.h',
       'atom/renderer/api/atom_api_renderer_ipc.cc',
-      'atom/renderer/api/atom_api_renderer_ipc.h',
       'atom/renderer/api/atom_renderer_bindings.cc',
       'atom/renderer/api/atom_renderer_bindings.h',
+      'atom/renderer/api/atom_api_web_view.cc',
+      'atom/renderer/api/atom_api_web_view.h',
       'atom/renderer/atom_render_view_observer.cc',
       'atom/renderer/atom_render_view_observer.h',
       'atom/renderer/atom_renderer_client.cc',
@@ -215,11 +238,23 @@
       'chrome/browser/ui/gtk/gtk_window_util.h',
       'chrome/browser/ui/gtk/menu_gtk.cc',
       'chrome/browser/ui/gtk/menu_gtk.h',
+      'chrome/browser/ui/views/status_icons/status_tray_state_changer_win.cc',
+      'chrome/browser/ui/views/status_icons/status_tray_state_changer_win.h',
+      '<@(native_mate_files)',
     ],
     'framework_sources': [
       'atom/app/atom_library_main.cc',
       'atom/app/atom_library_main.h',
     ],
+    'locales': [
+      'am', 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en-GB',
+      'en-US', 'es-419', 'es', 'et', 'fa', 'fi', 'fil', 'fr', 'gu', 'he',
+      'hi', 'hr', 'hu', 'id', 'it', 'ja', 'kn', 'ko', 'lt', 'lv',
+      'ml', 'mr', 'ms', 'nb', 'nl', 'pl', 'pt-BR', 'pt-PT', 'ro', 'ru',
+      'sk', 'sl', 'sr', 'sv', 'sw', 'ta', 'te', 'th', 'tr', 'uk',
+      'vi', 'zh-CN', 'zh-TW',
+    ],
+    'atom_source_root': '<!(python tools/atom_source_root.py)',
     'conditions': [
       ['OS=="win"', {
         'app_sources': [
@@ -229,12 +264,14 @@
           '<(libchromiumcontent_src_dir)/content/app/startup_helper_win.cc',
         ],
       }],  # OS=="win"
+      ['OS=="mac"', {
+        'apply_locales_cmd': ['python', 'tools/mac/apply_locales.py'],
+      }],  # OS=="mac"
     ],
-    'atom_source_root': '<!(python tools/atom_source_root.py)',
   },
   'target_defaults': {
     'mac_framework_dirs': [
-      '<(atom_source_root)/frameworks',
+      '<(atom_source_root)/external_binaries',
     ],
     'includes': [
        # Rules for excluding e.g. foo_win.cc from the build on non-Windows.
@@ -287,9 +324,9 @@
               'files': [
                 '<(PRODUCT_DIR)/<(product_name) Helper.app',
                 '<(PRODUCT_DIR)/<(framework_name).framework',
-                'frameworks/Squirrel.framework',
-                'frameworks/ReactiveCocoa.framework',
-                'frameworks/Mantle.framework',
+                'external_binaries/Squirrel.framework',
+                'external_binaries/ReactiveCocoa.framework',
+                'external_binaries/Mantle.framework',
               ],
             },
             {
@@ -316,8 +353,27 @@
                 '<(product_name)',
               ],
             },
+              # The application doesn't have real localizations, it just has
+              # empty .lproj directories, which is enough to convince Cocoa
+              # atom-shell supports those languages.
+            {
+              'postbuild_name': 'Make Empty Localizations',
+              'variables': {
+                'locale_dirs': [
+                  '>!@(<(apply_locales_cmd) -d ZZLOCALE.lproj <(locales))',
+                ],
+              },
+              'action': [
+                'tools/mac/make_locale_dirs.sh',
+                '<@(locale_dirs)',
+              ],
+            },
           ]
-        }],  # OS=="mac"
+        }, {  # OS=="mac"
+          'dependencies': [
+            'make_locale_paks',
+          ],
+        }],  # OS!="mac"
         ['OS=="win"', {
           'copies': [
             {
@@ -326,8 +382,11 @@
                 '<(libchromiumcontent_library_dir)/chromiumcontent.dll',
                 '<(libchromiumcontent_library_dir)/ffmpegsumo.dll',
                 '<(libchromiumcontent_library_dir)/icudt.dll',
+                '<(libchromiumcontent_library_dir)/libEGL.dll',
                 '<(libchromiumcontent_library_dir)/libGLESv2.dll',
                 '<(libchromiumcontent_resources_dir)/content_shell.pak',
+                'external_binaries/d3dcompiler_43.dll',
+                'external_binaries/xinput1_3.dll',
               ],
             },
             {
@@ -371,6 +430,7 @@
       'include_dirs': [
         '.',
         'vendor/brightray',
+        'vendor/native_mate',
         # Include directories for uv and node.
         'vendor/node/src',
         'vendor/node/deps/http_parser',
@@ -596,9 +656,9 @@
           'link_settings': {
             'libraries': [
               '$(SDKROOT)/System/Library/Frameworks/Carbon.framework',
-              'frameworks/Squirrel.framework',
-              'frameworks/ReactiveCocoa.framework',
-              'frameworks/Mantle.framework',
+              'external_binaries/Squirrel.framework',
+              'external_binaries/ReactiveCocoa.framework',
+              'external_binaries/Mantle.framework',
             ],
           },
           'mac_bundle': 1,
@@ -669,7 +729,31 @@
           },
         },  # target helper
       ],
-    }],  # OS==Mac
+    }, {  # OS=="mac"
+      'targets': [
+        {
+          'target_name': 'make_locale_paks',
+          'type': 'none',
+          'actions': [
+            {
+              'action_name': 'Make Empty Paks',
+              'inputs': [
+                'tools/posix/make_locale_paks.sh',
+              ],
+              'outputs': [
+                '<(PRODUCT_DIR)/locales'
+              ],
+              'action': [
+                'tools/posix/make_locale_paks.sh',
+                '<(PRODUCT_DIR)',
+                '<@(locales)',
+              ],
+              'msvs_cygwin_shell': 0,
+            },
+          ],
+        },
+      ],
+    }],  # OS!="mac"
     ['OS=="win"', {
       'targets': [
         {

atom/app/atom_library_main.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/app/atom_library_main.h"

atom/app/atom_library_main.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_APP_ATOM_LIBRARY_MAIN_H_

atom/app/atom_main.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/app/atom_main.h"

atom/app/atom_main.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_APP_ATOM_MAIN_H_

atom/app/atom_main_delegate.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/app/atom_main_delegate.h"

atom/app/atom_main_delegate.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_APP_ATOM_MAIN_DELEGATE_H_

atom/app/atom_main_delegate_mac.mm

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/app/atom_main_delegate.h"

atom/browser/api/atom_api_app.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_app.h"
@@ -9,16 +9,18 @@
 #include "base/values.h"
 #include "base/command_line.h"
 #include "atom/browser/browser.h"
-#include "atom/common/v8/native_type_conversions.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
 
-#include "atom/common/v8/node_common.h"
+#include "atom/common/node_includes.h"
+
+using atom::Browser;
 
 namespace atom {
 
 namespace api {
 
-App::App(v8::Handle<v8::Object> wrapper)
-    : EventEmitter(wrapper) {
+App::App() {
   Browser::Get()->AddObserver(this);
 }
 
@@ -37,13 +39,13 @@ void App::OnWindowAllClosed() {
 void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
   base::ListValue args;
   args.AppendString(file_path);
-  *prevent_default = Emit("open-file", &args);
+  *prevent_default = Emit("open-file", args);
 }
 
 void App::OnOpenURL(const std::string& url) {
   base::ListValue args;
   args.AppendString(url);
-  Emit("open-url", &args);
+  Emit("open-url", args);
 }
 
 void App::OnActivateWithNoOpenWindows() {
@@ -58,156 +60,80 @@ void App::OnFinishLaunching() {
   Emit("ready");
 }
 
-// static
-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());
+mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  Browser* browser = Browser::Get();
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("quit", base::Bind(&Browser::Quit,
+                                    base::Unretained(browser)))
+      .SetMethod("focus", base::Bind(&Browser::Focus,
+                                     base::Unretained(browser)))
+      .SetMethod("getVersion", base::Bind(&Browser::GetVersion,
+                                          base::Unretained(browser)))
+      .SetMethod("setVersion", base::Bind(&Browser::SetVersion,
+                                          base::Unretained(browser)))
+      .SetMethod("getName", base::Bind(&Browser::GetName,
+                                       base::Unretained(browser)))
+      .SetMethod("setName", base::Bind(&Browser::SetName,
+                                       base::Unretained(browser)));
 }
 
 // static
-void App::Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  Browser::Get()->Quit();
-}
-
-// static
-void App::Exit(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  exit(args[0]->IntegerValue());
-}
-
-// static
-void App::Terminate(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  Browser::Get()->Terminate();
-}
-
-// static
-void App::Focus(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  Browser::Get()->Focus();
-}
-
-// static
-void App::GetVersion(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  args.GetReturnValue().Set(ToV8Value(Browser::Get()->GetVersion()));
-}
-
-// static
-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");
-
-  if (args.Length() == 1) {
-    CommandLine::ForCurrentProcess()->AppendSwitch(switch_string);
-  } else {
-    std::string value = FromV8Value(args[1]);
-    CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-        switch_string, value);
-  }
-}
-
-// static
-void App::AppendArgument(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  std::string value;
-  if (!FromV8Arguments(args, &value))
-    return node::ThrowError("Bad argument");
-
-  CommandLine::ForCurrentProcess()->AppendArg(value);
-}
-
-#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::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(v8::String::NewSymbol("Application"));
-
-  NODE_SET_PROTOTYPE_METHOD(t, "quit", Quit);
-  NODE_SET_PROTOTYPE_METHOD(t, "exit", Exit);
-  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)
+mate::Handle<App> App::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new App);
 }
 
 }  // namespace api
 
 }  // namespace atom
 
-NODE_MODULE(atom_browser_app, atom::api::App::Initialize)
+
+namespace {
+
+void AppendSwitch(const std::string& switch_string, mate::Arguments* args) {
+  std::string value;
+  if (args->GetNext(&value))
+    CommandLine::ForCurrentProcess()->AppendSwitchASCII(switch_string, value);
+  else
+    CommandLine::ForCurrentProcess()->AppendSwitch(switch_string);
+}
+
+#if defined(OS_MACOSX)
+int DockBounce(const std::string& type) {
+  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);
+  return request_id;
+}
+#endif
+
+void Initialize(v8::Handle<v8::Object> exports) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  Browser* browser = Browser::Get();
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("app", atom::api::App::Create(isolate));
+  dict.SetMethod("appendSwitch", &AppendSwitch);
+  dict.SetMethod("appendArgument",
+                 base::Bind(&CommandLine::AppendArg,
+                            base::Unretained(command_line)));
+#if defined(OS_MACOSX)
+  dict.SetMethod("dockBounce", &DockBounce);
+  dict.SetMethod("dockCancelBounce",
+                 base::Bind(&Browser::DockCancelBounce,
+                            base::Unretained(browser)));
+  dict.SetMethod("dockSetBadgeText",
+                 base::Bind(&Browser::DockSetBadgeText,
+                            base::Unretained(browser)));
+  dict.SetMethod("dockGetBadgeText",
+                 base::Bind(&Browser::DockGetBadgeText,
+                            base::Unretained(browser)));
+#endif
+}
+
+}  // namespace
+
+NODE_MODULE(atom_browser_app, Initialize)

atom/browser/api/atom_api_app.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_APP_H_
@@ -8,22 +8,22 @@
 #include <string>
 
 #include "base/compiler_specific.h"
+#include "atom/browser/api/event_emitter.h"
 #include "atom/browser/browser_observer.h"
-#include "atom/common/api/atom_api_event_emitter.h"
+#include "native_mate/handle.h"
 
 namespace atom {
 
 namespace api {
 
-class App : public EventEmitter,
+class App : public mate::EventEmitter,
             public BrowserObserver {
  public:
-  virtual ~App();
-
-  static void Initialize(v8::Handle<v8::Object> target);
+  static mate::Handle<App> Create(v8::Isolate* isolate);
 
  protected:
-  explicit App(v8::Handle<v8::Object> wrapper);
+  App();
+  virtual ~App();
 
   // BrowserObserver implementations:
   virtual void OnWillQuit(bool* prevent_default) OVERRIDE;
@@ -35,27 +35,11 @@ class App : public EventEmitter,
   virtual void OnWillFinishLaunching() OVERRIDE;
   virtual void OnFinishLaunching() OVERRIDE;
 
+  // mate::Wrappable implementations:
+  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate);
+
  private:
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& 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);
 };
 

atom/browser/api/atom_api_auto_updater.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_auto_updater.h"
@@ -7,16 +7,17 @@
 #include "base/time/time.h"
 #include "base/values.h"
 #include "atom/browser/auto_updater.h"
-#include "atom/common/v8/native_type_conversions.h"
+#include "atom/browser/browser.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
 
-#include "atom/common/v8/node_common.h"
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
 namespace api {
 
-AutoUpdater::AutoUpdater(v8::Handle<v8::Object> wrapper)
-    : EventEmitter(wrapper) {
+AutoUpdater::AutoUpdater() {
   auto_updater::AutoUpdater::SetDelegate(this);
 }
 
@@ -27,7 +28,7 @@ AutoUpdater::~AutoUpdater() {
 void AutoUpdater::OnError(const std::string& error) {
   base::ListValue args;
   args.AppendString(error);
-  Emit("error", &args);
+  Emit("error", args);
 }
 
 void AutoUpdater::OnCheckingForUpdate() {
@@ -54,53 +55,42 @@ void AutoUpdater::OnUpdateDownloaded(const std::string& release_notes,
   args.AppendString(release_name);
   args.AppendDouble(release_date.ToJsTime());
   args.AppendString(update_url);
-  Emit("update-downloaded-raw", &args);
+  Emit("update-downloaded-raw", args);
+}
+
+mate::ObjectTemplateBuilder AutoUpdater::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("setFeedUrl", &auto_updater::AutoUpdater::SetFeedURL)
+      .SetMethod("checkForUpdates", &auto_updater::AutoUpdater::CheckForUpdates)
+      .SetMethod("_quitAndInstall", &AutoUpdater::QuitAndInstall);
+}
+
+void AutoUpdater::QuitAndInstall() {
+  if (quit_and_install_.is_null())
+    Browser::Get()->Shutdown();
+  else
+    quit_and_install_.Run();
 }
 
 // static
-void AutoUpdater::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  if (!args.IsConstructCall())
-    return node::ThrowError("Require constructor call");
-
-  new AutoUpdater(args.This());
-}
-
-// static
-void AutoUpdater::SetFeedURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  auto_updater::AutoUpdater::SetFeedURL(FromV8Value(args[0]));
-}
-
-// static
-void AutoUpdater::CheckForUpdates(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  auto_updater::AutoUpdater::CheckForUpdates();
-}
-
-// static
-void AutoUpdater::QuitAndInstall(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  AutoUpdater* self = AutoUpdater::Unwrap<AutoUpdater>(args.This());
-
-  if (!self->quit_and_install_.is_null())
-    self->quit_and_install_.Run();
-}
-
-// static
-void AutoUpdater::Initialize(v8::Handle<v8::Object> target) {
-  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, "checkForUpdates", CheckForUpdates);
-  NODE_SET_PROTOTYPE_METHOD(t, "quitAndInstall", QuitAndInstall);
-
-  target->Set(v8::String::NewSymbol("AutoUpdater"), t->GetFunction());
+mate::Handle<AutoUpdater> AutoUpdater::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new AutoUpdater);
 }
 
 }  // namespace api
 
 }  // namespace atom
 
-NODE_MODULE(atom_browser_auto_updater, atom::api::AutoUpdater::Initialize)
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("autoUpdater", atom::api::AutoUpdater::Create(isolate));
+}
+
+}  // namespace
+
+NODE_MODULE(atom_browser_auto_updater, Initialize)

atom/browser/api/atom_api_auto_updater.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_
@@ -8,23 +8,22 @@
 #include <string>
 
 #include "base/callback.h"
-#include "base/memory/scoped_ptr.h"
+#include "atom/browser/api/event_emitter.h"
 #include "atom/browser/auto_updater_delegate.h"
-#include "atom/common/api/atom_api_event_emitter.h"
+#include "native_mate/handle.h"
 
 namespace atom {
 
 namespace api {
 
-class AutoUpdater : public EventEmitter,
+class AutoUpdater : public mate::EventEmitter,
                     public auto_updater::AutoUpdaterDelegate {
  public:
-  virtual ~AutoUpdater();
-
-  static void Initialize(v8::Handle<v8::Object> target);
+  static mate::Handle<AutoUpdater> Create(v8::Isolate* isolate);
 
  protected:
-  explicit AutoUpdater(v8::Handle<v8::Object> wrapper);
+  AutoUpdater();
+  virtual ~AutoUpdater();
 
   // AutoUpdaterDelegate implementations.
   virtual void OnError(const std::string& error) OVERRIDE;
@@ -38,14 +37,12 @@ class AutoUpdater : public EventEmitter,
       const std::string& update_url,
       const base::Closure& quit_and_install) OVERRIDE;
 
+  // mate::Wrappable implementations:
+  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate);
+
  private:
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void SetFeedURL(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CheckForUpdates(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void ContinueUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void QuitAndInstall(const v8::FunctionCallbackInfo<v8::Value>& args);
+  void QuitAndInstall();
 
   base::Closure quit_and_install_;
 

atom/browser/api/atom_api_browser_ipc.cc

@@ -1,48 +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 "atom/browser/api/atom_api_browser_ipc.h"
-
-#include "atom/common/api/api_messages.h"
-#include "atom/common/v8/node_common.h"
-#include "atom/common/v8/native_type_conversions.h"
-#include "content/public/browser/render_view_host.h"
-
-using content::RenderViewHost;
-
-namespace atom {
-
-namespace api {
-
-// static
-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");
-
-  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");
-
-  args.GetReturnValue().Set(render_view_host->Send(new AtomViewMsg_Message(
-      routing_id,
-      channel,
-      *static_cast<base::ListValue*>(arguments.get()))));
-}
-
-// static
-void BrowserIPC::Initialize(v8::Handle<v8::Object> target) {
-  NODE_SET_METHOD(target, "send", Send);
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-NODE_MODULE(atom_browser_ipc, atom::api::BrowserIPC::Initialize)

atom/browser/api/atom_api_browser_ipc.h

@@ -1,29 +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_API_ATOM_API_BROWSER_IPC_H_
-#define ATOM_BROWSER_API_ATOM_API_BROWSER_IPC_H_
-
-#include "base/basictypes.h"
-#include "v8/include/v8.h"
-
-namespace atom {
-
-namespace api {
-
-class BrowserIPC {
- public:
-  static void Initialize(v8::Handle<v8::Object> target);
-
- private:
-  static void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(BrowserIPC);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_BROWSER_IPC_H_

atom/browser/api/atom_api_dialog.cc

@@ -1,144 +1,88 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "atom/browser/api/atom_api_dialog.h"
-
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
+#include "atom/browser/api/atom_api_window.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/ui/file_dialog.h"
 #include "atom/browser/ui/message_box.h"
-#include "atom/common/v8/node_common.h"
-#include "atom/common/v8/native_type_conversions.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/function_converter.h"
+#include "native_mate/dictionary.h"
 
-namespace atom {
-
-namespace api {
+#include "atom/common/node_includes.h"
 
 namespace {
 
-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);
+void ShowMessageBox(int type,
+                    const std::vector<std::string>& buttons,
+                    const std::string& title,
+                    const std::string& message,
+                    const std::string& detail,
+                    atom::NativeWindow* window,
+                    mate::Arguments* args) {
+  v8::Handle<v8::Value> peek = args->PeekNext();
+  atom::MessageBoxCallback callback;
+  if (mate::Converter<atom::MessageBoxCallback>::FromV8(node_isolate,
+                                                        peek,
+                                                        &callback)) {
+    atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons, title,
+                         message, detail, callback);
+  } else {
+    int chosen = atom::ShowMessageBox(window, (atom::MessageBoxType)type,
+                                      buttons, title, message, detail);
+    args->Return(chosen);
+  }
 }
 
-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 ShowOpenDialog(const std::string& title,
+                    const base::FilePath& default_path,
+                    int properties,
+                    atom::NativeWindow* window,
+                    mate::Arguments* args) {
+  v8::Handle<v8::Value> peek = args->PeekNext();
+  file_dialog::OpenDialogCallback callback;
+  if (mate::Converter<file_dialog::OpenDialogCallback>::FromV8(node_isolate,
+                                                               peek,
+                                                               &callback)) {
+    file_dialog::ShowOpenDialog(window, title, default_path, properties,
+                                callback);
+  } else {
+    std::vector<base::FilePath> paths;
+    if (file_dialog::ShowOpenDialog(window, title, default_path, properties,
+                                    &paths))
+      args->Return(paths);
+  }
 }
 
-void Initialize(v8::Handle<v8::Object> target) {
-  NODE_SET_METHOD(target, "showMessageBox", ShowMessageBox);
-  NODE_SET_METHOD(target, "showOpenDialog", ShowOpenDialog);
-  NODE_SET_METHOD(target, "showSaveDialog", ShowSaveDialog);
+void ShowSaveDialog(const std::string& title,
+                    const base::FilePath& default_path,
+                    atom::NativeWindow* window,
+                    mate::Arguments* args) {
+  v8::Handle<v8::Value> peek = args->PeekNext();
+  file_dialog::SaveDialogCallback callback;
+  if (mate::Converter<file_dialog::SaveDialogCallback>::FromV8(node_isolate,
+                                                               peek,
+                                                               &callback)) {
+    file_dialog::ShowSaveDialog(window, title, default_path, callback);
+  } else {
+    base::FilePath path;
+    if (file_dialog::ShowSaveDialog(window, title, default_path, &path))
+      args->Return(path);
+  }
+}
+
+void Initialize(v8::Handle<v8::Object> exports) {
+  mate::Dictionary dict(v8::Isolate::GetCurrent(), exports);
+  dict.SetMethod("showMessageBox", &ShowMessageBox);
+  dict.SetMethod("showOpenDialog", &ShowOpenDialog);
+  dict.SetMethod("showSaveDialog", &ShowSaveDialog);
 }
 
 }  // namespace
 
-void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  int type;
-  std::vector<std::string> buttons;
-  std::string title, message, detail;
-  if (!FromV8Arguments(args, &type, &buttons, &title, &message, &detail))
-    return node::ThrowTypeError("Bad argument");
-
-  NativeWindow* native_window = FromV8Value(args[5]);
-
-  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));
-  }
-}
-
-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");
-
-  NativeWindow* native_window = FromV8Value(args[3]);
-
-  if (!args[4]->IsFunction()) {
-    std::vector<base::FilePath> paths;
-    if (!file_dialog::ShowOpenDialog(native_window,
-                                     title,
-                                     default_path,
-                                     properties,
-                                     &paths))
-      return;
-
-    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]));
-
-    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
-
-}  // namespace atom
-
-NODE_MODULE(atom_browser_dialog, atom::api::Initialize)
+NODE_MODULE(atom_browser_dialog, Initialize)

atom/browser/api/atom_api_dialog.h

@@ -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.
-
-#ifndef ATOM_BROWSER_API_ATOM_API_DIALOG_H_
-#define ATOM_BROWSER_API_ATOM_API_DIALOG_H_
-
-#include "v8/include/v8.h"
-
-namespace atom {
-
-namespace api {
-
-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
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_DIALOG_H_

atom/browser/api/atom_api_event.cc

@@ -1,99 +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 "atom/browser/api/atom_api_event.h"
-
-#include "atom/common/api/api_messages.h"
-#include "atom/common/v8/node_common.h"
-#include "atom/common/v8/native_type_conversions.h"
-#include "content/public/browser/web_contents.h"
-
-namespace atom {
-
-namespace api {
-
-ScopedPersistent<v8::Function> Event::constructor_template_;
-
-Event::Event()
-    : sender_(NULL),
-      message_(NULL),
-      prevent_default_(false) {
-}
-
-Event::~Event() {
-}
-
-// static
-v8::Handle<v8::Object> Event::CreateV8Object() {
-  if (constructor_template_.IsEmpty()) {
-    v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
-    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::Function> t = constructor_template_.NewHandle(node_isolate);
-  return t->NewInstance(0, NULL);
-}
-
-void Event::SetSenderAndMessage(content::WebContents* sender,
-                                IPC::Message* message) {
-  DCHECK(!sender_);
-  DCHECK(!message_);
-  sender_ = sender;
-  message_ = message;
-
-  Observe(sender);
-}
-
-void Event::WebContentsDestroyed(content::WebContents* web_contents) {
-  sender_ = NULL;
-  message_ = NULL;
-}
-
-// static
-void Event::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  Event* event = new Event;
-  event->Wrap(args.This());
-}
-
-// 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;
-}
-
-// 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
-
-}  // namespace atom

atom/browser/api/atom_api_event.h

@@ -1,65 +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_API_ATOM_API_EVENT_H_
-#define ATOM_BROWSER_API_ATOM_API_EVENT_H_
-
-#include "atom/common/v8/scoped_persistent.h"
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "base/strings/string16.h"
-#include "content/public/browser/web_contents_observer.h"
-#include "vendor/node/src/node_object_wrap.h"
-
-namespace IPC {
-class Message;
-}
-
-namespace atom {
-
-namespace api {
-
-class Event : public node::ObjectWrap,
-              public content::WebContentsObserver {
- public:
-  virtual ~Event();
-
-  // Create a V8 Event object.
-  static v8::Handle<v8::Object> CreateV8Object();
-
-  // Pass the sender and message to be replied.
-  void SetSenderAndMessage(content::WebContents* sender, IPC::Message* message);
-
-  // Whether event.preventDefault() is called.
-  bool prevent_default() const { return prevent_default_; }
-
- protected:
-  Event();
-
-  // content::WebContentsObserver implementations:
-  virtual void WebContentsDestroyed(content::WebContents*) OVERRIDE;
-
- 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.
-  content::WebContents* sender_;
-  IPC::Message* message_;
-
-  bool prevent_default_;
-
-  DISALLOW_COPY_AND_ASSIGN(Event);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_EVENT_H_

atom/browser/api/atom_api_menu.cc

@@ -1,19 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_menu.h"
 
-#include <string>
-
+#include "atom/browser/api/atom_api_window.h"
 #include "atom/browser/ui/accelerator_util.h"
-#include "atom/common/v8/node_common.h"
-#include "atom/common/v8/native_type_conversions.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "native_mate/constructor.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
 
-#define UNWRAP_MEMNU_AND_CHECK \
-  Menu* self = ObjectWrap::Unwrap<Menu>(args.This()); \
-  if (self == NULL) \
-    return node::ThrowError("Menu is already destroyed")
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
@@ -46,9 +44,9 @@ v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
 
 }  // namespace
 
-Menu::Menu(v8::Handle<v8::Object> wrapper)
-    : EventEmitter(wrapper),
-      model_(new ui::SimpleMenuModel(this)) {
+Menu::Menu()
+    : model_(new ui::SimpleMenuModel(this)),
+      parent_(NULL) {
 }
 
 Menu::~Menu() {
@@ -58,7 +56,7 @@ bool Menu::IsCommandIdChecked(int command_id) const {
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::False(),
-                      const_cast<Menu*>(this)->handle(),
+                      const_cast<Menu*>(this)->GetWrapper(node_isolate),
                       "isCommandIdChecked",
                       command_id)->BooleanValue();
 }
@@ -67,7 +65,7 @@ bool Menu::IsCommandIdEnabled(int command_id) const {
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::True(),
-                      const_cast<Menu*>(this)->handle(),
+                      const_cast<Menu*>(this)->GetWrapper(node_isolate),
                       "isCommandIdEnabled",
                       command_id)->BooleanValue();
 }
@@ -76,7 +74,7 @@ bool Menu::IsCommandIdVisible(int command_id) const {
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::True(),
-                      const_cast<Menu*>(this)->handle(),
+                      const_cast<Menu*>(this)->GetWrapper(node_isolate),
                       "isCommandIdVisible",
                       command_id)->BooleanValue();
 }
@@ -86,11 +84,11 @@ bool Menu::GetAcceleratorForCommandId(int command_id,
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
   v8::Handle<v8::Value> shortcut = CallDelegate(v8::Undefined(),
-                                                handle(),
+                                                GetWrapper(node_isolate),
                                                 "getAcceleratorForCommandId",
                                                 command_id);
   if (shortcut->IsString()) {
-    std::string shortcut_str = FromV8Value(shortcut);
+    std::string shortcut_str = mate::V8ToString(shortcut);
     return accelerator_util::StringToAccelerator(shortcut_str, accelerator);
   }
 
@@ -101,7 +99,7 @@ bool Menu::IsItemForCommandIdDynamic(int command_id) const {
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::False(),
-                      const_cast<Menu*>(this)->handle(),
+                      const_cast<Menu*>(this)->GetWrapper(node_isolate),
                       "isItemForCommandIdDynamic",
                       command_id)->BooleanValue();
 }
@@ -109,254 +107,160 @@ bool Menu::IsItemForCommandIdDynamic(int command_id) const {
 string16 Menu::GetLabelForCommandId(int command_id) const {
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
-  return FromV8Value(CallDelegate(v8::False(),
-                                  const_cast<Menu*>(this)->handle(),
-                                  "getLabelForCommandId",
-                                  command_id));
+  v8::Handle<v8::Value> result = CallDelegate(
+      v8::False(),
+      const_cast<Menu*>(this)->GetWrapper(node_isolate),
+      "getLabelForCommandId",
+      command_id);
+  string16 label;
+  mate::ConvertFromV8(node_isolate, result, &label);
+  return label;
 }
 
 string16 Menu::GetSublabelForCommandId(int command_id) const {
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
-  return FromV8Value(CallDelegate(v8::False(),
-                                  const_cast<Menu*>(this)->handle(),
-                                  "getSubLabelForCommandId",
-                                  command_id));
+  v8::Handle<v8::Value> result = CallDelegate(
+      v8::False(),
+      const_cast<Menu*>(this)->GetWrapper(node_isolate),
+      "getSubLabelForCommandId",
+      command_id);
+  string16 label;
+  mate::ConvertFromV8(node_isolate, result, &label);
+  return label;
 }
 
 void Menu::ExecuteCommand(int command_id, int event_flags) {
   v8::Locker locker(node_isolate);
   v8::HandleScope handle_scope(node_isolate);
-  CallDelegate(v8::False(), handle(), "executeCommand", command_id);
+  CallDelegate(v8::False(), GetWrapper(node_isolate), "executeCommand",
+               command_id);
+}
+
+void Menu::MenuWillShow(ui::SimpleMenuModel* source) {
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+  CallDelegate(v8::False(), GetWrapper(node_isolate), "menuWillShow", -1);
+}
+
+void Menu::InsertItemAt(
+    int index, int command_id, const base::string16& label) {
+  model_->InsertItemAt(index, command_id, label);
+}
+
+void Menu::InsertSeparatorAt(int index) {
+  model_->InsertSeparatorAt(index, ui::NORMAL_SEPARATOR);
+}
+
+void Menu::InsertCheckItemAt(int index,
+                             int command_id,
+                             const base::string16& label) {
+  model_->InsertCheckItemAt(index, command_id, label);
+}
+
+void Menu::InsertRadioItemAt(int index,
+                             int command_id,
+                             const base::string16& label,
+                             int group_id) {
+  model_->InsertRadioItemAt(index, command_id, label, group_id);
+}
+
+void Menu::InsertSubMenuAt(int index,
+                           int command_id,
+                           const base::string16& label,
+                           Menu* menu) {
+  menu->parent_ = this;
+  model_->InsertSubMenuAt(index, command_id, label, menu->model_.get());
+}
+
+void Menu::SetSublabel(int index, const base::string16& sublabel) {
+  model_->SetSublabel(index, sublabel);
+}
+
+void Menu::Clear() {
+  model_->Clear();
+}
+
+int Menu::GetIndexOfCommandId(int command_id) {
+  return model_->GetIndexOfCommandId(command_id);
+}
+
+int Menu::GetItemCount() const {
+  return model_->GetItemCount();
+}
+
+int Menu::GetCommandIdAt(int index) const {
+  return model_->GetCommandIdAt(index);
+}
+
+base::string16 Menu::GetLabelAt(int index) const {
+  return model_->GetLabelAt(index);
+}
+
+base::string16 Menu::GetSublabelAt(int index) const {
+  return model_->GetSublabelAt(index);
+}
+
+bool Menu::IsItemCheckedAt(int index) const {
+  return model_->IsItemCheckedAt(index);
+}
+
+bool Menu::IsEnabledAt(int index) const {
+  return model_->IsEnabledAt(index);
+}
+
+bool Menu::IsVisibleAt(int index) const {
+  return model_->IsVisibleAt(index);
 }
 
 // static
-void Menu::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  if (!args.IsConstructCall())
-    return node::ThrowError("Require constructor call");
-
-  Menu::Create(args.This());
-}
-
-// static
-void Menu::InsertItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-
-  int index, command_id;
-  string16 label;
-  if (!FromV8Arguments(args, &index, &command_id, &label))
-    return node::ThrowTypeError("Bad argument");
-
-  if (index < 0)
-    self->model_->AddItem(command_id, label);
-  else
-    self->model_->InsertItemAt(index, command_id, label);
-}
-
-// static
-void Menu::InsertCheckItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-
-  int index, command_id;
-  string16 label;
-  if (!FromV8Arguments(args, &index, &command_id, &label))
-    return node::ThrowTypeError("Bad argument");
-
-  if (index < 0)
-    self->model_->AddCheckItem(command_id, label);
-  else
-    self->model_->InsertCheckItemAt(index, command_id, label);
-}
-
-// static
-void Menu::InsertRadioItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-
-  int index, command_id, group_id;
-  string16 label;
-  if (!FromV8Arguments(args, &index, &command_id, &label, &group_id))
-    return node::ThrowTypeError("Bad argument");
-
-  if (index < 0)
-    self->model_->AddRadioItem(command_id, label, group_id);
-  else
-    self->model_->InsertRadioItemAt(index, command_id, label, group_id);
-}
-
-// static
-void Menu::InsertSeparator(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-
-  int index;
-  if (!FromV8Arguments(args, &index))
-    return node::ThrowTypeError("Bad argument");
-
-  if (index < 0)
-    self->model_->AddSeparator(ui::NORMAL_SEPARATOR);
-  else
-    self->model_->InsertSeparatorAt(index, ui::NORMAL_SEPARATOR);
-}
-
-// static
-void Menu::InsertSubMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-
-  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");
-
-  if (index < 0)
-    self->model_->AddSubMenu(command_id, label, submenu->model_.get());
-  else
-    self->model_->InsertSubMenuAt(
-        index, command_id, label, submenu->model_.get());
-}
-
-// static
-void Menu::SetIcon(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-
-  int index;
-  base::FilePath path;
-  if (!FromV8Arguments(args, &index, &path))
-    return node::ThrowTypeError("Bad argument");
-
-  // FIXME use webkit_glue's image decoder here.
-}
-
-// static
-void Menu::SetSublabel(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-
-  int index;
-  string16 label;
-  if (!FromV8Arguments(args, &index, &label))
-    return node::ThrowTypeError("Bad argument");
-
-  self->model_->SetSublabel(index, label);
-}
-
-// static
-void Menu::Clear(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  self->model_->Clear();
-}
-
-// static
-void Menu::GetIndexOfCommandId(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  int index = FromV8Value(args[0]);
-  args.GetReturnValue().Set(self->model_->GetIndexOfCommandId(index));
-}
-
-// static
-void Menu::GetItemCount(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  args.GetReturnValue().Set(self->model_->GetItemCount());
-}
-
-// static
-void Menu::GetCommandIdAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  int index = FromV8Value(args[0]);
-  args.GetReturnValue().Set(self->model_->GetCommandIdAt(index));
-}
-
-// static
-void Menu::GetLabelAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  int index = FromV8Value(args[0]);
-  args.GetReturnValue().Set(ToV8Value(self->model_->GetLabelAt(index)));
-}
-
-// static
-void Menu::GetSublabelAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  int index = FromV8Value(args[0]);
-  args.GetReturnValue().Set(ToV8Value(self->model_->GetSublabelAt(index)));
-}
-
-// static
-void Menu::IsItemCheckedAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  int index = FromV8Value(args[0]);
-  args.GetReturnValue().Set(self->model_->IsItemCheckedAt(index));
-}
-
-// static
-void Menu::IsEnabledAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  int index = FromV8Value(args[0]);
-  args.GetReturnValue().Set(self->model_->IsEnabledAt(index));
-}
-
-// static
-void Menu::IsVisibleAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-  int index = FromV8Value(args[0]);
-  args.GetReturnValue().Set(self->model_->IsVisibleAt(index));
-}
-
-// static
-void Menu::Popup(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_MEMNU_AND_CHECK;
-
-  atom::NativeWindow* window;
-  if (!FromV8Arguments(args, &window))
-    return node::ThrowTypeError("Bad argument");
-
-  self->Popup(window);
-}
-
-// static
-void Menu::Initialize(v8::Handle<v8::Object> target) {
-  v8::Local<v8::FunctionTemplate> t(v8::FunctionTemplate::New(Menu::New));
-  t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(v8::String::NewSymbol("Menu"));
-
-  NODE_SET_PROTOTYPE_METHOD(t, "insertItem", InsertItem);
-  NODE_SET_PROTOTYPE_METHOD(t, "insertCheckItem", InsertCheckItem);
-  NODE_SET_PROTOTYPE_METHOD(t, "insertRadioItem", InsertRadioItem);
-  NODE_SET_PROTOTYPE_METHOD(t, "insertSeparator", InsertSeparator);
-  NODE_SET_PROTOTYPE_METHOD(t, "insertSubMenu", InsertSubMenu);
-
-  NODE_SET_PROTOTYPE_METHOD(t, "setIcon", SetIcon);
-  NODE_SET_PROTOTYPE_METHOD(t, "setSublabel", SetSublabel);
-
-  NODE_SET_PROTOTYPE_METHOD(t, "clear", Clear);
-
-  NODE_SET_PROTOTYPE_METHOD(t, "getIndexOfCommandId", GetIndexOfCommandId);
-  NODE_SET_PROTOTYPE_METHOD(t, "getItemCount", GetItemCount);
-  NODE_SET_PROTOTYPE_METHOD(t, "getCommandIdAt", GetCommandIdAt);
-  NODE_SET_PROTOTYPE_METHOD(t, "getLabelAt", GetLabelAt);
-  NODE_SET_PROTOTYPE_METHOD(t, "getSublabelAt", GetSublabelAt);
-  NODE_SET_PROTOTYPE_METHOD(t, "isItemCheckedAt", IsItemCheckedAt);
-  NODE_SET_PROTOTYPE_METHOD(t, "isEnabledAt", IsEnabledAt);
-  NODE_SET_PROTOTYPE_METHOD(t, "isVisibleAt", IsVisibleAt);
-
-  NODE_SET_PROTOTYPE_METHOD(t, "popup", Popup);
-
+void Menu::BuildPrototype(v8::Isolate* isolate,
+                          v8::Handle<v8::ObjectTemplate> prototype) {
+  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("insertItem", &Menu::InsertItemAt)
+      .SetMethod("insertCheckItem", &Menu::InsertCheckItemAt)
+      .SetMethod("insertRadioItem", &Menu::InsertRadioItemAt)
+      .SetMethod("insertSeparator", &Menu::InsertSeparatorAt)
+      .SetMethod("insertSubMenu", &Menu::InsertSubMenuAt)
+      .SetMethod("setSublabel", &Menu::SetSublabel)
+      .SetMethod("clear", &Menu::Clear)
+      .SetMethod("getIndexOfCommandId", &Menu::GetIndexOfCommandId)
+      .SetMethod("getItemCount", &Menu::GetItemCount)
+      .SetMethod("getCommandIdAt", &Menu::GetCommandIdAt)
+      .SetMethod("getLabelAt", &Menu::GetLabelAt)
+      .SetMethod("getSublabelAt", &Menu::GetSublabelAt)
+      .SetMethod("isItemCheckedAt", &Menu::IsItemCheckedAt)
+      .SetMethod("isEnabledAt", &Menu::IsEnabledAt)
+      .SetMethod("isVisibleAt", &Menu::IsVisibleAt)
 #if defined(OS_WIN) || defined(TOOLKIT_GTK)
-  NODE_SET_PROTOTYPE_METHOD(t, "attachToWindow", AttachToWindow);
+      .SetMethod("_attachToWindow", &Menu::AttachToWindow)
 #endif
-
-  target->Set(v8::String::NewSymbol("Menu"), t->GetFunction());
-
-#if defined(OS_MACOSX)
-  NODE_SET_METHOD(target, "setApplicationMenu", SetApplicationMenu);
-  NODE_SET_METHOD(
-      target, "sendActionToFirstResponder", SendActionToFirstResponder);
+#if defined(OS_WIN)
+      .SetMethod("_updateStates", &Menu::UpdateStates)
 #endif
+      .SetMethod("_popup", &Menu::Popup);
 }
 
 }  // namespace api
 
 }  // namespace atom
 
-NODE_MODULE(atom_browser_menu, atom::api::Menu::Initialize)
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports) {
+  using atom::api::Menu;
+  v8::Local<v8::Function> constructor = mate::CreateConstructor<Menu>(
+      node_isolate, "Menu", base::Bind(&Menu::Create));
+  mate::Dictionary dict(v8::Isolate::GetCurrent(), exports);
+  dict.Set("Menu", static_cast<v8::Handle<v8::Value>>(constructor));
+#if defined(OS_MACOSX)
+  dict.SetMethod("setApplicationMenu", &Menu::SetApplicationMenu);
+  dict.SetMethod("sendActionToFirstResponder",
+                 &Menu::SendActionToFirstResponder);
+#endif
+}
+
+}  // namespace
+
+NODE_MODULE(atom_browser_menu, Initialize)

atom/browser/api/atom_api_menu.h

@@ -1,31 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_MENU_H_
 #define ATOM_BROWSER_API_ATOM_API_MENU_H_
 
+#include <string>
+
+#include "atom/browser/api/atom_api_window.h"
 #include "base/memory/scoped_ptr.h"
-#include "atom/common/api/atom_api_event_emitter.h"
 #include "ui/base/models/simple_menu_model.h"
+#include "native_mate/wrappable.h"
 
 namespace atom {
 
-class NativeWindow;
-
 namespace api {
 
-class Menu : public EventEmitter,
+class MenuMac;
+
+class Menu : public mate::Wrappable,
              public ui::SimpleMenuModel::Delegate {
  public:
-  virtual ~Menu();
+  static mate::Wrappable* Create();
 
-  static Menu* Create(v8::Handle<v8::Object> wrapper);
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Handle<v8::ObjectTemplate> prototype);
 
-  static void Initialize(v8::Handle<v8::Object> target);
+#if defined(OS_MACOSX)
+  // Set the global menubar.
+  static void SetApplicationMenu(Menu* menu);
+
+  // Fake sending an action from the application menu.
+  static void SendActionToFirstResponder(const std::string& action);
+#endif
+
+  ui::SimpleMenuModel* model() const { return model_.get(); }
 
  protected:
-  explicit Menu(v8::Handle<v8::Object> wrapper);
+  Menu();
+  virtual ~Menu();
 
   // ui::SimpleMenuModel::Delegate implementations:
   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
@@ -38,44 +51,44 @@ class Menu : public EventEmitter,
   virtual string16 GetLabelForCommandId(int command_id) const OVERRIDE;
   virtual string16 GetSublabelForCommandId(int command_id) const OVERRIDE;
   virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE;
+  virtual void MenuWillShow(ui::SimpleMenuModel* source) OVERRIDE;
 
-  virtual void Popup(NativeWindow* window) = 0;
+  virtual void Popup(Window* window) = 0;
 
   scoped_ptr<ui::SimpleMenuModel> model_;
+  Menu* parent_;
 
  private:
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  void InsertItemAt(int index, int command_id, const base::string16& label);
+  void InsertSeparatorAt(int index);
+  void InsertCheckItemAt(int index,
+                         int command_id,
+                         const base::string16& label);
+  void InsertRadioItemAt(int index,
+                         int command_id,
+                         const base::string16& label,
+                         int group_id);
+  void InsertSubMenuAt(int index,
+                       int command_id,
+                       const base::string16& label,
+                       Menu* menu);
+  void SetSublabel(int index, const base::string16& sublabel);
+  void Clear();
+  int GetIndexOfCommandId(int command_id);
+  int GetItemCount() const;
+  int GetCommandIdAt(int index) const;
+  base::string16 GetLabelAt(int index) const;
+  base::string16 GetSublabelAt(int index) const;
+  bool IsItemCheckedAt(int index) const;
+  bool IsEnabledAt(int index) const;
+  bool IsVisibleAt(int index) const;
 
-  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 void SetIcon(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetSublabel(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void Clear(const v8::FunctionCallbackInfo<v8::Value>& 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 void Popup(const v8::FunctionCallbackInfo<v8::Value>& args);
+#if defined(OS_WIN)
+  virtual void UpdateStates() = 0;
+#endif
 
 #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);
+  virtual void AttachToWindow(Window* window) = 0;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(Menu);

atom/browser/api/atom_api_menu_gtk.cc

@@ -1,32 +1,28 @@
 // Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_menu_gtk.h"
 
 #include "atom/browser/native_window_gtk.h"
-#include "atom/common/v8/native_type_conversions.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/screen.h"
 
-#include "atom/common/v8/node_common.h"
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
 namespace api {
 
-MenuGtk::MenuGtk(v8::Handle<v8::Object> wrapper)
-    : Menu(wrapper) {
+MenuGtk::MenuGtk() {
 }
 
-MenuGtk::~MenuGtk() {
-}
-
-void MenuGtk::Popup(NativeWindow* native_window) {
+void MenuGtk::Popup(Window* window) {
   uint32_t triggering_event_time;
   gfx::Point point;
 
+  NativeWindow* native_window = window->window();
   GdkEventButton* event = native_window->GetWebContents()->
       GetRenderWidgetHostView()->GetLastMouseDown();
   if (event) {
@@ -41,22 +37,13 @@ void MenuGtk::Popup(NativeWindow* native_window) {
   menu_gtk_->PopupAsContext(point, triggering_event_time);
 }
 
-// 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<NativeWindowGtk*>(native_window)->SetMenu(self->model_.get());
+void MenuGtk::AttachToWindow(Window* window) {
+  static_cast<NativeWindowGtk*>(window->window())->SetMenu(model_.get());
 }
 
 // static
-Menu* Menu::Create(v8::Handle<v8::Object> wrapper) {
-  return new MenuGtk(wrapper);
+mate::Wrappable* Menu::Create() {
+  return new MenuGtk();
 }
 
 }  // namespace api

atom/browser/api/atom_api_menu_gtk.h

@@ -1,5 +1,5 @@
 // Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_
@@ -15,11 +15,11 @@ namespace api {
 class MenuGtk : public Menu,
                 public ::MenuGtk::Delegate {
  public:
-  explicit MenuGtk(v8::Handle<v8::Object> wrapper);
-  virtual ~MenuGtk();
+  MenuGtk();
 
  protected:
-  virtual void Popup(NativeWindow* window) OVERRIDE;
+  virtual void Popup(Window* window) OVERRIDE;
+  virtual void AttachToWindow(Window* window) OVERRIDE;
 
  private:
   scoped_ptr<::MenuGtk> menu_gtk_;

atom/browser/api/atom_api_menu_mac.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
@@ -16,19 +16,16 @@ namespace atom {
 namespace api {
 
 class MenuMac : public Menu {
- public:
-  explicit MenuMac(v8::Handle<v8::Object> wrapper);
-  virtual ~MenuMac();
-
  protected:
-  virtual void Popup(NativeWindow* window) OVERRIDE;
+  MenuMac();
+
+  virtual void Popup(Window* window) OVERRIDE;
 
   base::scoped_nsobject<AtomMenuController> menu_controller_;
 
  private:
   friend class Menu;
 
-  // Fake sending an action from the application menu.
   static void SendActionToFirstResponder(const std::string& action);
 
   DISALLOW_COPY_AND_ASSIGN(MenuMac);

atom/browser/api/atom_api_menu_mac.mm

@@ -1,44 +1,41 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #import "atom/browser/api/atom_api_menu_mac.h"
 
+#include "atom/browser/native_window.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
-#include "atom/browser/native_window.h"
-#include "atom/common/v8/node_common.h"
-#include "atom/common/v8/native_type_conversions.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 
+#include "atom/common/node_includes.h"
+
 namespace atom {
 
 namespace api {
 
-MenuMac::MenuMac(v8::Handle<v8::Object> wrapper)
-    : Menu(wrapper) {
+MenuMac::MenuMac() {
 }
 
-MenuMac::~MenuMac() {
-}
-
-void MenuMac::Popup(NativeWindow* native_window) {
+void MenuMac::Popup(Window* window) {
   base::scoped_nsobject<AtomMenuController> menu_controller(
       [[AtomMenuController alloc] initWithModel:model_.get()]);
 
-  NSWindow* window = native_window->GetNativeWindow();
+  NativeWindow* native_window = window->window();
+  NSWindow* nswindow = native_window->GetNativeWindow();
   content::WebContents* web_contents = native_window->GetWebContents();
 
   // Fake out a context menu event.
   NSEvent* currentEvent = [NSApp currentEvent];
-  NSPoint position = [window mouseLocationOutsideOfEventStream];
+  NSPoint position = [nswindow mouseLocationOutsideOfEventStream];
   NSTimeInterval eventTime = [currentEvent timestamp];
   NSEvent* clickEvent = [NSEvent mouseEventWithType:NSRightMouseDown
                                            location:position
                                       modifierFlags:NSRightMouseDownMask
                                           timestamp:eventTime
-                                       windowNumber:[window windowNumber]
+                                       windowNumber:[nswindow windowNumber]
                                             context:nil
                                         eventNumber:0
                                          clickCount:1
@@ -51,22 +48,8 @@ void MenuMac::Popup(NativeWindow* native_window) {
 }
 
 // static
-void MenuMac::SendActionToFirstResponder(const std::string& action) {
-  SEL selector = NSSelectorFromString(base::SysUTF8ToNSString(action));
-  [[NSApplication sharedApplication] sendAction:selector
-                                             to:nil
-                                           from:[NSApp mainMenu]];
-}
-
-// static
-void Menu::SetApplicationMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  if (!args[0]->IsObject())
-    return node::ThrowTypeError("Bad argument");
-
-  MenuMac* menu = ObjectWrap::Unwrap<MenuMac>(args[0]->ToObject());
-  if (!menu)
-    return node::ThrowError("Menu is destroyed");
-
+void Menu::SetApplicationMenu(Menu* base_menu) {
+  MenuMac* menu = static_cast<MenuMac*>(base_menu);
   base::scoped_nsobject<AtomMenuController> menu_controller(
       [[AtomMenuController alloc] initWithModel:menu->model_.get()]);
   [NSApp setMainMenu:[menu_controller menu]];
@@ -76,18 +59,14 @@ void Menu::SetApplicationMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
 }
 
 // static
-void Menu::SendActionToFirstResponder(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  std::string action;
-  if (!FromV8Arguments(args, &action))
-    return node::ThrowTypeError("Bad argument");
-
-  MenuMac::SendActionToFirstResponder(action);
+void Menu::SendActionToFirstResponder(const std::string& action) {
+  SEL selector = NSSelectorFromString(base::SysUTF8ToNSString(action));
+  [NSApp sendAction:selector to:nil from:[NSApp mainMenu]];
 }
 
 // static
-Menu* Menu::Create(v8::Handle<v8::Object> wrapper) {
-  return new MenuMac(wrapper);
+mate::Wrappable* Menu::Create() {
+  return new MenuMac();
 }
 
 }  // namespace api

atom/browser/api/atom_api_menu_win.cc

@@ -1,50 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_menu_win.h"
 
 #include "atom/browser/native_window_win.h"
 #include "atom/browser/ui/win/menu_2.h"
-#include "atom/common/v8/native_type_conversions.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/screen.h"
 
-#include "atom/common/v8/node_common.h"
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
 namespace api {
 
-MenuWin::MenuWin(v8::Handle<v8::Object> wrapper)
-    : Menu(wrapper) {
+MenuWin::MenuWin() : menu_(NULL) {
 }
 
-MenuWin::~MenuWin() {
-}
-
-void MenuWin::Popup(NativeWindow* native_window) {
+void MenuWin::Popup(Window* window) {
   gfx::Point cursor = gfx::Screen::GetNativeScreen()->GetCursorScreenPoint();
-  menu_.reset(new atom::Menu2(model_.get()));
+  popup_menu_.reset(new atom::Menu2(model_.get()));
+  menu_ = popup_menu_.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");
+void MenuWin::UpdateStates() {
+  MenuWin* top = this;
+  while (top->parent_)
+    top = static_cast<MenuWin*>(top->parent_);
+  if (top->menu_)
+    top->menu_->UpdateStates();
+}
 
-  NativeWindow* native_window;
-  if (!FromV8Arguments(args, &native_window))
-    return node::ThrowTypeError("Bad argument");
-
-  static_cast<NativeWindowWin*>(native_window)->SetMenu(self->model_.get());
+void MenuWin::AttachToWindow(Window* window) {
+  NativeWindowWin* nw = static_cast<NativeWindowWin*>(window->window());
+  nw->SetMenu(model_.get());
+  menu_ = nw->menu();
 }
 
 // static
-Menu* Menu::Create(v8::Handle<v8::Object> wrapper) {
-  return new MenuWin(wrapper);
+mate::Wrappable* Menu::Create() {
+  return new MenuWin();
 }
 
 }  // namespace api

atom/browser/api/atom_api_menu_win.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_MENU_WIN_H_
@@ -15,14 +15,16 @@ namespace api {
 
 class MenuWin : public Menu {
  public:
-  explicit MenuWin(v8::Handle<v8::Object> wrapper);
-  virtual ~MenuWin();
+  MenuWin();
 
  protected:
-  virtual void Popup(NativeWindow* window) OVERRIDE;
+  virtual void Popup(Window* window) OVERRIDE;
+  virtual void UpdateStates() OVERRIDE;
+  virtual void AttachToWindow(Window* window) OVERRIDE;
 
  private:
-  scoped_ptr<atom::Menu2> menu_;
+  atom::Menu2* menu_;  // Weak ref, could be window menu or popup menu.
+  scoped_ptr<atom::Menu2> popup_menu_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuWin);
 };

atom/browser/api/atom_api_power_monitor.cc

@@ -1,20 +1,20 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_power_monitor.h"
 
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
+#include "native_mate/dictionary.h"
 
-#include "atom/common/v8/node_common.h"
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
 namespace api {
 
-PowerMonitor::PowerMonitor(v8::Handle<v8::Object> wrapper)
-    : EventEmitter(wrapper) {
+PowerMonitor::PowerMonitor() {
   base::PowerMonitor::Get()->AddObserver(this);
 }
 
@@ -38,30 +38,29 @@ void PowerMonitor::OnResume() {
 }
 
 // static
-void PowerMonitor::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  if (!args.IsConstructCall())
-    return node::ThrowError("Require constructor call");
-
-  new PowerMonitor(args.This());
+mate::Handle<PowerMonitor> PowerMonitor::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new PowerMonitor);
 }
 
-// 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)
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports) {
+#if defined(OS_MACOSX)
+  base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
+#endif
+
+  using atom::api::PowerMonitor;
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  mate::Handle<PowerMonitor> power_monitor = PowerMonitor::Create(isolate);
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("powerMonitor", power_monitor);
+}
+
+}  // namespace
+
+NODE_MODULE(atom_browser_power_monitor, Initialize)

atom/browser/api/atom_api_power_monitor.h

@@ -1,35 +1,34 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
 #define ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
 
+#include "atom/browser/api/event_emitter.h"
 #include "base/compiler_specific.h"
 #include "base/power_monitor/power_observer.h"
-#include "atom/common/api/atom_api_event_emitter.h"
+#include "native_mate/handle.h"
 
 namespace atom {
 
 namespace api {
 
-class PowerMonitor : public EventEmitter,
+class PowerMonitor : public mate::EventEmitter,
                      public base::PowerObserver {
  public:
-  virtual ~PowerMonitor();
-
-  static void Initialize(v8::Handle<v8::Object> target);
+  static mate::Handle<PowerMonitor> Create(v8::Isolate* isolate);
 
  protected:
-  explicit PowerMonitor(v8::Handle<v8::Object> wrapper);
+  PowerMonitor();
+  virtual ~PowerMonitor();
 
+  // base::PowerObserver implementations:
   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);
 };
 

atom/browser/api/atom_api_protocol.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_protocol.h"
@@ -9,142 +9,111 @@
 #include "atom/browser/net/adapter_request_job.h"
 #include "atom/browser/net/atom_url_request_context_getter.h"
 #include "atom/browser/net/atom_url_request_job_factory.h"
-#include "atom/common/v8/native_type_conversions.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/function_converter.h"
 #include "content/public/browser/browser_thread.h"
+#include "native_mate/dictionary.h"
 #include "net/url_request/url_request_context.h"
 
-#include "atom/common/v8/node_common.h"
+#include "atom/common/node_includes.h"
+
+using content::BrowserThread;
+
+namespace mate {
+
+template<>
+struct Converter<const net::URLRequest*> {
+  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+                                    const net::URLRequest* val) {
+    return mate::ObjectTemplateBuilder(isolate)
+        .SetValue("method", val->method())
+        .SetValue("url", val->url().spec())
+        .SetValue("referrer", val->referrer())
+        .Build()->NewInstance();
+  }
+};
+
+}  // namespace mate
+
 
 namespace atom {
 
 namespace api {
 
-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();
-}
+typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
 
 class CustomProtocolRequestJob : public AdapterRequestJob {
  public:
-  CustomProtocolRequestJob(ProtocolHandler* protocol_handler,
+  CustomProtocolRequestJob(Protocol* registry,
+                           ProtocolHandler* protocol_handler,
                            net::URLRequest* request,
                            net::NetworkDelegate* network_delegate)
-      : AdapterRequestJob(protocol_handler, request, network_delegate) {
+      : AdapterRequestJob(protocol_handler, request, network_delegate),
+        registry_(registry) {
   }
 
   // AdapterRequestJob:
   virtual void GetJobTypeInUI() OVERRIDE {
-    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    DCHECK(BrowserThread::CurrentlyOn(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);
+    Protocol::JsProtocolHandler callback =
+        registry_->GetProtocolHandler(request()->url().scheme());
+    v8::Handle<v8::Value> result = callback.Run(request());
 
     // 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,
+      std::string data = mate::V8ToString(result);
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
           base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
-                     GetWeakPtr(),
-                     "text/plain",
-                     "UTF-8",
-                     data));
+                     GetWeakPtr(), "text/plain", "UTF-8", data));
       return;
     } else if (result->IsObject()) {
       v8::Handle<v8::Object> obj = result->ToObject();
-      std::string name = FromV8Value(obj->GetConstructorName());
+      mate::Dictionary dict(node_isolate, obj);
+      std::string name = mate::V8ToString(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")));
+        std::string mime_type, charset, data;
+        dict.Get("mimeType", &mime_type);
+        dict.Get("charset", &charset);
+        dict.Get("data", &data);
 
-        content::BrowserThread::PostTask(
-            content::BrowserThread::IO,
-            FROM_HERE,
+        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
             base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
-                       GetWeakPtr(),
-                       mime_type,
-                       charset,
-                       data));
+                       GetWeakPtr(), mime_type, charset, data));
         return;
       } else if (name == "RequestFileJob") {
-        base::FilePath path = FromV8Value(obj->Get(v8::String::New("path")));
+        base::FilePath path;
+        dict.Get("path", &path);
 
-        content::BrowserThread::PostTask(
-            content::BrowserThread::IO,
-            FROM_HERE,
+        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
             base::Bind(&AdapterRequestJob::CreateFileJobAndStart,
-                       GetWeakPtr(),
-                       path));
+                       GetWeakPtr(), path));
         return;
       }
     }
 
     // Try the default protocol handler if we have.
     if (default_protocol_handler()) {
-      content::BrowserThread::PostTask(
-          content::BrowserThread::IO,
-          FROM_HERE,
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
           base::Bind(&AdapterRequestJob::CreateJobFromProtocolHandlerAndStart,
                      GetWeakPtr()));
       return;
     }
 
     // Fallback to the not implemented error.
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO,
-        FROM_HERE,
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         base::Bind(&AdapterRequestJob::CreateErrorJobAndStart,
-                   GetWeakPtr(),
-                   net::ERR_NOT_IMPLEMENTED));
+                   GetWeakPtr(), net::ERR_NOT_IMPLEMENTED));
   }
+
+ private:
+  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
 };
 
 // Always return the same CustomProtocolRequestJob for all requests, because
@@ -155,16 +124,16 @@ class CustomProtocolRequestJob : public AdapterRequestJob {
 // 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) {
+  CustomProtocolHandler(api::Protocol* registry,
+                        ProtocolHandler* protocol_handler = NULL)
+      : registry_(registry), 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);
+    return new CustomProtocolRequestJob(registry_, protocol_handler_.get(),
+                                        request, network_delegate);
   }
 
   ProtocolHandler* ReleaseDefaultProtocolHandler() {
@@ -174,6 +143,7 @@ class CustomProtocolHandler : public ProtocolHandler {
   ProtocolHandler* original_handler() { return protocol_handler_.get(); }
 
  private:
+  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
   scoped_ptr<ProtocolHandler> protocol_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
@@ -181,206 +151,186 @@ class CustomProtocolHandler : public ProtocolHandler {
 
 }  // 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");
+Protocol::Protocol() : job_factory_(
+    AtomBrowserContext::Get()->url_request_context_getter()->job_factory()) {
+}
 
-  if (g_handlers.find(scheme) != g_handlers.end() ||
-      GetRequestJobFactory()->IsHandledProtocol(scheme))
+Protocol::JsProtocolHandler Protocol::GetProtocolHandler(
+    const std::string& scheme) {
+  return protocol_handlers_[scheme];
+}
+
+mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("registerProtocol",
+                 base::Bind(&Protocol::RegisterProtocol,
+                            base::Unretained(this)))
+      .SetMethod("unregisterProtocol",
+                 base::Bind(&Protocol::UnregisterProtocol,
+                            base::Unretained(this)))
+      .SetMethod("isHandledProtocol",
+                 base::Bind(&Protocol::IsHandledProtocol,
+                            base::Unretained(this)))
+      .SetMethod("interceptProtocol",
+                 base::Bind(&Protocol::InterceptProtocol,
+                            base::Unretained(this)))
+      .SetMethod("uninterceptProtocol",
+                 base::Bind(&Protocol::UninterceptProtocol,
+                            base::Unretained(this)));
+}
+
+void Protocol::RegisterProtocol(const std::string& scheme,
+                                const JsProtocolHandler& callback) {
+  if (ContainsKey(protocol_handlers_, scheme) ||
+      job_factory_->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));
+  protocol_handlers_[scheme] = callback;
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::RegisterProtocolInIO,
+                                     base::Unretained(this), 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())
+void Protocol::UnregisterProtocol(const std::string& scheme) {
+  ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
+  if (it == protocol_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));
+  protocol_handlers_.erase(it);
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::UnregisterProtocolInIO,
+                                     base::Unretained(this), 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));
+bool Protocol::IsHandledProtocol(const std::string& scheme) {
+  return job_factory_->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");
+void Protocol::InterceptProtocol(const std::string& scheme,
+                                 const JsProtocolHandler& callback) {
+  if (!job_factory_->HasProtocolHandler(scheme))
+    return node::ThrowError("Scheme does not exist.");
 
-  if (!GetRequestJobFactory()->HasProtocolHandler(scheme))
-    return node::ThrowError("Cannot intercept procotol");
-
-  if (ContainsKey(g_handlers, scheme))
+  if (ContainsKey(protocol_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));
+  protocol_handlers_[scheme] = callback;
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::InterceptProtocolInIO,
+                                     base::Unretained(this), 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())
+void Protocol::UninterceptProtocol(const std::string& scheme) {
+  ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
+  if (it == protocol_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));
+  protocol_handlers_.erase(it);
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::UninterceptProtocolInIO,
+                                     base::Unretained(this), 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);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  content::BrowserThread::PostTask(content::BrowserThread::UI,
-                                   FROM_HERE,
-                                   base::Bind(&EmitEventInUI,
-                                              "registered",
-                                              scheme));
+  job_factory_->SetProtocolHandler(scheme, new CustomProtocolHandler(this));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "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);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  content::BrowserThread::PostTask(content::BrowserThread::UI,
-                                   FROM_HERE,
-                                   base::Bind(&EmitEventInUI,
-                                              "unregistered",
-                                              scheme));
+  job_factory_->SetProtocolHandler(scheme, NULL);
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "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);
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  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"));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
+        &Protocol::EmitEventInUI,
+        base::Unretained(this),
+        "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));
+  job_factory_->ReplaceProtocol(
+      scheme, new CustomProtocolHandler(this, original_handler));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "intercepted", scheme));
 }
 
-// static
 void Protocol::UninterceptProtocolInIO(const std::string& scheme) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  AtomURLRequestJobFactory* job_factory(GetRequestJobFactory());
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  // Check if the protocol handler is intercepted.
   CustomProtocolHandler* handler = static_cast<CustomProtocolHandler*>(
-      job_factory->GetProtocolHandler(scheme));
+      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"));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
+        &Protocol::EmitEventInUI,
+        base::Unretained(this),
+        "error", "The protocol is not intercpeted"));
     return;
   }
 
-  // Reset the protocol handler to the orignal one and delete current
-  // protocol handler.
+  // 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);
+  delete job_factory_->ReplaceProtocol(scheme, original_handler);
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "unintercepted", scheme));
+}
 
-  content::BrowserThread::PostTask(content::BrowserThread::UI,
-                                   FROM_HERE,
-                                   base::Bind(&EmitEventInUI,
-                                              "unintercepted",
-                                              scheme));
+void Protocol::EmitEventInUI(const std::string& event,
+                             const std::string& parameter) {
+  base::ListValue args;
+  args.AppendString(parameter);
+  Emit(event, args);
 }
 
 // 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);
+mate::Handle<Protocol> Protocol::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new Protocol);
 }
 
 }  // namespace api
 
 }  // namespace atom
 
-NODE_MODULE(atom_browser_protocol, atom::api::Protocol::Initialize)
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports) {
+  // Make sure the job factory has been created.
+  atom::AtomBrowserContext::Get()->url_request_context_getter()->
+      GetURLRequestContext();
+
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("protocol", atom::api::Protocol::Create(isolate));
+}
+
+}  // namespace
+
+NODE_MODULE(atom_browser_protocol, Initialize)

atom/browser/api/atom_api_protocol.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
@@ -8,36 +8,68 @@
 #include <string>
 #include <map>
 
-#include "base/basictypes.h"
-#include "v8/include/v8.h"
+#include "atom/browser/api/event_emitter.h"
+#include "base/callback.h"
+#include "native_mate/handle.h"
+
+namespace net {
+class URLRequest;
+}
 
 namespace atom {
 
+class AtomURLRequestJobFactory;
+
 namespace api {
 
-class Protocol {
+class Protocol : public mate::EventEmitter {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  typedef base::Callback<v8::Handle<v8::Value>(const net::URLRequest*)>
+          JsProtocolHandler;
+
+  static mate::Handle<Protocol> Create(v8::Isolate* isolate);
+
+  JsProtocolHandler GetProtocolHandler(const std::string& scheme);
+
+ protected:
+  Protocol();
+
+  // mate::Wrappable implementations:
+  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate);
 
  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);
+  typedef std::map<std::string, JsProtocolHandler> ProtocolHandlersMap;
 
-  static void InterceptProtocol(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void UninterceptProtocol(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
+  // Register/unregister an networking |scheme| which would be handled by
+  // |callback|.
+  void RegisterProtocol(const std::string& scheme,
+                        const JsProtocolHandler& callback);
+  void UnregisterProtocol(const std::string& scheme);
 
-  static void RegisterProtocolInIO(const std::string& scheme);
-  static void UnregisterProtocolInIO(const std::string& scheme);
+  // Returns whether a scheme has been registered.
+  // FIXME Should accept a callback and be asynchronous so we do not have to use
+  // locks.
+  bool IsHandledProtocol(const std::string& scheme);
 
-  static void InterceptProtocolInIO(const std::string& scheme);
-  static void UninterceptProtocolInIO(const std::string& scheme);
+  // Intercept/unintercept an existing protocol handler.
+  void InterceptProtocol(const std::string& scheme,
+                         const JsProtocolHandler& callback);
+  void UninterceptProtocol(const std::string& scheme);
 
-  DISALLOW_IMPLICIT_CONSTRUCTORS(Protocol);
+  // The networking related operations have to be done in IO thread.
+  void RegisterProtocolInIO(const std::string& scheme);
+  void UnregisterProtocolInIO(const std::string& scheme);
+  void InterceptProtocolInIO(const std::string& scheme);
+  void UninterceptProtocolInIO(const std::string& scheme);
+
+  // Do protocol.emit(event, parameter) under UI thread.
+  void EmitEventInUI(const std::string& event, const std::string& parameter);
+
+  AtomURLRequestJobFactory* job_factory_;
+  ProtocolHandlersMap protocol_handlers_;
+
+  DISALLOW_COPY_AND_ASSIGN(Protocol);
 };
 
 }  // namespace api

atom/browser/api/atom_api_tray.cc

@@ -0,0 +1,83 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_tray.h"
+
+#include <string>
+
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/ui/tray_icon.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "native_mate/constructor.h"
+#include "native_mate/dictionary.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+Tray::Tray(const gfx::ImageSkia& image)
+    : tray_icon_(TrayIcon::Create()) {
+  tray_icon_->SetImage(image);
+  tray_icon_->AddObserver(this);
+}
+
+Tray::~Tray() {
+}
+
+// static
+mate::Wrappable* Tray::New(const gfx::ImageSkia& image) {
+  return new Tray(image);
+}
+
+void Tray::OnClicked() {
+  Emit("clicked");
+}
+
+void Tray::SetImage(const gfx::ImageSkia& image) {
+  tray_icon_->SetImage(image);
+}
+
+void Tray::SetPressedImage(const gfx::ImageSkia& image) {
+  tray_icon_->SetPressedImage(image);
+}
+
+void Tray::SetToolTip(const std::string& tool_tip) {
+  tray_icon_->SetToolTip(tool_tip);
+}
+
+void Tray::SetContextMenu(Menu* menu) {
+  tray_icon_->SetContextMenu(menu->model());
+}
+
+// static
+void Tray::BuildPrototype(v8::Isolate* isolate,
+                          v8::Handle<v8::ObjectTemplate> prototype) {
+  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("setImage", &Tray::SetImage)
+      .SetMethod("setPressedImage", &Tray::SetPressedImage)
+      .SetMethod("setToolTip", &Tray::SetToolTip)
+      .SetMethod("_setContextMenu", &Tray::SetContextMenu);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports) {
+  using atom::api::Tray;
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Handle<v8::Function> constructor = mate::CreateConstructor<Tray>(
+      isolate, "Tray", base::Bind(&Tray::New));
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("Tray", static_cast<v8::Handle<v8::Value>>(constructor));
+}
+
+}  // namespace
+
+NODE_MODULE(atom_browser_tray, Initialize)

atom/browser/api/atom_api_tray.h

@@ -0,0 +1,56 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_TRAY_H_
+#define ATOM_BROWSER_API_ATOM_API_TRAY_H_
+
+#include <string>
+
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/ui/tray_icon_observer.h"
+#include "base/memory/scoped_ptr.h"
+
+namespace gfx {
+class ImageSkia;
+}
+
+namespace atom {
+
+class TrayIcon;
+
+namespace api {
+
+class Menu;
+
+class Tray : public mate::EventEmitter,
+             public TrayIconObserver {
+ public:
+  static mate::Wrappable* New(const gfx::ImageSkia& image);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Handle<v8::ObjectTemplate> prototype);
+
+ protected:
+  explicit Tray(const gfx::ImageSkia& image);
+  virtual ~Tray();
+
+  // TrayIcon implementations:
+  virtual void OnClicked() OVERRIDE;
+
+  void SetImage(const gfx::ImageSkia& image);
+  void SetPressedImage(const gfx::ImageSkia& image);
+  void SetToolTip(const std::string& tool_tip);
+  void SetContextMenu(Menu* menu);
+
+ private:
+  scoped_ptr<TrayIcon> tray_icon_;
+
+  DISALLOW_COPY_AND_ASSIGN(Tray);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_TRAY_H_

atom/browser/api/atom_api_web_contents.cc

@@ -0,0 +1,214 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_web_contents.h"
+
+#include "atom/common/api/api_messages.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/web_contents.h"
+#include "native_mate/object_template_builder.h"
+
+namespace atom {
+
+namespace api {
+
+WebContents::WebContents(content::WebContents* web_contents)
+    : content::WebContentsObserver(web_contents),
+      web_contents_(web_contents) {
+}
+
+void WebContents::RenderViewDeleted(content::RenderViewHost* render_view_host) {
+  base::ListValue args;
+  args.AppendInteger(render_view_host->GetProcess()->GetID());
+  args.AppendInteger(render_view_host->GetRoutingID());
+  Emit("render-view-deleted", args);
+}
+
+void WebContents::RenderProcessGone(base::TerminationStatus status) {
+  Emit("crashed");
+}
+
+void WebContents::DidFinishLoad(int64 frame_id,
+                                const GURL& validated_url,
+                                bool is_main_frame,
+                                content::RenderViewHost* render_view_host) {
+  base::ListValue args;
+  args.AppendBoolean(is_main_frame);
+  Emit("did-frame-finish-load", args);
+
+  if (is_main_frame)
+    Emit("did-finish-load");
+}
+
+void WebContents::DidStartLoading(content::RenderViewHost* render_view_host) {
+  Emit("did-start-loading");
+}
+
+void WebContents::DidStopLoading(content::RenderViewHost* render_view_host) {
+  Emit("did-stop-loading");
+}
+
+bool WebContents::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(WebContents, message)
+    IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
+                                    OnRendererMessageSync)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  return handled;
+}
+
+void WebContents::WebContentsDestroyed(content::WebContents*) {
+  // The RenderViewDeleted was not called when the WebContents is destroyed.
+  RenderViewDeleted(web_contents_->GetRenderViewHost());
+  Emit("destroyed");
+}
+
+bool WebContents::IsAlive() const {
+  return web_contents() != NULL;
+}
+
+void WebContents::LoadURL(const GURL& url) {
+  content::NavigationController::LoadURLParams params(url);
+  params.transition_type = content::PAGE_TRANSITION_TYPED;
+  params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
+  web_contents()->GetController().LoadURLWithParams(params);
+}
+
+GURL WebContents::GetURL() const {
+  return web_contents()->GetURL();
+}
+
+string16 WebContents::GetTitle() const {
+  return web_contents()->GetTitle();
+}
+
+bool WebContents::IsLoading() const {
+  return web_contents()->IsLoading();
+}
+
+bool WebContents::IsWaitingForResponse() const {
+  return web_contents()->IsWaitingForResponse();
+}
+
+void WebContents::Stop() {
+  web_contents()->Stop();
+}
+
+void WebContents::Reload() {
+  // Navigating to a URL would always restart the renderer process, we want this
+  // because normal reloading will break our node integration.
+  // This is done by AtomBrowserClient::ShouldSwapProcessesForNavigation.
+  LoadURL(GetURL());
+}
+
+void WebContents::ReloadIgnoringCache() {
+  Reload();
+}
+
+bool WebContents::CanGoBack() const {
+  return web_contents()->GetController().CanGoBack();
+}
+
+bool WebContents::CanGoForward() const {
+  return web_contents()->GetController().CanGoForward();
+}
+
+bool WebContents::CanGoToOffset(int offset) const {
+  return web_contents()->GetController().CanGoToOffset(offset);
+}
+
+void WebContents::GoBack() {
+  web_contents()->GetController().GoBack();
+}
+
+void WebContents::GoForward() {
+  web_contents()->GetController().GoForward();
+}
+
+void WebContents::GoToIndex(int index) {
+  web_contents()->GetController().GoToIndex(index);
+}
+
+void WebContents::GoToOffset(int offset) {
+  web_contents()->GetController().GoToOffset(offset);
+}
+
+int WebContents::GetRoutingID() const {
+  return web_contents()->GetRoutingID();
+}
+
+int WebContents::GetProcessID() const {
+  return web_contents()->GetRenderProcessHost()->GetID();
+}
+
+bool WebContents::IsCrashed() const {
+  return web_contents()->IsCrashed();
+}
+
+void WebContents::ExecuteJavaScript(const string16& code) {
+  web_contents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
+      string16(), code);
+}
+
+bool WebContents::SendIPCMessage(const string16& channel,
+                                 const base::ListValue& args) {
+  return Send(new AtomViewMsg_Message(routing_id(), channel, args));
+}
+
+mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("isAlive", &WebContents::IsAlive)
+      .SetMethod("loadUrl", &WebContents::LoadURL)
+      .SetMethod("getUrl", &WebContents::GetURL)
+      .SetMethod("getTitle", &WebContents::GetTitle)
+      .SetMethod("isLoading", &WebContents::IsLoading)
+      .SetMethod("isWaitingForResponse", &WebContents::IsWaitingForResponse)
+      .SetMethod("stop", &WebContents::Stop)
+      .SetMethod("reload", &WebContents::Reload)
+      .SetMethod("reloadIgnoringCache", &WebContents::ReloadIgnoringCache)
+      .SetMethod("canGoBack", &WebContents::CanGoBack)
+      .SetMethod("canGoForward", &WebContents::CanGoForward)
+      .SetMethod("canGoToOffset", &WebContents::CanGoToOffset)
+      .SetMethod("goBack", &WebContents::GoBack)
+      .SetMethod("goForward", &WebContents::GoForward)
+      .SetMethod("goToIndex", &WebContents::GoToIndex)
+      .SetMethod("goToOffset", &WebContents::GoToOffset)
+      .SetMethod("getRoutingId", &WebContents::GetRoutingID)
+      .SetMethod("getProcessId", &WebContents::GetProcessID)
+      .SetMethod("isCrashed", &WebContents::IsCrashed)
+      .SetMethod("_executeJavaScript", &WebContents::ExecuteJavaScript)
+      .SetMethod("_send", &WebContents::SendIPCMessage);
+}
+
+void WebContents::OnRendererMessage(const string16& channel,
+                                    const base::ListValue& args) {
+  // webContents.emit(channel, new Event(), args...);
+  Emit(UTF16ToUTF8(channel), args, web_contents(), NULL);
+}
+
+void WebContents::OnRendererMessageSync(const string16& channel,
+                                        const base::ListValue& args,
+                                        IPC::Message* message) {
+  // webContents.emit(channel, new Event(sender, message), args...);
+  Emit(UTF16ToUTF8(channel), args, web_contents(), message);
+}
+
+// static
+mate::Handle<WebContents> WebContents::Create(
+    v8::Isolate* isolate, content::WebContents* web_contents) {
+  return mate::CreateHandle(isolate, new WebContents(web_contents));
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_web_contents.h

@@ -0,0 +1,84 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_WEB_CONTENTS_H_
+#define ATOM_BROWSER_API_ATOM_API_WEB_CONTENTS_H_
+
+#include "atom/browser/api/event_emitter.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "native_mate/handle.h"
+
+namespace atom {
+
+namespace api {
+
+class WebContents : public mate::EventEmitter,
+                    public content::WebContentsObserver {
+ public:
+  static mate::Handle<WebContents> Create(v8::Isolate* isolate,
+                                          content::WebContents* web_contents);
+
+  bool IsAlive() const;
+  void LoadURL(const GURL& url);
+  GURL GetURL() const;
+  string16 GetTitle() const;
+  bool IsLoading() const;
+  bool IsWaitingForResponse() const;
+  void Stop();
+  void Reload();
+  void ReloadIgnoringCache();
+  bool CanGoBack() const;
+  bool CanGoForward() const;
+  bool CanGoToOffset(int offset) const;
+  void GoBack();
+  void GoForward();
+  void GoToIndex(int index);
+  void GoToOffset(int offset);
+  int GetRoutingID() const;
+  int GetProcessID() const;
+  bool IsCrashed() const;
+  void ExecuteJavaScript(const string16& code);
+  bool SendIPCMessage(const string16& channel, const base::ListValue& args);
+
+ protected:
+  explicit WebContents(content::WebContents* web_contents);
+
+  // mate::Wrappable implementations:
+  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) OVERRIDE;
+
+  // content::WebContentsObserver implementations:
+  virtual void RenderViewDeleted(content::RenderViewHost*) OVERRIDE;
+  virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
+  virtual void DidFinishLoad(
+      int64 frame_id,
+      const GURL& validated_url,
+      bool is_main_frame,
+      content::RenderViewHost* render_view_host) OVERRIDE;
+  virtual void DidStartLoading(
+      content::RenderViewHost* render_view_host) OVERRIDE;
+  virtual void DidStopLoading(
+      content::RenderViewHost* render_view_host) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual void WebContentsDestroyed(content::WebContents*) OVERRIDE;
+
+ private:
+  // Called when received a message from renderer.
+  void OnRendererMessage(const string16& channel, const base::ListValue& args);
+
+  // Called when received a synchronous message from renderer.
+  void OnRendererMessageSync(const string16& channel,
+                             const base::ListValue& args,
+                             IPC::Message* message);
+
+  content::WebContents* web_contents_;  // Weak.
+
+  DISALLOW_COPY_AND_ASSIGN(WebContents);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_WEB_CONTENTS_H_

atom/browser/api/atom_api_window.cc

@@ -1,60 +1,83 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/api/atom_api_window.h"
 
-#include <string>
-
-#include "base/bind.h"
-#include "base/process/kill.h"
+#include "atom/browser/api/atom_api_web_contents.h"
 #include "atom/browser/native_window.h"
-#include "atom/common/v8/native_type_conversions.h"
-#include "content/public/browser/navigation_entry.h"
-#include "content/public/browser/web_contents.h"
+#include "atom/common/native_mate_converters/function_converter.h"
+#include "base/bind.h"
+#include "base/callback.h"
 #include "content/public/browser/render_process_host.h"
+#include "native_mate/constructor.h"
+#include "native_mate/dictionary.h"
 #include "ui/gfx/point.h"
+#include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
-#include "atom/common/v8/node_common.h"
-#include "vendor/node/src/node_buffer.h"
+#include "atom/common/node_includes.h"
 
-using content::NavigationController;
-using node::ObjectWrap;
+namespace mate {
 
-#define UNWRAP_WINDOW_AND_CHECK \
-  Window* self = ObjectWrap::Unwrap<Window>(args.This()); \
-  if (self == NULL) \
-    return node::ThrowError("Window is already destroyed")
+template<>
+struct Converter<gfx::Rect> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     gfx::Rect* out) {
+    if (!val->IsObject())
+      return false;
+    mate::Dictionary dict(isolate, val->ToObject());
+    int x, y, width, height;
+    if (!dict.Get("x", &x) || !dict.Get("y", &y) ||
+        !dict.Get("width", &width) || !dict.Get("height", &height))
+      return false;
+    *out = gfx::Rect(x, y, width, height);
+    return true;
+  }
+};
+
+}  // namespace mate
 
 namespace atom {
 
 namespace api {
 
-Window::Window(v8::Handle<v8::Object> wrapper, base::DictionaryValue* options)
-    : EventEmitter(wrapper),
-      window_(NativeWindow::Create(options)) {
+namespace {
+
+void OnCapturePageDone(
+    const base::Callback<void(v8::Handle<v8::Value>)>& 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.Run(buffer);
+}
+
+}  // namespace
+
+
+Window::Window(const mate::Dictionary& options)
+    : window_(NativeWindow::Create(options)) {
   window_->InitFromOptions(options);
   window_->AddObserver(this);
 }
 
 Window::~Window() {
-  Emit("destroyed");
+  if (window_)
+    Destroy();
 
-  window_->RemoveObserver(this);
+  Emit("destroyed");
 }
 
 void Window::OnPageTitleUpdated(bool* prevent_default,
                                 const std::string& title) {
   base::ListValue args;
   args.AppendString(title);
-  *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);
+  *prevent_default = Emit("page-title-updated", args);
 }
 
 void Window::WillCloseWindow(bool* prevent_default) {
@@ -64,15 +87,17 @@ void Window::WillCloseWindow(bool* prevent_default) {
 void Window::OnWindowClosed() {
   Emit("closed");
 
-  // 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);
+  window_->RemoveObserver(this);
 }
 
 void Window::OnWindowBlur() {
   Emit("blur");
 }
 
+void Window::OnWindowFocus() {
+  Emit("focus");
+}
+
 void Window::OnRendererUnresponsive() {
   Emit("unresponsive");
 }
@@ -81,657 +106,300 @@ 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");
-}
-
-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");
-
-  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("Options must be dictionary");
-
-  new Window(args.This(), static_cast<base::DictionaryValue*>(options.get()));
-
-  // Give js code a chance to do initialization.
-  node::MakeCallback(args.This(), "_init", 0, NULL);
+mate::Wrappable* Window::New(const mate::Dictionary& options) {
+  return new Window(options);
 }
 
-// static
-void Window::Destroy(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  base::ProcessHandle handle = self->window_->GetRenderProcessHandle();
-  delete self;
-
-  // 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));
+void Window::Destroy() {
+  window_->DestroyWebContents();
+  window_->CloseImmediately();
 }
 
-// static
-void Window::Close(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Close();
+void Window::Close() {
+  window_->Close();
 }
 
-// static
-void Window::Focus(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Focus(args[0]->IsBoolean() ? args[0]->BooleanValue(): true);
+void Window::Focus() {
+  window_->Focus(true);
 }
 
-// static
-void Window::IsFocused(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->IsFocused());
+bool Window::IsFocused() {
+  return window_->IsFocused();
 }
 
-// static
-void Window::Show(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Show();
+void Window::Show() {
+  window_->Show();
 }
 
-// static
-void Window::Hide(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Hide();
+void Window::Hide() {
+  window_->Hide();
 }
 
-// static
-void Window::IsVisible(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  return args.GetReturnValue().Set(self->window_->IsVisible());
+bool Window::IsVisible() {
+  return window_->IsVisible();
 }
 
-// static
-void Window::Maximize(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Maximize();
+void Window::Maximize() {
+  window_->Maximize();
 }
 
-// static
-void Window::Unmaximize(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Unmaximize();
+void Window::Unmaximize() {
+  window_->Unmaximize();
 }
 
-// static
-void Window::Minimize(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Minimize();
+void Window::Minimize() {
+  window_->Minimize();
 }
 
-// static
-void Window::Restore(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Restore();
+void Window::Restore() {
+  window_->Restore();
 }
 
-// static
-void Window::SetFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  bool fs;
-  if (!FromV8Arguments(args, &fs))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->SetFullscreen(fs);
+void Window::SetFullscreen(bool fullscreen) {
+  window_->SetFullscreen(fullscreen);
 }
 
-// static
-void Window::IsFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->IsFullscreen());
+bool Window::IsFullscreen() {
+  return window_->IsFullscreen();
 }
 
-// static
-void Window::SetSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  int width, height;
-  if (!FromV8Arguments(args, &width, &height))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->SetSize(gfx::Size(width, height));
+void Window::SetSize(int width, int height) {
+  window_->SetSize(gfx::Size(width, height));
 }
 
-// static
-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, ToV8Value(size.width()));
-  ret->Set(1, ToV8Value(size.height()));
-
-  args.GetReturnValue().Set(ret);
+std::vector<int> Window::GetSize() {
+  std::vector<int> result(2);
+  gfx::Size size = window_->GetSize();
+  result[0] = size.width();
+  result[1] = size.height();
+  return result;
 }
 
-// static
-void Window::SetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  int width, height;
-  if (!FromV8Arguments(args, &width, &height))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->SetMinimumSize(gfx::Size(width, height));
+void Window::SetContentSize(int width, int height) {
+  window_->SetContentSize(gfx::Size(width, height));
 }
 
-// static
-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, ToV8Value(size.width()));
-  ret->Set(1, ToV8Value(size.height()));
-
-  args.GetReturnValue().Set(ret);
+std::vector<int> Window::GetContentSize() {
+  std::vector<int> result(2);
+  gfx::Size size = window_->GetContentSize();
+  result[0] = size.width();
+  result[1] = size.height();
+  return result;
 }
 
-// static
-void Window::SetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  int width, height;
-  if (!FromV8Arguments(args, &width, &height))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->SetMaximumSize(gfx::Size(width, height));
+void Window::SetMinimumSize(int width, int height) {
+  window_->SetMinimumSize(gfx::Size(width, height));
 }
 
-// static
-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, ToV8Value(size.width()));
-  ret->Set(1, ToV8Value(size.height()));
-
-  args.GetReturnValue().Set(ret);
+std::vector<int> Window::GetMinimumSize() {
+  std::vector<int> result(2);
+  gfx::Size size = window_->GetMinimumSize();
+  result[0] = size.width();
+  result[1] = size.height();
+  return result;
 }
 
-// static
-void Window::SetResizable(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  bool resizable;
-  if (!FromV8Arguments(args, &resizable))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->SetResizable(resizable);
+void Window::SetMaximumSize(int width, int height) {
+  window_->SetMaximumSize(gfx::Size(width, height));
 }
 
-// static
-void Window::IsResizable(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->IsResizable());
+std::vector<int> Window::GetMaximumSize() {
+  std::vector<int> result(2);
+  gfx::Size size = window_->GetMaximumSize();
+  result[0] = size.width();
+  result[1] = size.height();
+  return result;
 }
 
-// static
-void Window::SetAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  bool top;
-  if (!FromV8Arguments(args, &top))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->SetAlwaysOnTop(top);
+void Window::SetResizable(bool resizable) {
+  window_->SetResizable(resizable);
 }
 
-// static
-void Window::IsAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->IsAlwaysOnTop());
+bool Window::IsResizable() {
+  return window_->IsResizable();
 }
 
-// static
-void Window::Center(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->Center();
+void Window::SetAlwaysOnTop(bool top) {
+  window_->SetAlwaysOnTop(top);
 }
 
-// static
-void Window::SetPosition(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_->SetPosition(gfx::Point(x, y));
+bool Window::IsAlwaysOnTop() {
+  return window_->IsAlwaysOnTop();
 }
 
-// static
-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, ToV8Value(pos.x()));
-  ret->Set(1, ToV8Value(pos.y()));
-
-  args.GetReturnValue().Set(ret);
+void Window::Center() {
+  window_->Center();
 }
 
-// static
-void Window::SetTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  std::string title;
-  if (!FromV8Arguments(args, &title))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->SetTitle(title);
+void Window::SetPosition(int x, int y) {
+  window_->SetPosition(gfx::Point(x, y));
 }
 
-// static
-void Window::GetTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(ToV8Value(self->window_->GetTitle()));
+std::vector<int> Window::GetPosition() {
+  std::vector<int> result(2);
+  gfx::Point pos = window_->GetPosition();
+  result[0] = pos.x();
+  result[1] = pos.y();
+  return result;
 }
 
-// static
-void Window::FlashFrame(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->FlashFrame(
-      args[0]->IsBoolean() ? args[0]->BooleanValue(): true);
+void Window::SetTitle(const std::string& title) {
+  window_->SetTitle(title);
 }
 
-// static
-void Window::SetKiosk(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  bool kiosk;
-  if (!FromV8Arguments(args, &kiosk))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->SetKiosk(kiosk);
+std::string Window::GetTitle() {
+  return window_->GetTitle();
 }
 
-// static
-void Window::IsKiosk(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->IsKiosk());
+void Window::FlashFrame(bool flash) {
+  window_->FlashFrame(flash);
 }
 
-// static
-void Window::OpenDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->OpenDevTools();
+void Window::SetSkipTaskbar(bool skip) {
+  window_->SetSkipTaskbar(skip);
 }
 
-// static
-void Window::CloseDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->CloseDevTools();
+void Window::SetKiosk(bool kiosk) {
+  window_->SetKiosk(kiosk);
 }
 
-// static
-void Window::IsDevToolsOpened(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->IsDevToolsOpened());
+bool Window::IsKiosk() {
+  return window_->IsKiosk();
 }
 
-// static
-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);
+void Window::OpenDevTools() {
+  window_->OpenDevTools();
 }
 
-// static
-void Window::DebugDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  if (self->window_->IsDevToolsOpened())
-    NativeWindow::Debug(self->window_->GetDevToolsWebContents());
+void Window::CloseDevTools() {
+  window_->CloseDevTools();
 }
 
-// static
-void Window::FocusOnWebView(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->FocusOnWebView();
+bool Window::IsDevToolsOpened() {
+  return window_->IsDevToolsOpened();
 }
 
-// static
-void Window::BlurWebView(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->BlurWebView();
+void Window::InspectElement(int x, int y) {
+  window_->InspectElement(x, y);
 }
 
-// static
-void Window::IsWebViewFocused(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->IsWebViewFocused());
+void Window::DebugDevTools() {
+  if (window_->IsDevToolsOpened())
+    NativeWindow::Debug(window_->GetDevToolsWebContents());
 }
 
-// static
-void Window::CapturePage(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
+void Window::FocusOnWebView() {
+  window_->FocusOnWebView();
+}
 
+void Window::BlurWebView() {
+  window_->BlurWebView();
+}
+
+bool Window::IsWebViewFocused() {
+  return window_->IsWebViewFocused();
+}
+
+void Window::CapturePage(mate::Arguments* args) {
   gfx::Rect rect;
-  RefCountedV8Function callback;
-  if (!FromV8Arguments(args, &rect, &callback) &&
-      !FromV8Arguments(args, &callback))
-    return node::ThrowTypeError("Bad argument");
+  base::Callback<void(v8::Handle<v8::Value>)> callback;
 
-  self->window_->CapturePage(rect, base::Bind(&Window::OnCapturePageDone,
-                                              base::Unretained(self),
-                                              callback));
+  if (!(args->Length() == 1 && args->GetNext(&callback)) &&
+      !(args->Length() == 2 && args->GetNext(&rect)
+                            && args->GetNext(&callback))) {
+    args->ThrowError();
+    return;
+  }
+
+  window_->CapturePage(rect, base::Bind(&OnCapturePageDone, callback));
+}
+
+void Window::SetRepresentedFilename(const std::string& filename) {
+  window_->SetRepresentedFilename(filename);
+}
+
+void Window::SetDocumentEdited(bool edited) {
+  window_->SetDocumentEdited(edited);
+}
+
+mate::Handle<WebContents> Window::GetWebContents(v8::Isolate* isolate) const {
+  return WebContents::Create(isolate, window_->GetWebContents());
+}
+
+mate::Handle<WebContents> Window::GetDevToolsWebContents(
+    v8::Isolate* isolate) const {
+  return WebContents::Create(isolate, window_->GetDevToolsWebContents());
 }
 
 // static
-void Window::GetPageTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(ToV8Value(
-      self->window_->GetWebContents()->GetTitle()));
-}
-
-// static
-void Window::IsLoading(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->GetWebContents()->IsLoading());
-}
-
-// static
-void Window::IsWaitingForResponse(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(
-      self->window_->GetWebContents()->IsWaitingForResponse());
-}
-
-// static
-void Window::Stop(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  self->window_->GetWebContents()->Stop();
-}
-
-// static
-void Window::GetRoutingID(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->GetWebContents()->GetRoutingID());
-}
-
-// static
-void Window::GetProcessID(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  args.GetReturnValue().Set(
-      self->window_->GetWebContents()->GetRenderProcessHost()->GetID());
-}
-
-// static
-void Window::IsCrashed(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-  args.GetReturnValue().Set(self->window_->GetWebContents()->IsCrashed());
-}
-
-// static
-void Window::GetDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  content::WebContents* web_contents = self->window_->GetDevToolsWebContents();
-  v8::Local<v8::Object> devtools = v8::Object::New();
-  devtools->Set(ToV8Value("processId"),
-                ToV8Value(web_contents->GetRenderProcessHost()->GetID()));
-  devtools->Set(ToV8Value("routingId"),
-                ToV8Value(web_contents->GetRoutingID()));
-  args.GetReturnValue().Set(devtools);
-}
-
-// static
-void Window::ExecuteJavaScriptInDevTools(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  std::string code;
-  if (!FromV8Arguments(args, &code))
-    return node::ThrowTypeError("Bad argument");
-
-  self->window_->ExecuteJavaScriptInDevTools(code);
-}
-
-// static
-void Window::LoadURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  GURL url;
-  if (!FromV8Arguments(args, &url))
-    return node::ThrowTypeError("Bad argument");
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-
-  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
-void Window::GetURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-  GURL url;
-  if (controller.GetActiveEntry())
-    url = controller.GetActiveEntry()->GetVirtualURL();
-
-  args.GetReturnValue().Set(ToV8Value(url));
-}
-
-// static
-void Window::CanGoBack(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-
-  args.GetReturnValue().Set(controller.CanGoBack());
-}
-
-// static
-void Window::CanGoForward(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-
-  args.GetReturnValue().Set(controller.CanGoForward());
-}
-
-// static
-void Window::CanGoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  int offset;
-  if (!FromV8Arguments(args, &offset))
-    return node::ThrowTypeError("Bad argument");
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-
-  args.GetReturnValue().Set(controller.CanGoToOffset(offset));
-}
-
-// static
-void Window::GoBack(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-  controller.GoBack();
-}
-
-// static
-void Window::GoForward(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-  controller.GoForward();
-}
-
-// static
-void Window::GoToIndex(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  int index;
-  if (!FromV8Arguments(args, &index))
-    return node::ThrowTypeError("Bad argument");
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-  controller.GoToIndex(index);
-}
-
-// static
-void Window::GoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  UNWRAP_WINDOW_AND_CHECK;
-
-  int offset;
-  if (!FromV8Arguments(args, &offset))
-    return node::ThrowTypeError("Bad argument");
-
-  NavigationController& controller =
-      self->window_->GetWebContents()->GetController();
-  controller.GoToOffset(offset);
-}
-
-// static
-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);
-}
-
-// static
-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);
-}
-
-// static
-void Window::Initialize(v8::Handle<v8::Object> target) {
-  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(Window::New);
-  t->InstanceTemplate()->SetInternalFieldCount(1);
-  t->SetClassName(v8::String::NewSymbol("BrowserWindow"));
-
-  NODE_SET_PROTOTYPE_METHOD(t, "destroy", Destroy);
-  NODE_SET_PROTOTYPE_METHOD(t, "close", Close);
-  NODE_SET_PROTOTYPE_METHOD(t, "focus", Focus);
-  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);
-  NODE_SET_PROTOTYPE_METHOD(t, "restore", Restore);
-  NODE_SET_PROTOTYPE_METHOD(t, "setFullScreen", SetFullscreen);
-  NODE_SET_PROTOTYPE_METHOD(t, "isFullScreen", IsFullscreen);
-  NODE_SET_PROTOTYPE_METHOD(t, "setSize", SetSize);
-  NODE_SET_PROTOTYPE_METHOD(t, "getSize", GetSize);
-  NODE_SET_PROTOTYPE_METHOD(t, "setMinimumSize", SetMinimumSize);
-  NODE_SET_PROTOTYPE_METHOD(t, "getMinimumSize", GetMinimumSize);
-  NODE_SET_PROTOTYPE_METHOD(t, "setMaximumSize", SetMaximumSize);
-  NODE_SET_PROTOTYPE_METHOD(t, "getMaximumSize", GetMaximumSize);
-  NODE_SET_PROTOTYPE_METHOD(t, "setResizable", SetResizable);
-  NODE_SET_PROTOTYPE_METHOD(t, "isResizable", IsResizable);
-  NODE_SET_PROTOTYPE_METHOD(t, "setAlwaysOnTop", SetAlwaysOnTop);
-  NODE_SET_PROTOTYPE_METHOD(t, "isAlwaysOnTop", IsAlwaysOnTop);
-  NODE_SET_PROTOTYPE_METHOD(t, "center", Center);
-  NODE_SET_PROTOTYPE_METHOD(t, "setPosition", SetPosition);
-  NODE_SET_PROTOTYPE_METHOD(t, "getPosition", GetPosition);
-  NODE_SET_PROTOTYPE_METHOD(t, "setTitle", SetTitle);
-  NODE_SET_PROTOTYPE_METHOD(t, "getTitle", GetTitle);
-  NODE_SET_PROTOTYPE_METHOD(t, "flashFrame", FlashFrame);
-  NODE_SET_PROTOTYPE_METHOD(t, "setKiosk", SetKiosk);
-  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, "isWebViewFocused", IsWebViewFocused);
-  NODE_SET_PROTOTYPE_METHOD(t, "capturePage", CapturePage);
-
-  NODE_SET_PROTOTYPE_METHOD(t, "getPageTitle", GetPageTitle);
-  NODE_SET_PROTOTYPE_METHOD(t, "isLoading", IsLoading);
-  NODE_SET_PROTOTYPE_METHOD(t, "isWaitingForResponse", IsWaitingForResponse);
-  NODE_SET_PROTOTYPE_METHOD(t, "stop", Stop);
-  NODE_SET_PROTOTYPE_METHOD(t, "getRoutingId", GetRoutingID);
-  NODE_SET_PROTOTYPE_METHOD(t, "getProcessId", GetProcessID);
-  NODE_SET_PROTOTYPE_METHOD(t, "isCrashed", IsCrashed);
-
-  NODE_SET_PROTOTYPE_METHOD(t, "getDevTools", GetDevTools);
-  NODE_SET_PROTOTYPE_METHOD(
-      t, "executeJavaScriptInDevTools", ExecuteJavaScriptInDevTools);
-
-  NODE_SET_PROTOTYPE_METHOD(t, "loadUrl", LoadURL);
-  NODE_SET_PROTOTYPE_METHOD(t, "getUrl", GetURL);
-  NODE_SET_PROTOTYPE_METHOD(t, "canGoBack", CanGoBack);
-  NODE_SET_PROTOTYPE_METHOD(t, "canGoForward", CanGoForward);
-  NODE_SET_PROTOTYPE_METHOD(t, "canGoToOffset", CanGoToOffset);
-  NODE_SET_PROTOTYPE_METHOD(t, "goBack", GoBack);
-  NODE_SET_PROTOTYPE_METHOD(t, "goForward", GoForward);
-  NODE_SET_PROTOTYPE_METHOD(t, "goToIndex", GoToIndex);
-  NODE_SET_PROTOTYPE_METHOD(t, "goToOffset", GoToOffset);
-  NODE_SET_PROTOTYPE_METHOD(t, "reload", Reload);
-  NODE_SET_PROTOTYPE_METHOD(t, "reloadIgnoringCache", ReloadIgnoringCache);
-
-  target->Set(v8::String::NewSymbol("BrowserWindow"), t->GetFunction());
+void Window::BuildPrototype(v8::Isolate* isolate,
+                            v8::Handle<v8::ObjectTemplate> prototype) {
+  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("destroy", &Window::Destroy)
+      .SetMethod("close", &Window::Close)
+      .SetMethod("focus", &Window::Focus)
+      .SetMethod("isFocused", &Window::IsFocused)
+      .SetMethod("show", &Window::Show)
+      .SetMethod("hide", &Window::Hide)
+      .SetMethod("isVisible", &Window::IsVisible)
+      .SetMethod("maximize", &Window::Maximize)
+      .SetMethod("unmaximize", &Window::Unmaximize)
+      .SetMethod("minimize", &Window::Minimize)
+      .SetMethod("restore", &Window::Restore)
+      .SetMethod("setFullScreen", &Window::SetFullscreen)
+      .SetMethod("isFullScreen", &Window::IsFullscreen)
+      .SetMethod("getSize", &Window::GetSize)
+      .SetMethod("setSize", &Window::SetSize)
+      .SetMethod("getContentSize", &Window::GetContentSize)
+      .SetMethod("setContentSize", &Window::SetContentSize)
+      .SetMethod("setMinimumSize", &Window::SetMinimumSize)
+      .SetMethod("getMinimumSize", &Window::GetMinimumSize)
+      .SetMethod("setMaximumSize", &Window::SetMaximumSize)
+      .SetMethod("getMaximumSize", &Window::GetMaximumSize)
+      .SetMethod("setResizable", &Window::SetResizable)
+      .SetMethod("isResizable", &Window::IsResizable)
+      .SetMethod("setAlwaysOnTop", &Window::SetAlwaysOnTop)
+      .SetMethod("isAlwaysOnTop", &Window::IsAlwaysOnTop)
+      .SetMethod("center", &Window::Center)
+      .SetMethod("setPosition", &Window::SetPosition)
+      .SetMethod("getPosition", &Window::GetPosition)
+      .SetMethod("setTitle", &Window::SetTitle)
+      .SetMethod("getTitle", &Window::GetTitle)
+      .SetMethod("flashFrame", &Window::FlashFrame)
+      .SetMethod("setSkipTaskbar", &Window::SetSkipTaskbar)
+      .SetMethod("setKiosk", &Window::SetKiosk)
+      .SetMethod("isKiosk", &Window::IsKiosk)
+      .SetMethod("setRepresentedFilename", &Window::SetRepresentedFilename)
+      .SetMethod("setDocumentEdited", &Window::SetDocumentEdited)
+      .SetMethod("_openDevTools", &Window::OpenDevTools)
+      .SetMethod("closeDevTools", &Window::CloseDevTools)
+      .SetMethod("isDevToolsOpened", &Window::IsDevToolsOpened)
+      .SetMethod("inspectElement", &Window::InspectElement)
+      .SetMethod("debugDevTools", &Window::DebugDevTools)
+      .SetMethod("focusOnWebView", &Window::FocusOnWebView)
+      .SetMethod("blurWebView", &Window::BlurWebView)
+      .SetMethod("isWebViewFocused", &Window::IsWebViewFocused)
+      .SetMethod("capturePage", &Window::CapturePage)
+      .SetMethod("_getWebContents", &Window::GetWebContents)
+      .SetMethod("_getDevToolsWebContents", &Window::GetDevToolsWebContents);
 }
 
 }  // namespace api
 
 }  // namespace atom
 
-NODE_MODULE(atom_browser_window, atom::api::Window::Initialize)
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports) {
+  using atom::api::Window;
+  v8::Local<v8::Function> constructor = mate::CreateConstructor<Window>(
+      node_isolate, "BrowserWindow", base::Bind(&Window::New));
+  mate::Dictionary dict(v8::Isolate::GetCurrent(), exports);
+  dict.Set("BrowserWindow", static_cast<v8::Handle<v8::Value>>(constructor));
+}
+
+}  // namespace
+
+NODE_MODULE(atom_browser_window, Initialize)

atom/browser/api/atom_api_window.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_API_ATOM_API_WINDOW_H_
@@ -10,11 +10,14 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "atom/browser/native_window_observer.h"
-#include "atom/common/api/atom_api_event_emitter.h"
-#include "atom/common/v8/scoped_persistent.h"
+#include "atom/browser/api/event_emitter.h"
+#include "native_mate/handle.h"
 
-namespace base {
-class DictionaryValue;
+class GURL;
+
+namespace mate {
+class Arguments;
+class Dictionary;
 }
 
 namespace atom {
@@ -23,108 +26,83 @@ class NativeWindow;
 
 namespace api {
 
-class Window : public EventEmitter,
+class WebContents;
+
+class Window : public mate::EventEmitter,
                public NativeWindowObserver {
  public:
-  virtual ~Window();
+  static mate::Wrappable* New(const mate::Dictionary& options);
 
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Handle<v8::ObjectTemplate> prototype);
 
-  NativeWindow* window() { return window_.get(); }
+  NativeWindow* window() const { return window_.get(); }
 
  protected:
-  explicit Window(v8::Handle<v8::Object> wrapper,
-                  base::DictionaryValue* options);
+  explicit Window(const mate::Dictionary& options);
+  virtual ~Window();
 
-  // Implementations of NativeWindowObserver.
+  // 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 OnWindowFocus() 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 void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
-
   // APIs for NativeWindow.
-  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);
+  void Destroy();
+  void Close();
+  void Focus();
+  bool IsFocused();
+  void Show();
+  void Hide();
+  bool IsVisible();
+  void Maximize();
+  void Unmaximize();
+  void Minimize();
+  void Restore();
+  void SetFullscreen(bool fullscreen);
+  bool IsFullscreen();
+  void SetSize(int width, int height);
+  std::vector<int> GetSize();
+  void SetContentSize(int width, int height);
+  std::vector<int> GetContentSize();
+  void SetMinimumSize(int width, int height);
+  std::vector<int> GetMinimumSize();
+  void SetMaximumSize(int width, int height);
+  std::vector<int> GetMaximumSize();
+  void SetResizable(bool resizable);
+  bool IsResizable();
+  void SetAlwaysOnTop(bool top);
+  bool IsAlwaysOnTop();
+  void Center();
+  void SetPosition(int x, int y);
+  std::vector<int> GetPosition();
+  void SetTitle(const std::string& title);
+  std::string GetTitle();
+  void FlashFrame(bool flash);
+  void SetSkipTaskbar(bool skip);
+  void SetKiosk(bool kiosk);
+  bool IsKiosk();
+  void OpenDevTools();
+  void CloseDevTools();
+  bool IsDevToolsOpened();
+  void InspectElement(int x, int y);
+  void DebugDevTools();
+  void FocusOnWebView();
+  void BlurWebView();
+  bool IsWebViewFocused();
+  void CapturePage(mate::Arguments* args);
+  void SetRepresentedFilename(const std::string& filename);
+  void SetDocumentEdited(bool edited);
 
   // APIs for WebContents.
-  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 devtools.
-  static void GetDevTools(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void ExecuteJavaScriptInDevTools(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  // APIs for NavigationController.
-  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);
+  mate::Handle<WebContents> GetWebContents(v8::Isolate* isolate) const;
+  mate::Handle<WebContents> GetDevToolsWebContents(v8::Isolate* isolate) const;
 
   scoped_ptr<NativeWindow> window_;
 
@@ -135,4 +113,27 @@ class Window : public EventEmitter,
 
 }  // namespace atom
 
+
+namespace mate {
+
+template<>
+struct Converter<atom::NativeWindow*> {
+  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+                     atom::NativeWindow** out) {
+    // null would be tranfered to NULL.
+    if (val->IsNull()) {
+      *out = NULL;
+      return true;
+    }
+
+    atom::api::Window* window;
+    if (!Converter<atom::api::Window*>::FromV8(isolate, val, &window))
+      return false;
+    *out = window->window();
+    return true;
+  }
+};
+
+}  // namespace mate
+
 #endif  // ATOM_BROWSER_API_ATOM_API_WINDOW_H_

atom/browser/api/atom_browser_bindings.cc

@@ -1,94 +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 "atom/browser/api/atom_browser_bindings.h"
-
-#include <vector>
-
-#include "base/logging.h"
-#include "atom/browser/api/atom_api_event.h"
-#include "atom/common/v8/native_type_conversions.h"
-#include "content/public/browser/browser_thread.h"
-
-#include "atom/common/v8/node_common.h"
-
-namespace atom {
-
-AtomBrowserBindings::AtomBrowserBindings() {
-}
-
-AtomBrowserBindings::~AtomBrowserBindings() {
-}
-
-void AtomBrowserBindings::OnRendererMessage(int process_id,
-                                            int routing_id,
-                                            const string16& channel,
-                                            const base::ListValue& args) {
-  v8::Locker locker(node_isolate);
-  v8::HandleScope handle_scope(node_isolate);
-
-  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(ToV8Value(channel));
-  const base::Value* value;
-  if (args.Get(0, &value))
-    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, global_env->context()));
-  }
-
-  node::MakeCallback(global_env->process_object(),
-                     "emit",
-                     arguments.size(),
-                     &arguments[0]);
-}
-
-void AtomBrowserBindings::OnRendererMessageSync(
-    int process_id,
-    int routing_id,
-    const string16& channel,
-    const base::ListValue& args,
-    content::WebContents* sender,
-    IPC::Message* message) {
-  v8::Locker locker(node_isolate);
-  v8::HandleScope handle_scope(node_isolate);
-
-  scoped_ptr<V8ValueConverter> converter(new V8ValueConverter);
-
-  // 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(ToV8Value(channel));
-  const base::Value* value;
-  if (args.Get(0, &value))
-    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));
-
-  for (size_t i = 1; i < args.GetSize(); i++) {
-    const base::Value* value;
-    if (args.Get(i, &value))
-      arguments.push_back(converter->ToV8Value(value, global_env->context()));
-  }
-
-  node::MakeCallback(global_env->process_object(),
-                     "emit",
-                     arguments.size(),
-                     &arguments[0]);
-}
-
-}  // namespace atom

atom/browser/api/atom_browser_bindings.h

@@ -1,51 +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_API_ATOM_BROWSER_BINDINGS_H_
-#define ATOM_BROWSER_API_ATOM_BROWSER_BINDINGS_H_
-
-#include "base/strings/string16.h"
-#include "atom/common/api/atom_bindings.h"
-#include "atom/common/v8/scoped_persistent.h"
-
-namespace base {
-class ListValue;
-}
-
-namespace content {
-class WebContents;
-}
-
-namespace IPC {
-class Message;
-}
-
-namespace atom {
-
-class AtomBrowserBindings : public AtomBindings {
- public:
-  AtomBrowserBindings();
-  virtual ~AtomBrowserBindings();
-
-  // Called when received a message from renderer.
-  void OnRendererMessage(int process_id,
-                         int routing_id,
-                         const string16& channel,
-                         const base::ListValue& args);
-
-  // Called when received a synchronous message from renderer.
-  void OnRendererMessageSync(int process_id,
-                             int routing_id,
-                             const string16& channel,
-                             const base::ListValue& args,
-                             content::WebContents* sender,
-                             IPC::Message* message);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AtomBrowserBindings);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_BROWSER_BINDINGS_H_

atom/browser/api/event.cc

@@ -0,0 +1,61 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/event.h"
+
+#include "atom/common/api/api_messages.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "content/public/browser/web_contents.h"
+#include "native_mate/object_template_builder.h"
+
+namespace mate {
+
+Event::Event()
+    : sender_(NULL),
+      message_(NULL),
+      prevent_default_(false) {
+}
+
+Event::~Event() {
+}
+
+ObjectTemplateBuilder Event::GetObjectTemplateBuilder(v8::Isolate* isolate) {
+  return ObjectTemplateBuilder(isolate)
+      .SetMethod("preventDefault", &Event::PreventDefault)
+      .SetMethod("sendReply", &Event::SendReply);
+}
+
+void Event::SetSenderAndMessage(content::WebContents* sender,
+                                IPC::Message* message) {
+  DCHECK(!sender_);
+  DCHECK(!message_);
+  sender_ = sender;
+  message_ = message;
+
+  Observe(sender);
+}
+
+void Event::WebContentsDestroyed(content::WebContents* web_contents) {
+  sender_ = NULL;
+  message_ = NULL;
+}
+
+void Event::PreventDefault() {
+  prevent_default_ = true;
+}
+
+bool Event::SendReply(const string16& json) {
+  if (message_ == NULL || sender_ == NULL)
+    return false;
+
+  AtomViewHostMsg_Message_Sync::WriteReplyParams(message_, json);
+  return sender_->Send(message_);
+}
+
+// static
+Handle<Event> Event::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new Event);
+}
+
+}  // namespace mate

atom/browser/api/event.h

@@ -0,0 +1,57 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_EVENT_H_
+#define ATOM_BROWSER_API_EVENT_H_
+
+#include "content/public/browser/web_contents_observer.h"
+#include "native_mate/wrappable.h"
+#include "native_mate/handle.h"
+
+namespace IPC {
+class Message;
+}
+
+namespace mate {
+
+class Event : public Wrappable,
+              public content::WebContentsObserver {
+ public:
+  static Handle<Event> Create(v8::Isolate* isolate);
+
+  // Pass the sender and message to be replied.
+  void SetSenderAndMessage(content::WebContents* sender, IPC::Message* message);
+
+  // event.PreventDefault().
+  void PreventDefault();
+
+  // event.sendReply(json), used for replying synchronous message.
+  bool SendReply(const string16& json);
+
+  // Whether event.preventDefault() is called.
+  bool prevent_default() const { return prevent_default_; }
+
+ protected:
+  Event();
+  virtual ~Event();
+
+  // Wrappable implementations:
+  virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate);
+
+  // content::WebContentsObserver implementations:
+  virtual void WebContentsDestroyed(content::WebContents*) OVERRIDE;
+
+ private:
+  // Replyer for the synchronous messages.
+  content::WebContents* sender_;
+  IPC::Message* message_;
+
+  bool prevent_default_;
+
+  DISALLOW_COPY_AND_ASSIGN(Event);
+};
+
+}  // namespace mate
+
+#endif  // ATOM_BROWSER_API_EVENT_H_

atom/browser/api/event_emitter.cc

@@ -0,0 +1,62 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/event_emitter.h"
+
+#include <vector>
+
+#include "atom/browser/api/event.h"
+#include "atom/common/native_mate_converters/v8_value_converter.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
+
+#include "atom/common/node_includes.h"
+
+namespace mate {
+
+EventEmitter::EventEmitter() {
+}
+
+bool EventEmitter::Emit(const base::StringPiece& name) {
+  return Emit(name, base::ListValue());
+}
+
+bool EventEmitter::Emit(const base::StringPiece& name,
+                        const base::ListValue& args) {
+  return Emit(name, args, NULL, NULL);
+}
+
+bool EventEmitter::Emit(const base::StringPiece& name,
+                        const base::ListValue& args,
+                        content::WebContents* 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<atom::V8ValueConverter> converter(new atom::V8ValueConverter);
+
+  mate::Handle<mate::Event> event = mate::Event::Create(node_isolate);
+  if (sender && message)
+    event->SetSenderAndMessage(sender, message);
+
+  // v8_args = [name, event, args...];
+  std::vector<v8::Handle<v8::Value>> v8_args;
+  v8_args.reserve(args.GetSize() + 2);
+  v8_args.push_back(mate::StringToV8(node_isolate, name));
+  v8_args.push_back(event.ToV8());
+  for (size_t i = 0; i < args.GetSize(); i++) {
+    const base::Value* value(NULL);
+    if (args.Get(i, &value))
+      v8_args.push_back(converter->ToV8Value(value, context));
+  }
+
+  // this.emit.apply(this, v8_args);
+  node::MakeCallback(
+      GetWrapper(node_isolate), "emit", v8_args.size(), &v8_args[0]);
+
+  return event->prevent_default();
+}
+
+}  // namespace mate

atom/browser/api/event_emitter.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_EVENT_EMITTER_H_
+#define ATOM_BROWSER_API_EVENT_EMITTER_H_
+
+#include "native_mate/wrappable.h"
+
+namespace base {
+class ListValue;
+}
+
+namespace content {
+class WebContents;
+}
+
+namespace IPC {
+class Message;
+}
+
+namespace mate {
+
+// Provide helperers to emit event in JavaScript.
+class EventEmitter : public Wrappable {
+ protected:
+  EventEmitter();
+
+  // this.emit(name, new Event());
+  bool Emit(const base::StringPiece& name);
+
+  // this.emit(name, new Event(), args...);
+  bool Emit(const base::StringPiece& name, const base::ListValue& args);
+
+  // this.emit(name, new Event(sender, message), args...);
+  bool Emit(const base::StringPiece& name, const base::ListValue& args,
+            content::WebContents* sender, IPC::Message* message);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EventEmitter);
+};
+
+}  // namespace mate
+
+#endif  // ATOM_BROWSER_API_EVENT_EMITTER_H_

atom/browser/api/lib/app.coffee

@@ -2,10 +2,8 @@ EventEmitter = require('events').EventEmitter
 
 bindings = process.atomBinding 'app'
 
-Application = bindings.Application
-Application::__proto__ = EventEmitter.prototype
-
-app = new Application
+app = bindings.app
+app.__proto__ = EventEmitter.prototype
 
 app.getHomeDir = ->
   process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
@@ -27,8 +25,10 @@ if process.platform is 'darwin'
     setBadge: bindings.dockSetBadgeText
     getBadge: bindings.dockGetBadgeText
 
-# Support old event name.
+# Be compatible with old API.
 app.once 'ready', -> app.emit 'finish-launching'
+app.terminate = app.quit
+app.exit = process.exit
 
 # Only one App object pemitted.
 module.exports = app

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

@@ -1,9 +1,8 @@
-AutoUpdater = process.atomBinding('auto_updater').AutoUpdater
+autoUpdater = process.atomBinding('auto_updater').autoUpdater
 EventEmitter = require('events').EventEmitter
 
-AutoUpdater::__proto__ = EventEmitter.prototype
+autoUpdater.__proto__ = EventEmitter.prototype
 
-autoUpdater = new AutoUpdater
 autoUpdater.on 'update-downloaded-raw', (args...) ->
   args[3] = new Date(args[3])  # releaseDate
   @emit 'update-downloaded', args..., => @quitAndInstall()
@@ -13,13 +12,13 @@ autoUpdater.quitAndInstall = ->
   BrowserWindow = require 'browser-window'
   windows = BrowserWindow.getAllWindows()
   if windows.length is 0
-    AutoUpdater::quitAndInstall.call this
+    @_quitAndInstall()
     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)
+  app.once 'window-all-closed', @_quitAndInstall.bind(this)
   win.close() for win in windows
 
 module.exports = autoUpdater

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

@@ -1,6 +1,7 @@
 EventEmitter = require('events').EventEmitter
 IDWeakMap = require 'id-weak-map'
 app = require 'app'
+wrapWebContents = require('web-contents').wrap
 
 BrowserWindow = process.atomBinding('window').BrowserWindow
 BrowserWindow::__proto__ = EventEmitter.prototype
@@ -14,24 +15,34 @@ BrowserWindow::_init = ->
     menu = app.getApplicationMenu()
     @setMenu menu if menu?
 
-  # Remember the window.
-  id = BrowserWindow.windows.add this
+  @webContents = @getWebContents()
+  @webContents.once 'destroyed', => @webContents = null
+
+  # Remember the window ID.
+  Object.defineProperty this, 'id',
+    value: BrowserWindow.windows.add(this)
+    enumerable: true
 
   # 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
+  # could be iterating windows before GC happened.
+  @once 'closed', =>
+    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::openDevTools = ->
+  @_openDevTools()
+
+  # Force devToolsWebContents to be created.
+  @devToolsWebContents = @getDevToolsWebContents()
+  @devToolsWebContents.once 'destroyed', => @devToolsWebContents = null
 
 BrowserWindow::toggleDevTools = ->
   if @isDevToolsOpened() then @closeDevTools() else @openDevTools()
 
-BrowserWindow::restart = ->
-  @loadUrl(@getUrl())
+BrowserWindow::getWebContents = ->
+  wrapWebContents @_getWebContents()
+
+BrowserWindow::getDevToolsWebContents = ->
+  wrapWebContents @_getDevToolsWebContents()
 
 BrowserWindow::setMenu = (menu) ->
   if process.platform is 'darwin'
@@ -50,16 +61,34 @@ BrowserWindow.getFocusedWindow = ->
   windows = BrowserWindow.getAllWindows()
   return window for window in windows when window.isFocused()
 
-BrowserWindow.fromProcessIdAndRoutingId = (processId, routingId) ->
+BrowserWindow.fromWebContents = (webContents) ->
   windows = BrowserWindow.getAllWindows()
-  return window for window in windows when window.getProcessId() == processId and
-                                           window.getRoutingId() == routingId
+  return window for window in windows when webContents.equal window.webContents
 
-BrowserWindow.fromDevTools = (processId, routingId) ->
+BrowserWindow.fromDevToolsWebContents = (webContents) ->
   windows = BrowserWindow.getAllWindows()
-  for window in windows
-    devtools = window.getDevTools()
-    return window if devtools.processId == processId and
-                     devtools.routingId == routingId
+  return window for window in windows when webContents.equal window.devToolsWebContents
+
+BrowserWindow.fromId = (id) ->
+  BrowserWindow.windows.get id
+
+# Helpers.
+BrowserWindow::loadUrl = -> @webContents.loadUrl.apply @webContents, arguments
+BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
+
+# Be compatible with old API.
+BrowserWindow::restart = -> @webContents.reload()
+BrowserWindow::getUrl = -> @webContents.getUrl()
+BrowserWindow::reload = -> @webContents.reload()
+BrowserWindow::reloadIgnoringCache = -> @webContents.reloadIgnoringCache()
+BrowserWindow::getPageTitle = -> @webContents.getTitle()
+BrowserWindow::isLoading = -> @webContents.isLoading()
+BrowserWindow::isWaitingForResponse = -> @webContents.isWaitingForResponse()
+BrowserWindow::stop = -> @webContents.stop()
+BrowserWindow::getRoutingId = -> @webContents.getRoutingId()
+BrowserWindow::getProcessId = -> @webContents.getProcessId()
+BrowserWindow::isCrashed = -> @webContents.isCrashed()
+BrowserWindow::executeJavaScriptInDevTools = (code) ->
+  @devToolsWebContents.executeJavaScript code
 
 module.exports = BrowserWindow

atom/browser/api/lib/dialog.coffee

@@ -26,11 +26,17 @@ module.exports =
     options.title ?= ''
     options.defaultPath ?= ''
 
+    wrappedCallback =
+      if typeof callback is 'function'
+        (success, result) -> callback(if success then result)
+      else
+        null
+
     binding.showOpenDialog String(options.title),
                            String(options.defaultPath),
                            properties,
                            window,
-                           callback
+                           wrappedCallback
 
   showSaveDialog: (window, options, callback) ->
     unless window?.constructor is BrowserWindow
@@ -43,10 +49,16 @@ module.exports =
     options.title ?= ''
     options.defaultPath ?= ''
 
+    wrappedCallback =
+      if typeof callback is 'function'
+        (success, result) -> callback(if success then result)
+      else
+        null
+
     binding.showSaveDialog String(options.title),
                            String(options.defaultPath),
                            window,
-                           callback
+                           wrappedCallback
 
   showMessageBox: (window, options, callback) ->
     unless window?.constructor is BrowserWindow

atom/browser/api/lib/ipc.coffee

@@ -1,32 +1,3 @@
 EventEmitter = require('events').EventEmitter
-send = process.atomBinding('ipc').send
 
-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...]
-
-class Ipc extends EventEmitter
-  constructor: ->
-    process.on 'ATOM_INTERNAL_MESSAGE', (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...)
-
-  sendChannel: (args...) ->
-    sendWrap('ATOM_INTERNAL_MESSAGE', args...)
-
-module.exports = new Ipc
+module.exports = new EventEmitter

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

@@ -1,4 +1,5 @@
 BrowserWindow = require 'browser-window'
+v8Util = process.atomBinding 'v8_util'
 
 nextCommandId = 0
 
@@ -8,28 +9,50 @@ 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, @submenu} = options
 
     @type = 'submenu' if not @type? and @submenu?
     throw new Error('Invalid submenu') if @type is 'submenu' and @submenu?.constructor isnt Menu
 
-    @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
+    @overrideReadOnlyProperty 'type', 'normal'
+    @overrideReadOnlyProperty 'accelerator'
+    @overrideReadOnlyProperty 'submenu'
+    @overrideProperty 'label', ''
+    @overrideProperty 'sublabel', ''
+    @overrideProperty 'enabled', true
+    @overrideProperty 'visible', true
+    @overrideProperty 'checked', false
 
-    throw new Error('Unknown menu type') if MenuItem.types.indexOf(@type) is -1
+    throw new Error("Unknown menu type #{@type}") if MenuItem.types.indexOf(@type) is -1
 
     @commandId = ++nextCommandId
     @click = =>
+      # Manually flip the checked flags when clicked.
+      @checked = !@checked if @type in ['checkbox', 'radio']
+
       if typeof click is 'function'
         click this, BrowserWindow.getFocusedWindow()
       else if typeof @selector is 'string'
         Menu.sendActionToFirstResponder @selector
 
+  overrideProperty: (name, defaultValue=null) ->
+    this[name] ?= defaultValue
+
+    # Update states when property is changed on Windows.
+    return unless process.platform is 'win32'
+    v8Util.setHiddenValue this, name, this[name]
+    Object.defineProperty this, name,
+      enumerable: true
+      get: => v8Util.getHiddenValue this, name
+      set: (val) =>
+        v8Util.setHiddenValue this, name, val
+        @menu?._updateStates()
+
+  overrideReadOnlyProperty: (name, defaultValue=null) ->
+    this[name] ?= defaultValue
+    Object.defineProperty this, name,
+      enumerable: true
+      writable: false
+      value: this[name]
+
 module.exports = MenuItem

atom/browser/api/lib/menu.coffee

@@ -1,17 +1,53 @@
 BrowserWindow = require 'browser-window'
 EventEmitter = require('events').EventEmitter
 MenuItem = require 'menu-item'
+v8Util = process.atomBinding 'v8_util'
 
 bindings = process.atomBinding 'menu'
 
+# Automatically generated radio menu item's group id.
+nextGroupId = 0
+
+# Search between seperators to find a radio menu item and return its group id,
+# otherwise generate a group id.
+generateGroupId = (items, pos) ->
+  if pos > 0
+    for i in [pos - 1..0]
+      item = items[i]
+      return item.groupId if item.type is 'radio'
+      break if item.type is 'separator'
+  else if pos < items.length
+    for i in [pos..items.length - 1]
+      item = items[i]
+      return item.groupId if item.type is 'radio'
+      break if item.type is 'separator'
+  ++nextGroupId
+
 Menu = bindings.Menu
 Menu::__proto__ = EventEmitter.prototype
 
-popup = Menu::popup
+Menu::_init = ->
+  @commandsMap = {}
+  @groupsMap = {}
+  @items = []
+  @delegate =
+    isCommandIdChecked: (commandId) => @commandsMap[commandId]?.checked
+    isCommandIdEnabled: (commandId) => @commandsMap[commandId]?.enabled
+    isCommandIdVisible: (commandId) => @commandsMap[commandId]?.visible
+    getAcceleratorForCommandId: (commandId) => @commandsMap[commandId]?.accelerator
+    executeCommand: (commandId) => @commandsMap[commandId]?.click()
+    menuWillShow: =>
+      # Make sure radio groups have at least one menu item seleted.
+      for id, group of @groupsMap
+        checked = false
+        for radioItem in group when radioItem.checked
+          checked = true
+          break
+        v8Util.setHiddenValue group[0], 'checked', true unless checked
+
 Menu::popup = (window) ->
   throw new TypeError('Invalid window') unless window?.constructor is BrowserWindow
-
-  popup.call this, window
+  @_popup window
 
 Menu::append = (item) ->
   @insert @getItemCount(), item
@@ -22,32 +58,54 @@ Menu::insert = (pos, item) ->
   switch item.type
     when 'normal' then @insertItem pos, item.commandId, item.label
     when 'checkbox' then @insertCheckItem pos, item.commandId, item.label
-    when 'radio' then @insertRadioItem pos, item.commandId, item.label, item.groupId
     when 'separator' then @insertSeparator pos
     when 'submenu' then @insertSubMenu pos, item.commandId, item.label, item.submenu
+    when 'radio'
+      # Grouping radio menu items.
+      item.overrideReadOnlyProperty 'groupId', generateGroupId(@items, pos)
+      @groupsMap[item.groupId] ?= []
+      @groupsMap[item.groupId].push item
+
+      # Setting a radio menu item should flip other items in the group.
+      v8Util.setHiddenValue item, 'checked', item.checked
+      Object.defineProperty item, 'checked',
+        enumerable: true
+        get: -> v8Util.getHiddenValue item, 'checked'
+        set: (val) =>
+          for otherItem in @groupsMap[item.groupId] when otherItem isnt item
+            v8Util.setHiddenValue otherItem, 'checked', false
+          v8Util.setHiddenValue item, 'checked', true
+
+          # Update states when clicked on Windows.
+          @_updateStates() if process.platform is 'win32'
+
+      @insertRadioItem pos, item.commandId, item.label, item.groupId
 
   @setSublabel pos, item.sublabel if item.sublabel?
 
-  unless @delegate?
-    @commandsMap = {}
-    @items = []
-    @delegate =
-      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?
+  # Make menu accessable to items.
+  item.overrideReadOnlyProperty 'menu', this
+
+  # Remember the items.
   @items.splice pos, 0, item
   @commandsMap[item.commandId] = item
 
+Menu::attachToWindow = (window) ->
+  @_callMenuWillShow() if process.platform is 'win32'
+  @_attachToWindow window
+
+# Force menuWillShow to be called
+Menu::_callMenuWillShow = ->
+  @delegate?.menuWillShow()
+  item.submenu._callMenuWillShow() for item in @items when item.submenu?
+
 applicationMenu = null
 Menu.setApplicationMenu = (menu) ->
   throw new TypeError('Invalid menu') unless menu?.constructor is Menu
   applicationMenu = menu  # Keep a reference.
 
   if process.platform is 'darwin'
+    menu._callMenuWillShow()
     bindings.setApplicationMenu menu
   else
     windows = BrowserWindow.getAllWindows()

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

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

atom/browser/api/lib/protocol.coffee

@@ -1,7 +1,7 @@
-protocol = process.atomBinding 'protocol'
+protocol = process.atomBinding('protocol').protocol
 EventEmitter = require('events').EventEmitter
 
-protocol[key] = value for key, value of EventEmitter.prototype
+protocol.__proto__ = EventEmitter.prototype
 
 protocol.RequestStringJob =
 class RequestStringJob

atom/browser/api/lib/tray.coffee

@@ -0,0 +1,10 @@
+EventEmitter = require('events').EventEmitter
+bindings = process.atomBinding 'tray'
+
+Tray = bindings.Tray
+Tray::__proto__ = EventEmitter.prototype
+Tray::setContextMenu = (menu) ->
+  @_setContextMenu menu
+  @menu = menu  # Keep a strong reference of menu.
+
+module.exports = Tray

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

@@ -0,0 +1,42 @@
+EventEmitter = require('events').EventEmitter
+ipc = require 'ipc'
+
+module.exports.wrap = (webContents) ->
+  return null unless webContents.isAlive()
+
+  # webContents is an EventEmitter.
+  webContents.__proto__ = EventEmitter.prototype
+
+  # WebContents::send(channel, args..)
+  webContents.send = (args...) ->
+    @_send 'ATOM_INTERNAL_MESSAGE', [args...]
+
+  # Make sure webContents.executeJavaScript would run the code only when the
+  # web contents has been loaded.
+  webContents.loaded = false
+  webContents.once 'did-finish-load', -> @loaded = true
+  webContents.executeJavaScript = (code) ->
+    if @loaded
+      @_executeJavaScript code
+    else
+      webContents.once 'did-finish-load', @_executeJavaScript.bind(this, code)
+
+  # The processId and routingId and identify a webContents.
+  webContents.getId = -> "#{@getProcessId()}-#{@getRoutingId()}"
+  webContents.equal = (other) -> @getId() is other.getId()
+
+  # Tell the rpc server that a render view has been deleted and we need to
+  # release all objects owned by it.
+  webContents.on 'render-view-deleted', (event, processId, routingId) ->
+    process.emit 'ATOM_BROWSER_RELEASE_RENDER_VIEW', "#{processId}-#{routingId}"
+
+  # Dispatch IPC messages to the ipc module.
+  webContents.on 'ipc-message', (event, channel, args...) =>
+    Object.defineProperty event, 'sender', value: webContents
+    ipc.emit channel, event, args...
+  webContents.on 'ipc-message-sync', (event, channel, args...) =>
+    Object.defineProperty event, 'returnValue', set: (value) -> event.sendReply JSON.stringify(value)
+    Object.defineProperty event, 'sender', value: webContents
+    ipc.emit channel, event, args...
+
+  webContents

atom/browser/atom_browser_client.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/atom_browser_client.h"
@@ -13,6 +13,7 @@
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "webkit/common/webpreferences.h"
 
 namespace atom {
@@ -65,7 +66,7 @@ void AtomBrowserClient::OverrideWebkitPrefs(
   prefs->application_cache_enabled = true;
   prefs->allow_universal_access_from_file_urls = true;
   prefs->allow_file_access_from_file_urls = true;
-  prefs->experimental_webgl_enabled = false;
+  prefs->experimental_webgl_enabled = true;
   prefs->allow_displaying_insecure_content = true;
   prefs->allow_running_insecure_content = true;
 
@@ -83,10 +84,15 @@ bool AtomBrowserClient::ShouldSwapProcessesForNavigation(
   if (site_instance->HasProcess())
     dying_render_process_ = site_instance->GetProcess();
 
-  // Restart renderer process for all navigations.
+  // Restart renderer process for all navigations, this relies on a patch to
+  // Chromium: http://git.io/_PaNyg.
   return true;
 }
 
+std::string AtomBrowserClient::GetApplicationLocale() {
+  return l10n_util::GetApplicationLocale("");
+}
+
 void AtomBrowserClient::AppendExtraCommandLineSwitches(
     CommandLine* command_line,
     int child_process_id) {

atom/browser/atom_browser_client.h

@@ -1,10 +1,12 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 #define ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 
+#include <string>
+
 #include "brightray/browser/browser_client.h"
 
 namespace atom {
@@ -25,6 +27,7 @@ class AtomBrowserClient : public brightray::BrowserClient {
       content::SiteInstance* site_instance,
       const GURL& current_url,
       const GURL& new_url) OVERRIDE;
+  virtual std::string GetApplicationLocale() OVERRIDE;
   virtual void AppendExtraCommandLineSwitches(CommandLine* command_line,
                                               int child_process_id) OVERRIDE;
 

atom/browser/atom_browser_context.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/atom_browser_context.h"

atom/browser/atom_browser_context.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_

atom/browser/atom_browser_main_parts.cc

@@ -1,13 +1,13 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/atom_browser_main_parts.h"
 
-#include "atom/browser/api/atom_browser_bindings.h"
 #include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/browser.h"
+#include "atom/common/api/atom_bindings.h"
 #include "atom/common/node_bindings.h"
 #include "net/proxy/proxy_resolver_v8.h"
 
@@ -15,7 +15,7 @@
 #include "ui/gfx/win/dpi.h"
 #endif
 
-#include "atom/common/v8/node_common.h"
+#include "atom/common/node_includes.h"
 
 namespace atom {
 
@@ -23,7 +23,7 @@ namespace atom {
 AtomBrowserMainParts* AtomBrowserMainParts::self_ = NULL;
 
 AtomBrowserMainParts::AtomBrowserMainParts()
-    : atom_bindings_(new AtomBrowserBindings),
+    : atom_bindings_(new AtomBindings),
       browser_(new Browser),
       node_bindings_(NodeBindings::Create(true)) {
   DCHECK(!self_) << "Cannot have two AtomBrowserMainParts";

atom/browser/atom_browser_main_parts.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
@@ -9,7 +9,7 @@
 
 namespace atom {
 
-class AtomBrowserBindings;
+class AtomBindings;
 class Browser;
 class NodeBindings;
 
@@ -20,7 +20,6 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 
   static AtomBrowserMainParts* Get();
 
-  AtomBrowserBindings* atom_bindings() { return atom_bindings_.get(); }
   Browser* browser() { return browser_.get(); }
 
  protected:
@@ -37,7 +36,7 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 #endif
 
  private:
-  scoped_ptr<AtomBrowserBindings> atom_bindings_;
+  scoped_ptr<AtomBindings> atom_bindings_;
   scoped_ptr<Browser> browser_;
   scoped_ptr<NodeBindings> node_bindings_;
 

atom/browser/atom_browser_main_parts_mac.mm

@@ -1,18 +1,22 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/atom_browser_main_parts.h"
 
+#import "atom/browser/mac/atom_application.h"
+#import "atom/browser/mac/atom_application_delegate.h"
 #include "base/files/file_path.h"
 #import "base/mac/foundation_util.h"
-#import "atom/browser/atom_application_mac.h"
-#import "atom/browser/atom_application_delegate_mac.h"
+#include "ui/base/l10n/l10n_util_mac.h"
 #import "vendor/brightray/common/mac/main_application_bundle.h"
 
 namespace atom {
 
 void AtomBrowserMainParts::PreMainMessageLoopStart() {
+  // Initialize locale setting.
+  l10n_util::OverrideLocaleWithCocoaLocale();
+
   // Force the NSApplication subclass to be used.
   NSApplication* application = [AtomApplication sharedApplication];
 

atom/browser/atom_javascript_dialog_manager.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/atom_javascript_dialog_manager.h"

atom/browser/atom_javascript_dialog_manager.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_

atom/browser/auto_updater.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/auto_updater.h"

atom/browser/auto_updater.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_AUTO_UPDATER_H_

atom/browser/auto_updater_delegate.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_

atom/browser/auto_updater_linux.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/auto_updater.h"

atom/browser/auto_updater_mac.mm

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/auto_updater.h"

atom/browser/auto_updater_win.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/auto_updater.h"

atom/browser/browser.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/browser.h"
@@ -8,6 +8,7 @@
 
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/window_list.h"
+#include "base/message_loop/message_loop.h"
 
 namespace atom {
 
@@ -30,11 +31,16 @@ void Browser::Quit() {
 
   atom::WindowList* window_list = atom::WindowList::GetInstance();
   if (window_list->size() == 0)
-    NotifyAndTerminate();
+    NotifyAndShutdown();
 
   window_list->CloseAllWindows();
 }
 
+void Browser::Shutdown() {
+  is_quiting_ = true;
+  base::MessageLoop::current()->Quit();
+}
+
 std::string Browser::GetVersion() const {
   if (version_override_.empty()) {
     std::string version = GetExecutableFileVersion();
@@ -88,7 +94,7 @@ void Browser::DidFinishLaunching() {
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnFinishLaunching());
 }
 
-void Browser::NotifyAndTerminate() {
+void Browser::NotifyAndShutdown() {
   bool prevent_default = false;
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWillQuit(&prevent_default));
 
@@ -97,22 +103,19 @@ void Browser::NotifyAndTerminate() {
     return;
   }
 
-  Terminate();
+  Shutdown();
 }
 
 void Browser::OnWindowCloseCancelled(NativeWindow* window) {
-  if (is_quiting_) {
+  if (is_quiting_)
     // Once a beforeunload handler has prevented the closing, we think the quit
     // is cancelled too.
     is_quiting_ = false;
-
-    CancelQuit();
-  }
 }
 
 void Browser::OnWindowAllClosed() {
   if (is_quiting_)
-    NotifyAndTerminate();
+    NotifyAndShutdown();
   else
     FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWindowAllClosed());
 }

atom/browser/browser.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_BROWSER_H_
@@ -26,8 +26,8 @@ class Browser : public WindowListObserver {
   // Try to close all windows and quit the application.
   void Quit();
 
-  // Quit the application immediately without cleanup work.
-  void Terminate();
+  // Cleanup everything and shutdown the application gracefully.
+  void Shutdown();
 
   // Focus the application.
   void Focus();
@@ -88,11 +88,8 @@ class Browser : public WindowListObserver {
   // 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();
-
-  // Tell the system we have cancelled quiting.
-  void CancelQuit();
+  // Send the will-quit message and then shutdown the application.
+  void NotifyAndShutdown();
 
   bool is_quiting_;
 

atom/browser/browser_linux.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/browser.h"
@@ -12,11 +12,6 @@
 
 namespace atom {
 
-void Browser::Terminate() {
-  is_quiting_ = true;
-  exit(0);
-}
-
 void Browser::Focus() {
   // Focus on the first visible window.
   WindowList* list = WindowList::GetInstance();
@@ -37,8 +32,4 @@ std::string Browser::GetExecutableFileProductName() const {
   return "Atom-Shell";
 }
 
-void Browser::CancelQuit() {
-  // No way to cancel quit on Linux.
-}
-
 }  // namespace atom

atom/browser/browser_mac.mm

@@ -1,20 +1,15 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/browser.h"
 
 #import "base/mac/bundle_locations.h"
 #include "base/strings/sys_string_conversions.h"
-#import "atom/browser/atom_application_mac.h"
+#import "atom/browser/mac/atom_application.h"
 
 namespace atom {
 
-void Browser::Terminate() {
-  is_quiting_ = true;
-  [[AtomApplication sharedApplication] terminate:nil];
-}
-
 void Browser::Focus() {
   [[AtomApplication sharedApplication] activateIgnoringOtherApps:YES];
 }
@@ -31,10 +26,6 @@ std::string Browser::GetExecutableFileProductName() const {
   return base::SysNSStringToUTF8(version);
 }
 
-void Browser::CancelQuit() {
-  [[AtomApplication sharedApplication] replyToApplicationShouldTerminate:NO];
-}
-
 int Browser::DockBounce(BounceType type) {
   return [[AtomApplication sharedApplication] requestUserAttention:type];
 }

atom/browser/browser_observer.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_BROWSER_OBSERVER_H_

atom/browser/browser_win.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/browser.h"
@@ -33,11 +33,6 @@ BOOL CALLBACK WindowsEnumerationHandler(HWND hwnd, LPARAM param) {
 
 }  // namespace
 
-void Browser::Terminate() {
-  is_quiting_ = true;
-  PostQuitMessage(0);
-}
-
 void Browser::Focus() {
   // On Windows we just focus on the first window found for this process.
   DWORD pid = GetCurrentProcessId();
@@ -66,8 +61,4 @@ std::string Browser::GetExecutableFileProductName() const {
   return "Atom-Shell";
 }
 
-void Browser::CancelQuit() {
-  // TODO(zcbenz): Research on how to cancel shutdown in Windows.
-}
-
 }  // namespace atom

atom/browser/default_app/default_app.js

@@ -1,6 +1,4 @@
 var app = require('app');
-var dialog = require('dialog');
-var ipc = require('ipc');
 var Menu = require('menu');
 var MenuItem = require('menu-item');
 var BrowserWindow = require('browser-window');
@@ -10,33 +8,20 @@ var menu = null;
 
 // Quit when all windows are closed.
 app.on('window-all-closed', function() {
-  app.terminate();
-});
-
-app.on('open-url', function(event, url) {
-  dialog.showMessageBox({message: url, buttons: ['OK']});
+  app.quit();
 });
 
 app.on('ready', function() {
   app.commandLine.appendSwitch('js-flags', '--harmony_collections');
 
-  mainWindow = new BrowserWindow({ width: 800, height: 600 });
+  mainWindow = new BrowserWindow({
+    width: 800,
+    height: 600,
+    resizable: false,
+    'use-content-size': true,
+  });
   mainWindow.loadUrl('file://' + __dirname + '/index.html');
 
-  mainWindow.on('page-title-updated', function(event, title) {
-    event.preventDefault();
-
-    this.setTitle('Atom Shell - ' + title);
-  });
-
-  mainWindow.on('closed', function() {
-    mainWindow = null;
-  });
-
-  mainWindow.on('unresponsive', function() {
-    console.log('unresponsive');
-  });
-
   if (process.platform == 'darwin') {
     var template = [
       {
@@ -117,16 +102,16 @@ app.on('ready', function() {
           {
             label: 'Reload',
             accelerator: 'Command+R',
-            click: function() { BrowserWindow.getFocusedWindow().restart(); }
+            click: function() { mainWindow.restart(); }
           },
           {
             label: 'Enter Fullscreen',
-            click: function() { BrowserWindow.getFocusedWindow().setFullscreen(true); }
+            click: function() { mainWindow.setFullScreen(true); }
           },
           {
             label: 'Toggle DevTools',
             accelerator: 'Alt+Command+I',
-            click: function() { BrowserWindow.getFocusedWindow().toggleDevTools(); }
+            click: function() { mainWindow.toggleDevTools(); }
           },
         ]
       },
@@ -196,9 +181,4 @@ app.on('ready', function() {
     menu = Menu.buildFromTemplate(template);
     mainWindow.setMenu(menu);
   }
-
-  ipc.on('message', function(processId, routingId, type) {
-    if (type == 'menu')
-      menu.popup(mainWindow);
-  });
 });

atom/browser/default_app/index.html

@@ -1,18 +1,127 @@
 <html>
 <head>
-  <meta http-equiv="content-type" content="text/html; charset=utf-8">
   <title>Atom Shell</title>
+  <style>
+    html {
+      height: 100%;
+      width: 100%;
+      overflow: hidden;
+    }
+
+    body {
+      color: #555;
+      font-family: 'Open Sans',Helvetica,Arial,sans-serif;
+      padding: 30px;
+    }
+
+    h2 {
+      color: #2b6cc2;
+      font-family: "Crimson Text",Georgia,serif;
+      font-weight: 400;
+      line-height: 1.1;
+      letter-spacing: -0.015em;
+    }
+
+    a {
+      color: #2b6cc2;
+      text-decoration: none;
+    }
+    a:hover {
+      text-decoration: underline;
+    }
+
+    pre, code {
+      font-family: "Menlo","Lucida Console",monospace;
+      border: 1px solid #ddd;
+      background-color: #f8f8f8;
+      border-radius: 3px;
+    }
+
+    pre {
+      white-space: pre-wrap;
+      font-size: 13px;
+      line-height: 19px;
+      overflow: auto;
+      padding: 6px 10px;
+    }
+
+    #holder {
+      border: 4px dashed #ccc;
+      margin: 0 auto;
+      height: 300px;
+      color: #ccc;
+      font-size: 40px;
+      line-height: 300px;
+      text-align: center;
+      -webkit-user-select: none;
+    }
+    #holder.hover {
+      border: 4px dashed #999;
+      color: #eee;
+    }
+  </style>
 </head>
 <body>
-  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');
+  <script>
+    var execPath = require('remote').process.execPath;
+    var command = execPath + ' path-to-your-app';
 
-    window.addEventListener('contextmenu', function (e) {
+    document.onclick = function(e) {
       e.preventDefault();
-      ipc.send('menu');
-    }, false);
+      if (e.target.tagName == 'A')
+        require('shell').openExternal(e.target.href);
+      return false;
+    };
+    document.ondragover = document.ondrop = function(e) {
+      e.preventDefault();
+      return false;
+    };
+  </script>
+
+  <h2>Welcome to Atom Shell</h2>
+
+  <p>
+  To run your app with atom-shell, execute the following command under your
+  Console (or Terminal):
+  </p>
+
+  <script>document.write('<pre>' + command + '</pre>')</script>
+
+  <p>
+  The <code>path-to-your-app</code> should be the path to your own atom-shell
+  app, you can read the <a href='https://github.com/atom/atom-shell/blob/master/docs/tutorial/quick-start.md'>quick start</a>
+  guide in atom-shell's <a href='https://github.com/atom/atom-shell/blob/master/docs'>docs</a>
+  on how to write one.
+  </p>
+
+  <p>
+  Or you can just drag your app here to run it:
+  </p>
+
+  <div id="holder">
+    Drag your app here to run it
+  </div>
+
+  <script>
+    var holder = document.getElementById('holder');
+    holder.ondragover = function () {
+      this.className = 'hover';
+      return false;
+    };
+    holder.ondragleave = holder.ondragend = function () {
+      this.className = '';
+      return false;
+    };
+    holder.ondrop = function (e) {
+      this.className = '';
+      e.preventDefault();
+
+      var file = e.dataTransfer.files[0];
+      require('child_process').execFile(execPath, [file.path], {
+        detached: true, stdio: 'ignore'
+      }).unref();
+      return false;
+    };
   </script>
 </body>
 </html>

atom/browser/default_app/main.js

@@ -1,4 +1,6 @@
 var app = require('app');
+var dialog = require('dialog');
+var fs = require('fs');
 var path = require('path');
 var optimist = require('optimist');
 
@@ -14,13 +16,34 @@ var argv = optimist(process.argv.slice(1)).boolean('ci').argv;
 // start the default app.
 if (argv._.length > 0) {
   try {
-    require(path.resolve(argv._[0]));
+    // Override app name and version.
+    var packagePath = path.resolve(argv._[0]);
+    var packageJsonPath = path.join(packagePath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      var packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
+      if (packageJson.version)
+        app.setVersion(packageJson.version);
+      if (packageJson.productName)
+        app.setName(packageJson.productName);
+      else if (packageJson.name)
+        app.setName(packageJson.name);
+    }
+
+    // Run the app.
+    require('module')._load(packagePath, module, true);
   } catch(e) {
     if (e.code == 'MODULE_NOT_FOUND') {
-      console.error(e.stack);
-      console.error('Specified app is invalid');
+      app.focus();
+      dialog.showMessageBox({
+        type: 'warning',
+        buttons: ['OK'],
+        title: 'Error opening app',
+        message: 'The app provided is not a valid atom-shell app, please read the docs on how to write one:',
+        detail: 'https://github.com/atom/atom-shell/tree/master/docs'
+      });
       process.exit(1);
     } else {
+      console.error('App throwed an error when running', e);
       throw e;
     }
   }

atom/browser/default_app/package.json

@@ -1,5 +1,6 @@
 {
   "name": "atom-shell-default-app",
+  "productName": "Atom Shell Default App",
   "version": "0.1.0",
   "main": "main.js",
   "dependencies": {

atom/browser/devtools_delegate.cc

@@ -1,5 +1,5 @@
 // Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/devtools_delegate.h"
@@ -7,13 +7,13 @@
 #include <string>
 
 #include "base/message_loop/message_loop.h"
-#include "base/values.h"
 #include "atom/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"
+#include "native_mate/dictionary.h"
 #include "ui/gfx/point.h"
 
 namespace atom {
@@ -37,9 +37,9 @@ DevToolsDelegate::DevToolsDelegate(NativeWindow* window,
       devtools_agent_host_.get(), devtools_client_host_.get());
 
   // Go!
-  base::DictionaryValue options;
-  options.SetString("title", "DevTools Debugger");
-  window->InitFromOptions(&options);
+  mate::Dictionary options;
+  options.Set("title", "DevTools Debugger");
+  window->InitFromOptions(options);
   window->AddObserver(this);
   web_contents->GetController().LoadURL(
       GURL("chrome-devtools://devtools/devtools.html?dockSide=undocked"),

atom/browser/devtools_delegate.h

@@ -1,5 +1,5 @@
 // Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_DEVTOOLS_DELEGATE_H_

atom/browser/devtools_web_contents_observer.cc

@@ -1,64 +0,0 @@
-// 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 "atom/browser/devtools_web_contents_observer.h"
-
-#include "atom/browser/api/atom_browser_bindings.h"
-#include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/native_window.h"
-#include "atom/common/api/api_messages.h"
-#include "base/logging.h"
-#include "content/public/browser/render_process_host.h"
-#include "ipc/ipc_message_macros.h"
-
-namespace atom {
-
-DevToolsWebContentsObserver::DevToolsWebContentsObserver(
-    NativeWindow* native_window,
-    content::WebContents* web_contents)
-    : content::WebContentsObserver(web_contents),
-      inspected_window_(native_window) {
-  DCHECK(native_window);
-}
-
-DevToolsWebContentsObserver::~DevToolsWebContentsObserver() {
-}
-
-bool DevToolsWebContentsObserver::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(DevToolsWebContentsObserver, message)
-    IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
-                                    OnRendererMessageSync)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  return handled;
-}
-
-void DevToolsWebContentsObserver::OnRendererMessage(
-    const string16& channel,
-    const base::ListValue& args) {
-  AtomBrowserMainParts::Get()->atom_bindings()->OnRendererMessage(
-      web_contents()->GetRenderProcessHost()->GetID(),
-      web_contents()->GetRoutingID(),
-      channel,
-      args);
-}
-
-void DevToolsWebContentsObserver::OnRendererMessageSync(
-    const string16& channel,
-    const base::ListValue& args,
-    IPC::Message* reply_msg) {
-  AtomBrowserMainParts::Get()->atom_bindings()->OnRendererMessageSync(
-      web_contents()->GetRenderProcessHost()->GetID(),
-      web_contents()->GetRoutingID(),
-      channel,
-      args,
-      web_contents(),
-      reply_msg);
-}
-
-}  // namespace atom

atom/browser/devtools_web_contents_observer.h

@@ -1,41 +0,0 @@
-// 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_WEB_CONTENTS_OBSERVER_H_
-#define ATOM_BROWSER_DEVTOOLS_WEB_CONTENTS_OBSERVER_H_
-
-#include "content/public/browser/web_contents_observer.h"
-
-namespace base {
-class ListValue;
-}
-
-namespace atom {
-
-class NativeWindow;
-
-class DevToolsWebContentsObserver : public content::WebContentsObserver {
- public:
-  DevToolsWebContentsObserver(NativeWindow* native_window,
-                              content::WebContents* web_contents);
-  virtual ~DevToolsWebContentsObserver();
-
- protected:
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
-
-  void OnRendererMessage(const string16& channel,
-                         const base::ListValue& args);
-  void OnRendererMessageSync(const string16& channel,
-                             const base::ListValue& args,
-                             IPC::Message* reply_msg);
-
- private:
-  NativeWindow* inspected_window_;
-
-  DISALLOW_COPY_AND_ASSIGN(DevToolsWebContentsObserver);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_DEVTOOLS_WEB_CONTENTS_OBSERVER_H_

atom/browser/lib/init.coffee

@@ -1,9 +1,10 @@
-fs   = require 'fs'
-path = require 'path'
-util = require 'util'
+fs     = require 'fs'
+path   = require 'path'
+module = require 'module'
+util   = require 'util'
 
 # Expose information of current process.
-process.__atom_type = 'browser'
+process.type = 'browser'
 process.resourcesPath = path.resolve process.argv[1], '..', '..', '..', '..'
 
 # We modified the original process.argv to let node.js load the atom.js,
@@ -17,7 +18,7 @@ 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 = module.globalPaths
 globalPaths.push path.join process.resourcesPath, 'atom', 'browser', 'api', 'lib'
 
 # Do loading in next tick since we still need some initialize work before
@@ -77,4 +78,4 @@ setImmediate ->
     app.setName packageJson.name
 
   # Finally load app's main.js and transfer control to C++.
-  require path.join(packagePath, packageJson.main)
+  module._load path.join(packagePath, packageJson.main), module, true

atom/browser/lib/objects-registry.coffee

@@ -29,13 +29,11 @@ class ObjectsStore
     throw new Error("Invalid key #{id} for ObjectsStore") unless @has id
     @objects[id]
 
-  @forRenderView: (processId, routingId) ->
-    key = "#{processId}_#{routingId}"
+  @forRenderView: (key) ->
     @stores[key] = new ObjectsStore unless @stores[key]?
     @stores[key]
 
-  @releaseForRenderView: (processId, routingId) ->
-    key = "#{processId}_#{routingId}"
+  @releaseForRenderView: (key) ->
     delete @stores[key]
 
 class ObjectsRegistry extends EventEmitter
@@ -52,7 +50,7 @@ class ObjectsRegistry extends EventEmitter
 
   # Register a new object, the object would be kept referenced until you release
   # it explicitly.
-  add: (processId, routingId, obj) ->
+  add: (key, obj) ->
     # Some native objects may already been added to objectsWeakMap, be care not
     # to add it twice.
     @objectsWeakMap.add obj unless v8Util.getHiddenValue obj, 'atomId'
@@ -63,7 +61,7 @@ class ObjectsRegistry extends EventEmitter
     # 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
+    store = ObjectsStore.forRenderView key
     storeId = store.add obj
 
     [id, storeId]
@@ -73,12 +71,12 @@ class ObjectsRegistry extends EventEmitter
     @objectsWeakMap.get id
 
   # Remove an object according to its storeId.
-  remove: (processId, routingId, storeId) ->
-    ObjectsStore.forRenderView(processId, routingId).remove storeId
+  remove: (key, storeId) ->
+    ObjectsStore.forRenderView(key).remove storeId
 
   # Clear all references to objects from renderer view.
-  clear: (processId, routingId) ->
-    @emit "release-renderer-view-#{processId}-#{routingId}"
-    ObjectsStore.releaseForRenderView processId, routingId
+  clear: (key) ->
+    @emit "clear-#{key}"
+    ObjectsStore.releaseForRenderView key
 
 module.exports = new ObjectsRegistry

atom/browser/lib/rpc-server.coffee

@@ -4,7 +4,7 @@ objectsRegistry = require './objects-registry.js'
 v8Util = process.atomBinding 'v8_util'
 
 # Convert a real value into meta data.
-valueToMeta = (processId, routingId, value) ->
+valueToMeta = (sender, value) ->
   meta = type: typeof value
 
   meta.type = 'value' if value is null
@@ -15,14 +15,14 @@ valueToMeta = (processId, routingId, value) ->
 
   if meta.type is 'array'
     meta.members = []
-    meta.members.push valueToMeta(processId, routingId, el) for el in value
+    meta.members.push valueToMeta(sender, el) for el in value
   else if meta.type is 'object' or meta.type is 'function'
     meta.name = value.constructor.name
 
     # Reference the original value if it's an object, because when it's
     # passed to renderer we would assume the renderer keeps a reference of
     # it.
-    [meta.id, meta.storeId] = objectsRegistry.add processId, routingId, value
+    [meta.id, meta.storeId] = objectsRegistry.add sender.getId(), value
 
     meta.members = []
     meta.members.push {name: prop, type: typeof field} for prop, field of value
@@ -37,12 +37,12 @@ errorToMeta = (error) ->
   type: 'error', message: error.message, stack: (error.stack || error)
 
 # Convert array of meta data from renderer into array of real values.
-unwrapArgs = (processId, routingId, args) ->
+unwrapArgs = (sender, args) ->
   metaToValue = (meta) ->
     switch meta.type
       when 'value' then meta.value
       when 'remote-object' then objectsRegistry.get meta.id
-      when 'array' then unwrapArgs processId, routingId, meta.value
+      when 'array' then unwrapArgs sender, meta.value
       when 'object'
         ret = v8Util.createObjectWithName meta.name
         for member in meta.members
@@ -53,15 +53,15 @@ unwrapArgs = (processId, routingId, args) ->
         -> returnValue
       when 'function'
         rendererReleased = false
-        objectsRegistry.once "release-renderer-view-#{processId}-#{routingId}", ->
+        objectsRegistry.once "clear-#{sender.getId()}", ->
           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)
+          sender.send 'ATOM_RENDERER_CALLBACK', meta.id, valueToMeta(sender, arguments)
         v8Util.setDestructor ret, ->
           return if rendererReleased
-          ipc.sendChannel processId, routingId, 'ATOM_RENDERER_RELEASE_CALLBACK', meta.id
+          sender.send 'ATOM_RENDERER_RELEASE_CALLBACK', meta.id
         ret
       else throw new TypeError("Unknown type: #{meta.type}")
 
@@ -69,78 +69,78 @@ unwrapArgs = (processId, routingId, args) ->
 
 # 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) ->
+callFunction = (event, 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
+      event.returnValue = valueToMeta event.sender, ret
     func.apply caller, args
   else
     ret = func.apply caller, args
-    event.returnValue = valueToMeta processId, routingId, ret
+    event.returnValue = valueToMeta event.sender, ret
 
 # Send by BrowserWindow when its render view is deleted.
-process.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (processId, routingId) ->
-  objectsRegistry.clear processId, routingId
+process.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (id) ->
+  objectsRegistry.clear id
 
-ipc.on 'ATOM_BROWSER_REQUIRE', (event, processId, routingId, module) ->
+ipc.on 'ATOM_BROWSER_REQUIRE', (event, module) ->
   try
-    event.returnValue = valueToMeta processId, routingId, require(module)
+    event.returnValue = valueToMeta event.sender, process.mainModule.require(module)
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_GLOBAL', (event, processId, routingId, name) ->
+ipc.on 'ATOM_BROWSER_GLOBAL', (event, name) ->
   try
-    event.returnValue = valueToMeta processId, routingId, global[name]
+    event.returnValue = valueToMeta event.sender, global[name]
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_CURRENT_WINDOW', (event, processId, routingId) ->
+ipc.on 'ATOM_BROWSER_CURRENT_WINDOW', (event) ->
   try
     BrowserWindow = require 'browser-window'
-    window = BrowserWindow.fromProcessIdAndRoutingId processId, routingId
-    window = BrowserWindow.fromDevTools processId, routingId unless window?
-    event.returnValue = valueToMeta processId, routingId, window
+    window = BrowserWindow.fromWebContents event.sender
+    window = BrowserWindow.fromDevToolsWebContents event.sender unless window?
+    event.returnValue = valueToMeta event.sender, window
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_CONSTRUCTOR', (event, processId, routingId, id, args) ->
+ipc.on 'ATOM_BROWSER_CONSTRUCTOR', (event, id, args) ->
   try
-    args = unwrapArgs processId, routingId, args
+    args = unwrapArgs event.sender, args
     constructor = objectsRegistry.get id
     # Call new with array of arguments.
     # http://stackoverflow.com/questions/1606797/use-of-apply-with-new-operator-is-this-possible
     obj = new (Function::bind.apply(constructor, [null].concat(args)))
-    event.returnValue = valueToMeta processId, routingId, obj
+    event.returnValue = valueToMeta event.sender, obj
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_FUNCTION_CALL', (event, processId, routingId, id, args) ->
+ipc.on 'ATOM_BROWSER_FUNCTION_CALL', (event, id, args) ->
   try
-    args = unwrapArgs processId, routingId, args
+    args = unwrapArgs event.sender, args
     func = objectsRegistry.get id
-    callFunction event, processId, routingId, func, global, args
+    callFunction event, func, global, args
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_MEMBER_CONSTRUCTOR', (event, processId, routingId, id, method, args) ->
+ipc.on 'ATOM_BROWSER_MEMBER_CONSTRUCTOR', (event, id, method, args) ->
   try
-    args = unwrapArgs processId, routingId, args
+    args = unwrapArgs event.sender, args
     constructor = objectsRegistry.get(id)[method]
     # Call new with array of arguments.
     obj = new (Function::bind.apply(constructor, [null].concat(args)))
-    event.returnValue = valueToMeta processId, routingId, obj
+    event.returnValue = valueToMeta event.sender, obj
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_MEMBER_CALL', (event, processId, routingId, id, method, args) ->
+ipc.on 'ATOM_BROWSER_MEMBER_CALL', (event, id, method, args) ->
   try
-    args = unwrapArgs processId, routingId, args
+    args = unwrapArgs event.sender, args
     obj = objectsRegistry.get id
-    callFunction event, processId, routingId, obj[method], obj, args
+    callFunction event, obj[method], obj, args
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_MEMBER_SET', (event, processId, routingId, id, name, value) ->
+ipc.on 'ATOM_BROWSER_MEMBER_SET', (event, id, name, value) ->
   try
     obj = objectsRegistry.get id
     obj[name] = value
@@ -148,12 +148,12 @@ ipc.on 'ATOM_BROWSER_MEMBER_SET', (event, processId, routingId, id, name, value)
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_MEMBER_GET', (event, processId, routingId, id, name) ->
+ipc.on 'ATOM_BROWSER_MEMBER_GET', (event, id, name) ->
   try
     obj = objectsRegistry.get id
-    event.returnValue = valueToMeta processId, routingId, obj[name]
+    event.returnValue = valueToMeta event.sender, obj[name]
   catch e
     event.returnValue = errorToMeta e
 
-ipc.on 'ATOM_BROWSER_DEREFERENCE', (processId, routingId, storeId) ->
-  objectsRegistry.remove processId, routingId, storeId
+ipc.on 'ATOM_BROWSER_DEREFERENCE', (event, storeId) ->
+  objectsRegistry.remove event.sender.getId(), storeId

atom/browser/mac/atom_application.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #import "base/mac/scoped_sending_event.h"

atom/browser/mac/atom_application.mm

@@ -1,8 +1,8 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#import "atom/browser/atom_application_mac.h"
+#import "atom/browser/mac/atom_application.h"
 
 #include "base/auto_reset.h"
 #include "base/strings/sys_string_conversions.h"

atom/browser/mac/atom_application_delegate.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #import <Cocoa/Cocoa.h>

atom/browser/mac/atom_application_delegate.mm

@@ -1,12 +1,12 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#import "atom/browser/atom_application_delegate_mac.h"
+#import "atom/browser/mac/atom_application_delegate.h"
 
-#include "base/strings/sys_string_conversions.h"
-#import "atom/browser/atom_application_mac.h"
+#import "atom/browser/mac/atom_application.h"
 #include "atom/browser/browser.h"
+#include "base/strings/sys_string_conversions.h"
 
 @implementation AtomApplicationDelegate
 
@@ -31,7 +31,7 @@
   } else {
     // System started termination.
     atom::Browser::Get()->Quit();
-    return NSTerminateLater;
+    return NSTerminateCancel;
   }
 }
 

atom/browser/native_window.cc

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/native_window.h"
@@ -8,39 +8,43 @@
 #include <utility>
 #include <vector>
 
-#include "atom/browser/api/atom_browser_bindings.h"
 #include "atom/browser/atom_browser_context.h"
-#include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_javascript_dialog_manager.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/devtools_delegate.h"
-#include "atom/browser/devtools_web_contents_observer.h"
 #include "atom/browser/ui/file_dialog.h"
 #include "atom/browser/window_list.h"
 #include "atom/common/api/api_messages.h"
 #include "atom/common/atom_version.h"
+#include "atom/common/chrome_version.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/prefs/pref_service.h"
 #include "base/message_loop/message_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/renderer_preferences.h"
 #include "ipc/ipc_message_macros.h"
+#include "native_mate/dictionary.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
@@ -54,16 +58,17 @@ using content::NavigationEntry;
 namespace atom {
 
 NativeWindow::NativeWindow(content::WebContents* web_contents,
-                           base::DictionaryValue* options)
+                           const mate::Dictionary& options)
     : content::WebContentsObserver(web_contents),
       has_frame_(true),
       is_closed_(false),
       node_integration_("except-iframe"),
       has_dialog_attached_(false),
+      zoom_factor_(1.0),
       weak_factory_(this),
       inspectable_web_contents_(
           brightray::InspectableWebContents::Create(web_contents)) {
-  options->GetBoolean(switches::kFrame, &has_frame_);
+  options.Get(switches::kFrame, &has_frame_);
 
 #if defined(OS_MACOSX)
   // Temporary fix for flashing devtools, try removing this after upgraded to
@@ -72,12 +77,20 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
 #endif
 
   // 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;
+  gfx::ImageSkia icon;
+  if (options.Get(switches::kIcon, &icon))
+    icon_.reset(new gfx::Image(icon));
 
   // Read iframe security before any navigation.
-  options->GetString(switches::kNodeIntegration, &node_integration_);
+  options.Get(switches::kNodeIntegration, &node_integration_);
+
+  // Read the web preferences.
+  scoped_ptr<mate::Dictionary> web_preferences(new mate::Dictionary);
+  if (options.Get(switches::kWebPreferences, web_preferences.get()))
+    web_preferences_.reset(web_preferences.release());
+
+  // Read the zoom factor before any navigation.
+  options.Get(switches::kZoomFactor, &zoom_factor_);
 
   web_contents->SetDelegate(this);
   inspectable_web_contents()->SetDelegate(this);
@@ -87,9 +100,10 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
   // 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,
+      "%s/%s Chrome/%s Atom-Shell/" ATOM_VERSION_STRING,
       browser->GetName().c_str(),
-      browser->GetVersion().c_str());
+      browser->GetVersion().c_str(),
+      CHROME_VERSION_STRING);
   web_contents->GetMutableRendererPrefs()->user_agent_override =
       webkit_glue::BuildUserAgentFromProduct(product_name);
 
@@ -99,21 +113,25 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
 }
 
 NativeWindow::~NativeWindow() {
+  // Make sure we have the OnRenderViewDeleted message sent even when the window
+  // is destroyed directly.
+  DestroyWebContents();
+
   // It's possible that the windows gets destroyed before it's closed, in that
   // case we need to ensure the OnWindowClosed message is still notified.
   NotifyWindowClosed();
 }
 
 // static
-NativeWindow* NativeWindow::Create(base::DictionaryValue* options) {
+NativeWindow* NativeWindow::Create(const mate::Dictionary& options) {
   content::WebContents::CreateParams create_params(AtomBrowserContext::Get());
   return Create(content::WebContents::Create(create_params), options);
 }
 
 // static
 NativeWindow* NativeWindow::Debug(content::WebContents* web_contents) {
-  base::DictionaryValue options;
-  NativeWindow* window = NativeWindow::Create(&options);
+  mate::Dictionary options;
+  NativeWindow* window = NativeWindow::Create(options);
   window->devtools_delegate_.reset(new DevToolsDelegate(window, web_contents));
   return window;
 }
@@ -134,56 +152,65 @@ NativeWindow* NativeWindow::FromRenderView(int process_id, int routing_id) {
   return NULL;
 }
 
-void NativeWindow::InitFromOptions(base::DictionaryValue* options) {
+void NativeWindow::InitFromOptions(const mate::Dictionary& options) {
   // Setup window from options.
   int x = -1, y = -1;
   bool center;
-  if (options->GetInteger(switches::kX, &x) &&
-      options->GetInteger(switches::kY, &y)) {
+  if (options.Get(switches::kX, &x) && options.Get(switches::kY, &y)) {
     int width = -1, height = -1;
-    options->GetInteger(switches::kWidth, &width);
-    options->GetInteger(switches::kHeight, &height);
+    options.Get(switches::kWidth, &width);
+    options.Get(switches::kHeight, &height);
     Move(gfx::Rect(x, y, width, height));
-  } else if (options->GetBoolean(switches::kCenter, &center) && center) {
+  } else if (options.Get(switches::kCenter, &center) && center) {
     Center();
   }
   int min_height = -1, min_width = -1;
-  if (options->GetInteger(switches::kMinHeight, &min_height) &&
-      options->GetInteger(switches::kMinWidth, &min_width)) {
+  if (options.Get(switches::kMinHeight, &min_height) &&
+      options.Get(switches::kMinWidth, &min_width)) {
     SetMinimumSize(gfx::Size(min_width, min_height));
   }
   int max_height = -1, max_width = -1;
-  if (options->GetInteger(switches::kMaxHeight, &max_height) &&
-      options->GetInteger(switches::kMaxWidth, &max_width)) {
+  if (options.Get(switches::kMaxHeight, &max_height) &&
+      options.Get(switches::kMaxWidth, &max_width)) {
     SetMaximumSize(gfx::Size(max_width, max_height));
   }
   bool resizable;
-  if (options->GetBoolean(switches::kResizable, &resizable)) {
+  if (options.Get(switches::kResizable, &resizable)) {
     SetResizable(resizable);
   }
   bool top;
-  if (options->GetBoolean(switches::kAlwaysOnTop, &top) && top) {
+  if (options.Get(switches::kAlwaysOnTop, &top) && top) {
     SetAlwaysOnTop(true);
   }
   bool fullscreen;
-  if (options->GetBoolean(switches::kFullscreen, &fullscreen) && fullscreen) {
+  if (options.Get(switches::kFullscreen, &fullscreen) && fullscreen) {
     SetFullscreen(true);
   }
+  bool skip;
+  if (options.Get(switches::kSkipTaskbar, &skip) && skip) {
+    SetSkipTaskbar(skip);
+  }
   bool kiosk;
-  if (options->GetBoolean(switches::kKiosk, &kiosk) && kiosk) {
+  if (options.Get(switches::kKiosk, &kiosk) && kiosk) {
     SetKiosk(kiosk);
   }
   std::string title("Atom Shell");
-  options->GetString(switches::kTitle, &title);
+  options.Get(switches::kTitle, &title);
   SetTitle(title);
 
   // Then show it.
   bool show = true;
-  options->GetBoolean(switches::kShow, &show);
+  options.Get(switches::kShow, &show);
   if (show)
     Show();
 }
 
+void NativeWindow::SetRepresentedFilename(const std::string& filename) {
+}
+
+void NativeWindow::SetDocumentEdited(bool edited) {
+}
+
 bool NativeWindow::HasModalDialog() {
   return has_dialog_attached_;
 }
@@ -191,12 +218,8 @@ bool NativeWindow::HasModalDialog() {
 void NativeWindow::OpenDevTools() {
   if (devtools_window_) {
     devtools_window_->Focus(true);
-    devtools_web_contents_observer_.reset(new DevToolsWebContentsObserver(
-        this, devtools_window_->GetWebContents()));
   } else {
     inspectable_web_contents()->ShowDevTools();
-    devtools_web_contents_observer_.reset(new DevToolsWebContentsObserver(
-        this, GetDevToolsWebContents()));
 #if defined(OS_MACOSX)
     // Temporary fix for flashing devtools, try removing this after upgraded to
     // Chrome 32.
@@ -225,11 +248,6 @@ void NativeWindow::InspectElement(int x, int y) {
   agent->InspectElement(x, y);
 }
 
-void NativeWindow::ExecuteJavaScriptInDevTools(const std::string& script) {
-  GetDevToolsWebContents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
-      string16(), base::UTF8ToUTF16(script));
-}
-
 void NativeWindow::FocusOnWebView() {
   GetWebContents()->GetRenderViewHost()->Focus();
 }
@@ -244,26 +262,6 @@ bool NativeWindow::IsWebViewFocused() {
   return host_view && host_view->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();
 }
@@ -297,6 +295,13 @@ void NativeWindow::CapturePage(const gfx::Rect& rect,
                  callback));
 }
 
+void NativeWindow::DestroyWebContents() {
+  if (!inspectable_web_contents_)
+    return;
+
+  inspectable_web_contents_.reset();
+}
+
 void NativeWindow::CloseWebContents() {
   bool prevent_default = false;
   FOR_EACH_OBSERVER(NativeWindowObserver,
@@ -308,9 +313,13 @@ void NativeWindow::CloseWebContents() {
   }
 
   content::WebContents* web_contents(GetWebContents());
+  if (!web_contents) {
+    CloseImmediately();
+    return;
+  }
 
   // Assume the window is not responding if it doesn't cancel the close and is
-  // not closed in 5000ms, in this way we can quickly show the unresponsive
+  // not closed in 5s, 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 (window_unresposive_closure_.IsCancelled())
@@ -323,10 +332,14 @@ void NativeWindow::CloseWebContents() {
 }
 
 content::WebContents* NativeWindow::GetWebContents() const {
-  return inspectable_web_contents_->GetWebContents();
+  if (!inspectable_web_contents_)
+    return NULL;
+  return inspectable_web_contents()->GetWebContents();
 }
 
 content::WebContents* NativeWindow::GetDevToolsWebContents() const {
+  if (!inspectable_web_contents_)
+    return NULL;
   return inspectable_web_contents()->devtools_web_contents();
 }
 
@@ -335,29 +348,56 @@ void NativeWindow::AppendExtraCommandLineSwitches(CommandLine* command_line,
   // Append --node-integration to renderer process.
   command_line->AppendSwitchASCII(switches::kNodeIntegration,
                                   node_integration_);
+
+  // Append --zoom-factor.
+  if (zoom_factor_ != 1.0)
+    command_line->AppendSwitchASCII(switches::kZoomFactor,
+                                    base::DoubleToString(zoom_factor_));
 }
 
 void NativeWindow::OverrideWebkitPrefs(const GURL& url, WebPreferences* prefs) {
   // FIXME Disable accelerated composition in frameless window.
   if (!has_frame_)
     prefs->accelerated_compositing_enabled = false;
+
+  bool b;
+  std::vector<base::FilePath> list;
+  if (!web_preferences_)
+    return;
+  if (web_preferences_->Get("javascript", &b))
+    prefs->javascript_enabled = b;
+  if (web_preferences_->Get("web-security", &b))
+    prefs->web_security_enabled = b;
+  if (web_preferences_->Get("images", &b))
+    prefs->images_enabled = b;
+  if (web_preferences_->Get("java", &b))
+    prefs->java_enabled = b;
+  if (web_preferences_->Get("text-areas-are-resizable", &b))
+    prefs->text_areas_are_resizable = b;
+  if (web_preferences_->Get("webgl", &b))
+    prefs->experimental_webgl_enabled = b;
+  if (web_preferences_->Get("webaudio", &b))
+    prefs->webaudio_enabled = b;
+  if (web_preferences_->Get("accelerated-compositing", &b))
+    prefs->accelerated_compositing_enabled = b;
+  if (web_preferences_->Get("plugins", &b))
+    prefs->plugins_enabled = b;
+  if (web_preferences_->Get("extra-plugin-dirs", &list))
+    for (size_t i = 0; i < list.size(); ++i)
+      content::PluginService::GetInstance()->AddExtraPluginDir(list[i]);
 }
 
 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());
 
+  // Do not receive any notification after window has been closed, there is a
+  // crash that seems to be caused by this: http://git.io/YqMG5g.
+  registrar_.RemoveAll();
+
   WindowList::RemoveWindow(this);
 }
 
@@ -365,6 +405,10 @@ void NativeWindow::NotifyWindowBlur() {
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowBlur());
 }
 
+void NativeWindow::NotifyWindowFocus() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowFocus());
+}
+
 // 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
@@ -401,11 +445,12 @@ void NativeWindow::BeforeUnloadFired(content::WebContents* tab,
                                      bool* proceed_to_fire_unload) {
   *proceed_to_fire_unload = proceed;
 
-  if (!proceed)
+  if (!proceed) {
     WindowList::WindowCloseCancelled(this);
 
-  // When the "beforeunload" callback is fired the window is certainly live.
-  window_unresposive_closure_.Cancel();
+    // Cancel unresponsive event when window close is cancelled.
+    window_unresposive_closure_.Cancel();
+  }
 }
 
 void NativeWindow::RequestToLockMouse(content::WebContents* web_contents,
@@ -426,13 +471,6 @@ 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());
@@ -440,6 +478,9 @@ void NativeWindow::MoveContents(content::WebContents* source,
 }
 
 void NativeWindow::CloseContents(content::WebContents* source) {
+  // Destroy the WebContents before we close the window.
+  DestroyWebContents();
+
   // When the web contents is gone, close the window immediately, but the
   // memory will not be freed until you call delete.
   // In this way, it would be safe to manage windows via smart pointers. If you
@@ -447,8 +488,6 @@ void NativeWindow::CloseContents(content::WebContents* source) {
   // overriding the OnWindowClosed method in the observer.
   CloseImmediately();
 
-  NotifyWindowClosed();
-
   // Do not sent "unresponsive" event after window is closed.
   window_unresposive_closure_.Cancel();
 }
@@ -460,8 +499,12 @@ bool NativeWindow::IsPopupOrPanel(const content::WebContents* source) const {
 
 void NativeWindow::RendererUnresponsive(content::WebContents* source) {
   // Schedule the unresponsive shortly later, since we may receive the
-  // responsive event soon.
-  // This could happen after the whole application had blocked for a while.
+  // responsive event soon. This could happen after the whole application had
+  // blocked for a while.
+  // Also notice that when closing this event would be ignored because we have
+  // explicity started a close timeout counter. This is on purpose because we
+  // don't want the unresponsive event to be sent too early when user is closing
+  // the window.
   ScheduleUnresponsiveEvent(50);
 }
 
@@ -470,16 +513,6 @@ void NativeWindow::RendererResponsive(content::WebContents* source) {
   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.
@@ -488,9 +521,6 @@ void NativeWindow::BeforeUnloadFired(const base::TimeTicks& proceed_time) {
 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_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
-                                    OnRendererMessageSync)
     IPC_MESSAGE_HANDLER(AtomViewHostMsg_UpdateDraggableRegions,
                         UpdateDraggableRegions)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ -519,22 +549,6 @@ void NativeWindow::Observe(int type,
   }
 }
 
-bool NativeWindow::DevToolsSetDockSide(const std::string& dock_side,
-                                       bool* succeed) {
-  if (dock_side == "undocked") {
-    *succeed = false;
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool NativeWindow::DevToolsShow(std::string* dock_side) {
-  if (*dock_side == "undocked")
-    *dock_side = "bottom";
-  return false;
-}
-
 void NativeWindow::DevToolsSaveToFile(const std::string& url,
                                       const std::string& content,
                                       bool save_as) {
@@ -543,7 +557,8 @@ void NativeWindow::DevToolsSaveToFile(const std::string& url,
   if (it != saved_files_.end() && !save_as) {
     path = it->second;
   } else {
-    if (!file_dialog::ShowSaveDialog(this, url, base::FilePath(url), &path))
+    base::FilePath default_path(base::FilePath::FromUTF8Unsafe(url));
+    if (!file_dialog::ShowSaveDialog(this, url, default_path, &path))
       return;
   }
 
@@ -571,6 +586,9 @@ void NativeWindow::DevToolsAppendToFile(const std::string& url,
 }
 
 void NativeWindow::ScheduleUnresponsiveEvent(int ms) {
+  if (!window_unresposive_closure_.IsCancelled())
+    return;
+
   window_unresposive_closure_.Reset(
       base::Bind(&NativeWindow::NotifyWindowUnresponsive,
                  weak_factory_.GetWeakPtr()));
@@ -583,7 +601,7 @@ void NativeWindow::ScheduleUnresponsiveEvent(int ms) {
 void NativeWindow::NotifyWindowUnresponsive() {
   window_unresposive_closure_.Cancel();
 
-  if (!HasModalDialog())
+  if (!is_closed_ && !HasModalDialog())
     FOR_EACH_OBSERVER(NativeWindowObserver,
                       observers_,
                       OnRendererUnresponsive());
@@ -616,28 +634,8 @@ void NativeWindow::CallDevToolsFunction(const std::string& function_name,
       }
     }
   }
-  ExecuteJavaScriptInDevTools(function_name + "(" + params + ");");
-}
-
-void NativeWindow::OnRendererMessage(const string16& channel,
-                                     const base::ListValue& args) {
-  AtomBrowserMainParts::Get()->atom_bindings()->OnRendererMessage(
-      GetWebContents()->GetRenderProcessHost()->GetID(),
-      GetWebContents()->GetRoutingID(),
-      channel,
-      args);
-}
-
-void NativeWindow::OnRendererMessageSync(const string16& channel,
-                                         const base::ListValue& args,
-                                         IPC::Message* reply_msg) {
-  AtomBrowserMainParts::Get()->atom_bindings()->OnRendererMessageSync(
-      GetWebContents()->GetRenderProcessHost()->GetID(),
-      GetWebContents()->GetRoutingID(),
-      channel,
-      args,
-      GetWebContents(),
-      reply_msg);
+  GetDevToolsWebContents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
+      string16(), base::UTF8ToUTF16(function_name + "(" + params + ");"));
 }
 
 }  // namespace atom

atom/browser/native_window.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_NATIVE_WINDOW_H_
@@ -18,7 +18,6 @@
 #include "atom/browser/native_window_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_observer.h"
-#include "ui/gfx/image/image.h"
 #include "vendor/brightray/browser/default_web_contents_delegate.h"
 #include "vendor/brightray/browser/inspectable_web_contents_delegate.h"
 #include "vendor/brightray/browser/inspectable_web_contents_impl.h"
@@ -26,27 +25,26 @@
 class CommandLine;
 struct WebPreferences;
 
-namespace base {
-class DictionaryValue;
-class ListValue;
-}
-
 namespace content {
 class BrowserContext;
 class WebContents;
 }
 
 namespace gfx {
+class Image;
 class Point;
 class Rect;
 class Size;
 }
 
+namespace mate {
+class Dictionary;
+}
+
 namespace atom {
 
 class AtomJavaScriptDialogManager;
 class DevToolsDelegate;
-class DevToolsWebContentsObserver;
 struct DraggableRegion;
 
 class NativeWindow : public brightray::DefaultWebContentsDelegate,
@@ -81,11 +79,11 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   // Create window with existing WebContents, the caller is responsible for
   // managing the window's live.
   static NativeWindow* Create(content::WebContents* web_contents,
-                              base::DictionaryValue* options);
+                              const mate::Dictionary& options);
 
   // Create window with new WebContents, the caller is responsible for
   // managing the window's live.
-  static NativeWindow* Create(base::DictionaryValue* options);
+  static NativeWindow* Create(const mate::Dictionary& options);
 
   // Creates a devtools window to debug the WebContents, the returned window
   // will manage its own life.
@@ -94,7 +92,7 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   // Find a window from its process id and routing id.
   static NativeWindow* FromRenderView(int process_id, int routing_id);
 
-  void InitFromOptions(base::DictionaryValue* options);
+  void InitFromOptions(const mate::Dictionary& options);
 
   virtual void Close() = 0;
   virtual void CloseImmediately() = 0;
@@ -112,6 +110,8 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   virtual bool IsFullscreen() = 0;
   virtual void SetSize(const gfx::Size& size) = 0;
   virtual gfx::Size GetSize() = 0;
+  virtual void SetContentSize(const gfx::Size& size) = 0;
+  virtual gfx::Size GetContentSize() = 0;
   virtual void SetMinimumSize(const gfx::Size& size) = 0;
   virtual gfx::Size GetMinimumSize() = 0;
   virtual void SetMaximumSize(const gfx::Size& size) = 0;
@@ -126,8 +126,11 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   virtual void SetTitle(const std::string& title) = 0;
   virtual std::string GetTitle() = 0;
   virtual void FlashFrame(bool flash) = 0;
+  virtual void SetSkipTaskbar(bool skip) = 0;
   virtual void SetKiosk(bool kiosk) = 0;
   virtual bool IsKiosk() = 0;
+  virtual void SetRepresentedFilename(const std::string& filename);
+  virtual void SetDocumentEdited(bool edited);
   virtual bool HasModalDialog();
   virtual gfx::NativeWindow GetNativeWindow() = 0;
 
@@ -136,14 +139,11 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   virtual void CloseDevTools();
   virtual bool IsDevToolsOpened();
   virtual void InspectElement(int x, int y);
-  virtual void ExecuteJavaScriptInDevTools(const std::string& script);
 
   virtual void FocusOnWebView();
   virtual void BlurWebView();
   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();
@@ -158,6 +158,9 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   // Should be called by platform code when user want to close the window.
   virtual void CloseWebContents();
 
+  // Destroy the WebContents immediately.
+  virtual void DestroyWebContents();
+
   base::WeakPtr<NativeWindow> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
@@ -170,6 +173,12 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
                                       int child_process_id);
   void OverrideWebkitPrefs(const GURL& url, WebPreferences* prefs);
 
+  // Public API used by platform-dependent delegates and observers to send UI
+  // related notifications.
+  void NotifyWindowClosed();
+  void NotifyWindowBlur();
+  void NotifyWindowFocus();
+
   void AddObserver(NativeWindowObserver* obs) {
     observers_.AddObserver(obs);
   }
@@ -186,16 +195,13 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
 
  protected:
   explicit NativeWindow(content::WebContents* web_contents,
-                        base::DictionaryValue* options);
+                        const mate::Dictionary& options);
 
   brightray::InspectableWebContentsImpl* inspectable_web_contents() const {
     return static_cast<brightray::InspectableWebContentsImpl*>(
         inspectable_web_contents_.get());
   }
 
-  void NotifyWindowClosed();
-  void NotifyWindowBlur();
-
   // Called when the window needs to update its draggable region.
   virtual void UpdateDraggableRegions(
       const std::vector<DraggableRegion>& regions) = 0;
@@ -215,7 +221,6 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   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;
@@ -225,8 +230,6 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   virtual void RendererResponsive(content::WebContents* source) OVERRIDE;
 
   // Implementations of content::WebContentsObserver.
-  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;
 
@@ -236,9 +239,6 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Implementations of brightray::InspectableWebContentsDelegate.
-  virtual bool DevToolsSetDockSide(const std::string& dock_side,
-                                   bool* succeed) OVERRIDE;
-  virtual bool DevToolsShow(std::string* dock_side) OVERRIDE;
   virtual void DevToolsSaveToFile(const std::string& url,
                                   const std::string& content,
                                   bool save_as) OVERRIDE;
@@ -249,7 +249,7 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   bool has_frame_;
 
   // Window icon.
-  gfx::Image icon_;
+  scoped_ptr<gfx::Image> icon_;
 
  private:
   // Schedule a notification unresponsive event.
@@ -269,13 +269,6 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
                          bool succeed,
                          const SkBitmap& bitmap);
 
-  void OnRendererMessage(const string16& channel,
-                         const base::ListValue& args);
-
-  void OnRendererMessageSync(const string16& channel,
-                             const base::ListValue& args,
-                             IPC::Message* reply_msg);
-
   // Notification manager.
   content::NotificationRegistrar registrar_;
 
@@ -295,15 +288,22 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   // it should be cancelled when we can prove that the window is responsive.
   base::CancelableClosure window_unresposive_closure_;
 
+  // Web preferences.
+  scoped_ptr<mate::Dictionary> web_preferences_;
+
+  // Page's default zoom factor.
+  double zoom_factor_;
+
   base::WeakPtrFactory<NativeWindow> weak_factory_;
 
   base::WeakPtr<NativeWindow> devtools_window_;
   scoped_ptr<DevToolsDelegate> devtools_delegate_;
 
-  // WebContentsObserver for the WebContents of devtools.
-  scoped_ptr<DevToolsWebContentsObserver> devtools_web_contents_observer_;
-
   scoped_ptr<AtomJavaScriptDialogManager> dialog_manager_;
+
+  // Notice that inspectable_web_contents_ must be placed after dialog_manager_,
+  // so we can make sure inspectable_web_contents_ is destroyed before
+  // dialog_manager_, otherwise a crash would happen.
   scoped_ptr<brightray::InspectableWebContents> inspectable_web_contents_;
 
   // Maps url to file path, used by the file requests sent from devtools.

atom/browser/native_window_gtk.cc

@@ -1,5 +1,5 @@
 // Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/native_window_gtk.h"
@@ -11,17 +11,19 @@
 #include "atom/common/options_switches.h"
 #include "base/environment.h"
 #include "base/nix/xdg_util.h"
-#include "base/values.h"
 #include "chrome/browser/ui/gtk/gtk_window_util.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/common/renderer_preferences.h"
+#include "native_mate/dictionary.h"
 #include "ui/base/accelerators/platform_accelerator_gtk.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/x/active_window_watcher_x.h"
 #include "ui/base/x/x11_util.h"
+#include "ui/gfx/font_render_params_linux.h"
 #include "ui/gfx/gtk_util.h"
+#include "ui/gfx/image/image.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/skia_utils_gtk.h"
 
@@ -54,10 +56,48 @@ void SubstractBorderSize(int* width, int* height) {
   }
 }
 
+content::RendererPreferencesHintingEnum GetRendererPreferencesHintingEnum(
+    gfx::FontRenderParams::Hinting hinting) {
+  switch (hinting) {
+    case gfx::FontRenderParams::HINTING_NONE:
+      return content::RENDERER_PREFERENCES_HINTING_NONE;
+    case gfx::FontRenderParams::HINTING_SLIGHT:
+      return content::RENDERER_PREFERENCES_HINTING_SLIGHT;
+    case gfx::FontRenderParams::HINTING_MEDIUM:
+      return content::RENDERER_PREFERENCES_HINTING_MEDIUM;
+    case gfx::FontRenderParams::HINTING_FULL:
+      return content::RENDERER_PREFERENCES_HINTING_FULL;
+    default:
+      NOTREACHED() << "Unhandled hinting style " << hinting;
+      return content::RENDERER_PREFERENCES_HINTING_SYSTEM_DEFAULT;
+  }
+}
+
+content::RendererPreferencesSubpixelRenderingEnum
+GetRendererPreferencesSubpixelRenderingEnum(
+    gfx::FontRenderParams::SubpixelRendering subpixel_rendering) {
+  switch (subpixel_rendering) {
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE:
+      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_NONE;
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_RGB:
+      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_RGB;
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_BGR:
+      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_BGR;
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_VRGB:
+      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_VRGB;
+    case gfx::FontRenderParams::SUBPIXEL_RENDERING_VBGR:
+      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_VBGR;
+    default:
+      NOTREACHED() << "Unhandled subpixel rendering style "
+                   << subpixel_rendering;
+      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_SYSTEM_DEFAULT;
+  }
+}
+
 }  // namespace
 
 NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
-                                 base::DictionaryValue* options)
+                                 const mate::Dictionary& options)
     : NativeWindow(web_contents, options),
       window_(GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL))),
       vbox_(gtk_vbox_new(FALSE, 0)),
@@ -72,11 +112,12 @@ NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
                     GetWebContents()->GetView()->GetNativeView());
 
   int width = 800, height = 600;
-  options->GetInteger(switches::kWidth, &width);
-  options->GetInteger(switches::kHeight, &height);
+  options.Get(switches::kWidth, &width);
+  options.Get(switches::kHeight, &height);
 
-  // Fixup the initial window size.
-  if (has_frame_)
+  bool use_content_size = false;
+  options.Get(switches::kUseContentSize, &use_content_size);
+  if (has_frame_ && !use_content_size)
     SubstractBorderSize(&width, &height);
 
   // Force a size allocation so the web page of hidden window can have correct
@@ -89,8 +130,8 @@ NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
   // Create the underlying gdk window.
   gtk_widget_realize(GTK_WIDGET(window_));
 
-  if (!icon_.IsEmpty())
-    gtk_window_set_icon(window_, icon_.ToGdkPixbuf());
+  if (icon_)
+    gtk_window_set_icon(window_, icon_->ToGdkPixbuf());
 
   ui::ActiveWindowWatcherX::AddObserver(this);
 
@@ -105,6 +146,8 @@ NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
                    G_CALLBACK(OnWindowDeleteEventThunk), this);
   g_signal_connect(window_, "focus-out-event",
                    G_CALLBACK(OnFocusOutThunk), this);
+  g_signal_connect(window_, "focus-in-event",
+                   G_CALLBACK(OnFocusInThunk), this);
   g_signal_connect(window_, "window-state-event",
                    G_CALLBACK(OnWindowStateThunk), this);
 
@@ -118,13 +161,11 @@ NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
   }
 
   SetWebKitColorStyle();
+  SetFontRenderering();
 }
 
 NativeWindowGtk::~NativeWindowGtk() {
-  ui::ActiveWindowWatcherX::RemoveObserver(this);
-
-  if (window_)
-    gtk_widget_destroy(GTK_WIDGET(window_));
+  CloseImmediately();
 }
 
 void NativeWindowGtk::Close() {
@@ -132,6 +173,12 @@ void NativeWindowGtk::Close() {
 }
 
 void NativeWindowGtk::CloseImmediately() {
+  if (window_ == NULL)
+    return;
+
+  NotifyWindowClosed();
+  ui::ActiveWindowWatcherX::RemoveObserver(this);
+
   gtk_widget_destroy(GTK_WIDGET(window_));
   window_ = NULL;
 }
@@ -218,6 +265,24 @@ gfx::Size NativeWindowGtk::GetSize() {
   return gfx::Size(frame_extents.width, frame_extents.height);
 }
 
+void NativeWindowGtk::SetContentSize(const gfx::Size& size) {
+  if (!has_frame_ || !has_ever_been_shown_) {
+    gtk_window_util::SetWindowSize(window_, size);
+  } else {
+    gfx::Size large = GetSize();
+    gfx::Size small = GetContentSize();
+    gfx::Size target(size.width() + large.width() - small.width(),
+                     size.height() + large.height() - small.height());
+    gtk_window_util::SetWindowSize(window_, target);
+  }
+}
+
+gfx::Size NativeWindowGtk::GetContentSize() {
+  gint width, height;
+  gtk_window_get_size(window_, &width, &height);
+  return gfx::Size(width, height);
+}
+
 void NativeWindowGtk::SetMinimumSize(const gfx::Size& size) {
   minimum_size_ = size;
 
@@ -251,7 +316,7 @@ gfx::Size NativeWindowGtk::GetMaximumSize() {
 void NativeWindowGtk::SetResizable(bool resizable) {
   // Should request widget size after setting unresizable, otherwise the
   // window will shrink to a very small size.
-  if (!IsResizable()) {
+  if (!IsResizable() || !has_ever_been_shown_) {
     gint width, height;
     gtk_window_get_size(window_, &width, &height);
     gtk_widget_set_size_request(GTK_WIDGET(window_), width, height);
@@ -302,6 +367,11 @@ void NativeWindowGtk::FlashFrame(bool flash) {
   gtk_window_set_urgency_hint(window_, flash);
 }
 
+void NativeWindowGtk::SetSkipTaskbar(bool skip) {
+  gtk_window_set_skip_taskbar_hint(window_, skip);
+  gtk_window_set_skip_pager_hint(window_, skip);
+}
+
 void NativeWindowGtk::SetKiosk(bool kiosk) {
   SetFullscreen(kiosk);
 }
@@ -318,6 +388,7 @@ void NativeWindowGtk::SetMenu(ui::MenuModel* menu_model) {
   menu_.reset(new ::MenuGtk(this, menu_model, true));
   gtk_box_pack_start(GTK_BOX(vbox_), menu_->widget(), FALSE, FALSE, 0);
   gtk_box_reorder_child(GTK_BOX(vbox_), menu_->widget(), 0);
+  gtk_widget_show_all(vbox_);
   RegisterAccelerators();
 }
 
@@ -396,6 +467,19 @@ void NativeWindowGtk::SetWebKitColorStyle() {
       0;
 }
 
+void NativeWindowGtk::SetFontRenderering() {
+  content::RendererPreferences* prefs =
+      GetWebContents()->GetMutableRendererPrefs();
+  const gfx::FontRenderParams& params = gfx::GetDefaultWebKitFontRenderParams();
+  prefs->should_antialias_text = params.antialiasing;
+  prefs->use_subpixel_positioning = params.subpixel_positioning;
+  prefs->hinting = GetRendererPreferencesHintingEnum(params.hinting);
+  prefs->use_autohinter = params.autohinter;
+  prefs->use_bitmaps = params.use_bitmaps;
+  prefs->subpixel_rendering =
+  GetRendererPreferencesSubpixelRenderingEnum(params.subpixel_rendering);
+}
+
 bool NativeWindowGtk::IsMaximized() const {
   return state_ & GDK_WINDOW_STATE_MAXIMIZED;
 }
@@ -416,6 +500,11 @@ gboolean NativeWindowGtk::OnWindowDeleteEvent(GtkWidget* widget,
   return TRUE;
 }
 
+gboolean NativeWindowGtk::OnFocusIn(GtkWidget* window, GdkEventFocus*) {
+  NotifyWindowFocus();
+  return FALSE;
+}
+
 gboolean NativeWindowGtk::OnFocusOut(GtkWidget* window, GdkEventFocus*) {
   NotifyWindowBlur();
   return FALSE;
@@ -520,7 +609,7 @@ gboolean NativeWindowGtk::OnButtonPress(GtkWidget* widget,
 
 // static
 NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
-                                   base::DictionaryValue* options) {
+                                   const mate::Dictionary& options) {
   return new NativeWindowGtk(web_contents, options);
 }
 

atom/browser/native_window_gtk.h

@@ -1,5 +1,5 @@
 // Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_NATIVE_WINDOW_GTK_H_
@@ -26,7 +26,7 @@ class NativeWindowGtk : public NativeWindow,
                         public ui::ActiveWindowWatcherXObserver {
  public:
   explicit NativeWindowGtk(content::WebContents* web_contents,
-                           base::DictionaryValue* options);
+                           const mate::Dictionary& options);
   virtual ~NativeWindowGtk();
 
   // NativeWindow implementation.
@@ -46,6 +46,8 @@ class NativeWindowGtk : public NativeWindow,
   virtual bool IsFullscreen() OVERRIDE;
   virtual void SetSize(const gfx::Size& size) OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
+  virtual void SetContentSize(const gfx::Size& size) OVERRIDE;
+  virtual gfx::Size GetContentSize() OVERRIDE;
   virtual void SetMinimumSize(const gfx::Size& size) OVERRIDE;
   virtual gfx::Size GetMinimumSize() OVERRIDE;
   virtual void SetMaximumSize(const gfx::Size& size) OVERRIDE;
@@ -60,6 +62,7 @@ class NativeWindowGtk : public NativeWindow,
   virtual void SetTitle(const std::string& title) OVERRIDE;
   virtual std::string GetTitle() OVERRIDE;
   virtual void FlashFrame(bool flash) OVERRIDE;
+  virtual void SetSkipTaskbar(bool skip) OVERRIDE;
   virtual void SetKiosk(bool kiosk) OVERRIDE;
   virtual bool IsKiosk() OVERRIDE;
   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE;
@@ -86,6 +89,9 @@ class NativeWindowGtk : public NativeWindow,
   // Set WebKit's style from current theme.
   void SetWebKitColorStyle();
 
+  // Set how font is renderered.
+  void SetFontRenderering();
+
   // Whether window is maximized.
   bool IsMaximized() const;
 
@@ -96,6 +102,7 @@ class NativeWindowGtk : public NativeWindow,
 
   CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnWindowDeleteEvent,
                        GdkEvent*);
+  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnFocusIn, GdkEventFocus*);
   CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnFocusOut, GdkEventFocus*);
   CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnWindowState,
                        GdkEventWindowState*);

atom/browser/native_window_mac.h

@@ -1,5 +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
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_NATIVE_WINDOW_MAC_H_
@@ -7,6 +7,7 @@
 
 #import <Cocoa/Cocoa.h>
 
+#include "base/mac/scoped_nsobject.h"
 #include "base/memory/scoped_ptr.h"
 #include "atom/browser/native_window.h"
 
@@ -17,7 +18,7 @@ namespace atom {
 class NativeWindowMac : public NativeWindow {
  public:
   explicit NativeWindowMac(content::WebContents* web_contents,
-                           base::DictionaryValue* options);
+                           const mate::Dictionary& options);
   virtual ~NativeWindowMac();
 
   // NativeWindow implementation.
@@ -37,6 +38,8 @@ class NativeWindowMac : public NativeWindow {
   virtual bool IsFullscreen() OVERRIDE;
   virtual void SetSize(const gfx::Size& size) OVERRIDE;
   virtual gfx::Size GetSize() OVERRIDE;
+  virtual void SetContentSize(const gfx::Size& size) OVERRIDE;
+  virtual gfx::Size GetContentSize() OVERRIDE;
   virtual void SetMinimumSize(const gfx::Size& size) OVERRIDE;
   virtual gfx::Size GetMinimumSize() OVERRIDE;
   virtual void SetMaximumSize(const gfx::Size& size) OVERRIDE;
@@ -51,13 +54,14 @@ class NativeWindowMac : public NativeWindow {
   virtual void SetTitle(const std::string& title) OVERRIDE;
   virtual std::string GetTitle() OVERRIDE;
   virtual void FlashFrame(bool flash) OVERRIDE;
+  virtual void SetSkipTaskbar(bool skip) OVERRIDE;
   virtual void SetKiosk(bool kiosk) OVERRIDE;
   virtual bool IsKiosk() OVERRIDE;
+  virtual void SetRepresentedFilename(const std::string& filename) OVERRIDE;
+  virtual void SetDocumentEdited(bool edited) OVERRIDE;
   virtual bool HasModalDialog() OVERRIDE;
   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE;
 
-  void NotifyWindowBlur() { NativeWindow::NotifyWindowBlur(); }
-
   // Returns true if |point| in local Cocoa coordinate system falls within
   // the draggable region.
   bool IsWithinDraggableRegion(NSPoint point) const;
@@ -68,7 +72,6 @@ class NativeWindowMac : public NativeWindow {
   // Clip web view to rounded corner.
   void ClipWebView();
 
-  NSWindow*& window() { return window_; }
   SkRegion* draggable_region() const { return draggable_region_.get(); }
 
  protected:
@@ -87,12 +90,15 @@ class NativeWindowMac : public NativeWindow {
   void UpdateDraggableRegionsForCustomDrag(
       const std::vector<DraggableRegion>& regions);
 
-  NSWindow* window_;
+  base::scoped_nsobject<NSWindow> window_;
 
   bool is_kiosk_;
 
   NSInteger attention_request_id_;  // identifier from requestUserAttention
 
+  // The presentation options before entering kiosk mode.
+  NSApplicationPresentationOptions kiosk_options_;
+
   // 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_;

atom/browser/native_window_mac.mm

@@ -1,24 +1,23 @@
 // Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #include "atom/browser/native_window_mac.h"
 
 #include <string>
 
-#include "base/mac/mac_util.h"
-#include "base/mac/scoped_nsobject.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/values.h"
 #import "atom/browser/ui/cocoa/event_processing_window.h"
-#include "brightray/browser/inspectable_web_contents.h"
-#include "brightray/browser/inspectable_web_contents_view.h"
 #include "atom/common/draggable_region.h"
 #include "atom/common/options_switches.h"
+#include "base/mac/mac_util.h"
+#include "base/strings/sys_string_conversions.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"
+#include "native_mate/dictionary.h"
+#include "vendor/brightray/browser/inspectable_web_contents.h"
+#include "vendor/brightray/browser/inspectable_web_contents_view.h"
 
 static const CGFloat kAtomWindowCornerRadius = 4.0;
 
@@ -30,6 +29,7 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
  @private
   atom::NativeWindowMac* shell_;
   BOOL acceptsFirstMouse_;
+  BOOL hasSetInitialFocus_;
 }
 - (id)initWithShell:(atom::NativeWindowMac*)shell;
 - (void)setAcceptsFirstMouse:(BOOL)accept;
@@ -41,6 +41,7 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
   if ((self = [super init])) {
     shell_ = shell;
     acceptsFirstMouse_ = NO;
+    hasSetInitialFocus_ = NO;
   }
   return self;
 }
@@ -49,6 +50,16 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
   acceptsFirstMouse_ = accept;
 }
 
+- (void)windowDidBecomeMain:(NSNotification*)notification {
+  shell_->NotifyWindowFocus();
+
+  // Make sure the web view is the first responder of the window.
+  if (!hasSetInitialFocus_) {
+    shell_->GetWebContents()->GetView()->Focus();
+    hasSetInitialFocus_ = YES;
+  }
+}
+
 - (void)windowDidResignMain:(NSNotification*)notification {
   shell_->NotifyWindowBlur();
 }
@@ -66,7 +77,7 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
 }
 
 - (void)windowWillClose:(NSNotification*)notification {
-  shell_->window() = nil;
+  shell_->NotifyWindowClosed();
   [self autorelease];
 }
 
@@ -145,13 +156,13 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
 namespace atom {
 
 NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
-                                 base::DictionaryValue* options)
+                                 const mate::Dictionary& options)
     : NativeWindow(web_contents, options),
       is_kiosk_(false),
       attention_request_id_(0) {
   int width = 800, height = 600;
-  options->GetInteger(switches::kWidth, &width);
-  options->GetInteger(switches::kHeight, &height);
+  options.Get(switches::kWidth, &width);
+  options.Get(switches::kHeight, &height);
 
   NSRect main_screen_rect = [[[NSScreen screens] objectAtIndex:0] frame];
   NSRect cocoa_bounds = NSMakeRect(
@@ -171,24 +182,33 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
                     defer:YES];
 
   [atomWindow setShell:this];
-  window_ = atomWindow;
+  window_.reset(atomWindow);
 
   AtomNSWindowDelegate* delegate =
       [[AtomNSWindowDelegate alloc] initWithShell:this];
-  [window() setDelegate:delegate];
+  [window_ setDelegate:delegate];
+
+  // We will manage window's lifetime ourselves.
+  [window_ setReleasedWhenClosed:NO];
+
+  // On OS X the initial window size doesn't include window frame.
+  bool use_content_size = false;
+  options.Get(switches::kUseContentSize, &use_content_size);
+  if (has_frame_ && !use_content_size)
+    SetSize(gfx::Size(width, height));
 
   // Enable the NSView to accept first mouse event.
   bool acceptsFirstMouse = false;
-  options->GetBoolean(switches::kAcceptFirstMouse, &acceptsFirstMouse);
+  options.Get(switches::kAcceptFirstMouse, &acceptsFirstMouse);
   [delegate setAcceptsFirstMouse:acceptsFirstMouse];
 
   // Disable fullscreen button when 'fullscreen' is specified to false.
   bool fullscreen;
-  if (!(options->GetBoolean(switches::kFullscreen, &fullscreen) &&
+  if (!(options.Get(switches::kFullscreen, &fullscreen) &&
         !fullscreen)) {
-    NSUInteger collectionBehavior = [window() collectionBehavior];
+    NSUInteger collectionBehavior = [window_ collectionBehavior];
     collectionBehavior |= NSWindowCollectionBehaviorFullScreenPrimary;
-    [window() setCollectionBehavior:collectionBehavior];
+    [window_ setCollectionBehavior:collectionBehavior];
   }
 
   NSView* view = inspectable_web_contents()->GetView()->GetNativeView();
@@ -198,18 +218,17 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
 }
 
 NativeWindowMac::~NativeWindowMac() {
-  if (window())
-    // Use autorelease since we may have delegates or observers at this time.
-    [window() autorelease];
+  // Force InspectableWebContents to be destroyed before we destroy window,
+  // because it may still be observing the window at this time.
+  DestroyWebContents();
 }
 
 void NativeWindowMac::Close() {
-  [window() performClose:nil];
+  [window_ performClose:nil];
 }
 
 void NativeWindowMac::CloseImmediately() {
-  [window() orderOut:nil];
-  [window() close];
+  [window_ close];
 }
 
 void NativeWindowMac::Move(const gfx::Rect& pos) {
@@ -221,7 +240,7 @@ void NativeWindowMac::Move(const gfx::Rect& pos) {
   cocoa_bounds.origin.y =
       NSHeight([screen frame]) - pos.height() - pos.y();
 
-  [window() setFrame:cocoa_bounds display:YES];
+  [window_ setFrame:cocoa_bounds display:YES];
 }
 
 void NativeWindowMac::Focus(bool focus) {
@@ -230,42 +249,42 @@ void NativeWindowMac::Focus(bool focus) {
 
   if (focus) {
     [[NSApplication sharedApplication] activateIgnoringOtherApps:YES];
-    [window() makeKeyAndOrderFront:nil];
+    [window_ makeKeyAndOrderFront:nil];
   } else {
-    [window() orderBack:nil];
+    [window_ orderBack:nil];
   }
 }
 
 bool NativeWindowMac::IsFocused() {
-  return [window() isKeyWindow];
+  return [window_ isKeyWindow];
 }
 
 void NativeWindowMac::Show() {
-  [window() makeKeyAndOrderFront:nil];
+  [window_ makeKeyAndOrderFront:nil];
 }
 
 void NativeWindowMac::Hide() {
-  [window() orderOut:nil];
+  [window_ orderOut:nil];
 }
 
 bool NativeWindowMac::IsVisible() {
-  return [window() isVisible];
+  return [window_ isVisible];
 }
 
 void NativeWindowMac::Maximize() {
-  [window() zoom:nil];
+  [window_ zoom:nil];
 }
 
 void NativeWindowMac::Unmaximize() {
-  [window() zoom:nil];
+  [window_ zoom:nil];
 }
 
 void NativeWindowMac::Minimize() {
-  [window() miniaturize:nil];
+  [window_ miniaturize:nil];
 }
 
 void NativeWindowMac::Restore() {
-  [window() deminiaturize:nil];
+  [window_ deminiaturize:nil];
 }
 
 void NativeWindowMac::SetFullscreen(bool fullscreen) {
@@ -277,11 +296,11 @@ void NativeWindowMac::SetFullscreen(bool fullscreen) {
     return;
   }
 
-  [window() toggleFullScreen:nil];
+  [window_ toggleFullScreen:nil];
 }
 
 bool NativeWindowMac::IsFullscreen() {
-  return [window() styleMask] & NSFullScreenWindowMask;
+  return [window_ styleMask] & NSFullScreenWindowMask;
 }
 
 void NativeWindowMac::SetSize(const gfx::Size& size) {
@@ -290,7 +309,7 @@ void NativeWindowMac::SetSize(const gfx::Size& size) {
   frame.size.width = size.width();
   frame.size.height = size.height();
 
-  [window() setFrame:frame display:YES];
+  [window_ setFrame:frame display:YES];
 }
 
 gfx::Size NativeWindowMac::GetSize() {
@@ -298,56 +317,74 @@ gfx::Size NativeWindowMac::GetSize() {
   return gfx::Size(frame.size.width, frame.size.height);
 }
 
+void NativeWindowMac::SetContentSize(const gfx::Size& size) {
+  NSRect frame_nsrect = [window_ frame];
+  NSSize frame = frame_nsrect.size;
+  NSSize content = [window_ contentRectForFrameRect:frame_nsrect].size;
+
+  int width = size.width() + frame.width - content.width;
+  int height = size.height() + frame.height - content.height;
+  frame_nsrect.origin.y -= height - frame_nsrect.size.height;
+  frame_nsrect.size.width = width;
+  frame_nsrect.size.height = height;
+  [window_ setFrame:frame_nsrect display:YES];
+}
+
+gfx::Size NativeWindowMac::GetContentSize() {
+  NSRect bounds = [[window_ contentView] bounds];
+  return gfx::Size(bounds.size.width, bounds.size.height);
+}
+
 void NativeWindowMac::SetMinimumSize(const gfx::Size& size) {
   NSSize min_size = NSMakeSize(size.width(), size.height());
-  NSView* content = [window() contentView];
-  [window() setContentMinSize:[content convertSize:min_size toView:nil]];
+  NSView* content = [window_ contentView];
+  [window_ setContentMinSize:[content convertSize:min_size toView:nil]];
 }
 
 gfx::Size NativeWindowMac::GetMinimumSize() {
-  NSView* content = [window() contentView];
-  NSSize min_size = [content convertSize:[window() contentMinSize]
+  NSView* content = [window_ contentView];
+  NSSize min_size = [content convertSize:[window_ contentMinSize]
                                 fromView:nil];
   return gfx::Size(min_size.width, min_size.height);
 }
 
 void NativeWindowMac::SetMaximumSize(const gfx::Size& size) {
   NSSize max_size = NSMakeSize(size.width(), size.height());
-  NSView* content = [window() contentView];
-  [window() setContentMaxSize:[content convertSize:max_size toView:nil]];
+  NSView* content = [window_ contentView];
+  [window_ setContentMaxSize:[content convertSize:max_size toView:nil]];
 }
 
 gfx::Size NativeWindowMac::GetMaximumSize() {
-  NSView* content = [window() contentView];
-  NSSize max_size = [content convertSize:[window() contentMaxSize]
+  NSView* content = [window_ contentView];
+  NSSize max_size = [content convertSize:[window_ contentMaxSize]
                                 fromView:nil];
   return gfx::Size(max_size.width, max_size.height);
 }
 
 void NativeWindowMac::SetResizable(bool resizable) {
   if (resizable) {
-    [[window() standardWindowButton:NSWindowZoomButton] setEnabled:YES];
-    [window() setStyleMask:window().styleMask | NSResizableWindowMask];
+    [[window_ standardWindowButton:NSWindowZoomButton] setEnabled:YES];
+    [window_ setStyleMask:[window_ styleMask] | NSResizableWindowMask];
   } else {
-    [[window() standardWindowButton:NSWindowZoomButton] setEnabled:NO];
-    [window() setStyleMask:window().styleMask ^ NSResizableWindowMask];
+    [[window_ standardWindowButton:NSWindowZoomButton] setEnabled:NO];
+    [window_ setStyleMask:[window_ styleMask] ^ NSResizableWindowMask];
   }
 }
 
 bool NativeWindowMac::IsResizable() {
-  return [window() styleMask] & NSResizableWindowMask;
+  return [window_ styleMask] & NSResizableWindowMask;
 }
 
 void NativeWindowMac::SetAlwaysOnTop(bool top) {
-  [window() setLevel:(top ? NSFloatingWindowLevel : NSNormalWindowLevel)];
+  [window_ setLevel:(top ? NSFloatingWindowLevel : NSNormalWindowLevel)];
 }
 
 bool NativeWindowMac::IsAlwaysOnTop() {
-  return [window() level] == NSFloatingWindowLevel;
+  return [window_ level] == NSFloatingWindowLevel;
 }
 
 void NativeWindowMac::Center() {
-  [window() center];
+  [window_ center];
 }
 
 void NativeWindowMac::SetPosition(const gfx::Point& position) {
@@ -363,11 +400,11 @@ gfx::Point NativeWindowMac::GetPosition() {
 }
 
 void NativeWindowMac::SetTitle(const std::string& title) {
-  [window() setTitle:base::SysUTF8ToNSString(title)];
+  [window_ setTitle:base::SysUTF8ToNSString(title)];
 }
 
 std::string NativeWindowMac::GetTitle() {
-  return base::SysNSStringToUTF8([window() title]);
+  return base::SysNSStringToUTF8([window_ title]);
 }
 
 void NativeWindowMac::FlashFrame(bool flash) {
@@ -379,8 +416,12 @@ void NativeWindowMac::FlashFrame(bool flash) {
   }
 }
 
+void NativeWindowMac::SetSkipTaskbar(bool skip) {
+}
+
 void NativeWindowMac::SetKiosk(bool kiosk) {
-  if (kiosk) {
+  if (kiosk && !is_kiosk_) {
+    kiosk_options_ = [NSApp currentSystemPresentationOptions];
     NSApplicationPresentationOptions options =
         NSApplicationPresentationHideDock +
         NSApplicationPresentationHideMenuBar +
@@ -392,10 +433,10 @@ void NativeWindowMac::SetKiosk(bool kiosk) {
     [NSApp setPresentationOptions:options];
     is_kiosk_ = true;
     SetFullscreen(true);
-  } else {
-    [NSApp setPresentationOptions:[NSApp currentSystemPresentationOptions]];
-    is_kiosk_  = false;
+  } else if (!kiosk && is_kiosk_) {
+    is_kiosk_ = false;
     SetFullscreen(false);
+    [NSApp setPresentationOptions:kiosk_options_];
   }
 }
 
@@ -403,12 +444,20 @@ bool NativeWindowMac::IsKiosk() {
   return is_kiosk_;
 }
 
+void NativeWindowMac::SetRepresentedFilename(const std::string& filename) {
+  [window_ setRepresentedFilename:base::SysUTF8ToNSString(filename)];
+}
+
+void NativeWindowMac::SetDocumentEdited(bool edited) {
+  [window_ setDocumentEdited:edited];
+}
+
 bool NativeWindowMac::HasModalDialog() {
-  return [window() attachedSheet] != nil;
+  return [window_ attachedSheet] != nil;
 }
 
 gfx::NativeWindow NativeWindowMac::GetNativeWindow() {
-  return window();
+  return window_;
 }
 
 bool NativeWindowMac::IsWithinDraggableRegion(NSPoint point) const {
@@ -424,15 +473,15 @@ bool NativeWindowMac::IsWithinDraggableRegion(NSPoint point) const {
 
 void NativeWindowMac::HandleMouseEvent(NSEvent* event) {
   NSPoint current_mouse_location =
-      [window() convertBaseToScreen:[event locationInWindow]];
+      [window_ convertBaseToScreen:[event locationInWindow]];
 
   if ([event type] == NSLeftMouseDown) {
-    NSPoint frame_origin = [window() frame].origin;
+    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(
+    [window_ setFrameOrigin:NSMakePoint(
         current_mouse_location.x + last_mouse_offset_.x,
         current_mouse_location.y + last_mouse_offset_.y)];
   }
@@ -455,28 +504,35 @@ void NativeWindowMac::HandleKeyboardEvent(
       event.type == content::NativeWebKeyboardEvent::Char)
     return;
 
-  EventProcessingWindow* event_window =
-      static_cast<EventProcessingWindow*>(window());
-  DCHECK([event_window isKindOfClass:[EventProcessingWindow class]]);
-  [event_window redispatchKeyEvent:event.os_event];
+  if (event.os_event.window == window_) {
+    EventProcessingWindow* event_window =
+        static_cast<EventProcessingWindow*>(window_);
+    DCHECK([event_window isKindOfClass:[EventProcessingWindow class]]);
+    [event_window redispatchKeyEvent:event.os_event];
+  } else {
+    // The event comes from detached devtools view, and it has already been
+    // handled by the devtools itself, we now send it to application menu to
+    // make menu acclerators work.
+    [[NSApp mainMenu] performKeyEquivalent:event.os_event];
+  }
 }
 
 void NativeWindowMac::InstallView() {
   NSView* view = inspectable_web_contents()->GetView()->GetNativeView();
   if (has_frame_) {
-    [view setFrame:[[window() contentView] bounds]];
-    [[window() contentView] addSubview:view];
+    [view setFrame:[[window_ contentView] bounds]];
+    [[window_ contentView] addSubview:view];
   } else {
-    NSView* frameView = [[window() contentView] superview];
+    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];
+    [[window_ standardWindowButton:NSWindowZoomButton] setHidden:YES];
+    [[window_ standardWindowButton:NSWindowMiniaturizeButton] setHidden:YES];
+    [[window_ standardWindowButton:NSWindowCloseButton] setHidden:YES];
+    [[window_ standardWindowButton:NSWindowFullScreenButton] setHidden:YES];
   }
 }
 
@@ -556,7 +612,7 @@ void NativeWindowMac::UpdateDraggableRegionsForCustomDrag(
 
 // static
 NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
-                                   base::DictionaryValue* options) {
+                                   const mate::Dictionary& options) {
   return new NativeWindowMac(web_contents, options);
 }