Bump v0.12.1.

Improve the tutorials

.gitignore

@@ -5,6 +5,7 @@
 /out/
 /vendor/brightray/vendor/download/
 /vendor/python_26/
+/vendor/npm/
 node_modules/
 *.xcodeproj
 *.swp

.gitmodules

@@ -7,9 +7,9 @@
 [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

atom.gyp

@@ -1,223 +1,232 @@
 {
   'variables': {
+    'includes': [
+      'vendor/native_mate/native_mate_files.gypi',
+    ],
     'project_name': 'atom',
     'product_name': 'Atom',
     'framework_name': 'Atom Framework',
     'app_sources': [
-      'app/atom_main.cc',
-      'app/atom_main.h',
+      'atom/app/atom_main.cc',
+      'atom/app/atom_main.h',
     ],
     'bundle_sources': [
-      'browser/resources/mac/atom.icns',
+      'atom/browser/resources/mac/atom.icns',
     ],
     'coffee_sources': [
-      'browser/api/lib/app.coffee',
-      'browser/api/lib/atom-delegate.coffee',
-      'browser/api/lib/auto-updater.coffee',
-      'browser/api/lib/browser-window.coffee',
-      'browser/api/lib/dialog.coffee',
-      'browser/api/lib/ipc.coffee',
-      'browser/api/lib/menu.coffee',
-      'browser/api/lib/menu-item.coffee',
-      'browser/api/lib/power-monitor.coffee',
-      'browser/api/lib/protocol.coffee',
-      'browser/lib/init.coffee',
-      'browser/lib/objects-registry.coffee',
-      'browser/lib/rpc-server.coffee',
-      'common/api/lib/callbacks-registry.coffee',
-      'common/api/lib/clipboard.coffee',
-      'common/api/lib/crash-reporter.coffee',
-      'common/api/lib/id-weak-map.coffee',
-      'common/api/lib/screen.coffee',
-      'common/api/lib/shell.coffee',
-      'common/lib/init.coffee',
-      'renderer/lib/init.coffee',
-      'renderer/api/lib/ipc.coffee',
-      'renderer/api/lib/remote.coffee',
+      'atom/browser/api/lib/app.coffee',
+      'atom/browser/api/lib/atom-delegate.coffee',
+      'atom/browser/api/lib/auto-updater.coffee',
+      'atom/browser/api/lib/browser-window.coffee',
+      'atom/browser/api/lib/dialog.coffee',
+      'atom/browser/api/lib/ipc.coffee',
+      'atom/browser/api/lib/menu.coffee',
+      'atom/browser/api/lib/menu-item.coffee',
+      'atom/browser/api/lib/power-monitor.coffee',
+      'atom/browser/api/lib/protocol.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',
+      'atom/common/api/lib/callbacks-registry.coffee',
+      'atom/common/api/lib/clipboard.coffee',
+      'atom/common/api/lib/crash-reporter.coffee',
+      'atom/common/api/lib/id-weak-map.coffee',
+      'atom/common/api/lib/screen.coffee',
+      'atom/common/api/lib/shell.coffee',
+      'atom/common/lib/init.coffee',
+      'atom/renderer/lib/init.coffee',
+      'atom/renderer/lib/inspector.coffee',
+      'atom/renderer/lib/override.coffee',
+      'atom/renderer/api/lib/ipc.coffee',
+      'atom/renderer/api/lib/remote.coffee',
     ],
     'lib_sources': [
-      'app/atom_main_delegate.cc',
-      'app/atom_main_delegate.h',
-      'app/atom_main_delegate_mac.mm',
-      'browser/api/atom_api_app.cc',
-      'browser/api/atom_api_app.h',
-      'browser/api/atom_api_auto_updater.cc',
-      'browser/api/atom_api_auto_updater.h',
-      'browser/api/atom_api_browser_ipc.cc',
-      'browser/api/atom_api_browser_ipc.h',
-      'browser/api/atom_api_dialog.cc',
-      'browser/api/atom_api_dialog.h',
-      'browser/api/atom_api_event.cc',
-      'browser/api/atom_api_event.h',
-      'browser/api/atom_api_menu.cc',
-      'browser/api/atom_api_menu.h',
-      'browser/api/atom_api_menu_gtk.cc',
-      'browser/api/atom_api_menu_gtk.h',
-      'browser/api/atom_api_menu_mac.h',
-      'browser/api/atom_api_menu_mac.mm',
-      'browser/api/atom_api_menu_win.cc',
-      'browser/api/atom_api_menu_win.h',
-      'browser/api/atom_api_power_monitor.cc',
-      'browser/api/atom_api_power_monitor.h',
-      'browser/api/atom_api_protocol.cc',
-      'browser/api/atom_api_protocol.h',
-      'browser/api/atom_api_window.cc',
-      'browser/api/atom_api_window.h',
-      'browser/api/atom_browser_bindings.cc',
-      'browser/api/atom_browser_bindings.h',
-      'browser/auto_updater.cc',
-      'browser/auto_updater.h',
-      'browser/auto_updater_delegate.h',
-      'browser/auto_updater_linux.cc',
-      'browser/auto_updater_mac.mm',
-      'browser/auto_updater_win.cc',
-      'browser/atom_application_mac.h',
-      'browser/atom_application_mac.mm',
-      'browser/atom_application_delegate_mac.h',
-      'browser/atom_application_delegate_mac.mm',
-      'browser/atom_browser_client.cc',
-      'browser/atom_browser_client.h',
-      'browser/atom_browser_context.cc',
-      'browser/atom_browser_context.h',
-      'browser/atom_browser_main_parts.cc',
-      'browser/atom_browser_main_parts.h',
-      'browser/atom_browser_main_parts_mac.mm',
-      'browser/atom_javascript_dialog_manager.cc',
-      'browser/atom_javascript_dialog_manager.h',
-      'browser/browser.cc',
-      'browser/browser.h',
-      'browser/browser_linux.cc',
-      'browser/browser_mac.mm',
-      'browser/browser_win.cc',
-      'browser/browser_observer.h',
-      'browser/devtools_delegate.cc',
-      'browser/devtools_delegate.h',
-      'browser/native_window.cc',
-      'browser/native_window.h',
-      'browser/native_window_gtk.cc',
-      'browser/native_window_gtk.h',
-      'browser/native_window_mac.h',
-      'browser/native_window_mac.mm',
-      'browser/native_window_win.cc',
-      'browser/native_window_win.h',
-      'browser/native_window_observer.h',
-      'browser/net/adapter_request_job.cc',
-      'browser/net/adapter_request_job.h',
-      'browser/net/atom_url_request_context_getter.cc',
-      'browser/net/atom_url_request_context_getter.h',
-      'browser/net/atom_url_request_job_factory.cc',
-      'browser/net/atom_url_request_job_factory.h',
-      'browser/net/url_request_string_job.cc',
-      'browser/net/url_request_string_job.h',
-      'browser/ui/accelerator_util.cc',
-      'browser/ui/accelerator_util.h',
-      'browser/ui/accelerator_util_gtk.cc',
-      'browser/ui/accelerator_util_mac.mm',
-      'browser/ui/accelerator_util_win.cc',
-      'browser/ui/cocoa/atom_menu_controller.h',
-      'browser/ui/cocoa/atom_menu_controller.mm',
-      'browser/ui/cocoa/event_processing_window.h',
-      'browser/ui/cocoa/event_processing_window.mm',
-      'browser/ui/cocoa/nsalert_synchronous_sheet.h',
-      'browser/ui/cocoa/nsalert_synchronous_sheet.mm',
-      'browser/ui/file_dialog.h',
-      'browser/ui/file_dialog_gtk.cc',
-      'browser/ui/file_dialog_mac.mm',
-      'browser/ui/file_dialog_win.cc',
-      'browser/ui/gtk/gtk_custom_menu.cc',
-      'browser/ui/gtk/gtk_custom_menu.h',
-      'browser/ui/gtk/gtk_custom_menu_item.cc',
-      'browser/ui/gtk/gtk_custom_menu_item.h',
-      'browser/ui/gtk/gtk_window_util.cc',
-      'browser/ui/gtk/gtk_window_util.h',
-      'browser/ui/message_box.h',
-      'browser/ui/message_box_gtk.cc',
-      'browser/ui/message_box_mac.mm',
-      'browser/ui/message_box_win.cc',
-      'browser/ui/win/menu_2.cc',
-      'browser/ui/win/menu_2.h',
-      'browser/ui/win/native_menu_win.cc',
-      'browser/ui/win/native_menu_win.h',
-      'browser/window_list.cc',
-      'browser/window_list.h',
-      'browser/window_list_observer.h',
-      'common/api/api_messages.cc',
-      'common/api/api_messages.h',
-      'common/api/atom_api_clipboard.cc',
-      'common/api/atom_api_clipboard.h',
-      'common/api/atom_api_crash_reporter.cc',
-      'common/api/atom_api_crash_reporter.h',
-      'common/api/atom_api_event_emitter.cc',
-      'common/api/atom_api_event_emitter.h',
-      'common/api/atom_api_id_weak_map.cc',
-      'common/api/atom_api_id_weak_map.h',
-      'common/api/atom_api_screen.cc',
-      'common/api/atom_api_screen.h',
-      'common/api/atom_api_shell.cc',
-      'common/api/atom_api_shell.h',
-      'common/api/atom_api_v8_util.cc',
-      'common/api/atom_bindings.cc',
-      'common/api/atom_bindings.h',
-      'common/api/atom_extensions.cc',
-      'common/api/atom_extensions.h',
-      'common/api/object_life_monitor.cc',
-      'common/api/object_life_monitor.h',
-      'common/crash_reporter/crash_reporter.cc',
-      'common/crash_reporter/crash_reporter.h',
-      'common/crash_reporter/crash_reporter_linux.cc',
-      'common/crash_reporter/crash_reporter_linux.h',
-      'common/crash_reporter/crash_reporter_mac.h',
-      'common/crash_reporter/crash_reporter_mac.mm',
-      'common/crash_reporter/crash_reporter_win.cc',
-      'common/crash_reporter/crash_reporter_win.h',
-      'common/crash_reporter/linux/crash_dump_handler.cc',
-      'common/crash_reporter/linux/crash_dump_handler.h',
-      'common/crash_reporter/win/crash_service.cc',
-      'common/crash_reporter/win/crash_service.h',
-      'common/crash_reporter/win/crash_service_main.cc',
-      'common/crash_reporter/win/crash_service_main.h',
-      'common/draggable_region.cc',
-      'common/draggable_region.h',
-      'common/linux/application_info.cc',
-      'common/node_bindings.cc',
-      'common/node_bindings.h',
-      'common/node_bindings_linux.cc',
-      'common/node_bindings_linux.h',
-      'common/node_bindings_mac.cc',
-      'common/node_bindings_mac.h',
-      'common/node_bindings_win.cc',
-      'common/node_bindings_win.h',
-      'common/options_switches.cc',
-      'common/options_switches.h',
-      'common/platform_util.h',
-      'common/platform_util_linux.cc',
-      'common/platform_util_mac.mm',
-      'common/platform_util_win.cc',
-      'common/swap_or_assign.h',
-      'common/v8/node_common.h',
-      'common/v8/scoped_persistent.h',
-      'common/v8/native_type_conversions.h',
-      'common/v8/v8_value_converter.cc',
-      'common/v8/v8_value_converter.h',
-      'renderer/api/atom_api_renderer_ipc.cc',
-      'renderer/api/atom_api_renderer_ipc.h',
-      'renderer/api/atom_renderer_bindings.cc',
-      'renderer/api/atom_renderer_bindings.h',
-      'renderer/atom_render_view_observer.cc',
-      'renderer/atom_render_view_observer.h',
-      'renderer/atom_renderer_client.cc',
-      'renderer/atom_renderer_client.h',
+      'atom/app/atom_main_delegate.cc',
+      'atom/app/atom_main_delegate.h',
+      'atom/app/atom_main_delegate_mac.mm',
+      'atom/browser/api/atom_api_app.cc',
+      '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_dialog.cc',
+      'atom/browser/api/atom_api_menu.cc',
+      'atom/browser/api/atom_api_menu.h',
+      'atom/browser/api/atom_api_menu_gtk.cc',
+      'atom/browser/api/atom_api_menu_gtk.h',
+      'atom/browser/api/atom_api_menu_mac.h',
+      'atom/browser/api/atom_api_menu_mac.mm',
+      'atom/browser/api/atom_api_menu_win.cc',
+      'atom/browser/api/atom_api_menu_win.h',
+      'atom/browser/api/atom_api_power_monitor.cc',
+      '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_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/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_browser_client.cc',
+      'atom/browser/atom_browser_client.h',
+      'atom/browser/atom_browser_context.cc',
+      'atom/browser/atom_browser_context.h',
+      'atom/browser/atom_browser_main_parts.cc',
+      'atom/browser/atom_browser_main_parts.h',
+      'atom/browser/atom_browser_main_parts_mac.mm',
+      'atom/browser/atom_javascript_dialog_manager.cc',
+      'atom/browser/atom_javascript_dialog_manager.h',
+      'atom/browser/browser.cc',
+      'atom/browser/browser.h',
+      'atom/browser/browser_linux.cc',
+      'atom/browser/browser_mac.mm',
+      'atom/browser/browser_win.cc',
+      'atom/browser/browser_observer.h',
+      'atom/browser/devtools_delegate.cc',
+      'atom/browser/devtools_delegate.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',
+      'atom/browser/native_window_gtk.h',
+      'atom/browser/native_window_mac.h',
+      'atom/browser/native_window_mac.mm',
+      'atom/browser/native_window_win.cc',
+      'atom/browser/native_window_win.h',
+      'atom/browser/native_window_observer.h',
+      'atom/browser/net/adapter_request_job.cc',
+      'atom/browser/net/adapter_request_job.h',
+      'atom/browser/net/atom_url_request_context_getter.cc',
+      'atom/browser/net/atom_url_request_context_getter.h',
+      'atom/browser/net/atom_url_request_job_factory.cc',
+      'atom/browser/net/atom_url_request_job_factory.h',
+      'atom/browser/net/url_request_string_job.cc',
+      'atom/browser/net/url_request_string_job.h',
+      'atom/browser/ui/accelerator_util.cc',
+      'atom/browser/ui/accelerator_util.h',
+      'atom/browser/ui/accelerator_util_gtk.cc',
+      'atom/browser/ui/accelerator_util_mac.mm',
+      'atom/browser/ui/accelerator_util_win.cc',
+      'atom/browser/ui/cocoa/atom_menu_controller.h',
+      'atom/browser/ui/cocoa/atom_menu_controller.mm',
+      'atom/browser/ui/cocoa/event_processing_window.h',
+      'atom/browser/ui/cocoa/event_processing_window.mm',
+      'atom/browser/ui/file_dialog.h',
+      'atom/browser/ui/file_dialog_gtk.cc',
+      'atom/browser/ui/file_dialog_mac.mm',
+      'atom/browser/ui/file_dialog_win.cc',
+      '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/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/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_crash_reporter.cc',
+      '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_v8_util.cc',
+      'atom/common/api/atom_bindings.cc',
+      'atom/common/api/atom_bindings.h',
+      'atom/common/api/atom_extensions.cc',
+      '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',
+      'atom/common/crash_reporter/crash_reporter_linux.h',
+      'atom/common/crash_reporter/crash_reporter_mac.h',
+      'atom/common/crash_reporter/crash_reporter_mac.mm',
+      'atom/common/crash_reporter/crash_reporter_win.cc',
+      'atom/common/crash_reporter/crash_reporter_win.h',
+      'atom/common/crash_reporter/linux/crash_dump_handler.cc',
+      'atom/common/crash_reporter/linux/crash_dump_handler.h',
+      'atom/common/crash_reporter/win/crash_service.cc',
+      'atom/common/crash_reporter/win/crash_service.h',
+      'atom/common/crash_reporter/win/crash_service_main.cc',
+      'atom/common/crash_reporter/win/crash_service_main.h',
+      '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/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',
+      'atom/common/node_bindings_linux.h',
+      'atom/common/node_bindings_mac.cc',
+      '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/renderer/api/atom_api_renderer_ipc.cc',
+      'atom/renderer/api/atom_renderer_bindings.cc',
+      'atom/renderer/api/atom_renderer_bindings.h',
+      'atom/renderer/atom_render_view_observer.cc',
+      'atom/renderer/atom_render_view_observer.h',
+      'atom/renderer/atom_renderer_client.cc',
+      'atom/renderer/atom_renderer_client.h',
+      'chrome/browser/ui/gtk/event_utils.cc',
+      'chrome/browser/ui/gtk/event_utils.h',
+      'chrome/browser/ui/gtk/gtk_custom_menu.cc',
+      'chrome/browser/ui/gtk/gtk_custom_menu.h',
+      'chrome/browser/ui/gtk/gtk_custom_menu_item.cc',
+      'chrome/browser/ui/gtk/gtk_custom_menu_item.h',
+      'chrome/browser/ui/gtk/gtk_util.cc',
+      'chrome/browser/ui/gtk/gtk_util.h',
+      'chrome/browser/ui/gtk/gtk_window_util.cc',
+      'chrome/browser/ui/gtk/gtk_window_util.h',
+      'chrome/browser/ui/gtk/menu_gtk.cc',
+      'chrome/browser/ui/gtk/menu_gtk.h',
+      '<@(native_mate_files)',
     ],
     'framework_sources': [
-      'app/atom_library_main.cc',
-      'app/atom_library_main.h',
+      'atom/app/atom_library_main.cc',
+      'atom/app/atom_library_main.h',
     ],
     'conditions': [
       ['OS=="win"', {
         'app_sources': [
-          'browser/resources/win/resource.h',
-          'browser/resources/win/atom.ico',
-          'browser/resources/win/atom.rc',
+          'atom/browser/resources/win/resource.h',
+          'atom/browser/resources/win/atom.ico',
+          'atom/browser/resources/win/atom.rc',
           '<(libchromiumcontent_src_dir)/content/app/startup_helper_win.cc',
         ],
       }],  # OS=="win"
@@ -265,7 +274,7 @@
             '<(project_name)_helper',
           ],
           'xcode_settings': {
-            'INFOPLIST_FILE': 'browser/resources/mac/Info.plist',
+            'INFOPLIST_FILE': 'atom/browser/resources/mac/Info.plist',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@executable_path/../Frameworks',
             ],
@@ -285,9 +294,9 @@
               ],
             },
             {
-              'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources/browser',
+              'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources',
               'files': [
-                'browser/default_app',
+                'atom/browser/default_app',
               ],
             },
           ],
@@ -323,9 +332,9 @@
               ],
             },
             {
-              'destination': '<(PRODUCT_DIR)/resources/browser',
+              'destination': '<(PRODUCT_DIR)/resources',
               'files': [
-                'browser/default_app',
+                'atom/browser/default_app',
               ]
             },
           ],
@@ -341,9 +350,9 @@
               ],
             },
             {
-              'destination': '<(PRODUCT_DIR)/resources/browser',
+              'destination': '<(PRODUCT_DIR)/resources',
               'files': [
-                'browser/default_app',
+                'atom/browser/default_app',
               ]
             },
           ],
@@ -362,8 +371,8 @@
       ],
       'include_dirs': [
         '.',
-        'vendor',
         'vendor/brightray',
+        'vendor/native_mate',
         # Include directories for uv and node.
         'vendor/node/src',
         'vendor/node/deps/http_parser',
@@ -487,7 +496,7 @@
               ],
               'action': [
                 'python',
-                'tools/mac/generate_breakpad_symbols.py',
+                'tools/posix/generate_breakpad_symbols.py',
                 '--build-dir=<(PRODUCT_DIR)',
                 '--binary=<(PRODUCT_DIR)/<(product_name).app/Contents/MacOS/<(product_name)',
                 '--symbols-dir=<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
@@ -519,6 +528,49 @@
             },
           ],
         }],  # OS=="win"
+        ['OS=="linux"', {
+          'dependencies': [
+            'vendor/breakpad/breakpad.gyp:dump_syms',
+          ],
+          'actions': [
+            {
+              'action_name': 'Dump Symbols',
+              'inputs': [
+                '<(PRODUCT_DIR)/<(project_name)',
+              ],
+              'outputs': [
+                '<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
+              ],
+              'action': [
+                'python',
+                'tools/posix/generate_breakpad_symbols.py',
+                '--build-dir=<(PRODUCT_DIR)',
+                '--binary=<(PRODUCT_DIR)/<(project_name)',
+                '--symbols-dir=<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
+                '--libchromiumcontent-dir=<(libchromiumcontent_library_dir)',
+                '--clear',
+                '--jobs=16',
+              ],
+            },
+            {
+              'action_name': 'Strip Binary',
+              'inputs': [
+                '<(PRODUCT_DIR)/libchromiumcontent.so',
+                '<(PRODUCT_DIR)/libffmpegsumo.so',
+                '<(PRODUCT_DIR)/<(project_name)',
+                # Add the syms folder as input would force this action to run
+                # after the 'Dump Symbols' action. And since it is a folder,
+                # it would be ignored by the 'strip' command.
+                '<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
+              ],
+              'outputs': [
+                # Gyp action requires a output file, add a fake one here.
+                '<(PRODUCT_DIR)/dummy_file',
+              ],
+              'action': [ 'strip', '<@(_inputs)' ],
+            },
+          ],
+        }],  # OS=="linux"
       ],
     },  # target <(project_name>_dump_symbols
   ],
@@ -553,11 +605,11 @@
           },
           'mac_bundle': 1,
           'mac_bundle_resources': [
-            'common/resources/mac/MainMenu.xib',
+            'atom/common/resources/mac/MainMenu.xib',
             '<(libchromiumcontent_resources_dir)/content_shell.pak',
           ],
           'xcode_settings': {
-            'INFOPLIST_FILE': 'common/resources/mac/Info.plist',
+            'INFOPLIST_FILE': 'atom/common/resources/mac/Info.plist',
             'LIBRARY_SEARCH_PATHS': [
               '<(libchromiumcontent_library_dir)',
             ],
@@ -612,7 +664,7 @@
           ],
           'mac_bundle': 1,
           'xcode_settings': {
-            'INFOPLIST_FILE': 'renderer/resources/mac/Info.plist',
+            'INFOPLIST_FILE': 'atom/renderer/resources/mac/Info.plist',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@executable_path/../../..',
             ],

atom/app/atom_library_main.cc

@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "app/atom_library_main.h"
+#include "atom/app/atom_library_main.h"
 
-#include "app/atom_main_delegate.h"
+#include "atom/app/atom_main_delegate.h"
 #include "content/public/app/content_main.h"
 
 #if defined(OS_MACOSX)

atom/app/atom_library_main.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_APP_ATOM_LIBRARY_MAIN_
-#define ATOM_APP_ATOM_LIBRARY_MAIN_
+#ifndef ATOM_APP_ATOM_LIBRARY_MAIN_H_
+#define ATOM_APP_ATOM_LIBRARY_MAIN_H_
 
 #include "base/basictypes.h"
 
@@ -14,4 +14,4 @@ int AtomMain(int argc, const char* argv[]);
 }
 #endif  // OS_MACOSX
 
-#endif  // ATOM_APP_ATOM_LIBRARY_MAIN_
+#endif  // ATOM_APP_ATOM_LIBRARY_MAIN_H_

atom/app/atom_main.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "app/atom_main.h"
+#include "atom/app/atom_main.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -15,16 +15,16 @@
 #include <windows.h>
 #include <shellapi.h>
 
-#include "app/atom_main_delegate.h"
+#include "atom/app/atom_main_delegate.h"
 #include "base/environment.h"
-#include "common/crash_reporter/win/crash_service_main.h"
+#include "atom/common/crash_reporter/win/crash_service_main.h"
 #include "content/public/app/startup_helper_win.h"
 #include "sandbox/win/src/sandbox_types.h"
 #elif defined(OS_LINUX)  // defined(OS_WIN)
-#include "app/atom_main_delegate.h"  // NOLINT
+#include "atom/app/atom_main_delegate.h"  // NOLINT
 #include "content/public/app/content_main.h"
 #else  // defined(OS_LINUX)
-#include "app/atom_library_main.h"
+#include "atom/app/atom_library_main.h"
 #endif  // defined(OS_MACOSX)
 
 // Declaration of node::Start.

atom/app/atom_main.h

@@ -2,4 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef ATOM_APP_ATOM_MAIN_H_
+#define ATOM_APP_ATOM_MAIN_H_
+
 #include "content/public/app/content_main.h"
+
+#endif  // ATOM_APP_ATOM_MAIN_H_

atom/app/atom_main_delegate.cc

@@ -2,14 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "app/atom_main_delegate.h"
+#include "atom/app/atom_main_delegate.h"
+
+#include <string>
 
 #include "base/command_line.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
-#include "browser/atom_browser_client.h"
+#include "atom/browser/atom_browser_client.h"
 #include "content/public/common/content_switches.h"
-#include "renderer/atom_renderer_client.h"
+#include "atom/renderer/atom_renderer_client.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "base/path_service.h"
 
@@ -70,10 +72,6 @@ void AtomMainDelegate::PreSandboxStartup() {
   // Disable renderer sandbox for most of node's functions.
   command_line->AppendSwitch(switches::kNoSandbox);
 
-  // Disable accelerated compositing since it caused a lot of troubles (black
-  // devtools, screen flashes) and needed lots of effort to make it right.
-  command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
-
   // Add a flag to mark the end of switches added by atom-shell.
   command_line->AppendSwitch("atom-shell-switches-end");
 }

atom/app/atom_main_delegate.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_
-#define ATOM_APP_ATOM_MAIN_DELEGATE_
+#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_H_
+#define ATOM_APP_ATOM_MAIN_DELEGATE_H_
 
 #include "brightray/common/main_delegate.h"
 
@@ -38,4 +38,4 @@ class AtomMainDelegate : public brightray::MainDelegate {
 
 }  // namespace atom
 
-#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_
+#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_H_

atom/app/atom_main_delegate_mac.mm

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "app/atom_main_delegate.h"
+#include "atom/app/atom_main_delegate.h"
 
 #import "base/mac/bundle_locations.h"
 #import "base/mac/foundation_util.h"

atom/browser/api/atom_api_app.cc

@@ -0,0 +1,139 @@
+// 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_app.h"
+
+#include <string>
+
+#include "base/values.h"
+#include "base/command_line.h"
+#include "atom/browser/browser.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+
+#include "atom/common/node_includes.h"
+
+using atom::Browser;
+
+namespace atom {
+
+namespace api {
+
+App::App() {
+  Browser::Get()->AddObserver(this);
+}
+
+App::~App() {
+  Browser::Get()->RemoveObserver(this);
+}
+
+void App::OnWillQuit(bool* prevent_default) {
+  *prevent_default = Emit("will-quit");
+}
+
+void App::OnWindowAllClosed() {
+  Emit("window-all-closed");
+}
+
+void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
+  base::ListValue args;
+  args.AppendString(file_path);
+  *prevent_default = Emit("open-file", args);
+}
+
+void App::OnOpenURL(const std::string& url) {
+  base::ListValue args;
+  args.AppendString(url);
+  Emit("open-url", args);
+}
+
+void App::OnActivateWithNoOpenWindows() {
+  Emit("activate-with-no-open-windows");
+}
+
+void App::OnWillFinishLaunching() {
+  Emit("will-finish-launching");
+}
+
+void App::OnFinishLaunching() {
+  Emit("ready");
+}
+
+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
+mate::Handle<App> App::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new App);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+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

@@ -0,0 +1,50 @@
+// 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_APP_H_
+#define ATOM_BROWSER_API_ATOM_API_APP_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/browser_observer.h"
+#include "native_mate/handle.h"
+
+namespace atom {
+
+namespace api {
+
+class App : public mate::EventEmitter,
+            public BrowserObserver {
+ public:
+  static mate::Handle<App> Create(v8::Isolate* isolate);
+
+ protected:
+  App();
+  virtual ~App();
+
+  // BrowserObserver implementations:
+  virtual void OnWillQuit(bool* prevent_default) OVERRIDE;
+  virtual void OnWindowAllClosed() OVERRIDE;
+  virtual void OnOpenFile(bool* prevent_default,
+                          const std::string& file_path) OVERRIDE;
+  virtual void OnOpenURL(const std::string& url) OVERRIDE;
+  virtual void OnActivateWithNoOpenWindows() OVERRIDE;
+  virtual void OnWillFinishLaunching() OVERRIDE;
+  virtual void OnFinishLaunching() OVERRIDE;
+
+  // mate::Wrappable implementations:
+  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(App);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_APP_H_

atom/browser/api/atom_api_auto_updater.cc

@@ -0,0 +1,93 @@
+// 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_auto_updater.h"
+
+#include "base/time/time.h"
+#include "base/values.h"
+#include "atom/browser/auto_updater.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+AutoUpdater::AutoUpdater() {
+  auto_updater::AutoUpdater::SetDelegate(this);
+}
+
+AutoUpdater::~AutoUpdater() {
+  auto_updater::AutoUpdater::SetDelegate(NULL);
+}
+
+void AutoUpdater::OnError(const std::string& error) {
+  base::ListValue args;
+  args.AppendString(error);
+  Emit("error", args);
+}
+
+void AutoUpdater::OnCheckingForUpdate() {
+  Emit("checking-for-update");
+}
+
+void AutoUpdater::OnUpdateAvailable() {
+  Emit("update-available");
+}
+
+void AutoUpdater::OnUpdateNotAvailable() {
+  Emit("update-not-available");
+}
+
+void AutoUpdater::OnUpdateDownloaded(const std::string& release_notes,
+                                     const std::string& release_name,
+                                     const base::Time& release_date,
+                                     const std::string& update_url,
+                                     const base::Closure& quit_and_install) {
+  quit_and_install_ = quit_and_install;
+
+  base::ListValue args;
+  args.AppendString(release_notes);
+  args.AppendString(release_name);
+  args.AppendDouble(release_date.ToJsTime());
+  args.AppendString(update_url);
+  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())
+    quit_and_install_.Run();
+}
+
+// static
+mate::Handle<AutoUpdater> AutoUpdater::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new AutoUpdater);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+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

@@ -5,24 +5,25 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_
 #define ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_
 
+#include <string>
+
 #include "base/callback.h"
-#include "base/memory/scoped_ptr.h"
-#include "browser/auto_updater_delegate.h"
-#include "common/api/atom_api_event_emitter.h"
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/auto_updater_delegate.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;
@@ -36,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_dialog.cc

@@ -0,0 +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
+// found in the LICENSE file.
+
+#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/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/function_converter.h"
+#include "native_mate/dictionary.h"
+
+#include "atom/common/node_includes.h"
+
+namespace {
+
+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);
+  }
+}
+
+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 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
+
+NODE_MODULE(atom_browser_dialog, Initialize)

atom/browser/api/atom_api_menu.cc

@@ -0,0 +1,254 @@
+// 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_menu.h"
+
+#include "atom/browser/api/atom_api_window.h"
+#include "atom/browser/ui/accelerator_util.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"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+// Call method of delegate object.
+v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
+                                   v8::Handle<v8::Object> menu,
+                                   const char* method,
+                                   int command_id) {
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+
+  v8::Handle<v8::Value> delegate = menu->Get(v8::String::New("delegate"));
+  if (!delegate->IsObject())
+    return default_value;
+
+  v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(
+      delegate->ToObject()->Get(v8::String::New(method)));
+  if (!function->IsFunction())
+    return default_value;
+
+  v8::Handle<v8::Value> argv = v8::Integer::New(command_id);
+
+  return handle_scope.Close(
+      function->Call(v8::Context::GetCurrent()->Global(), 1, &argv));
+}
+
+}  // namespace
+
+Menu::Menu() : model_(new ui::SimpleMenuModel(this)) {
+}
+
+Menu::~Menu() {
+}
+
+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)->GetWrapper(node_isolate),
+                      "isCommandIdChecked",
+                      command_id)->BooleanValue();
+}
+
+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)->GetWrapper(node_isolate),
+                      "isCommandIdEnabled",
+                      command_id)->BooleanValue();
+}
+
+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)->GetWrapper(node_isolate),
+                      "isCommandIdVisible",
+                      command_id)->BooleanValue();
+}
+
+bool Menu::GetAcceleratorForCommandId(int command_id,
+                                      ui::Accelerator* accelerator) {
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+  v8::Handle<v8::Value> shortcut = CallDelegate(v8::Undefined(),
+                                                GetWrapper(node_isolate),
+                                                "getAcceleratorForCommandId",
+                                                command_id);
+  if (shortcut->IsString()) {
+    std::string shortcut_str = mate::V8ToString(shortcut);
+    return accelerator_util::StringToAccelerator(shortcut_str, accelerator);
+  }
+
+  return false;
+}
+
+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)->GetWrapper(node_isolate),
+                      "isItemForCommandIdDynamic",
+                      command_id)->BooleanValue();
+}
+
+string16 Menu::GetLabelForCommandId(int command_id) const {
+  v8::Locker locker(node_isolate);
+  v8::HandleScope handle_scope(node_isolate);
+  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);
+  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(), GetWrapper(node_isolate), "executeCommand",
+               command_id);
+}
+
+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) {
+  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::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)
+      .SetMethod("attachToWindow", &Menu::AttachToWindow)
+#endif
+      .SetMethod("popup", &Menu::Popup);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+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

@@ -0,0 +1,93 @@
+// 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_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 "ui/base/models/simple_menu_model.h"
+#include "native_mate/wrappable.h"
+
+namespace atom {
+
+namespace api {
+
+class MenuMac;
+
+class Menu : public mate::Wrappable,
+             public ui::SimpleMenuModel::Delegate {
+ public:
+  static mate::Wrappable* Create();
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Handle<v8::ObjectTemplate> prototype);
+
+#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
+
+ protected:
+  Menu();
+  virtual ~Menu();
+
+  // ui::SimpleMenuModel::Delegate implementations:
+  virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
+  virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
+  virtual bool IsCommandIdVisible(int command_id) const OVERRIDE;
+  virtual bool GetAcceleratorForCommandId(
+      int command_id,
+      ui::Accelerator* accelerator) OVERRIDE;
+  virtual bool IsItemForCommandIdDynamic(int command_id) const OVERRIDE;
+  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 Popup(Window* window) = 0;
+
+  scoped_ptr<ui::SimpleMenuModel> model_;
+
+ private:
+  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;
+
+#if defined(OS_WIN) || defined(TOOLKIT_GTK)
+  void AttachToWindow(Window* window);
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(Menu);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_H_

atom/browser/api/atom_api_menu_gtk.cc

@@ -0,0 +1,51 @@
+// 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/api/atom_api_menu_gtk.h"
+
+#include "atom/browser/native_window_gtk.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "ui/gfx/point.h"
+#include "ui/gfx/screen.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+MenuGtk::MenuGtk() {
+}
+
+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) {
+    triggering_event_time = event->time;
+    point = gfx::Point(event->x_root, event->y_root);
+  } else {
+    triggering_event_time = GDK_CURRENT_TIME;
+    point = gfx::Screen::GetNativeScreen()->GetCursorScreenPoint();
+  }
+
+  menu_gtk_.reset(new ::MenuGtk(this, model_.get()));
+  menu_gtk_->PopupAsContext(point, triggering_event_time);
+}
+
+void Menu::AttachToWindow(Window* window) {
+  static_cast<NativeWindowGtk*>(window->window())->SetMenu(model_.get());
+}
+
+// static
+mate::Wrappable* Menu::Create() {
+  return new MenuGtk();
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_menu_gtk.h

@@ -5,21 +5,24 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_
 #define ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_
 
-#include "browser/api/atom_api_menu.h"
+#include "atom/browser/api/atom_api_menu.h"
+#include "chrome/browser/ui/gtk/menu_gtk.h"
 
 namespace atom {
 
 namespace api {
 
-class MenuGtk : public Menu {
+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;
 
  private:
+  scoped_ptr<::MenuGtk> menu_gtk_;
+
   DISALLOW_COPY_AND_ASSIGN(MenuGtk);
 };
 

atom/browser/api/atom_api_menu_mac.h

@@ -5,28 +5,27 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
 #define ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
 
-#include "browser/api/atom_api_menu.h"
+#include "atom/browser/api/atom_api_menu.h"
 
-#import "browser/ui/cocoa/atom_menu_controller.h"
+#include <string>
+
+#import "atom/browser/ui/cocoa/atom_menu_controller.h"
 
 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

@@ -0,0 +1,74 @@
+// 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.
+
+#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 "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() {
+}
+
+void MenuMac::Popup(Window* window) {
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:model_.get()]);
+
+  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 = [nswindow mouseLocationOutsideOfEventStream];
+  NSTimeInterval eventTime = [currentEvent timestamp];
+  NSEvent* clickEvent = [NSEvent mouseEventWithType:NSRightMouseDown
+                                           location:position
+                                      modifierFlags:NSRightMouseDownMask
+                                          timestamp:eventTime
+                                       windowNumber:[nswindow windowNumber]
+                                            context:nil
+                                        eventNumber:0
+                                         clickCount:1
+                                           pressure:1.0];
+
+  // Show the menu.
+  [NSMenu popUpContextMenu:[menu_controller menu]
+                 withEvent:clickEvent
+                   forView:web_contents->GetView()->GetContentNativeView()];
+}
+
+// static
+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]];
+
+  // Ensure the menu_controller_ is destroyed after main menu is set.
+  menu_controller.swap(menu->menu_controller_);
+}
+
+// static
+void Menu::SendActionToFirstResponder(const std::string& action) {
+  SEL selector = NSSelectorFromString(base::SysUTF8ToNSString(action));
+  [NSApp sendAction:selector to:nil from:[NSApp mainMenu]];
+}
+
+// static
+mate::Wrappable* Menu::Create() {
+  return new MenuMac();
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_menu_win.cc

@@ -0,0 +1,38 @@
+// 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_menu_win.h"
+
+#include "atom/browser/native_window_win.h"
+#include "atom/browser/ui/win/menu_2.h"
+#include "ui/gfx/point.h"
+#include "ui/gfx/screen.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+MenuWin::MenuWin() {
+}
+
+void MenuWin::Popup(Window* window) {
+  gfx::Point cursor = gfx::Screen::GetNativeScreen()->GetCursorScreenPoint();
+  menu_.reset(new atom::Menu2(model_.get()));
+  menu_->RunContextMenuAt(cursor);
+}
+
+void Menu::AttachToWindow(Window* window) {
+  static_cast<NativeWindowWin*>(window->window())->SetMenu(model_.get());
+}
+
+// static
+mate::Wrappable* Menu::Create() {
+  return new MenuWin();
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_menu_win.h

@@ -5,7 +5,7 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_MENU_WIN_H_
 #define ATOM_BROWSER_API_ATOM_API_MENU_WIN_H_
 
-#include "browser/api/atom_api_menu.h"
+#include "atom/browser/api/atom_api_menu.h"
 
 namespace atom {
 
@@ -15,11 +15,10 @@ 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;
 
  private:
   scoped_ptr<atom::Menu2> menu_;

atom/browser/api/atom_api_power_monitor.cc

@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/api/atom_api_power_monitor.h"
+#include "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 "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

@@ -5,31 +5,30 @@
 #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 "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

@@ -0,0 +1,332 @@
+// 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_protocol.h"
+
+#include "base/stl_util.h"
+#include "atom/browser/atom_browser_context.h"
+#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/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/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 {
+
+namespace {
+
+typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
+
+class CustomProtocolRequestJob : public AdapterRequestJob {
+ public:
+  CustomProtocolRequestJob(Protocol* registry,
+                           ProtocolHandler* protocol_handler,
+                           net::URLRequest* request,
+                           net::NetworkDelegate* network_delegate)
+      : AdapterRequestJob(protocol_handler, request, network_delegate),
+        registry_(registry) {
+  }
+
+  // AdapterRequestJob:
+  virtual void GetJobTypeInUI() OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+    v8::Locker locker(node_isolate);
+    v8::HandleScope handle_scope(node_isolate);
+
+    // Call the JS handler.
+    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 = mate::V8ToString(result);
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+          base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
+                     GetWeakPtr(), "text/plain", "UTF-8", data));
+      return;
+    } else if (result->IsObject()) {
+      v8::Handle<v8::Object> obj = result->ToObject();
+      mate::Dictionary dict(node_isolate, obj);
+      std::string name = mate::V8ToString(obj->GetConstructorName());
+      if (name == "RequestStringJob") {
+        std::string mime_type, charset, data;
+        dict.Get("mimeType", &mime_type);
+        dict.Get("charset", &charset);
+        dict.Get("data", &data);
+
+        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+            base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
+                       GetWeakPtr(), mime_type, charset, data));
+        return;
+      } else if (name == "RequestFileJob") {
+        base::FilePath path;
+        dict.Get("path", &path);
+
+        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+            base::Bind(&AdapterRequestJob::CreateFileJobAndStart,
+                       GetWeakPtr(), path));
+        return;
+      }
+    }
+
+    // Try the default protocol handler if we have.
+    if (default_protocol_handler()) {
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+          base::Bind(&AdapterRequestJob::CreateJobFromProtocolHandlerAndStart,
+                     GetWeakPtr()));
+      return;
+    }
+
+    // Fallback to the not implemented error.
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+        base::Bind(&AdapterRequestJob::CreateErrorJobAndStart,
+                   GetWeakPtr(), net::ERR_NOT_IMPLEMENTED));
+  }
+
+ private:
+  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
+};
+
+// Always return the same CustomProtocolRequestJob for all requests, because
+// the content API needs the ProtocolHandler to return a job immediately, and
+// getting the real job from the JS requires asynchronous calls, so we have
+// to create an adapter job first.
+// Users can also pass an extra ProtocolHandler as the fallback one when
+// registered handler doesn't want to deal with the request.
+class CustomProtocolHandler : public ProtocolHandler {
+ public:
+  CustomProtocolHandler(api::Protocol* registry,
+                        ProtocolHandler* protocol_handler = NULL)
+      : registry_(registry), protocol_handler_(protocol_handler) {
+  }
+
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    return new CustomProtocolRequestJob(registry_, protocol_handler_.get(),
+                                        request, network_delegate);
+  }
+
+  ProtocolHandler* ReleaseDefaultProtocolHandler() {
+    return protocol_handler_.release();
+  }
+
+  ProtocolHandler* original_handler() { return protocol_handler_.get(); }
+
+ private:
+  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
+  scoped_ptr<ProtocolHandler> protocol_handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
+};
+
+}  // namespace
+
+Protocol::Protocol() : job_factory_(
+    AtomBrowserContext::Get()->url_request_context_getter()->job_factory()) {
+}
+
+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");
+
+  protocol_handlers_[scheme] = callback;
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::RegisterProtocolInIO,
+                                     base::Unretained(this), scheme));
+}
+
+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");
+
+  protocol_handlers_.erase(it);
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::UnregisterProtocolInIO,
+                                     base::Unretained(this), scheme));
+}
+
+bool Protocol::IsHandledProtocol(const std::string& scheme) {
+  return job_factory_->IsHandledProtocol(scheme);
+}
+
+void Protocol::InterceptProtocol(const std::string& scheme,
+                                 const JsProtocolHandler& callback) {
+  if (!job_factory_->HasProtocolHandler(scheme))
+    return node::ThrowError("Scheme does not exist.");
+
+  if (ContainsKey(protocol_handlers_, scheme))
+    return node::ThrowError("Cannot intercept custom procotols");
+
+  protocol_handlers_[scheme] = callback;
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::InterceptProtocolInIO,
+                                     base::Unretained(this), scheme));
+}
+
+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");
+
+  protocol_handlers_.erase(it);
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::UninterceptProtocolInIO,
+                                     base::Unretained(this), scheme));
+}
+
+void Protocol::RegisterProtocolInIO(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  job_factory_->SetProtocolHandler(scheme, new CustomProtocolHandler(this));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "registered", scheme));
+}
+
+void Protocol::UnregisterProtocolInIO(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  job_factory_->SetProtocolHandler(scheme, NULL);
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "unregistered", scheme));
+}
+
+void Protocol::InterceptProtocolInIO(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  ProtocolHandler* original_handler = job_factory_->GetProtocolHandler(scheme);
+  if (original_handler == NULL) {
+    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(this, original_handler));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "intercepted", scheme));
+}
+
+void Protocol::UninterceptProtocolInIO(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  CustomProtocolHandler* handler = static_cast<CustomProtocolHandler*>(
+      job_factory_->GetProtocolHandler(scheme));
+  if (handler->original_handler() == NULL) {
+    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.
+  ProtocolHandler* original_handler = handler->ReleaseDefaultProtocolHandler();
+  delete job_factory_->ReplaceProtocol(scheme, original_handler);
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "unintercepted", scheme));
+}
+
+void Protocol::EmitEventInUI(const std::string& event,
+                             const std::string& parameter) {
+  base::ListValue args;
+  args.AppendString(parameter);
+  Emit(event, args);
+}
+
+// static
+mate::Handle<Protocol> Protocol::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new Protocol);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports) {
+  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

@@ -0,0 +1,79 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
+#define ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
+
+#include <string>
+#include <map>
+
+#include "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 : public mate::EventEmitter {
+ public:
+  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:
+  typedef std::map<std::string, JsProtocolHandler> ProtocolHandlersMap;
+
+  // 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);
+
+  // 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);
+
+  // Intercept/unintercept an existing protocol handler.
+  void InterceptProtocol(const std::string& scheme,
+                         const JsProtocolHandler& callback);
+  void UninterceptProtocol(const std::string& scheme);
+
+  // 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
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_

atom/browser/api/atom_api_web_contents.cc

@@ -0,0 +1,209 @@
+// 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/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) {
+  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 a BSD-style 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

@@ -0,0 +1,381 @@
+// 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_window.h"
+
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/native_window.h"
+#include "atom/common/native_mate_converters/function_converter.h"
+#include "atom/common/native_mate_converters/value_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/node_includes.h"
+
+namespace mate {
+
+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 {
+
+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(base::DictionaryValue* options)
+    : window_(NativeWindow::Create(options)) {
+  window_->InitFromOptions(options);
+  window_->AddObserver(this);
+}
+
+Window::~Window() {
+  if (window_)
+    Destroy();
+
+  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::WillCloseWindow(bool* prevent_default) {
+  *prevent_default = Emit("close");
+}
+
+void Window::OnWindowClosed() {
+  Emit("closed");
+
+  window_->RemoveObserver(this);
+}
+
+void Window::OnWindowBlur() {
+  Emit("blur");
+}
+
+void Window::OnRendererUnresponsive() {
+  Emit("unresponsive");
+}
+
+void Window::OnRendererResponsive() {
+  Emit("responsive");
+}
+
+// static
+mate::Wrappable* Window::New(mate::Arguments* args,
+                             const base::DictionaryValue& options) {
+  scoped_ptr<base::DictionaryValue> copied_options(options.DeepCopy());
+  Window* window = new Window(copied_options.get());
+  window->Wrap(args->isolate(), args->GetThis());
+
+  // Give js code a chance to do initialization.
+  node::MakeCallback(args->GetThis(), "_init", 0, NULL);
+
+  return window;
+}
+
+void Window::Destroy() {
+  window_->DestroyWebContents();
+  window_->CloseImmediately();
+}
+
+void Window::Close() {
+  window_->Close();
+}
+
+void Window::Focus() {
+  window_->Focus(true);
+}
+
+bool Window::IsFocused() {
+  return window_->IsFocused();
+}
+
+void Window::Show() {
+  window_->Show();
+}
+
+void Window::Hide() {
+  window_->Hide();
+}
+
+bool Window::IsVisible() {
+  return window_->IsVisible();
+}
+
+void Window::Maximize() {
+  window_->Maximize();
+}
+
+void Window::Unmaximize() {
+  window_->Unmaximize();
+}
+
+void Window::Minimize() {
+  window_->Minimize();
+}
+
+void Window::Restore() {
+  window_->Restore();
+}
+
+void Window::SetFullscreen(bool fullscreen) {
+  window_->SetFullscreen(fullscreen);
+}
+
+bool Window::IsFullscreen() {
+  return window_->IsFullscreen();
+}
+
+void Window::SetSize(int width, int height) {
+  window_->SetSize(gfx::Size(width, height));
+}
+
+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;
+}
+
+void Window::SetMinimumSize(int width, int height) {
+  window_->SetMinimumSize(gfx::Size(width, height));
+}
+
+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;
+}
+
+void Window::SetMaximumSize(int width, int height) {
+  window_->SetMaximumSize(gfx::Size(width, height));
+}
+
+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;
+}
+
+void Window::SetResizable(bool resizable) {
+  window_->SetResizable(resizable);
+}
+
+bool Window::IsResizable() {
+  return window_->IsResizable();
+}
+
+void Window::SetAlwaysOnTop(bool top) {
+  window_->SetAlwaysOnTop(top);
+}
+
+bool Window::IsAlwaysOnTop() {
+  return window_->IsAlwaysOnTop();
+}
+
+void Window::Center() {
+  window_->Center();
+}
+
+void Window::SetPosition(int x, int y) {
+  window_->SetPosition(gfx::Point(x, y));
+}
+
+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;
+}
+
+void Window::SetTitle(const std::string& title) {
+  window_->SetTitle(title);
+}
+
+std::string Window::GetTitle() {
+  return window_->GetTitle();
+}
+
+void Window::FlashFrame(bool flash) {
+  window_->FlashFrame(flash);
+}
+
+void Window::SetKiosk(bool kiosk) {
+  window_->SetKiosk(kiosk);
+}
+
+bool Window::IsKiosk() {
+  return window_->IsKiosk();
+}
+
+void Window::OpenDevTools() {
+  window_->OpenDevTools();
+}
+
+void Window::CloseDevTools() {
+  window_->CloseDevTools();
+}
+
+bool Window::IsDevToolsOpened() {
+  return window_->IsDevToolsOpened();
+}
+
+void Window::InspectElement(int x, int y) {
+  window_->InspectElement(x, y);
+}
+
+void Window::DebugDevTools() {
+  if (window_->IsDevToolsOpened())
+    NativeWindow::Debug(window_->GetDevToolsWebContents());
+}
+
+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;
+  base::Callback<void(v8::Handle<v8::Value>)> 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));
+}
+
+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::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("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("setKiosk", &Window::SetKiosk)
+      .SetMethod("isKiosk", &Window::IsKiosk)
+      .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
+
+
+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

@@ -0,0 +1,138 @@
+// 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_WINDOW_H_
+#define ATOM_BROWSER_API_ATOM_API_WINDOW_H_
+
+#include <string>
+#include <vector>
+
+#include "base/memory/scoped_ptr.h"
+#include "atom/browser/native_window_observer.h"
+#include "atom/browser/api/event_emitter.h"
+#include "native_mate/handle.h"
+
+class GURL;
+
+namespace base {
+class DictionaryValue;
+}
+
+namespace mate {
+class Arguments;
+class Dictionary;
+}
+
+namespace atom {
+
+class NativeWindow;
+
+namespace api {
+
+class WebContents;
+
+class Window : public mate::EventEmitter,
+               public NativeWindowObserver {
+ public:
+  static mate::Wrappable* New(mate::Arguments* args,
+                              const base::DictionaryValue& options);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Handle<v8::ObjectTemplate> prototype);
+
+  NativeWindow* window() const { return window_.get(); }
+
+ protected:
+  explicit Window(base::DictionaryValue* options);
+  virtual ~Window();
+
+  // Implementations of NativeWindowObserver:
+  virtual void OnPageTitleUpdated(bool* prevent_default,
+                                  const std::string& title) OVERRIDE;
+  virtual void WillCloseWindow(bool* prevent_default) OVERRIDE;
+  virtual void OnWindowClosed() OVERRIDE;
+  virtual void OnWindowBlur() OVERRIDE;
+  virtual void OnRendererUnresponsive() OVERRIDE;
+  virtual void OnRendererResponsive() OVERRIDE;
+
+ private:
+  // APIs for NativeWindow.
+  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 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 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);
+
+  // APIs for WebContents.
+  mate::Handle<WebContents> GetWebContents(v8::Isolate* isolate) const;
+  mate::Handle<WebContents> GetDevToolsWebContents(v8::Isolate* isolate) const;
+
+  scoped_ptr<NativeWindow> window_;
+
+  DISALLOW_COPY_AND_ASSIGN(Window);
+};
+
+}  // namespace api
+
+}  // 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/event.cc

@@ -0,0 +1,61 @@
+// 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/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 a BSD-style 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 a BSD-style 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 a BSD-style 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()

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

@@ -0,0 +1,98 @@
+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
+
+# Store all created windows in the weak map.
+BrowserWindow.windows = new IDWeakMap
+
+BrowserWindow::_init = ->
+  # Simulate the application menu on platforms other than OS X.
+  if process.platform isnt 'darwin'
+    menu = app.getApplicationMenu()
+    @setMenu menu if menu?
+
+  @webContents = @getWebContents()
+  @webContents.once 'destroyed', => @webContents = null
+
+  # Define getter for devToolsWebContents.
+  devToolsWebContents = null
+  @__defineGetter__ 'devToolsWebContents', ->
+    if @isDevToolsOpened()
+      # Get a new devToolsWebContents if previous one has been destroyed, it
+      # could happen when the devtools has been closed and then reopened.
+      devToolsWebContents = null unless devToolsWebContents?.isAlive()
+      devToolsWebContents ?= @getDevToolsWebContents()
+    else
+      devToolsWebContents = null
+
+  # Remember the window.
+  id = BrowserWindow.windows.add this
+
+  # Remove the window from weak map immediately when it's destroyed, since we
+  # could be iterating windows before GC happended.
+  @once '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.
+  @webContents.on 'render-view-deleted', (event, processId, routingId) ->
+    process.emit 'ATOM_BROWSER_RELEASE_RENDER_VIEW', "#{processId}-#{routingId}"
+
+BrowserWindow::toggleDevTools = ->
+  if @isDevToolsOpened() then @closeDevTools() else @openDevTools()
+
+BrowserWindow::getWebContents = ->
+  wrapWebContents @_getWebContents()
+
+BrowserWindow::getDevToolsWebContents = ->
+  wrapWebContents @_getDevToolsWebContents()
+
+BrowserWindow::setMenu = (menu) ->
+  if process.platform is 'darwin'
+    throw new Error('BrowserWindow.setMenu is not available on OS X')
+
+  throw new TypeError('Invalid menu') unless menu?.constructor?.name is 'Menu'
+
+  @menu = menu  # Keep a reference of menu in case of GC.
+  @menu.attachToWindow this
+
+BrowserWindow.getAllWindows = ->
+  windows = BrowserWindow.windows
+  windows.get key for key in windows.keys()
+
+BrowserWindow.getFocusedWindow = ->
+  windows = BrowserWindow.getAllWindows()
+  return window for window in windows when window.isFocused()
+
+BrowserWindow.fromWebContents = (webContents) ->
+  windows = BrowserWindow.getAllWindows()
+  return window for window in windows when webContents.equal window.webContents
+
+BrowserWindow.fromDevToolsWebContents = (webContents) ->
+  windows = BrowserWindow.getAllWindows()
+  return window for window in windows when webContents.equal window.devToolsWebContents
+
+# 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

@@ -30,7 +30,7 @@ module.exports =
                            String(options.defaultPath),
                            properties,
                            window,
-                           callback
+                           (success, result) -> callback if success then result
 
   showSaveDialog: (window, options, callback) ->
     unless window?.constructor is BrowserWindow
@@ -46,7 +46,7 @@ module.exports =
     binding.showSaveDialog String(options.title),
                            String(options.defaultPath),
                            window,
-                           callback
+                           (success, result) -> callback if success then result
 
   showMessageBox: (window, options, callback) ->
     unless window?.constructor is BrowserWindow

atom/browser/api/lib/ipc.coffee

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

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

@@ -0,0 +1,6 @@
+powerMonitor = process.atomBinding('power_monitor').powerMonitor
+EventEmitter = require('events').EventEmitter
+
+powerMonitor.__proto__ = EventEmitter.prototype
+
+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/web-contents.coffee

@@ -0,0 +1,27 @@
+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...]
+
+  # The processId and routingId and identify a webContents.
+  webContents.getId = -> "#{@getProcessId()}-#{@getRoutingId()}"
+  webContents.equal = (other) -> @getId() is other.getId()
+
+  # 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

@@ -2,16 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/atom_browser_client.h"
+#include "atom/browser/atom_browser_client.h"
 
-#include "base/command_line.h"
-#include "browser/atom_browser_context.h"
-#include "browser/atom_browser_main_parts.h"
-#include "browser/native_window.h"
-#include "browser/net/atom_url_request_context_getter.h"
-#include "browser/window_list.h"
-#include "common/options_switches.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/net/atom_url_request_context_getter.h"
+#include "atom/browser/window_list.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "webkit/common/webpreferences.h"
@@ -54,7 +53,7 @@ void AtomBrowserClient::OverrideWebkitPrefs(
     const GURL& url,
     WebPreferences* prefs) {
   prefs->javascript_enabled = true;
-  prefs->web_security_enabled = false;
+  prefs->web_security_enabled = true;
   prefs->javascript_can_open_windows_automatically = true;
   prefs->plugins_enabled = false;
   prefs->dom_paste_enabled = true;
@@ -69,6 +68,12 @@ void AtomBrowserClient::OverrideWebkitPrefs(
   prefs->experimental_webgl_enabled = false;
   prefs->allow_displaying_insecure_content = true;
   prefs->allow_running_insecure_content = true;
+
+  NativeWindow* window = NativeWindow::FromRenderView(
+      render_view_host->GetProcess()->GetID(),
+      render_view_host->GetRoutingID());
+  if (window)
+    window->OverrideWebkitPrefs(url, prefs);
 }
 
 bool AtomBrowserClient::ShouldSwapProcessesForNavigation(
@@ -78,7 +83,8 @@ 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;
 }
 
@@ -105,10 +111,8 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches(
       window = *iter;
   }
 
-  // Append --node-integration to renderer process.
   if (window != NULL)
-    command_line->AppendSwitchASCII(switches::kNodeIntegration,
-                                    window->node_integration());
+    window->AppendExtraCommandLineSwitches(command_line, child_process_id);
 
   dying_render_process_ = NULL;
 }

atom/browser/atom_browser_client.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROWSER_ATOM_BROWSER_CLIENT_
-#define ATOM_BROWSER_ATOM_BROWSER_CLIENT_
+#ifndef ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
+#define ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 
 #include "brightray/browser/browser_client.h"
 
@@ -40,4 +40,4 @@ class AtomBrowserClient : public brightray::BrowserClient {
 
 }  // namespace atom
 
-#endif  // ATOM_BROWSER_ATOM_BROWSER_CLIENT_
+#endif  // ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_

atom/browser/atom_browser_context.cc

@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_context.h"
 
-#include "browser/atom_browser_main_parts.h"
-#include "browser/net/atom_url_request_context_getter.h"
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/net/atom_url_request_context_getter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_context.h"
 #include "vendor/brightray/browser/network_delegate.h"

atom/browser/atom_browser_main_parts.cc

@@ -2,20 +2,20 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/atom_browser_main_parts.h"
+#include "atom/browser/atom_browser_main_parts.h"
 
-#include "browser/api/atom_browser_bindings.h"
-#include "browser/atom_browser_client.h"
-#include "browser/atom_browser_context.h"
-#include "browser/browser.h"
-#include "common/node_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"
 
 #if defined(OS_WIN)
 #include "ui/gfx/win/dpi.h"
 #endif
 
-#include "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

@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_
-#define ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_
+#ifndef ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
+#define ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
 
 #include "brightray/browser/browser_main_parts.h"
 
 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_;
 
@@ -48,4 +47,4 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 
 }  // namespace atom
 
-#endif  // ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_
+#endif  // ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_

atom/browser/atom_browser_main_parts_mac.mm

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/atom_browser_main_parts.h"
+#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 "browser/atom_application_mac.h"
-#import "browser/atom_application_delegate_mac.h"
 #import "vendor/brightray/common/mac/main_application_bundle.h"
 
 namespace atom {

atom/browser/atom_javascript_dialog_manager.cc

@@ -2,12 +2,26 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/atom_javascript_dialog_manager.h"
+#include "atom/browser/atom_javascript_dialog_manager.h"
+
+#include <string>
 
 #include "base/strings/utf_string_conversions.h"
 
 namespace atom {
 
+void AtomJavaScriptDialogManager::RunJavaScriptDialog(
+    content::WebContents* web_contents,
+    const GURL& origin_url,
+    const std::string& accept_lang,
+    content::JavaScriptMessageType javascript_message_type,
+    const string16& message_text,
+    const string16& default_prompt_text,
+    const DialogClosedCallback& callback,
+    bool* did_suppress_message) {
+  callback.Run(false, string16());
+}
+
 void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(
     content::WebContents* web_contents,
     const string16& message_text,

atom/browser/atom_javascript_dialog_manager.h

@@ -2,8 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_
-#define ATOM_BROSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_
+#ifndef ATOM_BROWSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_
+#define ATOM_BROWSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_
+
+#include <string>
 
 #include "content/public/browser/javascript_dialog_manager.h"
 
@@ -20,7 +22,7 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
       const string16& message_text,
       const string16& default_prompt_text,
       const DialogClosedCallback& callback,
-      bool* did_suppress_message) OVERRIDE {}
+      bool* did_suppress_message) OVERRIDE;
   virtual void RunBeforeUnloadDialog(
       content::WebContents* web_contents,
       const string16& message_text,
@@ -34,4 +36,4 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
 
 }  // namespace atom
 
-#endif  // ATOM_BROSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_
+#endif  // ATOM_BROWSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_

atom/browser/auto_updater.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/auto_updater.h"
+#include "atom/browser/auto_updater.h"
 
 namespace auto_updater {
 

atom/browser/auto_updater_linux.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/auto_updater.h"
+#include "atom/browser/auto_updater.h"
 
 namespace auto_updater {
 

atom/browser/auto_updater_mac.mm

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/auto_updater.h"
+#include "atom/browser/auto_updater.h"
 
 #import <ReactiveCocoa/RACCommand.h>
 #import <ReactiveCocoa/RACSignal.h>
@@ -12,7 +12,7 @@
 #include "base/bind.h"
 #include "base/time/time.h"
 #include "base/strings/sys_string_conversions.h"
-#include "browser/auto_updater_delegate.h"
+#include "atom/browser/auto_updater_delegate.h"
 
 #include <iostream>
 

atom/browser/auto_updater_win.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/auto_updater.h"
+#include "atom/browser/auto_updater.h"
 
 namespace auto_updater {
 

atom/browser/browser.cc

@@ -2,10 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/browser.h"
+#include "atom/browser/browser.h"
 
-#include "browser/atom_browser_main_parts.h"
-#include "browser/window_list.h"
+#include <string>
+
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/window_list.h"
+#include "base/message_loop/message_loop.h"
 
 namespace atom {
 
@@ -28,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();
@@ -74,6 +82,10 @@ void Browser::OpenURL(const std::string& url) {
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnOpenURL(url));
 }
 
+void Browser::ActivateWithNoOpenWindows() {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnActivateWithNoOpenWindows());
+}
+
 void Browser::WillFinishLaunching() {
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWillFinishLaunching());
 }
@@ -82,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));
 
@@ -91,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

@@ -5,11 +5,13 @@
 #ifndef ATOM_BROWSER_BROWSER_H_
 #define ATOM_BROWSER_BROWSER_H_
 
+#include <string>
+
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/observer_list.h"
-#include "browser/browser_observer.h"
-#include "browser/window_list_observer.h"
+#include "atom/browser/browser_observer.h"
+#include "atom/browser/window_list_observer.h"
 
 namespace atom {
 
@@ -24,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();
@@ -62,6 +64,9 @@ class Browser : public WindowListObserver {
   // Tell the application to open a url.
   void OpenURL(const std::string& url);
 
+  // Tell the application that application is activated with no open windows.
+  void ActivateWithNoOpenWindows();
+
   // Tell the application the loading has been done.
   void WillFinishLaunching();
   void DidFinishLaunching();
@@ -83,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

@@ -2,21 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/browser.h"
+#include "atom/browser/browser.h"
 
 #include <stdlib.h>
 
-#include "browser/native_window.h"
-#include "browser/window_list.h"
-#include "common/atom_version.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/window_list.h"
+#include "atom/common/atom_version.h"
 
 namespace atom {
 
-void Browser::Terminate() {
-  is_quiting_ = true;
-  exit(0);
-}
-
 void Browser::Focus() {
   // Focus on the first visible window.
   WindowList* list = WindowList::GetInstance();
@@ -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

@@ -2,19 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/browser.h"
+#include "atom/browser/browser.h"
 
 #import "base/mac/bundle_locations.h"
 #include "base/strings/sys_string_conversions.h"
-#import "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

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROSER_BROWSER_OBSERVER_H_
-#define ATOM_BROSER_BROWSER_OBSERVER_H_
+#ifndef ATOM_BROWSER_BROWSER_OBSERVER_H_
+#define ATOM_BROWSER_BROWSER_OBSERVER_H_
 
 #include <string>
 
@@ -26,6 +26,10 @@ class BrowserObserver {
   // Browser is used to open a url.
   virtual void OnOpenURL(const std::string& url) {}
 
+  // The browser is activated with no open windows (usually by clicking on the
+  // dock icon).
+  virtual void OnActivateWithNoOpenWindows() {}
+
   // The browser has finished loading.
   virtual void OnWillFinishLaunching() {}
   virtual void OnFinishLaunching() {}
@@ -36,4 +40,4 @@ class BrowserObserver {
 
 }  // namespace atom
 
-#endif  // ATOM_BROSER_BROWSER_OBSERVER_H_
+#endif  // ATOM_BROWSER_BROWSER_OBSERVER_H_

atom/browser/browser_win.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/browser.h"
+#include "atom/browser/browser.h"
 
 #include <windows.h>
 
@@ -12,7 +12,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
-#include "common/atom_version.h"
+#include "atom/common/atom_version.h"
 
 namespace atom {
 
@@ -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

@@ -10,7 +10,7 @@ var menu = null;
 
 // Quit when all windows are closed.
 app.on('window-all-closed', function() {
-  app.terminate();
+  app.quit();
 });
 
 app.on('open-url', function(event, url) {
@@ -163,11 +163,11 @@ app.on('ready', function() {
         submenu: [
           {
             label: 'Open',
-            accelerator: 'Command+O',
+            accelerator: 'Ctrl+O',
           },
           {
             label: 'Close',
-            accelerator: 'Command+W',
+            accelerator: 'Ctrl+W',
             click: function() { mainWindow.close(); }
           },
         ]
@@ -177,16 +177,16 @@ app.on('ready', function() {
         submenu: [
           {
             label: 'Reload',
-            accelerator: 'Command+R',
+            accelerator: 'Ctrl+R',
             click: function() { mainWindow.restart(); }
           },
           {
             label: 'Enter Fullscreen',
-            click: function() { mainWindow.setFullscreen(true); }
+            click: function() { mainWindow.setFullScreen(true); }
           },
           {
             label: 'Toggle DevTools',
-            accelerator: 'Alt+Command+I',
+            accelerator: 'Alt+Ctrl+I',
             click: function() { mainWindow.toggleDevTools(); }
           },
         ]

atom/browser/devtools_delegate.cc

@@ -2,22 +2,29 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/devtools_delegate.h"
+#include "atom/browser/devtools_delegate.h"
 
+#include <string>
+
+#include "base/message_loop/message_loop.h"
 #include "base/values.h"
-#include "browser/native_window.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 "ui/gfx/point.h"
 
 namespace atom {
 
 DevToolsDelegate::DevToolsDelegate(NativeWindow* window,
                                    content::WebContents* target_web_contents)
     : content::WebContentsObserver(window->GetWebContents()),
-      owner_window_(window) {
+      owner_window_(window),
+      delegate_(NULL),
+      embedder_message_dispatcher_(
+          new DevToolsEmbedderMessageDispatcher(this)) {
   content::WebContents* web_contents = window->GetWebContents();
 
   // Setup devtools.
@@ -33,8 +40,9 @@ DevToolsDelegate::DevToolsDelegate(NativeWindow* window,
   base::DictionaryValue options;
   options.SetString("title", "DevTools Debugger");
   window->InitFromOptions(&options);
+  window->AddObserver(this);
   web_contents->GetController().LoadURL(
-      GURL("chrome-devtools://devtools/devtools.html"),
+      GURL("chrome-devtools://devtools/devtools.html?dockSide=undocked"),
       content::Referrer(),
       content::PAGE_TRANSITION_AUTO_TOPLEVEL,
       std::string());
@@ -44,10 +52,11 @@ DevToolsDelegate::~DevToolsDelegate() {
 }
 
 void DevToolsDelegate::DispatchOnEmbedder(const std::string& message) {
+  embedder_message_dispatcher_->Dispatch(message);
 }
 
 void DevToolsDelegate::InspectedContentsClosing() {
-  delete owner_window_;
+  owner_window_->Close();
 }
 
 void DevToolsDelegate::AboutToNavigateRenderView(
@@ -57,7 +66,59 @@ void DevToolsDelegate::AboutToNavigateRenderView(
 }
 
 void DevToolsDelegate::OnWindowClosed() {
-  delete owner_window_;
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, owner_window_);
+}
+
+void DevToolsDelegate::ActivateWindow() {
+}
+
+void DevToolsDelegate::CloseWindow() {
+  owner_window_->Close();
+}
+
+void DevToolsDelegate::MoveWindow(int x, int y) {
+  owner_window_->SetPosition(gfx::Point(x, y));
+}
+
+void DevToolsDelegate::SetDockSide(const std::string& dock_side) {
+  bool succeed = true;
+  if (delegate_ &&
+      delegate_->DevToolsSetDockSide("attach-back", &succeed) &&
+      succeed)
+    owner_window_->Close();
+}
+
+void DevToolsDelegate::OpenInNewTab(const std::string& url) {
+}
+
+void DevToolsDelegate::SaveToFile(
+    const std::string& url, const std::string& content, bool save_as) {
+}
+
+void DevToolsDelegate::AppendToFile(
+    const std::string& url, const std::string& content) {
+}
+
+void DevToolsDelegate::RequestFileSystems() {
+}
+
+void DevToolsDelegate::AddFileSystem() {
+}
+
+void DevToolsDelegate::RemoveFileSystem(const std::string& file_system_path) {
+}
+
+void DevToolsDelegate::IndexPath(
+    int request_id, const std::string& file_system_path) {
+}
+
+void DevToolsDelegate::StopIndexing(int request_id) {
+}
+
+void DevToolsDelegate::SearchInPath(
+    int request_id,
+    const std::string& file_system_path,
+    const std::string& query) {
 }
 
 }  // namespace atom

atom/browser/devtools_delegate.h

@@ -0,0 +1,87 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_DEVTOOLS_DELEGATE_H_
+#define ATOM_BROWSER_DEVTOOLS_DELEGATE_H_
+
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "atom/browser/native_window_observer.h"
+#include "content/public/browser/devtools_frontend_host_delegate.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "vendor/brightray/browser/devtools_embedder_message_dispatcher.h"
+#include "vendor/brightray/browser/inspectable_web_contents_delegate.h"
+
+namespace content {
+class DevToolsAgentHost;
+class DevToolsClientHost;
+}
+
+using brightray::DevToolsEmbedderMessageDispatcher;
+
+namespace atom {
+
+class NativeWindow;
+
+class DevToolsDelegate : public content::DevToolsFrontendHostDelegate,
+                         public content::WebContentsObserver,
+                         public NativeWindowObserver,
+                         public DevToolsEmbedderMessageDispatcher::Delegate {
+ public:
+  DevToolsDelegate(NativeWindow* window,
+                   content::WebContents* target_web_contents);
+  virtual ~DevToolsDelegate();
+
+  void SetDelegate(brightray::InspectableWebContentsDelegate* delegate) {
+    delegate_ = delegate;
+  }
+
+ protected:
+  // Implementations of content::DevToolsFrontendHostDelegate.
+  virtual void DispatchOnEmbedder(const std::string& message) OVERRIDE;
+  virtual void InspectedContentsClosing() OVERRIDE;
+
+  // Implementations of content::WebContentsObserver.
+  virtual void AboutToNavigateRenderView(
+      content::RenderViewHost* render_view_host) OVERRIDE;
+
+  // Implementations of NativeWindowObserver.
+  virtual void OnWindowClosed() OVERRIDE;
+
+  // Implementations of DevToolsEmbedderMessageDispatcher::Delegate.
+  virtual void ActivateWindow() OVERRIDE;
+  virtual void CloseWindow() OVERRIDE;
+  virtual void MoveWindow(int x, int y) OVERRIDE;
+  virtual void SetDockSide(const std::string& dock_side) OVERRIDE;
+  virtual void OpenInNewTab(const std::string& url) OVERRIDE;
+  virtual void SaveToFile(const std::string& url,
+                          const std::string& content,
+                          bool save_as) OVERRIDE;
+  virtual void AppendToFile(const std::string& url,
+                            const std::string& content) OVERRIDE;
+  virtual void RequestFileSystems() OVERRIDE;
+  virtual void AddFileSystem() OVERRIDE;
+  virtual void RemoveFileSystem(const std::string& file_system_path) OVERRIDE;
+  virtual void IndexPath(int request_id,
+                         const std::string& file_system_path) OVERRIDE;
+  virtual void StopIndexing(int request_id) OVERRIDE;
+  virtual void SearchInPath(int request_id,
+                            const std::string& file_system_path,
+                            const std::string& query) OVERRIDE;
+
+ private:
+  NativeWindow* owner_window_;
+  brightray::InspectableWebContentsDelegate* delegate_;
+
+  scoped_refptr<content::DevToolsAgentHost> devtools_agent_host_;
+  scoped_ptr<content::DevToolsClientHost> devtools_client_host_;
+  scoped_ptr<DevToolsEmbedderMessageDispatcher> embedder_message_dispatcher_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_DEVTOOLS_DELEGATE_H_

atom/browser/lib/init.coffee

@@ -4,7 +4,7 @@ util = require 'util'
 
 # Expose information of current process.
 process.__atom_type = 'browser'
-process.resourcesPath = path.resolve process.argv[1], '..', '..', '..'
+process.resourcesPath = path.resolve process.argv[1], '..', '..', '..', '..'
 
 # We modified the original process.argv to let node.js load the atom.js,
 # we need to restore it here.
@@ -18,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.push path.join process.resourcesPath, 'browser', 'api', 'lib'
+globalPaths.push path.join process.resourcesPath, 'atom', 'browser', 'api', 'lib'
 
 # Do loading in next tick since we still need some initialize work before
 # native bindings can work.
@@ -63,7 +63,7 @@ setImmediate ->
     packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
   catch error
     # If not found then we load browser/default_app
-    packagePath = path.join process.resourcesPath, 'browser', 'default_app'
+    packagePath = path.join process.resourcesPath, 'default_app'
     packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
 
   # Set application's version.

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,77 +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, 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
-    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
@@ -147,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.mm

@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#import "browser/atom_application_mac.h"
+#import "atom/browser/mac/atom_application.h"
 
 #include "base/auto_reset.h"
 #include "base/strings/sys_string_conversions.h"
-#include "browser/browser.h"
+#include "atom/browser/browser.h"
 
 @implementation AtomApplication
 

atom/browser/mac/atom_application_delegate.mm

@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#import "browser/atom_application_delegate_mac.h"
+#import "atom/browser/mac/atom_application_delegate.h"
 
+#import "atom/browser/mac/atom_application.h"
+#include "atom/browser/browser.h"
 #include "base/strings/sys_string_conversions.h"
-#import "browser/atom_application_mac.h"
-#include "browser/browser.h"
 
 @implementation AtomApplicationDelegate
 
@@ -31,7 +31,18 @@
   } else {
     // System started termination.
     atom::Browser::Get()->Quit();
-    return NSTerminateLater;
+    return NSTerminateCancel;
+  }
+}
+
+- (BOOL)applicationShouldHandleReopen:(NSApplication*)theApplication
+                    hasVisibleWindows:(BOOL)flag {
+  atom::Browser* browser = atom::Browser::Get();
+  if (flag) {
+    return YES;
+  } else {
+    browser->ActivateWithNoOpenWindows();
+    return NO;
   }
 }
 

atom/browser/native_window.cc

@@ -2,24 +2,29 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/native_window.h"
+#include "atom/browser/native_window.h"
 
 #include <string>
+#include <utility>
+#include <vector>
 
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_javascript_dialog_manager.h"
+#include "atom/browser/browser.h"
+#include "atom/browser/devtools_delegate.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/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/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "brightray/browser/inspectable_web_contents.h"
-#include "brightray/browser/inspectable_web_contents_view.h"
-#include "browser/api/atom_browser_bindings.h"
-#include "browser/atom_browser_context.h"
-#include "browser/atom_browser_main_parts.h"
-#include "browser/atom_javascript_dialog_manager.h"
-#include "browser/browser.h"
-#include "browser/devtools_delegate.h"
-#include "browser/window_list.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_entry.h"
@@ -29,17 +34,17 @@
 #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 "common/api/api_messages.h"
-#include "common/atom_version.h"
-#include "common/options_switches.h"
 #include "ipc/ipc_message_macros.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
-#include "vendor/brightray/browser/inspectable_web_contents_impl.h"
+#include "vendor/brightray/browser/inspectable_web_contents.h"
+#include "vendor/brightray/browser/inspectable_web_contents_view.h"
 #include "webkit/common/user_agent/user_agent_util.h"
+#include "webkit/common/webpreferences.h"
 
 using content::NavigationEntry;
 
@@ -50,13 +55,19 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
     : content::WebContentsObserver(web_contents),
       has_frame_(true),
       is_closed_(false),
-      node_integration_("all"),
+      node_integration_("except-iframe"),
       has_dialog_attached_(false),
       weak_factory_(this),
       inspectable_web_contents_(
           brightray::InspectableWebContents::Create(web_contents)) {
   options->GetBoolean(switches::kFrame, &has_frame_);
 
+#if defined(OS_MACOSX)
+  // Temporary fix for flashing devtools, try removing this after upgraded to
+  // Chrome 32.
+  web_contents->GetView()->SetAllowOverlappingViews(false);
+#endif
+
   // Read icon before window is created.
   std::string icon;
   if (options->GetString(switches::kIcon, &icon) && !SetIcon(icon))
@@ -66,6 +77,7 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
   options->GetString(switches::kNodeIntegration, &node_integration_);
 
   web_contents->SetDelegate(this);
+  inspectable_web_contents()->SetDelegate(this);
 
   WindowList::AddWindow(this);
 
@@ -84,6 +96,10 @@ 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();
@@ -95,6 +111,14 @@ NativeWindow* NativeWindow::Create(base::DictionaryValue* options) {
   return Create(content::WebContents::Create(create_params), options);
 }
 
+// static
+NativeWindow* NativeWindow::Debug(content::WebContents* web_contents) {
+  base::DictionaryValue options;
+  NativeWindow* window = NativeWindow::Create(&options);
+  window->devtools_delegate_.reset(new DevToolsDelegate(window, web_contents));
+  return window;
+}
+
 // static
 NativeWindow* NativeWindow::FromRenderView(int process_id, int routing_id) {
   // Stupid iterating.
@@ -166,15 +190,28 @@ bool NativeWindow::HasModalDialog() {
 }
 
 void NativeWindow::OpenDevTools() {
-  inspectable_web_contents()->ShowDevTools();
+  if (devtools_window_) {
+    devtools_window_->Focus(true);
+  } else {
+    inspectable_web_contents()->ShowDevTools();
+#if defined(OS_MACOSX)
+    // Temporary fix for flashing devtools, try removing this after upgraded to
+    // Chrome 32.
+    GetDevToolsWebContents()->GetView()->SetAllowOverlappingViews(false);
+#endif
+  }
 }
 
 void NativeWindow::CloseDevTools() {
-  inspectable_web_contents()->GetView()->CloseDevTools();
+  if (devtools_window_)
+    devtools_window_->Close();
+  else
+    inspectable_web_contents()->CloseDevTools();
 }
 
 bool NativeWindow::IsDevToolsOpened() {
-  return inspectable_web_contents()->IsDevToolsViewShowing();
+  return (devtools_window_ && devtools_window_->IsFocused()) ||
+         inspectable_web_contents()->IsDevToolsViewShowing();
 }
 
 void NativeWindow::InspectElement(int x, int y) {
@@ -185,16 +222,6 @@ void NativeWindow::InspectElement(int x, int y) {
   agent->InspectElement(x, y);
 }
 
-void NativeWindow::DebugDevTools() {
-  if (!IsDevToolsOpened())
-    return;
-
-  base::DictionaryValue options;
-  NativeWindow* window = NativeWindow::Create(&options);
-  window->devtools_delegate_.reset(new DevToolsDelegate(
-      window, GetDevToolsWebContents()));
-}
-
 void NativeWindow::FocusOnWebView() {
   GetWebContents()->GetRenderViewHost()->Focus();
 }
@@ -204,7 +231,9 @@ void NativeWindow::BlurWebView() {
 }
 
 bool NativeWindow::IsWebViewFocused() {
-  return GetWebContents()->GetRenderViewHost()->GetView()->HasFocus();
+  content::RenderWidgetHostView* host_view =
+      GetWebContents()->GetRenderViewHost()->GetView();
+  return host_view && host_view->HasFocus();
 }
 
 bool NativeWindow::SetIcon(const std::string& str_path) {
@@ -233,17 +262,40 @@ base::ProcessHandle NativeWindow::GetRenderProcessHandle() {
 
 void NativeWindow::CapturePage(const gfx::Rect& rect,
                                const CapturePageCallback& callback) {
+  content::RenderViewHost* render_view_host =
+      GetWebContents()->GetRenderViewHost();
+  content::RenderWidgetHostView* render_widget_host_view =
+      render_view_host->GetView();
+
+  if (!render_widget_host_view) {
+    callback.Run(std::vector<unsigned char>());
+    return;
+  }
+
   gfx::Rect flipped_y_rect = rect;
   flipped_y_rect.set_y(-rect.y());
 
+  gfx::Size size;
+  if (flipped_y_rect.IsEmpty())
+    size = render_widget_host_view->GetViewBounds().size();
+  else
+    size = flipped_y_rect.size();
+
   GetWebContents()->GetRenderViewHost()->CopyFromBackingStore(
       flipped_y_rect,
-      gfx::Size(),
+      size,
       base::Bind(&NativeWindow::OnCapturePageDone,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
+void NativeWindow::DestroyWebContents() {
+  if (!inspectable_web_contents_)
+    return;
+
+  inspectable_web_contents_.reset();
+}
+
 void NativeWindow::CloseWebContents() {
   bool prevent_default = false;
   FOR_EACH_OBSERVER(NativeWindowObserver,
@@ -257,20 +309,11 @@ void NativeWindow::CloseWebContents() {
   content::WebContents* web_contents(GetWebContents());
 
   // Assume the window is not responding if it doesn't cancel the close and is
-  // not closed in 500ms, in this way we can quickly show the unresponsive
+  // not closed in 10s, in this way we can quickly show the unresponsive
   // dialog when the window is busy executing some script withouth waiting for
   // the unresponsive timeout.
-  if (!Browser::Get()->is_quiting() &&
-      window_unresposive_closure_.IsCancelled()) {
-    window_unresposive_closure_.Reset(
-        base::Bind(&NativeWindow::RendererUnresponsive,
-                   weak_factory_.GetWeakPtr(),
-                   web_contents));
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        window_unresposive_closure_.callback(),
-        base::TimeDelta::FromMilliseconds(500));
-  }
+  if (window_unresposive_closure_.IsCancelled())
+    ScheduleUnresponsiveEvent(10000);
 
   if (web_contents->NeedToFireBeforeUnload())
     web_contents->GetRenderViewHost()->FirePageBeforeUnload(false);
@@ -283,24 +326,26 @@ content::WebContents* NativeWindow::GetWebContents() const {
 }
 
 content::WebContents* NativeWindow::GetDevToolsWebContents() const {
-  brightray::InspectableWebContentsImpl* inspectable_web_contents_impl =
-      static_cast<brightray::InspectableWebContentsImpl*>(
-          inspectable_web_contents());
-  return inspectable_web_contents_impl->devtools_web_contents();
+  return inspectable_web_contents()->devtools_web_contents();
+}
+
+void NativeWindow::AppendExtraCommandLineSwitches(CommandLine* command_line,
+                                                  int child_process_id) {
+  // Append --node-integration to renderer process.
+  command_line->AppendSwitchASCII(switches::kNodeIntegration,
+                                  node_integration_);
+}
+
+void NativeWindow::OverrideWebkitPrefs(const GURL& url, WebPreferences* prefs) {
+  // FIXME Disable accelerated composition in frameless window.
+  if (!has_frame_)
+    prefs->accelerated_compositing_enabled = false;
 }
 
 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());
 
@@ -372,13 +417,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());
@@ -386,6 +424,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
@@ -393,8 +434,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();
 }
@@ -405,12 +444,10 @@ bool NativeWindow::IsPopupOrPanel(const content::WebContents* source) const {
 }
 
 void NativeWindow::RendererUnresponsive(content::WebContents* source) {
-  window_unresposive_closure_.Cancel();
-
-  if (!HasModalDialog())
-    FOR_EACH_OBSERVER(NativeWindowObserver,
-                      observers_,
-                      OnRendererUnresponsive());
+  // 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.
+  ScheduleUnresponsiveEvent(50);
 }
 
 void NativeWindow::RendererResponsive(content::WebContents* source) {
@@ -418,16 +455,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.
@@ -436,9 +463,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)
@@ -467,6 +491,77 @@ 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) {
+  base::FilePath path;
+  PathsMap::iterator it = saved_files_.find(url);
+  if (it != saved_files_.end() && !save_as) {
+    path = it->second;
+  } else {
+    base::FilePath default_path(base::FilePath::FromUTF8Unsafe(url));
+    if (!file_dialog::ShowSaveDialog(this, url, default_path, &path))
+      return;
+  }
+
+  saved_files_[url] = path;
+  file_util::WriteFile(path, content.data(), content.size());
+
+  // Notify devtools.
+  base::StringValue url_value(url);
+  CallDevToolsFunction("InspectorFrontendAPI.savedURL", &url_value);
+
+  // TODO(zcbenz): In later Chrome we need to call canceledSaveURL when the save
+  // failed.
+}
+
+void NativeWindow::DevToolsAppendToFile(const std::string& url,
+                                        const std::string& content) {
+  PathsMap::iterator it = saved_files_.find(url);
+  if (it == saved_files_.end())
+    return;
+  file_util::AppendToFile(it->second, content.data(), content.size());
+
+  // Notify devtools.
+  base::StringValue url_value(url);
+  CallDevToolsFunction("InspectorFrontendAPI.appendedToURL", &url_value);
+}
+
+void NativeWindow::ScheduleUnresponsiveEvent(int ms) {
+  window_unresposive_closure_.Reset(
+      base::Bind(&NativeWindow::NotifyWindowUnresponsive,
+                 weak_factory_.GetWeakPtr()));
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      window_unresposive_closure_.callback(),
+      base::TimeDelta::FromMilliseconds(ms));
+}
+
+void NativeWindow::NotifyWindowUnresponsive() {
+  window_unresposive_closure_.Cancel();
+
+  if (!HasModalDialog())
+    FOR_EACH_OBSERVER(NativeWindowObserver,
+                      observers_,
+                      OnRendererUnresponsive());
+}
+
 void NativeWindow::OnCapturePageDone(const CapturePageCallback& callback,
                                      bool succeed,
                                      const SkBitmap& bitmap) {
@@ -476,25 +571,26 @@ void NativeWindow::OnCapturePageDone(const CapturePageCallback& callback,
   callback.Run(data);
 }
 
-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,
-      this,
-      reply_msg);
+void NativeWindow::CallDevToolsFunction(const std::string& function_name,
+                                        const base::Value* arg1,
+                                        const base::Value* arg2,
+                                        const base::Value* arg3) {
+  std::string params;
+  if (arg1) {
+    std::string json;
+    base::JSONWriter::Write(arg1, &json);
+    params.append(json);
+    if (arg2) {
+      base::JSONWriter::Write(arg2, &json);
+      params.append(", " + json);
+      if (arg3) {
+        base::JSONWriter::Write(arg3, &json);
+        params.append(", " + json);
+      }
+    }
+  }
+  GetDevToolsWebContents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
+      string16(), base::UTF8ToUTF16(function_name + "(" + params + ");"));
 }
 
 }  // namespace atom

atom/browser/native_window.h

@@ -5,28 +5,32 @@
 #ifndef ATOM_BROWSER_NATIVE_WINDOW_H_
 #define ATOM_BROWSER_NATIVE_WINDOW_H_
 
+#include <map>
+#include <string>
+#include <vector>
+
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
-#include "browser/native_window_observer.h"
+#include "atom/browser/native_window_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_observer.h"
-#include "content/public/browser/web_contents_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"
+
+class CommandLine;
+struct WebPreferences;
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
-namespace brightray {
-class InspectableWebContents;
-}
-
 namespace content {
 class BrowserContext;
 class WebContents;
@@ -38,10 +42,6 @@ class Rect;
 class Size;
 }
 
-namespace IPC {
-class Message;
-}
-
 namespace atom {
 
 class AtomJavaScriptDialogManager;
@@ -49,6 +49,7 @@ class DevToolsDelegate;
 struct DraggableRegion;
 
 class NativeWindow : public brightray::DefaultWebContentsDelegate,
+                     public brightray::InspectableWebContentsDelegate,
                      public content::WebContentsObserver,
                      public content::NotificationObserver {
  public:
@@ -76,13 +77,19 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
 
   virtual ~NativeWindow();
 
-  // Create window with existing WebContents.
+  // 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);
 
-  // Create window with new WebContents.
+  // Create window with new WebContents, the caller is responsible for
+  // managing the window's live.
   static NativeWindow* Create(base::DictionaryValue* options);
 
+  // Creates a devtools window to debug the WebContents, the returned window
+  // will manage its own life.
+  static NativeWindow* Debug(content::WebContents* web_contents);
+
   // Find a window from its process id and routing id.
   static NativeWindow* FromRenderView(int process_id, int routing_id);
 
@@ -129,9 +136,6 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   virtual bool IsDevToolsOpened();
   virtual void InspectElement(int x, int y);
 
-  // Creates a new window to debug the devtools.
-  virtual void DebugDevTools();
-
   virtual void FocusOnWebView();
   virtual void BlurWebView();
   virtual bool IsWebViewFocused();
@@ -152,9 +156,26 @@ 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();
+  }
+
   content::WebContents* GetWebContents() const;
   content::WebContents* GetDevToolsWebContents() const;
 
+  // Called when renderer process is going to be started.
+  void AppendExtraCommandLineSwitches(CommandLine* command_line,
+                                      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 AddObserver(NativeWindowObserver* obs) {
     observers_.AddObserver(obs);
   }
@@ -164,7 +185,6 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   }
 
   bool has_frame() const { return has_frame_; }
-  std::string node_integration() const { return node_integration_; }
 
   void set_has_dialog_attached(bool has_dialog_attached) {
     has_dialog_attached_ = has_dialog_attached;
@@ -174,13 +194,11 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   explicit NativeWindow(content::WebContents* web_contents,
                         base::DictionaryValue* options);
 
-  brightray::InspectableWebContents* inspectable_web_contents() const {
-    return inspectable_web_contents_.get();
+  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;
@@ -200,7 +218,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;
@@ -210,8 +227,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;
 
@@ -220,6 +235,16 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
                        const content::NotificationSource& source,
                        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;
+  virtual void DevToolsAppendToFile(const std::string& url,
+                                    const std::string& content) OVERRIDE;
+
   // Whether window has standard frame.
   bool has_frame_;
 
@@ -227,18 +252,23 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   gfx::Image icon_;
 
  private:
+  // Schedule a notification unresponsive event.
+  void ScheduleUnresponsiveEvent(int ms);
+
+  // Dispatch unresponsive event to observers.
+  void NotifyWindowUnresponsive();
+
+  // Call a function in devtools.
+  void CallDevToolsFunction(const std::string& function_name,
+                            const base::Value* arg1 = NULL,
+                            const base::Value* arg2 = NULL,
+                            const base::Value* arg3 = NULL);
+
   // Called when CapturePage has done.
   void OnCapturePageDone(const CapturePageCallback& callback,
                          bool succeed,
                          const SkBitmap& bitmap);
 
-  void OnRendererMessage(const string16& channel,
-                         const base::ListValue& args);
-
-  void OnRendererMessageSync(const string16& channel,
-                             const base::ListValue& args,
-                             IPC::Message* reply_msg);
-
   // Notification manager.
   content::NotificationRegistrar registrar_;
 
@@ -260,10 +290,20 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
 
   base::WeakPtrFactory<NativeWindow> weak_factory_;
 
+  base::WeakPtr<NativeWindow> devtools_window_;
   scoped_ptr<DevToolsDelegate> devtools_delegate_;
+
   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.
+  typedef std::map<std::string, base::FilePath> PathsMap;
+  PathsMap saved_files_;
+
   DISALLOW_COPY_AND_ASSIGN(NativeWindow);
 };
 

atom/browser/native_window_gtk.cc

@@ -2,15 +2,24 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/native_window_gtk.h"
+#include "atom/browser/native_window_gtk.h"
 
+#include <string>
+#include <vector>
+
+#include "atom/common/draggable_region.h"
+#include "atom/common/options_switches.h"
+#include "base/environment.h"
+#include "base/nix/xdg_util.h"
 #include "base/values.h"
-#include "browser/ui/gtk/gtk_window_util.h"
-#include "common/draggable_region.h"
-#include "common/options_switches.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 "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/gtk_util.h"
 #include "ui/gfx/rect.h"
@@ -25,25 +34,66 @@ namespace {
 // This matches the logic in the WebKit GTK port.
 const double kGtkCursorBlinkCycleFactor = 2000.0;
 
+// Substract window border's size from window size according to current window
+// manager.
+void SubstractBorderSize(int* width, int* height) {
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  base::nix::DesktopEnvironment de(base::nix::GetDesktopEnvironment(env.get()));
+  if (de == base::nix::DESKTOP_ENVIRONMENT_UNITY) {
+    *width -= 2;
+    *height -= 29;
+  } else if (de == base::nix::DESKTOP_ENVIRONMENT_GNOME) {
+    *width -= 2;
+    *height -= 33;
+  } else if (de == base::nix::DESKTOP_ENVIRONMENT_XFCE) {
+    *width -= 6;
+    *height -= 27;
+  } else {
+    *width -= 2;
+    *height -= 29;
+  }
+}
+
 }  // namespace
 
 NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
                                  base::DictionaryValue* options)
     : NativeWindow(web_contents, options),
       window_(GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL))),
+      vbox_(gtk_vbox_new(FALSE, 0)),
       state_(GDK_WINDOW_STATE_WITHDRAWN),
-      is_always_on_top_(false) {
-  gtk_container_add(GTK_CONTAINER(window_),
+      is_always_on_top_(false),
+      is_active_(false),
+      suppress_window_raise_(false),
+      has_ever_been_shown_(false),
+      frame_cursor_(NULL) {
+  gtk_container_add(GTK_CONTAINER(window_), vbox_);
+  gtk_container_add(GTK_CONTAINER(vbox_),
                     GetWebContents()->GetView()->GetNativeView());
 
   int width = 800, height = 600;
   options->GetInteger(switches::kWidth, &width);
   options->GetInteger(switches::kHeight, &height);
-  gtk_window_set_default_size(window_, width, height);
+
+  // Fixup the initial window size.
+  if (has_frame_)
+    SubstractBorderSize(&width, &height);
+
+  // Force a size allocation so the web page of hidden window can have correct
+  // value of $(window).width().
+  GtkAllocation size = { 0, 0, width, height };
+  gtk_widget_show_all(vbox_);
+  gtk_widget_size_allocate(GTK_WIDGET(window_), &size);
+  gtk_window_util::SetWindowSize(window_, gfx::Size(width, height));
+
+  // Create the underlying gdk window.
+  gtk_widget_realize(GTK_WIDGET(window_));
 
   if (!icon_.IsEmpty())
     gtk_window_set_icon(window_, icon_.ToGdkPixbuf());
 
+  ui::ActiveWindowWatcherX::AddObserver(this);
+
   // In some (older) versions of compiz, raising top-level windows when they
   // are partially off-screen causes them to get snapped back on screen, not
   // always even on the current virtual desktop.  If we are running under
@@ -55,6 +105,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_, "window-state-event",
+                   G_CALLBACK(OnWindowStateThunk), this);
 
   if (!has_frame_) {
     gtk_window_set_decorated(window_, false);
@@ -69,8 +121,7 @@ NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
 }
 
 NativeWindowGtk::~NativeWindowGtk() {
-  if (window_)
-    gtk_widget_destroy(GTK_WIDGET(window_));
+  CloseImmediately();
 }
 
 void NativeWindowGtk::Close() {
@@ -78,13 +129,19 @@ void NativeWindowGtk::Close() {
 }
 
 void NativeWindowGtk::CloseImmediately() {
+  if (window_ == NULL)
+    return;
+
+  NotifyWindowClosed();
+  ui::ActiveWindowWatcherX::RemoveObserver(this);
+
   gtk_widget_destroy(GTK_WIDGET(window_));
   window_ = NULL;
 }
 
 void NativeWindowGtk::Move(const gfx::Rect& pos) {
   gtk_window_move(window_, pos.x(), pos.y());
-  gtk_window_resize(window_, pos.width(), pos.height());
+  SetSize(pos.size());
 }
 
 void NativeWindowGtk::Focus(bool focus) {
@@ -98,10 +155,15 @@ void NativeWindowGtk::Focus(bool focus) {
 }
 
 bool NativeWindowGtk::IsFocused() {
+  if (ui::ActiveWindowWatcherX::WMSupportsActivation())
+    return is_active_;
+
+  // This still works even though we don't get the activation notification.
   return gtk_window_is_active(window_);
 }
 
 void NativeWindowGtk::Show() {
+  has_ever_been_shown_ = true;
   gtk_widget_show_all(GTK_WIDGET(window_));
 }
 
@@ -141,7 +203,13 @@ bool NativeWindowGtk::IsFullscreen() {
 }
 
 void NativeWindowGtk::SetSize(const gfx::Size& size) {
-  gtk_window_resize(window_, size.width(), size.height());
+  // When the window has not been mapped the window size does not include frame.
+  int width = size.width();
+  int height = size.height();
+  if (has_frame_ && !has_ever_been_shown_)
+    SubstractBorderSize(&width, &height);
+
+  gtk_window_util::SetWindowSize(window_, gfx::Size(width, height));
 }
 
 gfx::Size NativeWindowGtk::GetSize() {
@@ -245,22 +313,24 @@ bool NativeWindowGtk::IsKiosk() {
   return IsFullscreen();
 }
 
-bool NativeWindowGtk::HasModalDialog() {
-  // FIXME(zcbenz): Implement me.
-  return false;
-}
-
 gfx::NativeWindow NativeWindowGtk::GetNativeWindow() {
   return window_;
 }
 
+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);
+  RegisterAccelerators();
+}
+
 void NativeWindowGtk::UpdateDraggableRegions(
     const std::vector<DraggableRegion>& regions) {
   // Draggable region is not supported for non-frameless window.
   if (has_frame_)
     return;
 
-  SkRegion draggable_region;
+  draggable_region_.reset(new SkRegion);
 
   // By default, the whole window is non-draggable. We need to explicitly
   // include those draggable regions.
@@ -268,15 +338,36 @@ void NativeWindowGtk::UpdateDraggableRegions(
            regions.begin();
        iter != regions.end(); ++iter) {
     const DraggableRegion& region = *iter;
-    draggable_region.op(
+    draggable_region_->op(
         region.bounds.x(),
         region.bounds.y(),
         region.bounds.right(),
         region.bounds.bottom(),
         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
+}
 
-  draggable_region_ = draggable_region;
+void NativeWindowGtk::HandleKeyboardEvent(
+    content::WebContents*,
+    const content::NativeWebKeyboardEvent& event) {
+  if (event.type == WebKit::WebInputEvent::RawKeyDown) {
+    GdkEventKey* os_event = reinterpret_cast<GdkEventKey*>(event.os_event);
+    ui::Accelerator accelerator = ui::AcceleratorForGdkKeyCodeAndModifier(
+        os_event->keyval, static_cast<GdkModifierType>(os_event->state));
+    accelerator_util::TriggerAcceleratorTableCommand(&accelerator_table_,
+                                                     accelerator);
+  }
+}
+
+void NativeWindowGtk::ActiveWindowChanged(GdkWindow* active_window) {
+  is_active_ = gtk_widget_get_window(GTK_WIDGET(window_)) == active_window;
+}
+
+void NativeWindowGtk::RegisterAccelerators() {
+  DCHECK(menu_);
+  accelerator_table_.clear();
+  accelerator_util::GenerateAcceleratorTable(&accelerator_table_,
+                                             menu_->model());
 }
 
 void NativeWindowGtk::SetWebKitColorStyle() {
@@ -341,18 +432,22 @@ gboolean NativeWindowGtk::OnWindowState(GtkWidget* window,
 
 gboolean NativeWindowGtk::OnMouseMoveEvent(GtkWidget* widget,
                                            GdkEventMotion* event) {
+  if (has_frame_) {
+    // Reset the cursor.
+    if (frame_cursor_) {
+      frame_cursor_ = NULL;
+      gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)), NULL);
+    }
+    return FALSE;
+  }
+
   if (!IsResizable())
     return FALSE;
 
-  int win_x, win_y;
-  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
-  gdk_window_get_origin(gdk_window, &win_x, &win_y);
-  gfx::Point point(static_cast<int>(event->x_root - win_x),
-                   static_cast<int>(event->y_root - win_y));
-
   // Update the cursor if we're on the custom frame border.
   GdkWindowEdge edge;
-  bool has_hit_edge = GetWindowEdge(point.x(), point.y(), &edge);
+  bool has_hit_edge = GetWindowEdge(static_cast<int>(event->x),
+                                    static_cast<int>(event->y), &edge);
   GdkCursorType new_cursor = GDK_LAST_CURSOR;
   if (has_hit_edge)
     new_cursor = gtk_window_util::GdkWindowEdgeToGdkCursorType(edge);
@@ -371,18 +466,19 @@ gboolean NativeWindowGtk::OnMouseMoveEvent(GtkWidget* widget,
 
 gboolean NativeWindowGtk::OnButtonPress(GtkWidget* widget,
                                         GdkEventButton* event) {
+  DCHECK(!has_frame_);
   // Make the button press coordinate relative to the browser window.
   int win_x, win_y;
   GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
   gdk_window_get_origin(gdk_window, &win_x, &win_y);
 
-  bool resizable = IsResizable();
   GdkWindowEdge edge;
   gfx::Point point(static_cast<int>(event->x_root - win_x),
                    static_cast<int>(event->y_root - win_y));
-  bool has_hit_edge = resizable && GetWindowEdge(point.x(), point.y(), &edge);
-  bool has_hit_titlebar = !draggable_region_.isEmpty() &&
-      draggable_region_.contains(event->x, event->y);
+  bool has_hit_edge = IsResizable() &&
+                      GetWindowEdge(point.x(), point.y(), &edge);
+  bool has_hit_titlebar =
+      draggable_region_ && draggable_region_->contains(event->x, event->y);
 
   if (event->button == 1) {
     if (GDK_BUTTON_PRESS == event->type) {
@@ -399,11 +495,15 @@ gboolean NativeWindowGtk::OnButtonPress(GtkWidget* widget,
                                      event->time);
         return TRUE;
       } else if (has_hit_titlebar) {
+        GdkRectangle window_bounds = {0};
+        gdk_window_get_frame_extents(gdk_window, &window_bounds);
+        gfx::Rect bounds(window_bounds.x, window_bounds.y,
+                         window_bounds.width, window_bounds.height);
         return gtk_window_util::HandleTitleBarLeftMousePress(
-            window_, gfx::Rect(GetPosition(), GetSize()), event);
+            window_, bounds, event);
       }
     } else if (GDK_2BUTTON_PRESS == event->type) {
-      if (has_hit_titlebar && resizable) {
+      if (has_hit_titlebar && IsResizable()) {
         // Maximize/restore on double click.
         if (IsMaximized())
           gtk_window_unmaximize(window_);
@@ -417,6 +517,7 @@ gboolean NativeWindowGtk::OnButtonPress(GtkWidget* widget,
       gdk_window_lower(gdk_window);
     return TRUE;
   }
+
   return FALSE;
 }
 

atom/browser/native_window_gtk.h

@@ -7,14 +7,23 @@
 
 #include <gtk/gtk.h>
 
-#include "browser/native_window.h"
+#include <string>
+#include <vector>
+
+#include "atom/browser/native_window.h"
+#include "atom/browser/ui/accelerator_util.h"
+#include "chrome/browser/ui/gtk/menu_gtk.h"
 #include "third_party/skia/include/core/SkRegion.h"
+#include "ui/base/accelerators/accelerator.h"
 #include "ui/base/gtk/gtk_signal.h"
+#include "ui/base/x/active_window_watcher_x_observer.h"
 #include "ui/gfx/size.h"
 
 namespace atom {
 
-class NativeWindowGtk : public NativeWindow {
+class NativeWindowGtk : public NativeWindow,
+                        public MenuGtk::Delegate,
+                        public ui::ActiveWindowWatcherXObserver {
  public:
   explicit NativeWindowGtk(content::WebContents* web_contents,
                            base::DictionaryValue* options);
@@ -53,14 +62,27 @@ class NativeWindowGtk : public NativeWindow {
   virtual void FlashFrame(bool flash) OVERRIDE;
   virtual void SetKiosk(bool kiosk) OVERRIDE;
   virtual bool IsKiosk() OVERRIDE;
-  virtual bool HasModalDialog() OVERRIDE;
   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE;
 
+  // Set the native window menu.
+  void SetMenu(ui::MenuModel* menu_model);
+
  protected:
   virtual void UpdateDraggableRegions(
       const std::vector<DraggableRegion>& regions) OVERRIDE;
 
+  // Overridden from content::WebContentsDelegate:
+  virtual void HandleKeyboardEvent(
+      content::WebContents*,
+      const content::NativeWebKeyboardEvent&) OVERRIDE;
+
+  // Overridden from ActiveWindowWatcherXObserver.
+  virtual void ActiveWindowChanged(GdkWindow* active_window) OVERRIDE;
+
  private:
+  // Register accelerators supported by the menu model.
+  void RegisterAccelerators();
+
   // Set WebKit's style from current theme.
   void SetWebKitColorStyle();
 
@@ -77,30 +99,49 @@ class NativeWindowGtk : public NativeWindow {
   CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnFocusOut, GdkEventFocus*);
   CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnWindowState,
                        GdkEventWindowState*);
+
+  // Mouse move and mouse button press callbacks.
   CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnMouseMoveEvent,
                        GdkEventMotion*);
   CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnButtonPress,
                        GdkEventButton*);
 
   GtkWindow* window_;
+  GtkWidget* vbox_;
 
   GdkWindowState state_;
   bool is_always_on_top_;
   gfx::Size minimum_size_;
   gfx::Size maximum_size_;
 
-  // The region is treated as title bar, can be dragged to move
-  // and double clicked to maximize.
-  SkRegion draggable_region_;
+  // The region is treated as title bar, can be dragged to move and double
+  // clicked to maximize.
+  scoped_ptr<SkRegion> draggable_region_;
+
+  // True if the window manager thinks the window is active. It could happpen
+  // that the WM thinks a window is active but it's actually not, like when
+  // showing a context menu.
+  bool is_active_;
 
   // If true, don't call gdk_window_raise() when we get a click in the title
   // bar or window border.  This is to work around a compiz bug.
   bool suppress_window_raise_;
 
+  // True if the window has been visible for once, on Linux the window frame
+  // would // only be considered as part of the window untill the window has
+  // been shown, so we need it to correctly set the window size.
+  bool has_ever_been_shown_;
+
   // The current window cursor.  We set it to a resize cursor when over the
   // custom frame border.  We set it to NULL if we want the default cursor.
   GdkCursor* frame_cursor_;
 
+  // The window menu.
+  scoped_ptr<MenuGtk> menu_;
+
+  // Map from accelerator to menu item's command id.
+  accelerator_util::AcceleratorTable accelerator_table_;
+
   DISALLOW_COPY_AND_ASSIGN(NativeWindowGtk);
 };
 

atom/browser/native_window_mac.h

@@ -7,8 +7,9 @@
 
 #import <Cocoa/Cocoa.h>
 
+#include "base/mac/scoped_nsobject.h"
 #include "base/memory/scoped_ptr.h"
-#include "browser/native_window.h"
+#include "atom/browser/native_window.h"
 
 class SkRegion;
 
@@ -56,8 +57,6 @@ class NativeWindowMac : public NativeWindow {
   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 +67,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,7 +85,7 @@ class NativeWindowMac : public NativeWindow {
   void UpdateDraggableRegionsForCustomDrag(
       const std::vector<DraggableRegion>& regions);
 
-  NSWindow* window_;
+  base::scoped_nsobject<NSWindow> window_;
 
   bool is_kiosk_;
 

atom/browser/native_window_mac.mm

@@ -2,23 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/native_window_mac.h"
+#include "atom/browser/native_window_mac.h"
 
 #include <string>
 
-// FIXME: The foundation_util.h is aborting our compilation, do not
-// include it.
-#define BASE_MAC_FOUNDATION_UTIL_H_
-
 #include "base/mac/mac_util.h"
-#include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/values.h"
-#import "browser/ui/cocoa/event_processing_window.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 "common/draggable_region.h"
-#include "common/options_switches.h"
+#include "atom/common/draggable_region.h"
+#include "atom/common/options_switches.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
@@ -33,18 +28,26 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
 @interface AtomNSWindowDelegate : NSObject<NSWindowDelegate> {
  @private
   atom::NativeWindowMac* shell_;
+  BOOL acceptsFirstMouse_;
 }
 - (id)initWithShell:(atom::NativeWindowMac*)shell;
+- (void)setAcceptsFirstMouse:(BOOL)accept;
 @end
 
 @implementation AtomNSWindowDelegate
 
 - (id)initWithShell:(atom::NativeWindowMac*)shell {
-  if ((self = [super init]))
+  if ((self = [super init])) {
     shell_ = shell;
+    acceptsFirstMouse_ = NO;
+  }
   return self;
 }
 
+- (void)setAcceptsFirstMouse:(BOOL)accept {
+  acceptsFirstMouse_ = accept;
+}
+
 - (void)windowDidResignMain:(NSNotification*)notification {
   shell_->NotifyWindowBlur();
 }
@@ -54,8 +57,15 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
     shell_->ClipWebView();
 }
 
+- (void)windowDidExitFullScreen:(NSNotification*)notification {
+  if (!shell_->has_frame()) {
+    NSWindow* window = shell_->GetNativeWindow();
+    [[window standardWindowButton:NSWindowFullScreenButton] setHidden:YES];
+  }
+}
+
 - (void)windowWillClose:(NSNotification*)notification {
-  shell_->window() = nil;
+  shell_->NotifyWindowClosed();
   [self autorelease];
 }
 
@@ -67,11 +77,8 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
   return NO;
 }
 
-- (void)windowDidExitFullScreen:(NSNotification*)notification {
-  if (!shell_->has_frame()) {
-    NSWindow* window = shell_->GetNativeWindow();
-    [[window standardWindowButton:NSWindowFullScreenButton] setHidden:YES];
-  }
+- (BOOL)acceptsFirstMouse:(NSEvent*)event {
+  return acceptsFirstMouse_;
 }
 
 @end
@@ -81,7 +88,6 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
   atom::NativeWindowMac* shell_;
 }
 - (void)setShell:(atom::NativeWindowMac*)shell;
-- (IBAction)showDevTools:(id)sender;
 @end
 
 @implementation AtomNSWindow
@@ -164,17 +170,27 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
                     defer:YES];
 
   [atomWindow setShell:this];
-  window_ = atomWindow;
+  window_.reset(atomWindow);
 
-  [window() setDelegate:[[AtomNSWindowDelegate alloc] initWithShell:this]];
+  AtomNSWindowDelegate* delegate =
+      [[AtomNSWindowDelegate alloc] initWithShell:this];
+  [window_ setDelegate:delegate];
+
+  // We will manage window's lifetime ourselves.
+  [window_ setReleasedWhenClosed:NO];
+
+  // Enable the NSView to accept first mouse event.
+  bool acceptsFirstMouse = false;
+  options->GetBoolean(switches::kAcceptFirstMouse, &acceptsFirstMouse);
+  [delegate setAcceptsFirstMouse:acceptsFirstMouse];
 
   // Disable fullscreen button when 'fullscreen' is specified to false.
   bool fullscreen;
   if (!(options->GetBoolean(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();
@@ -184,17 +200,17 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
 }
 
 NativeWindowMac::~NativeWindowMac() {
-  if (window())
-    [window() release];
+  // 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) {
@@ -206,7 +222,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) {
@@ -215,42 +231,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) {
@@ -262,11 +278,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) {
@@ -275,7 +291,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() {
@@ -285,54 +301,54 @@ gfx::Size NativeWindowMac::GetSize() {
 
 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) {
@@ -348,11 +364,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) {
@@ -389,11 +405,11 @@ bool NativeWindowMac::IsKiosk() {
 }
 
 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 {
@@ -409,15 +425,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)];
   }
@@ -441,7 +457,7 @@ void NativeWindowMac::HandleKeyboardEvent(
     return;
 
   EventProcessingWindow* event_window =
-      static_cast<EventProcessingWindow*>(window());
+      static_cast<EventProcessingWindow*>(window_);
   DCHECK([event_window isKindOfClass:[EventProcessingWindow class]]);
   [event_window redispatchKeyEvent:event.os_event];
 }
@@ -449,19 +465,19 @@ void NativeWindowMac::HandleKeyboardEvent(
 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];
   }
 }
 

atom/browser/native_window_observer.h

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

atom/browser/native_window_win.cc

@@ -2,16 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/native_window_win.h"
+#include "atom/browser/native_window_win.h"
 
-#include "base/stl_util.h"
+#include <string>
+#include <vector>
+
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/ui/win/menu_2.h"
+#include "atom/browser/ui/win/native_menu_win.h"
+#include "atom/common/draggable_region.h"
+#include "atom/common/options_switches.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "browser/api/atom_api_menu.h"
-#include "browser/ui/win/menu_2.h"
-#include "browser/ui/win/native_menu_win.h"
-#include "common/draggable_region.h"
-#include "common/options_switches.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
@@ -431,17 +433,12 @@ void NativeWindowWin::ViewHierarchyChanged(
 
 bool NativeWindowWin::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
-  if (ContainsKey(accelerator_table_, accelerator)) {
-    const MenuItem& item = accelerator_table_[accelerator];
-    item.model->ActivatedAt(item.position);
-    return true;
-  } else {
-    return false;
-  }
+  return accelerator_util::TriggerAcceleratorTableCommand(
+      &accelerator_table_, accelerator);
 }
 
 void NativeWindowWin::DeleteDelegate() {
-  // Do nothing, window is managed by users.
+  NotifyWindowClosed();
 }
 
 views::View* NativeWindowWin::GetInitiallyFocusedView() {
@@ -530,39 +527,17 @@ void NativeWindowWin::RegisterAccelerators() {
   accelerator_table_.clear();
   focus_manager->UnregisterAccelerators(this);
 
-  GenerateAcceleratorTable();
-  for (AcceleratorTable::const_iterator iter = accelerator_table_.begin();
-       iter != accelerator_table_.end(); ++iter) {
+  accelerator_util::GenerateAcceleratorTable(&accelerator_table_,
+                                             menu_->model());
+  accelerator_util::AcceleratorTable::const_iterator iter;
+  for (iter = accelerator_table_.begin();
+       iter != accelerator_table_.end();
+       ++iter) {
     focus_manager->RegisterAccelerator(
         iter->first, ui::AcceleratorManager::kNormalPriority, this);
   }
 }
 
-void NativeWindowWin::GenerateAcceleratorTable() {
-  DCHECK(menu_);
-  ui::SimpleMenuModel* model = static_cast<ui::SimpleMenuModel*>(
-      menu_->model());
-  FillAcceleratorTable(&accelerator_table_, model);
-}
-
-void NativeWindowWin::FillAcceleratorTable(AcceleratorTable* table,
-                                           ui::MenuModel* model) {
-  int count = model->GetItemCount();
-  for (int i = 0; i < count; ++i) {
-    ui::MenuModel::ItemType type = model->GetTypeAt(i);
-    if (type == ui::MenuModel::TYPE_SUBMENU) {
-      ui::MenuModel* submodel = model->GetSubmenuModelAt(i);
-      FillAcceleratorTable(table, submodel);
-    } else {
-      ui::Accelerator accelerator;
-      if (model->GetAcceleratorAt(i, &accelerator)) {
-        MenuItem item = { i, model };
-        (*table)[accelerator] = item;
-      }
-    }
-  }
-}
-
 // static
 NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
                                    base::DictionaryValue* options) {

atom/browser/native_window_win.h

@@ -5,9 +5,14 @@
 #ifndef ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
 #define ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
 
+#include <map>
+#include <string>
+#include <vector>
+
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
-#include "browser/native_window.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/ui/accelerator_util.h"
 #include "ui/gfx/size.h"
 #include "ui/views/widget/widget_delegate.h"
 
@@ -113,13 +118,6 @@ class NativeWindowWin : public NativeWindow,
   // Register accelerators supported by the menu model.
   void RegisterAccelerators();
 
-  // Generate a table that contains memu model's accelerators and command ids.
-  void GenerateAcceleratorTable();
-
-  // Helper to fill the accelerator table from the model.
-  void FillAcceleratorTable(AcceleratorTable* table,
-                            ui::MenuModel* model);
-
   scoped_ptr<views::Widget> window_;
   views::WebView* web_view_;  // managed by window_.
 
@@ -127,7 +125,7 @@ class NativeWindowWin : public NativeWindow,
   scoped_ptr<atom::Menu2> menu_;
 
   // Map from accelerator to menu item's command id.
-  AcceleratorTable accelerator_table_;
+  accelerator_util::AcceleratorTable accelerator_table_;
 
   scoped_ptr<SkRegion> draggable_region_;
 

atom/browser/net/adapter_request_job.cc

@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/net/adapter_request_job.h"
+#include "atom/browser/net/adapter_request_job.h"
 
 #include "base/threading/sequenced_worker_pool.h"
-#include "browser/net/url_request_string_job.h"
+#include "atom/browser/net/url_request_string_job.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_error_job.h"

atom/browser/net/adapter_request_job.h

@@ -5,6 +5,8 @@
 #ifndef ATOM_BROWSER_NET_ADAPTER_REQUEST_JOB_H_
 #define ATOM_BROWSER_NET_ADAPTER_REQUEST_JOB_H_
 
+#include <string>
+
 #include "base/memory/weak_ptr.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"

atom/browser/net/atom_url_request_context_getter.cc

@@ -2,12 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/net/atom_url_request_context_getter.h"
+#include "atom/browser/net/atom_url_request_context_getter.h"
 
+#include <algorithm>
+
+#include "atom/browser/net/atom_url_request_job_factory.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
-#include "browser/net/atom_url_request_job_factory.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "content/public/common/url_constants.h"

atom/browser/net/atom_url_request_job_factory.cc

@@ -3,7 +3,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/net/atom_url_request_job_factory.h"
+#include "atom/browser/net/atom_url_request_job_factory.h"
 
 #include "base/stl_util.h"
 #include "net/base/load_flags.h"

atom/browser/net/atom_url_request_job_factory.h

@@ -3,10 +3,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROWSER_NET_ATOM_URL_REQUEST_URL_REQUEST_JOB_FACTORY_H_
-#define ATOM_BROWSER_NET_ATOM_URL_REQUEST_URL_REQUEST_JOB_FACTORY_H_
+#ifndef ATOM_BROWSER_NET_ATOM_URL_REQUEST_JOB_FACTORY_H_
+#define ATOM_BROWSER_NET_ATOM_URL_REQUEST_JOB_FACTORY_H_
 
 #include <map>
+#include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ -59,4 +60,4 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
 
 }  // namespace atom
 
-#endif  // ATOM_BROWSER_NET_ATOM_URL_REQUEST_URL_REQUEST_JOB_FACTORY_H_
+#endif  // ATOM_BROWSER_NET_ATOM_URL_REQUEST_JOB_FACTORY_H_

atom/browser/net/url_request_string_job.cc

@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "browser/net/url_request_string_job.h"
+#include "atom/browser/net/url_request_string_job.h"
+
+#include <string>
 
 #include "net/base/net_errors.h"
 

atom/browser/net/url_request_string_job.h

@@ -7,6 +7,8 @@
 
 #include "net/url_request/url_request_simple_job.h"
 
+#include <string>
+
 namespace atom {
 
 class URLRequestStringJob : public net::URLRequestSimpleJob {

atom/browser/resources/mac/Info.plist

@@ -11,10 +11,12 @@
   <key>CFBundleIconFile</key>
   <string>atom.icns</string>
   <key>CFBundleVersion</key>
-  <string>0.10.3</string>
+  <string>0.12.1</string>
 	<key>NSMainNibFile</key>
 	<string>MainMenu</string>
 	<key>NSPrincipalClass</key>
 	<string>AtomApplication</string>
+  <key>NSSupportsAutomaticGraphicsSwitching</key>
+  <true/>
 </dict>
 </plist>