Bump v0.18.1.

Fixes #709 and atom/atom#3854.

.travis.yml

@@ -1,4 +1,8 @@
-language: objective-c
+language: cpp
+compiler: clang
+os:
+  - linux
+  - osx
 
 notifications:
   email:
@@ -6,3 +10,6 @@ notifications:
     on_failure: change
 
 script: './script/cibuild'
+
+git:
+  depth: 10

appveyor.yml

@@ -0,0 +1,28 @@
+# appveyor file
+# http://www.appveyor.com/docs/appveyor-yml
+version: "{build}"
+
+init:
+  - git config --global core.autocrlf input
+
+environment:
+  matrix:
+    - nodejs_version: 0.10
+
+platform:
+  - x86
+
+install:
+  - ps: Install-Product node $env:nodejs_version
+  - cmd: SET PATH=C:\Program Files (x86)\MSBuild\12.0\bin\;%PATH%
+  - cmd: SET PATH=C:\python27;%PATH%
+  - cmd: python script/bootstrap.py
+  - cmd: python script/build.py -c Debug
+
+test_script:
+  - node --version
+  - npm --version
+  - cmd: python script/cpplint.py
+  - cmd: python script/coffeelint.py
+
+build: off

atom.gyp

@@ -18,13 +18,17 @@
       '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/content-tracing.coffee',
       'atom/browser/api/lib/dialog.coffee',
+      'atom/browser/api/lib/global-shortcut.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/tray.coffee',
       'atom/browser/api/lib/web-contents.coffee',
+      'atom/browser/lib/chrome-extension.coffee',
       'atom/browser/lib/init.coffee',
       'atom/browser/lib/objects-registry.coffee',
       'atom/browser/lib/rpc-server.coffee',
@@ -35,13 +39,18 @@
       'atom/common/api/lib/screen.coffee',
       'atom/common/api/lib/shell.coffee',
       'atom/common/lib/init.coffee',
+      'atom/common/lib/asar.coffee',
+      'atom/renderer/lib/chrome-api.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',
+      'atom/renderer/api/lib/web-view.coffee',
     ],
     'lib_sources': [
+      'atom/app/atom_content_client.cc',
+      'atom/app/atom_content_client.h',
       'atom/app/atom_main_delegate.cc',
       'atom/app/atom_main_delegate.h',
       'atom/app/atom_main_delegate_mac.mm',
@@ -49,19 +58,22 @@
       '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_content_tracing.cc',
       'atom/browser/api/atom_api_dialog.cc',
+      'atom/browser/api/atom_api_global_shortcut.cc',
+      'atom/browser/api/atom_api_global_shortcut.h',
       '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_views.cc',
+      'atom/browser/api/atom_api_menu_views.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_tray.cc',
+      'atom/browser/api/atom_api_tray.h',
       'atom/browser/api/atom_api_web_contents.cc',
       'atom/browser/api/atom_api_web_contents.h',
       'atom/browser/api/atom_api_window.cc',
@@ -76,6 +88,8 @@
       'atom/browser/auto_updater_linux.cc',
       'atom/browser/auto_updater_mac.mm',
       'atom/browser/auto_updater_win.cc',
+      'atom/browser/atom_access_token_store.cc',
+      'atom/browser/atom_access_token_store.h',
       'atom/browser/atom_browser_client.cc',
       'atom/browser/atom_browser_client.h',
       'atom/browser/atom_browser_context.cc',
@@ -85,40 +99,45 @@
       'atom/browser/atom_browser_main_parts_mac.mm',
       'atom/browser/atom_javascript_dialog_manager.cc',
       'atom/browser/atom_javascript_dialog_manager.h',
+      'atom/browser/atom_resource_dispatcher_host_delegate.cc',
+      'atom/browser/atom_resource_dispatcher_host_delegate.h',
+      'atom/browser/atom_speech_recognition_manager_delegate.cc',
+      'atom/browser/atom_speech_recognition_manager_delegate.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/javascript_environment.cc',
+      'atom/browser/javascript_environment.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_views.cc',
+      'atom/browser/native_window_views.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/asar/asar_protocol_handler.cc',
+      'atom/browser/net/asar/asar_protocol_handler.h',
+      'atom/browser/net/asar/url_request_asar_job.cc',
+      'atom/browser/net/asar/url_request_asar_job.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/node_debugger.cc',
+      'atom/browser/node_debugger.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/accelerator_util_views.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',
@@ -128,18 +147,41 @@
       '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/ui/message_box_views.cc',
+      'atom/browser/ui/tray_icon.cc',
+      'atom/browser/ui/tray_icon.h',
+      'atom/browser/ui/tray_icon_gtk.cc',
+      'atom/browser/ui/tray_icon_gtk.h',
+      'atom/browser/ui/tray_icon_cocoa.h',
+      'atom/browser/ui/tray_icon_cocoa.mm',
+      'atom/browser/ui/tray_icon_observer.h',
+      'atom/browser/ui/tray_icon_win.cc',
+      'atom/browser/ui/views/frameless_view.cc',
+      'atom/browser/ui/views/frameless_view.h',
+      'atom/browser/ui/views/global_menu_bar_x11.cc',
+      'atom/browser/ui/views/global_menu_bar_x11.h',
+      'atom/browser/ui/views/menu_bar.cc',
+      'atom/browser/ui/views/menu_bar.h',
+      'atom/browser/ui/views/menu_delegate.cc',
+      'atom/browser/ui/views/menu_delegate.h',
+      'atom/browser/ui/views/menu_layout.cc',
+      'atom/browser/ui/views/menu_layout.h',
+      'atom/browser/ui/views/submenu_button.cc',
+      'atom/browser/ui/views/submenu_button.h',
+      'atom/browser/ui/views/win_frame_view.cc',
+      'atom/browser/ui/views/win_frame_view.h',
+      'atom/browser/ui/win/notify_icon_host.cc',
+      'atom/browser/ui/win/notify_icon_host.h',
+      'atom/browser/ui/win/notify_icon.cc',
+      'atom/browser/ui/win/notify_icon.h',
+      'atom/browser/ui/x/x_window_utils.cc',
+      'atom/browser/ui/x/x_window_utils.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_asar.cc',
       'atom/common/api/atom_api_clipboard.cc',
       'atom/common/api/atom_api_crash_reporter.cc',
       'atom/common/api/atom_api_id_weak_map.cc',
@@ -150,12 +192,14 @@
       '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/asar/archive.cc',
+      'atom/common/asar/archive.h',
+      'atom/common/asar/scoped_temporary_file.cc',
+      'atom/common/asar/scoped_temporary_file.h',
+      'atom/common/common_message_generator.cc',
+      'atom/common/common_message_generator.h',
       'atom/common/crash_reporter/crash_reporter.cc',
       'atom/common/crash_reporter/crash_reporter.h',
       'atom/common/crash_reporter/crash_reporter_linux.cc',
@@ -172,10 +216,14 @@
       'atom/common/crash_reporter/win/crash_service_main.h',
       'atom/common/draggable_region.cc',
       'atom/common/draggable_region.h',
+      'atom/common/google_api_key.h',
       'atom/common/linux/application_info.cc',
+      'atom/common/native_mate_converters/accelerator_converter.cc',
+      'atom/common/native_mate_converters/accelerator_converter.h',
       'atom/common/native_mate_converters/file_path_converter.h',
-      'atom/common/native_mate_converters/function_converter.h',
       'atom/common/native_mate_converters/gurl_converter.h',
+      'atom/common/native_mate_converters/image_converter.cc',
+      'atom/common/native_mate_converters/image_converter.h',
       'atom/common/native_mate_converters/string16_converter.h',
       'atom/common/native_mate_converters/v8_value_converter.cc',
       'atom/common/native_mate_converters/v8_value_converter.h',
@@ -199,28 +247,87 @@
       'atom/renderer/api/atom_api_renderer_ipc.cc',
       'atom/renderer/api/atom_renderer_bindings.cc',
       'atom/renderer/api/atom_renderer_bindings.h',
+      'atom/renderer/api/atom_api_web_view.cc',
+      'atom/renderer/api/atom_api_web_view.h',
       'atom/renderer/atom_render_view_observer.cc',
       'atom/renderer/atom_render_view_observer.h',
       'atom/renderer/atom_renderer_client.cc',
       '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',
+      'chromium_src/chrome/browser/browser_process.cc',
+      'chromium_src/chrome/browser/browser_process.h',
+      'chromium_src/chrome/browser/chrome_notification_types.h',
+      'chromium_src/chrome/browser/extensions/global_shortcut_listener.cc',
+      'chromium_src/chrome/browser/extensions/global_shortcut_listener.h',
+      'chromium_src/chrome/browser/extensions/global_shortcut_listener_mac.mm',
+      'chromium_src/chrome/browser/extensions/global_shortcut_listener_mac.h',
+      'chromium_src/chrome/browser/extensions/global_shortcut_listener_x11.cc',
+      'chromium_src/chrome/browser/extensions/global_shortcut_listener_x11.h',
+      'chromium_src/chrome/browser/extensions/global_shortcut_listener_win.cc',
+      'chromium_src/chrome/browser/extensions/global_shortcut_listener_win.h',
+      'chromium_src/chrome/browser/printing/print_job.cc',
+      'chromium_src/chrome/browser/printing/print_job.h',
+      'chromium_src/chrome/browser/printing/print_job_manager.cc',
+      'chromium_src/chrome/browser/printing/print_job_manager.h',
+      'chromium_src/chrome/browser/printing/print_job_worker.cc',
+      'chromium_src/chrome/browser/printing/print_job_worker.h',
+      'chromium_src/chrome/browser/printing/print_job_worker_owner.h',
+      'chromium_src/chrome/browser/printing/print_view_manager_base.cc',
+      'chromium_src/chrome/browser/printing/print_view_manager_base.h',
+      'chromium_src/chrome/browser/printing/print_view_manager_basic.cc',
+      'chromium_src/chrome/browser/printing/print_view_manager_basic.h',
+      'chromium_src/chrome/browser/printing/print_view_manager_observer.h',
+      'chromium_src/chrome/browser/printing/printer_query.cc',
+      'chromium_src/chrome/browser/printing/printer_query.h',
+      'chromium_src/chrome/browser/printing/printing_message_filter.cc',
+      'chromium_src/chrome/browser/printing/printing_message_filter.h',
+      'chromium_src/chrome/browser/printing/printing_ui_web_contents_observer.cc',
+      'chromium_src/chrome/browser/printing/printing_ui_web_contents_observer.h',
+      'chromium_src/chrome/browser/speech/tts_controller.h',
+      'chromium_src/chrome/browser/speech/tts_controller_impl.cc',
+      'chromium_src/chrome/browser/speech/tts_controller_impl.h',
+      'chromium_src/chrome/browser/speech/tts_linux.cc',
+      'chromium_src/chrome/browser/speech/tts_mac.mm',
+      'chromium_src/chrome/browser/speech/tts_message_filter.cc',
+      'chromium_src/chrome/browser/speech/tts_message_filter.h',
+      'chromium_src/chrome/browser/speech/tts_platform.cc',
+      'chromium_src/chrome/browser/speech/tts_platform.h',
+      'chromium_src/chrome/browser/speech/tts_win.cc',
+      'chromium_src/chrome/browser/ui/libgtk2ui/app_indicator_icon_menu.cc',
+      'chromium_src/chrome/browser/ui/libgtk2ui/app_indicator_icon_menu.h',
+      'chromium_src/chrome/browser/ui/libgtk2ui/gtk2_status_icon.cc',
+      'chromium_src/chrome/browser/ui/libgtk2ui/gtk2_status_icon.h',
+      'chromium_src/chrome/browser/ui/views/frame/global_menu_bar_registrar_x11.cc',
+      'chromium_src/chrome/browser/ui/views/frame/global_menu_bar_registrar_x11.h',
+      'chromium_src/chrome/browser/ui/views/status_icons/status_tray_state_changer_win.cc',
+      'chromium_src/chrome/browser/ui/views/status_icons/status_tray_state_changer_win.h',
+      'chromium_src/chrome/common/print_messages.cc',
+      'chromium_src/chrome/common/print_messages.h',
+      'chromium_src/chrome/common/tts_messages.h',
+      'chromium_src/chrome/common/tts_utterance_request.cc',
+      'chromium_src/chrome/common/tts_utterance_request.h',
+      'chromium_src/chrome/renderer/printing/print_web_view_helper.cc',
+      'chromium_src/chrome/renderer/printing/print_web_view_helper_linux.cc',
+      'chromium_src/chrome/renderer/printing/print_web_view_helper_mac.mm',
+      'chromium_src/chrome/renderer/printing/print_web_view_helper_win.cc',
+      'chromium_src/chrome/renderer/printing/print_web_view_helper.h',
+      'chromium_src/chrome/renderer/tts_dispatcher.cc',
+      'chromium_src/chrome/renderer/tts_dispatcher.h',
+      'chromium_src/library_loaders/libspeechd_loader.cc',
       '<@(native_mate_files)',
     ],
     'framework_sources': [
       'atom/app/atom_library_main.cc',
       'atom/app/atom_library_main.h',
     ],
+    'locales': [
+      'am', 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en-GB',
+      'en-US', 'es-419', 'es', 'et', 'fa', 'fi', 'fil', 'fr', 'gu', 'he',
+      'hi', 'hr', 'hu', 'id', 'it', 'ja', 'kn', 'ko', 'lt', 'lv',
+      'ml', 'mr', 'ms', 'nb', 'nl', 'pl', 'pt-BR', 'pt-PT', 'ro', 'ru',
+      'sk', 'sl', 'sr', 'sv', 'sw', 'ta', 'te', 'th', 'tr', 'uk',
+      'vi', 'zh-CN', 'zh-TW',
+    ],
+    'atom_source_root': '<!(python tools/atom_source_root.py)',
     'conditions': [
       ['OS=="win"', {
         'app_sources': [
@@ -230,8 +337,10 @@
           '<(libchromiumcontent_src_dir)/content/app/startup_helper_win.cc',
         ],
       }],  # OS=="win"
+      ['OS=="mac"', {
+        'apply_locales_cmd': ['python', 'tools/mac/apply_locales.py'],
+      }],  # OS=="mac"
     ],
-    'atom_source_root': '<!(python tools/atom_source_root.py)',
   },
   'target_defaults': {
     'mac_framework_dirs': [
@@ -317,8 +426,27 @@
                 '<(product_name)',
               ],
             },
+              # The application doesn't have real localizations, it just has
+              # empty .lproj directories, which is enough to convince Cocoa
+              # atom-shell supports those languages.
+            {
+              'postbuild_name': 'Make Empty Localizations',
+              'variables': {
+                'locale_dirs': [
+                  '>!@(<(apply_locales_cmd) -d ZZLOCALE.lproj <(locales))',
+                ],
+              },
+              'action': [
+                'tools/mac/make_locale_dirs.sh',
+                '<@(locale_dirs)',
+              ],
+            },
           ]
-        }],  # OS=="mac"
+        }, {  # OS=="mac"
+          'dependencies': [
+            'make_locale_paks',
+          ],
+        }],  # OS!="mac"
         ['OS=="win"', {
           'copies': [
             {
@@ -326,11 +454,16 @@
               'files': [
                 '<(libchromiumcontent_library_dir)/chromiumcontent.dll',
                 '<(libchromiumcontent_library_dir)/ffmpegsumo.dll',
-                '<(libchromiumcontent_library_dir)/icudt.dll',
                 '<(libchromiumcontent_library_dir)/libEGL.dll',
                 '<(libchromiumcontent_library_dir)/libGLESv2.dll',
+                '<(libchromiumcontent_resources_dir)/icudtl.dat',
                 '<(libchromiumcontent_resources_dir)/content_shell.pak',
+                '<(libchromiumcontent_resources_dir)/ui_resources_200_percent.pak',
+                '<(libchromiumcontent_resources_dir)/webkit_resources_200_percent.pak',
                 'external_binaries/d3dcompiler_43.dll',
+                'external_binaries/msvcp120.dll',
+                'external_binaries/msvcr120.dll',
+                'external_binaries/vccorlib120.dll',
                 'external_binaries/xinput1_3.dll',
               ],
             },
@@ -349,6 +482,7 @@
               'files': [
                 '<(libchromiumcontent_library_dir)/libchromiumcontent.so',
                 '<(libchromiumcontent_library_dir)/libffmpegsumo.so',
+                '<(libchromiumcontent_resources_dir)/icudtl.dat',
                 '<(libchromiumcontent_resources_dir)/content_shell.pak',
               ],
             },
@@ -369,11 +503,16 @@
         'vendor/brightray/brightray.gyp:brightray',
         'vendor/node/node.gyp:node_lib',
       ],
+      'defines': [
+        # This is defined in skia/skia_common.gypi.
+        'SK_SUPPORT_LEGACY_GETTOPDEVICE',
+      ],
       'sources': [
         '<@(lib_sources)',
       ],
       'include_dirs': [
         '.',
+        'chromium_src',
         'vendor/brightray',
         'vendor/native_mate',
         # Include directories for uv and node.
@@ -401,7 +540,6 @@
               '-loleacc.lib',
               '-lComdlg32.lib',
               '-lWininet.lib',
-              '<(atom_source_root)/<(libchromiumcontent_library_dir)/chromiumviews.lib',
             ],
           },
           'dependencies': [
@@ -430,6 +568,7 @@
             'vendor/breakpad/src',
           ],
           'cflags': [
+            '-Wno-deprecated-register',
             '-Wno-empty-body',
           ],
           'dependencies': [
@@ -570,12 +709,45 @@
                 # Gyp action requires a output file, add a fake one here.
                 '<(PRODUCT_DIR)/dummy_file',
               ],
-              'action': [ 'strip', '<@(_inputs)' ],
+              'action': [
+                'tools/posix/strip.sh',
+                '<@(_inputs)',
+              ],
             },
           ],
         }],  # OS=="linux"
       ],
     },  # target <(project_name>_dump_symbols
+    {
+      'target_name': 'copy_chromedriver',
+      'type': 'none',
+      'actions': [
+        {
+          'action_name': 'Copy ChromeDriver Binary',
+          'variables': {
+            'conditions': [
+              ['OS=="win"', {
+                'chromedriver_binary': 'chromedriver.exe',
+              },{
+                'chromedriver_binary': 'chromedriver',
+              }],
+            ],
+          },
+          'inputs': [
+            '<(libchromiumcontent_library_dir)/<(chromedriver_binary)',
+          ],
+          'outputs': [
+            '<(PRODUCT_DIR)/<(chromedriver_binary)',
+          ],
+          'action': [
+            'python',
+            'tools/copy_binary.py',
+            '<@(_inputs)',
+            '<@(_outputs)',
+          ],
+        }
+      ],
+    },  # copy_chromedriver
   ],
   'conditions': [
     ['OS=="mac"', {
@@ -601,6 +773,7 @@
           'link_settings': {
             'libraries': [
               '$(SDKROOT)/System/Library/Frameworks/Carbon.framework',
+              '$(SDKROOT)/System/Library/Frameworks/QuartzCore.framework',
               'external_binaries/Squirrel.framework',
               'external_binaries/ReactiveCocoa.framework',
               'external_binaries/Mantle.framework',
@@ -610,6 +783,7 @@
           'mac_bundle_resources': [
             'atom/common/resources/mac/MainMenu.xib',
             '<(libchromiumcontent_resources_dir)/content_shell.pak',
+            '<(libchromiumcontent_resources_dir)/icudtl.dat',
           ],
           'xcode_settings': {
             'INFOPLIST_FILE': 'atom/common/resources/mac/Info.plist',
@@ -674,7 +848,31 @@
           },
         },  # target helper
       ],
-    }],  # OS==Mac
+    }, {  # OS=="mac"
+      'targets': [
+        {
+          'target_name': 'make_locale_paks',
+          'type': 'none',
+          'actions': [
+            {
+              'action_name': 'Make Empty Paks',
+              'inputs': [
+                'tools/posix/make_locale_paks.sh',
+              ],
+              'outputs': [
+                '<(PRODUCT_DIR)/locales'
+              ],
+              'action': [
+                'tools/posix/make_locale_paks.sh',
+                '<(PRODUCT_DIR)',
+                '<@(locales)',
+              ],
+              'msvs_cygwin_shell': 0,
+            },
+          ],
+        },
+      ],
+    }],  # OS!="mac"
     ['OS=="win"', {
       'targets': [
         {
@@ -707,5 +905,31 @@
         },  # target generate_node_lib
       ],
     }],  # OS==win
+    # Using Visual Studio Express.
+    ['msvs_express==1', {
+      'target_defaults': {
+        'defines!': [
+          '_SECURE_ATL',
+        ],
+        'msvs_settings': {
+          'VCLibrarianTool': {
+            'AdditionalLibraryDirectories': [
+              '<(atom_source_root)/external_binaries/atl/lib',
+            ],
+          },
+          'VCLinkerTool': {
+            'AdditionalLibraryDirectories': [
+              '<(atom_source_root)/external_binaries/atl/lib',
+            ],
+            'AdditionalDependencies': [
+              'atls.lib',
+            ],
+          },
+        },
+        'msvs_system_include_dirs': [
+          '<(atom_source_root)/external_binaries/atl/include',
+        ],
+      },
+    }],  # msvs_express==1
   ],
 }

atom/app/atom_content_client.cc

@@ -0,0 +1,30 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/app/atom_content_client.h"
+
+#include <string>
+#include <vector>
+
+#include "atom/common/chrome_version.h"
+
+namespace atom {
+
+AtomContentClient::AtomContentClient() {
+}
+
+AtomContentClient::~AtomContentClient() {
+}
+
+std::string AtomContentClient::GetProduct() const {
+  return "Chrome/" CHROME_VERSION_STRING;
+}
+
+void AtomContentClient::AddAdditionalSchemes(
+    std::vector<std::string>* standard_schemes,
+    std::vector<std::string>* savable_schemes) {
+  standard_schemes->push_back("chrome-extension");
+}
+
+}  // namespace atom

atom/app/atom_content_client.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_ATOM_CONTENT_CLIENT_H_
+#define ATOM_APP_ATOM_CONTENT_CLIENT_H_
+
+#include <string>
+#include <vector>
+
+#include "brightray/common/content_client.h"
+
+namespace atom {
+
+class AtomContentClient : public brightray::ContentClient {
+ public:
+  AtomContentClient();
+  virtual ~AtomContentClient();
+
+ protected:
+  // content::ContentClient:
+  virtual std::string GetProduct() const OVERRIDE;
+  virtual void AddAdditionalSchemes(
+      std::vector<std::string>* standard_schemes,
+      std::vector<std::string>* savable_schemes) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomContentClient);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_APP_ATOM_CONTENT_CLIENT_H_

atom/app/atom_library_main.cc

@@ -10,6 +10,9 @@
 #if defined(OS_MACOSX)
 int AtomMain(int argc, const char* argv[]) {
   atom::AtomMainDelegate delegate;
-  return content::ContentMain(argc, argv, &delegate);
+  content::ContentMainParams params(&delegate);
+  params.argc = argc;
+  params.argv = argv;
+  return content::ContentMain(params);
 }
 #endif  // OS_MACOSX

atom/app/atom_main.cc

@@ -16,10 +16,11 @@
 #include <shellapi.h>
 
 #include "atom/app/atom_main_delegate.h"
-#include "base/environment.h"
 #include "atom/common/crash_reporter/win/crash_service_main.h"
+#include "base/environment.h"
 #include "content/public/app/startup_helper_win.h"
 #include "sandbox/win/src/sandbox_types.h"
+#include "ui/gfx/win/dpi.h"
 #elif defined(OS_LINUX)  // defined(OS_WIN)
 #include "atom/app/atom_main_delegate.h"  // NOLINT
 #include "content/public/app/content_main.h"
@@ -98,7 +99,14 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   sandbox::SandboxInterfaceInfo sandbox_info = {0};
   content::InitializeSandboxInfo(&sandbox_info);
   atom::AtomMainDelegate delegate;
-  return content::ContentMain(instance, &sandbox_info, &delegate);
+
+  // Now chrome relies on a regkey to enable high dpi support.
+  gfx::EnableHighDPISupport();
+
+  content::ContentMainParams params(&delegate);
+  params.instance = instance;
+  params.sandbox_info = &sandbox_info;
+  return content::ContentMain(params);
 }
 
 #elif defined(OS_LINUX)  // defined(OS_WIN)
@@ -109,7 +117,10 @@ int main(int argc, const char* argv[]) {
     return node::Start(argc, const_cast<char**>(argv));
 
   atom::AtomMainDelegate delegate;
-  return content::ContentMain(argc, argv, &delegate);
+  content::ContentMainParams params(&delegate);
+  params.argc = argc;
+  params.argv = argv;
+  return content::ContentMain(params);
 }
 
 #else  // defined(OS_LINUX)

atom/app/atom_main_delegate.cc

@@ -6,14 +6,16 @@
 
 #include <string>
 
+#include "atom/app/atom_content_client.h"
+#include "atom/browser/atom_browser_client.h"
+#include "atom/common/google_api_key.h"
+#include "atom/renderer/atom_renderer_client.h"
 #include "base/command_line.h"
 #include "base/debug/stack_trace.h"
+#include "base/environment.h"
 #include "base/logging.h"
-#include "atom/browser/atom_browser_client.h"
 #include "content/public/common/content_switches.h"
-#include "atom/renderer/atom_renderer_client.h"
 #include "ui/base/resource/resource_bundle.h"
-#include "base/path_service.h"
 
 namespace atom {
 
@@ -35,8 +37,6 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 #else
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 #endif
-  settings.dcheck_state =
-      logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
   logging::InitLogging(settings);
 #endif  // defined(OS_WIN)
 
@@ -52,11 +52,12 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
 }
 
 void AtomMainDelegate::PreSandboxStartup() {
-#if defined(OS_MACOSX)
-  OverrideChildProcessPath();
-  OverrideFrameworkBundlePath();
-#endif
-  InitializeResourceBundle();
+  brightray::MainDelegate::PreSandboxStartup();
+
+  // Set google API key.
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  if (!env->HasVar("GOOGLE_API_KEY"))
+    env->SetVar("GOOGLE_API_KEY", GOOGLEAPIS_API_KEY);
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   std::string process_type = command_line->GetSwitchValueASCII(
@@ -69,24 +70,23 @@ void AtomMainDelegate::PreSandboxStartup() {
   // Add a flag to mark the start of switches added by atom-shell.
   command_line->AppendSwitch("atom-shell-switches-start");
 
+#if defined(OS_WIN)
+  // Disable the LegacyRenderWidgetHostHWND, it made frameless windows unable
+  // to move and resize. We may consider enabling it again after upgraded to
+  // Chrome 38, which should have fixed the problem.
+  command_line->AppendSwitch(switches::kDisableLegacyIntermediateWindow);
+#endif
+
   // Disable renderer sandbox for most of node's functions.
   command_line->AppendSwitch(switches::kNoSandbox);
 
-  // Add a flag to mark the end of switches added by atom-shell.
-  command_line->AppendSwitch("atom-shell-switches-end");
-}
-
-void AtomMainDelegate::InitializeResourceBundle() {
-  base::FilePath path;
 #if defined(OS_MACOSX)
-  path = GetResourcesPakFilePath();
-#else
-  base::FilePath pak_dir;
-  PathService::Get(base::DIR_MODULE, &pak_dir);
-  path = pak_dir.Append(FILE_PATH_LITERAL("content_shell.pak"));
+  // Enable AVFoundation.
+  command_line->AppendSwitch("enable-avfoundation");
 #endif
 
-  ui::ResourceBundle::InitSharedInstanceWithPakPath(path);
+  // Add a flag to mark the end of switches added by atom-shell.
+  command_line->AppendSwitch("atom-shell-switches-end");
 }
 
 content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
@@ -100,4 +100,20 @@ content::ContentRendererClient*
   return renderer_client_.get();
 }
 
+scoped_ptr<brightray::ContentClient> AtomMainDelegate::CreateContentClient() {
+  return scoped_ptr<brightray::ContentClient>(new AtomContentClient).Pass();
+}
+
+void AtomMainDelegate::AddDataPackFromPath(
+    ui::ResourceBundle* bundle, const base::FilePath& pak_dir) {
+#if defined(OS_WIN)
+  bundle->AddDataPackFromPath(
+      pak_dir.Append(FILE_PATH_LITERAL("ui_resources_200_percent.pak")),
+      ui::SCALE_FACTOR_200P);
+  bundle->AddDataPackFromPath(
+      pak_dir.Append(FILE_PATH_LITERAL("webkit_resources_200_percent.pak")),
+      ui::SCALE_FACTOR_200P);
+#endif
+}
+
 }  // namespace atom

atom/app/atom_main_delegate.h

@@ -6,6 +6,7 @@
 #define ATOM_APP_ATOM_MAIN_DELEGATE_H_
 
 #include "brightray/common/main_delegate.h"
+#include "brightray/common/content_client.h"
 
 namespace atom {
 
@@ -15,21 +16,24 @@ class AtomMainDelegate : public brightray::MainDelegate {
   ~AtomMainDelegate();
 
  protected:
+  // content::ContentMainDelegate:
   virtual bool BasicStartupComplete(int* exit_code) OVERRIDE;
   virtual void PreSandboxStartup() OVERRIDE;
-  virtual void InitializeResourceBundle();
-
-#if defined(OS_MACOSX)
-  virtual base::FilePath GetResourcesPakFilePath();
-  virtual void OverrideChildProcessPath();
-  virtual void OverrideFrameworkBundlePath();
-#endif
-
- private:
   virtual content::ContentBrowserClient* CreateContentBrowserClient() OVERRIDE;
   virtual content::ContentRendererClient*
       CreateContentRendererClient() OVERRIDE;
 
+  // brightray::MainDelegate:
+  virtual scoped_ptr<brightray::ContentClient> CreateContentClient() OVERRIDE;
+  virtual void AddDataPackFromPath(
+      ui::ResourceBundle* bundle, const base::FilePath& pak_dir) OVERRIDE;
+#if defined(OS_MACOSX)
+  virtual void OverrideChildProcessPath() OVERRIDE;
+  virtual void OverrideFrameworkBundlePath() OVERRIDE;
+#endif
+
+ private:
+  brightray::ContentClient content_client_;
   scoped_ptr<content::ContentBrowserClient> browser_client_;
   scoped_ptr<content::ContentRendererClient> renderer_client_;
 

atom/app/atom_main_delegate_mac.mm

@@ -4,16 +4,11 @@
 
 #include "atom/app/atom_main_delegate.h"
 
-#import "base/mac/bundle_locations.h"
-#import "base/mac/foundation_util.h"
-#import "base/mac/mac_util.h"
-#include "base/command_line.h"
+#include "base/mac/bundle_locations.h"
+#include "base/files/file_path.h"
 #include "base/path_service.h"
-#include "base/strings/sys_string_conversions.h"
+#include "brightray/common/mac/main_application_bundle.h"
 #include "content/public/common/content_paths.h"
-#include "content/public/common/content_switches.h"
-#include "vendor/brightray/common/application_info.h"
-#include "vendor/brightray/common/mac/main_application_bundle.h"
 
 namespace atom {
 
@@ -26,12 +21,6 @@ base::FilePath GetFrameworksPath() {
 
 }  // namespace
 
-base::FilePath AtomMainDelegate::GetResourcesPakFilePath() {
-  NSString* path = [base::mac::FrameworkBundle()
-      pathForResource:@"content_shell" ofType:@"pak"];
-  return base::mac::NSStringToFilePath(path);
-}
-
 void AtomMainDelegate::OverrideFrameworkBundlePath() {
   base::mac::SetOverrideFrameworkBundlePath(
       GetFrameworksPath().Append("Atom Framework.framework"));

atom/browser/api/atom_api_app.cc

@@ -5,21 +5,77 @@
 #include "atom/browser/api/atom_api_app.h"
 
 #include <string>
+#include <vector>
 
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
 #include "base/values.h"
 #include "base/command_line.h"
-#include "atom/browser/browser.h"
+#include "base/environment.h"
+#include "base/files/file_path.h"
+#include "base/path_service.h"
+#include "native_mate/callback.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
+#include "net/base/load_flags.h"
+#include "net/proxy/proxy_service.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
 
 #include "atom/common/node_includes.h"
 
+#if defined(OS_LINUX)
+#include "base/nix/xdg_util.h"
+#endif
+
 using atom::Browser;
 
 namespace atom {
 
 namespace api {
 
+namespace {
+
+class ResolveProxyHelper {
+ public:
+  ResolveProxyHelper(const GURL& url, App::ResolveProxyCallback callback)
+      : callback_(callback) {
+    net::ProxyService* proxy_service = AtomBrowserContext::Get()->
+        url_request_context_getter()->GetURLRequestContext()->proxy_service();
+
+    // Start the request.
+    int result = proxy_service->ResolveProxy(
+        url, net::LOAD_NORMAL, &proxy_info_,
+        base::Bind(&ResolveProxyHelper::OnResolveProxyCompleted,
+                   base::Unretained(this)),
+        &pac_req_, nullptr, net::BoundNetLog());
+
+    // Completed synchronously.
+    if (result != net::ERR_IO_PENDING)
+      OnResolveProxyCompleted(result);
+  }
+
+  void OnResolveProxyCompleted(int result) {
+    std::string proxy;
+    if (result == net::OK)
+      proxy = proxy_info_.ToPacString();
+    callback_.Run(proxy);
+
+    delete this;
+  }
+
+ private:
+  App::ResolveProxyCallback callback_;
+  net::ProxyInfo proxy_info_;
+  net::ProxyService::PacRequest* pac_req_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
+};
+
+}  // namespace
+
 App::App() {
   Browser::Get()->AddObserver(this);
 }
@@ -36,6 +92,10 @@ void App::OnWindowAllClosed() {
   Emit("window-all-closed");
 }
 
+void App::OnQuit() {
+  Emit("quit");
+}
+
 void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
   base::ListValue args;
   args.AppendString(file_path);
@@ -60,6 +120,32 @@ void App::OnFinishLaunching() {
   Emit("ready");
 }
 
+base::FilePath App::GetDataPath() {
+  base::FilePath path;
+#if defined(OS_LINUX)
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  path = base::nix::GetXDGDirectory(env.get(),
+                                    base::nix::kXdgConfigHomeEnvVar,
+                                    base::nix::kDotConfigDir);
+#else
+  PathService::Get(base::DIR_APP_DATA, &path);
+#endif
+
+  return path.Append(base::FilePath::FromUTF8Unsafe(
+      Browser::Get()->GetName()));
+}
+
+void App::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
+  new ResolveProxyHelper(url, callback);
+}
+
+void App::SetDesktopName(const std::string& desktop_name) {
+#if defined(OS_LINUX)
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  env->SetVar("CHROME_DESKTOP", desktop_name);
+#endif
+}
+
 mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   Browser* browser = Browser::Get();
@@ -75,7 +161,10 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
       .SetMethod("getName", base::Bind(&Browser::GetName,
                                        base::Unretained(browser)))
       .SetMethod("setName", base::Bind(&Browser::SetName,
-                                       base::Unretained(browser)));
+                                       base::Unretained(browser)))
+      .SetMethod("getDataPath", &App::GetDataPath)
+      .SetMethod("resolveProxy", &App::ResolveProxy)
+      .SetMethod("setDesktopName", &App::SetDesktopName);
 }
 
 // static
@@ -109,8 +198,9 @@ int DockBounce(const std::string& type) {
 }
 #endif
 
-void Initialize(v8::Handle<v8::Object> exports) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
   Browser* browser = Browser::Get();
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
@@ -131,9 +221,13 @@ void Initialize(v8::Handle<v8::Object> exports) {
   dict.SetMethod("dockGetBadgeText",
                  base::Bind(&Browser::DockGetBadgeText,
                             base::Unretained(browser)));
+  dict.SetMethod("dockHide",
+                 base::Bind(&Browser::DockHide, base::Unretained(browser)));
+  dict.SetMethod("dockShow",
+                 base::Bind(&Browser::DockShow, base::Unretained(browser)));
 #endif
 }
 
 }  // namespace
 
-NODE_MODULE(atom_browser_app, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_app, Initialize)

atom/browser/api/atom_api_app.h

@@ -7,11 +7,17 @@
 
 #include <string>
 
-#include "base/compiler_specific.h"
 #include "atom/browser/api/event_emitter.h"
 #include "atom/browser/browser_observer.h"
+#include "base/callback.h"
 #include "native_mate/handle.h"
 
+class GURL;
+
+namespace base {
+class FilePath;
+}
+
 namespace atom {
 
 namespace api {
@@ -19,6 +25,8 @@ namespace api {
 class App : public mate::EventEmitter,
             public BrowserObserver {
  public:
+  typedef base::Callback<void(std::string)> ResolveProxyCallback;
+
   static mate::Handle<App> Create(v8::Isolate* isolate);
 
  protected:
@@ -28,6 +36,7 @@ class App : public mate::EventEmitter,
   // BrowserObserver implementations:
   virtual void OnWillQuit(bool* prevent_default) OVERRIDE;
   virtual void OnWindowAllClosed() OVERRIDE;
+  virtual void OnQuit() OVERRIDE;
   virtual void OnOpenFile(bool* prevent_default,
                           const std::string& file_path) OVERRIDE;
   virtual void OnOpenURL(const std::string& url) OVERRIDE;
@@ -40,6 +49,10 @@ class App : public mate::EventEmitter,
       v8::Isolate* isolate);
 
  private:
+  base::FilePath GetDataPath();
+  void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
+  void SetDesktopName(const std::string& desktop_name);
+
   DISALLOW_COPY_AND_ASSIGN(App);
 };
 

atom/browser/api/atom_api_auto_updater.cc

@@ -85,12 +85,13 @@ mate::Handle<AutoUpdater> AutoUpdater::Create(v8::Isolate* isolate) {
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("autoUpdater", atom::api::AutoUpdater::Create(isolate));
 }
 
 }  // namespace
 
-NODE_MODULE(atom_browser_auto_updater, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_auto_updater, Initialize)

atom/browser/api/atom_api_content_tracing.cc

@@ -0,0 +1,91 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include <set>
+#include <string>
+
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "base/bind.h"
+#include "content/public/browser/tracing_controller.h"
+#include "native_mate/callback.h"
+#include "native_mate/dictionary.h"
+
+#include "atom/common/node_includes.h"
+
+using content::TracingController;
+
+namespace mate {
+
+template<typename T>
+struct Converter<std::set<T> > {
+  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+                                    const std::set<T>& val) {
+    v8::Handle<v8::Array> result = v8::Array::New(
+        isolate, static_cast<int>(val.size()));
+    typename std::set<T>::const_iterator it;
+    int i;
+    for (i = 0, it = val.begin(); it != val.end(); ++it, ++i)
+      result->Set(i, Converter<T>::ToV8(isolate, *it));
+    return result;
+  }
+};
+
+template<>
+struct Converter<base::debug::CategoryFilter> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     base::debug::CategoryFilter* out) {
+    std::string filter;
+    if (!ConvertFromV8(isolate, val, &filter))
+      return false;
+    *out = base::debug::CategoryFilter(filter);
+    return true;
+  }
+};
+
+template<>
+struct Converter<base::debug::TraceOptions> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     base::debug::TraceOptions* out) {
+    std::string options;
+    if (!ConvertFromV8(isolate, val, &options))
+      return false;
+    return out->SetFromString(options);
+  }
+};
+
+}  // namespace mate
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  TracingController* controller = TracingController::GetInstance();
+  mate::Dictionary dict(context->GetIsolate(), exports);
+  dict.SetMethod("getCategories", base::Bind(
+      &TracingController::GetCategories, base::Unretained(controller)));
+  dict.SetMethod("startRecording", base::Bind(
+      &TracingController::EnableRecording, base::Unretained(controller)));
+  dict.SetMethod("stopRecording", base::Bind(
+      &TracingController::DisableRecording, base::Unretained(controller)));
+  dict.SetMethod("startMonitoring", base::Bind(
+      &TracingController::EnableMonitoring, base::Unretained(controller)));
+  dict.SetMethod("stopMonitoring", base::Bind(
+      &TracingController::DisableMonitoring, base::Unretained(controller)));
+  dict.SetMethod("captureMonitoringSnapshot", base::Bind(
+      &TracingController::CaptureMonitoringSnapshot,
+      base::Unretained(controller)));
+  dict.SetMethod("getTraceBufferPercentFull", base::Bind(
+      &TracingController::GetTraceBufferPercentFull,
+      base::Unretained(controller)));
+  dict.SetMethod("setWatchEvent", base::Bind(
+      &TracingController::SetWatchEvent, base::Unretained(controller)));
+  dict.SetMethod("cancelWatchEvent", base::Bind(
+      &TracingController::CancelWatchEvent, base::Unretained(controller)));
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_content_tracing, Initialize)

atom/browser/api/atom_api_dialog.cc

@@ -3,19 +3,39 @@
 // found in the LICENSE file.
 
 #include <string>
+#include <utility>
 #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/callback.h"
 #include "native_mate/dictionary.h"
 
 #include "atom/common/node_includes.h"
 
+namespace mate {
+
+template<>
+struct Converter<file_dialog::Filter> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     file_dialog::Filter* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
+      return false;
+    if (!dict.Get("name", &(out->first)))
+      return false;
+    if (!dict.Get("extensions", &(out->second)))
+      return false;
+    return true;
+  }
+};
+
+}  // namespace mate
+
 namespace {
 
 void ShowMessageBox(int type,
@@ -27,7 +47,7 @@ void ShowMessageBox(int type,
                     mate::Arguments* args) {
   v8::Handle<v8::Value> peek = args->PeekNext();
   atom::MessageBoxCallback callback;
-  if (mate::Converter<atom::MessageBoxCallback>::FromV8(node_isolate,
+  if (mate::Converter<atom::MessageBoxCallback>::FromV8(args->isolate(),
                                                         peek,
                                                         &callback)) {
     atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons, title,
@@ -41,43 +61,47 @@ void ShowMessageBox(int type,
 
 void ShowOpenDialog(const std::string& title,
                     const base::FilePath& default_path,
+                    const file_dialog::Filters& filters,
                     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,
+  if (mate::Converter<file_dialog::OpenDialogCallback>::FromV8(args->isolate(),
                                                                peek,
                                                                &callback)) {
-    file_dialog::ShowOpenDialog(window, title, default_path, properties,
-                                callback);
+    file_dialog::ShowOpenDialog(window, title, default_path, filters,
+                                properties, callback);
   } else {
     std::vector<base::FilePath> paths;
-    if (file_dialog::ShowOpenDialog(window, title, default_path, properties,
-                                    &paths))
+    if (file_dialog::ShowOpenDialog(window, title, default_path, filters,
+                                    properties, &paths))
       args->Return(paths);
   }
 }
 
 void ShowSaveDialog(const std::string& title,
                     const base::FilePath& default_path,
+                    const file_dialog::Filters& filters,
                     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,
+  if (mate::Converter<file_dialog::SaveDialogCallback>::FromV8(args->isolate(),
                                                                peek,
                                                                &callback)) {
-    file_dialog::ShowSaveDialog(window, title, default_path, callback);
+    file_dialog::ShowSaveDialog(window, title, default_path, filters, callback);
   } else {
     base::FilePath path;
-    if (file_dialog::ShowSaveDialog(window, title, default_path, &path))
+    if (file_dialog::ShowSaveDialog(window, title, default_path, filters,
+                                    &path))
       args->Return(path);
   }
 }
 
-void Initialize(v8::Handle<v8::Object> exports) {
-  mate::Dictionary dict(v8::Isolate::GetCurrent(), exports);
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  mate::Dictionary dict(context->GetIsolate(), exports);
   dict.SetMethod("showMessageBox", &ShowMessageBox);
   dict.SetMethod("showOpenDialog", &ShowOpenDialog);
   dict.SetMethod("showSaveDialog", &ShowSaveDialog);
@@ -85,4 +109,4 @@ void Initialize(v8::Handle<v8::Object> exports) {
 
 }  // namespace
 
-NODE_MODULE(atom_browser_dialog, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_dialog, Initialize)

atom/browser/api/atom_api_global_shortcut.cc

@@ -0,0 +1,98 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_global_shortcut.h"
+
+#include <string>
+
+#include "atom/common/native_mate_converters/accelerator_converter.h"
+#include "base/stl_util.h"
+#include "native_mate/callback.h"
+#include "native_mate/dictionary.h"
+
+#include "atom/common/node_includes.h"
+
+using extensions::GlobalShortcutListener;
+
+namespace atom {
+
+namespace api {
+
+GlobalShortcut::GlobalShortcut() {
+}
+
+GlobalShortcut::~GlobalShortcut() {
+  UnregisterAll();
+}
+
+void GlobalShortcut::OnKeyPressed(const ui::Accelerator& accelerator) {
+  if (accelerator_callback_map_.find(accelerator) ==
+      accelerator_callback_map_.end()) {
+    // This should never occur, because if it does, GlobalGlobalShortcutListener
+    // notifes us with wrong accelerator.
+    NOTREACHED();
+    return;
+  }
+  accelerator_callback_map_[accelerator].Run();
+}
+
+bool GlobalShortcut::Register(const ui::Accelerator& accelerator,
+                              const base::Closure& callback) {
+  if (!GlobalShortcutListener::GetInstance()->RegisterAccelerator(
+      accelerator, this)) {
+    return false;
+  }
+
+  accelerator_callback_map_[accelerator] = callback;
+  return true;
+}
+
+void GlobalShortcut::Unregister(const ui::Accelerator& accelerator) {
+  if (!ContainsKey(accelerator_callback_map_, accelerator))
+    return;
+
+  accelerator_callback_map_.erase(accelerator);
+  GlobalShortcutListener::GetInstance()->UnregisterAccelerator(
+      accelerator, this);
+}
+
+bool GlobalShortcut::IsRegistered(const ui::Accelerator& accelerator) {
+  return ContainsKey(accelerator_callback_map_, accelerator);
+}
+
+void GlobalShortcut::UnregisterAll() {
+  accelerator_callback_map_.clear();
+  GlobalShortcutListener::GetInstance()->UnregisterAccelerators(this);
+}
+
+mate::ObjectTemplateBuilder GlobalShortcut::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("register", &GlobalShortcut::Register)
+      .SetMethod("isRegistered", &GlobalShortcut::IsRegistered)
+      .SetMethod("unregister", &GlobalShortcut::Unregister)
+      .SetMethod("unregisterAll", &GlobalShortcut::UnregisterAll);
+}
+
+// static
+mate::Handle<GlobalShortcut> GlobalShortcut::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new GlobalShortcut);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("globalShortcut", atom::api::GlobalShortcut::Create(isolate));
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_global_shortcut, Initialize)

atom/browser/api/atom_api_global_shortcut.h

@@ -0,0 +1,55 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_GLOBAL_SHORTCUT_H_
+#define ATOM_BROWSER_API_ATOM_API_GLOBAL_SHORTCUT_H_
+
+#include <map>
+#include <string>
+
+#include "base/callback.h"
+#include "chrome/browser/extensions/global_shortcut_listener.h"
+#include "native_mate/wrappable.h"
+#include "native_mate/handle.h"
+#include "ui/base/accelerators/accelerator.h"
+
+namespace atom {
+
+namespace api {
+
+class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
+                       public mate::Wrappable {
+ public:
+  static mate::Handle<GlobalShortcut> Create(v8::Isolate* isolate);
+
+ protected:
+  GlobalShortcut();
+  virtual ~GlobalShortcut();
+
+  // mate::Wrappable implementations:
+  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) OVERRIDE;
+
+ private:
+  typedef std::map<ui::Accelerator, base::Closure> AcceleratorCallbackMap;
+
+  bool Register(const ui::Accelerator& accelerator,
+                const base::Closure& callback);
+  bool IsRegistered(const ui::Accelerator& accelerator);
+  void Unregister(const ui::Accelerator& accelerator);
+  void UnregisterAll();
+
+  // GlobalShortcutListener::Observer implementation.
+  virtual void OnKeyPressed(const ui::Accelerator& accelerator) OVERRIDE;
+
+  AcceleratorCallbackMap accelerator_callback_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(GlobalShortcut);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_GLOBAL_SHORTCUT_H_

atom/browser/api/atom_api_menu.cc

@@ -4,8 +4,8 @@
 
 #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/browser/native_window.h"
+#include "atom/common/native_mate_converters/accelerator_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
@@ -20,119 +20,140 @@ namespace api {
 namespace {
 
 // Call method of delegate object.
-v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
+v8::Handle<v8::Value> CallDelegate(v8::Isolate* isolate,
+                                   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"));
+  v8::Handle<v8::Value> delegate = menu->Get(
+      MATE_STRING_NEW(isolate, "delegate"));
   if (!delegate->IsObject())
     return default_value;
 
   v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(
-      delegate->ToObject()->Get(v8::String::New(method)));
+      delegate->ToObject()->Get(MATE_STRING_NEW(isolate, 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));
+  v8::Handle<v8::Value> argv = MATE_INTEGER_NEW(isolate, command_id);
+  return function->Call(isolate->GetCurrentContext()->Global(), 1, &argv);
 }
 
 }  // namespace
 
-Menu::Menu() : model_(new ui::SimpleMenuModel(this)) {
+Menu::Menu()
+    : model_(new ui::SimpleMenuModel(this)),
+      parent_(NULL) {
 }
 
 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),
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  return CallDelegate(isolate,
+                      MATE_FALSE(isolate),
+                      const_cast<Menu*>(this)->GetWrapper(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),
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  return CallDelegate(isolate,
+                      MATE_TRUE(isolate),
+                      const_cast<Menu*>(this)->GetWrapper(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),
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  return CallDelegate(isolate,
+                      MATE_TRUE(isolate),
+                      const_cast<Menu*>(this)->GetWrapper(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),
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  v8::Handle<v8::Value> shortcut = CallDelegate(isolate,
+                                                MATE_UNDEFINED(isolate),
+                                                GetWrapper(isolate),
                                                 "getAcceleratorForCommandId",
                                                 command_id);
-  if (shortcut->IsString()) {
-    std::string shortcut_str = mate::V8ToString(shortcut);
-    return accelerator_util::StringToAccelerator(shortcut_str, accelerator);
-  }
-
-  return false;
+  return mate::ConvertFromV8(isolate, shortcut, accelerator);
 }
 
 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),
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  return CallDelegate(isolate,
+                      MATE_FALSE(isolate),
+                      const_cast<Menu*>(this)->GetWrapper(isolate),
                       "isItemForCommandIdDynamic",
                       command_id)->BooleanValue();
 }
 
-string16 Menu::GetLabelForCommandId(int command_id) const {
-  v8::Locker locker(node_isolate);
-  v8::HandleScope handle_scope(node_isolate);
+base::string16 Menu::GetLabelForCommandId(int command_id) const {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::Value> result = CallDelegate(
-      v8::False(),
-      const_cast<Menu*>(this)->GetWrapper(node_isolate),
+      isolate,
+      MATE_FALSE(isolate),
+      const_cast<Menu*>(this)->GetWrapper(isolate),
       "getLabelForCommandId",
       command_id);
-  string16 label;
-  mate::ConvertFromV8(node_isolate, result, &label);
+  base::string16 label;
+  mate::ConvertFromV8(isolate, result, &label);
   return label;
 }
 
-string16 Menu::GetSublabelForCommandId(int command_id) const {
-  v8::Locker locker(node_isolate);
-  v8::HandleScope handle_scope(node_isolate);
+base::string16 Menu::GetSublabelForCommandId(int command_id) const {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
   v8::Handle<v8::Value> result = CallDelegate(
-      v8::False(),
-      const_cast<Menu*>(this)->GetWrapper(node_isolate),
+      isolate,
+      MATE_FALSE(isolate),
+      const_cast<Menu*>(this)->GetWrapper(isolate),
       "getSubLabelForCommandId",
       command_id);
-  string16 label;
-  mate::ConvertFromV8(node_isolate, result, &label);
+  base::string16 label;
+  mate::ConvertFromV8(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);
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  CallDelegate(isolate, MATE_FALSE(isolate), GetWrapper(isolate),
+               "executeCommand", command_id);
+}
+
+void Menu::MenuWillShow(ui::SimpleMenuModel* source) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  CallDelegate(isolate, MATE_FALSE(isolate), GetWrapper(isolate),
+               "menuWillShow", -1);
+}
+
+void Menu::AttachToWindow(Window* window) {
+  window->window()->SetMenu(model_.get());
 }
 
 void Menu::InsertItemAt(
@@ -161,6 +182,7 @@ void Menu::InsertSubMenuAt(int index,
                            int command_id,
                            const base::string16& label,
                            Menu* menu) {
+  menu->parent_ = this;
   model_->InsertSubMenuAt(index, command_id, label, menu->model_.get());
 }
 
@@ -223,10 +245,8 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
       .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);
+      .SetMethod("_popup", &Menu::Popup);
 }
 
 }  // namespace api
@@ -236,11 +256,13 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports) {
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
   using atom::api::Menu;
+  v8::Isolate* isolate = context->GetIsolate();
   v8::Local<v8::Function> constructor = mate::CreateConstructor<Menu>(
-      node_isolate, "Menu", base::Bind(&Menu::Create));
-  mate::Dictionary dict(v8::Isolate::GetCurrent(), exports);
+      isolate, "Menu", base::Bind(&Menu::Create));
+  mate::Dictionary dict(isolate, exports);
   dict.Set("Menu", static_cast<v8::Handle<v8::Value>>(constructor));
 #if defined(OS_MACOSX)
   dict.SetMethod("setApplicationMenu", &Menu::SetApplicationMenu);
@@ -251,4 +273,4 @@ void Initialize(v8::Handle<v8::Object> exports) {
 
 }  // namespace
 
-NODE_MODULE(atom_browser_menu, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_menu, Initialize)

atom/browser/api/atom_api_menu.h

@@ -34,6 +34,8 @@ class Menu : public mate::Wrappable,
   static void SendActionToFirstResponder(const std::string& action);
 #endif
 
+  ui::SimpleMenuModel* model() const { return model_.get(); }
+
  protected:
   Menu();
   virtual ~Menu();
@@ -46,13 +48,16 @@ class Menu : public mate::Wrappable,
       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 base::string16 GetLabelForCommandId(int command_id) const OVERRIDE;
+  virtual base::string16 GetSublabelForCommandId(int command_id) const OVERRIDE;
   virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE;
+  virtual void MenuWillShow(ui::SimpleMenuModel* source) OVERRIDE;
 
+  virtual void AttachToWindow(Window* window);
   virtual void Popup(Window* window) = 0;
 
   scoped_ptr<ui::SimpleMenuModel> model_;
+  Menu* parent_;
 
  private:
   void InsertItemAt(int index, int command_id, const base::string16& label);
@@ -79,10 +84,6 @@ class Menu : public mate::Wrappable,
   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);
 };
 

atom/browser/api/atom_api_menu_gtk.cc

@@ -1,51 +0,0 @@
-// Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/atom_api_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_mac.mm

@@ -8,7 +8,6 @@
 #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"
 
@@ -44,7 +43,7 @@ void MenuMac::Popup(Window* window) {
   // Show the menu.
   [NSMenu popUpContextMenu:[menu_controller menu]
                  withEvent:clickEvent
-                   forView:web_contents->GetView()->GetContentNativeView()];
+                   forView:web_contents->GetContentNativeView()];
 }
 
 // static

atom/browser/api/atom_api_menu_views.cc

@@ -0,0 +1,38 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_menu_views.h"
+
+#include "atom/browser/native_window_views.h"
+#include "ui/gfx/screen.h"
+#include "ui/views/controls/menu/menu_runner.h"
+
+namespace atom {
+
+namespace api {
+
+MenuViews::MenuViews() {
+}
+
+void MenuViews::Popup(Window* window) {
+  gfx::Point cursor = gfx::Screen::GetNativeScreen()->GetCursorScreenPoint();
+  views::MenuRunner menu_runner(
+      model(),
+      views::MenuRunner::CONTEXT_MENU | views::MenuRunner::HAS_MNEMONICS);
+  ignore_result(menu_runner.RunMenuAt(
+      static_cast<NativeWindowViews*>(window->window())->widget(),
+      NULL,
+      gfx::Rect(cursor, gfx::Size()),
+      views::MENU_ANCHOR_TOPLEFT,
+      ui::MENU_SOURCE_MOUSE));
+}
+
+// static
+mate::Wrappable* Menu::Create() {
+  return new MenuViews();
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_menu_views.h

@@ -2,32 +2,28 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_
-#define ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_
+#ifndef ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_
+#define ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_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,
-                public ::MenuGtk::Delegate {
+class MenuViews : public Menu {
  public:
-  MenuGtk();
+  MenuViews();
 
  protected:
   virtual void Popup(Window* window) OVERRIDE;
 
  private:
-  scoped_ptr<::MenuGtk> menu_gtk_;
-
-  DISALLOW_COPY_AND_ASSIGN(MenuGtk);
+  DISALLOW_COPY_AND_ASSIGN(MenuViews);
 };
 
 }  // namespace api
 
 }  // namespace atom
 
-#endif  // ATOM_BROWSER_API_ATOM_API_MENU_GTK_H_
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_

atom/browser/api/atom_api_menu_win.cc

@@ -1,38 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/atom_api_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

@@ -1,33 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_API_ATOM_API_MENU_WIN_H_
-#define ATOM_BROWSER_API_ATOM_API_MENU_WIN_H_
-
-#include "atom/browser/api/atom_api_menu.h"
-
-namespace atom {
-
-class Menu2;
-
-namespace api {
-
-class MenuWin : public Menu {
- public:
-  MenuWin();
-
- protected:
-  virtual void Popup(Window* window) OVERRIDE;
-
- private:
-  scoped_ptr<atom::Menu2> menu_;
-
-  DISALLOW_COPY_AND_ASSIGN(MenuWin);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_MENU_WIN_H_

atom/browser/api/atom_api_power_monitor.cc

@@ -49,13 +49,14 @@ mate::Handle<PowerMonitor> PowerMonitor::Create(v8::Isolate* isolate) {
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports) {
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
 #if defined(OS_MACOSX)
   base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
 #endif
 
   using atom::api::PowerMonitor;
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Isolate* isolate = context->GetIsolate();
   mate::Handle<PowerMonitor> power_monitor = PowerMonitor::Create(isolate);
   mate::Dictionary dict(isolate, exports);
   dict.Set("powerMonitor", power_monitor);
@@ -63,4 +64,4 @@ void Initialize(v8::Handle<v8::Object> exports) {
 
 }  // namespace
 
-NODE_MODULE(atom_browser_power_monitor, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_power_monitor, Initialize)

atom/browser/api/atom_api_protocol.cc

@@ -4,14 +4,12 @@
 
 #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/callback.h"
 #include "native_mate/dictionary.h"
 #include "net/url_request/url_request_context.h"
 
@@ -58,8 +56,9 @@ class CustomProtocolRequestJob : public AdapterRequestJob {
   virtual void GetJobTypeInUI() OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-    v8::Locker locker(node_isolate);
-    v8::HandleScope handle_scope(node_isolate);
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);
 
     // Call the JS handler.
     Protocol::JsProtocolHandler callback =
@@ -75,7 +74,7 @@ class CustomProtocolRequestJob : public AdapterRequestJob {
       return;
     } else if (result->IsObject()) {
       v8::Handle<v8::Object> obj = result->ToObject();
-      mate::Dictionary dict(node_isolate, obj);
+      mate::Dictionary dict(isolate, obj);
       std::string name = mate::V8ToString(obj->GetConstructorName());
       if (name == "RequestStringJob") {
         std::string mime_type, charset, data;
@@ -151,8 +150,9 @@ class CustomProtocolHandler : public ProtocolHandler {
 
 }  // namespace
 
-Protocol::Protocol() : job_factory_(
-    AtomBrowserContext::Get()->url_request_context_getter()->job_factory()) {
+Protocol::Protocol()
+    : job_factory_(AtomBrowserContext::Get()->job_factory()) {
+  CHECK(job_factory_);
 }
 
 Protocol::JsProtocolHandler Protocol::GetProtocolHandler(
@@ -321,16 +321,13 @@ mate::Handle<Protocol> Protocol::Create(v8::Isolate* isolate) {
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports) {
-  // Make sure the job factory has been created.
-  atom::AtomBrowserContext::Get()->url_request_context_getter()->
-      GetURLRequestContext();
-
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("protocol", atom::api::Protocol::Create(isolate));
 }
 
 }  // namespace
 
-NODE_MODULE(atom_browser_protocol, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_protocol, Initialize)

atom/browser/api/atom_api_tray.cc

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

atom/browser/api/atom_api_tray.h

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

atom/browser/api/atom_api_web_contents.cc

@@ -9,6 +9,7 @@
 #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_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
@@ -34,11 +35,16 @@ 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::DidFinishLoad(content::RenderFrameHost* render_frame_host,
+                                const GURL& validated_url) {
+  bool is_main_frame = !render_frame_host->GetParent();
+
+  base::ListValue args;
+  args.AppendBoolean(is_main_frame);
+  Emit("did-frame-finish-load", args);
+
+  if (is_main_frame)
+    Emit("did-finish-load");
 }
 
 void WebContents::DidStartLoading(content::RenderViewHost* render_view_host) {
@@ -61,7 +67,7 @@ bool WebContents::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
-void WebContents::WebContentsDestroyed(content::WebContents*) {
+void WebContents::WebContentsDestroyed() {
   // The RenderViewDeleted was not called when the WebContents is destroyed.
   RenderViewDeleted(web_contents_->GetRenderViewHost());
   Emit("destroyed");
@@ -82,7 +88,7 @@ GURL WebContents::GetURL() const {
   return web_contents()->GetURL();
 }
 
-string16 WebContents::GetTitle() const {
+base::string16 WebContents::GetTitle() const {
   return web_contents()->GetTitle();
 }
 
@@ -149,12 +155,11 @@ bool WebContents::IsCrashed() const {
   return web_contents()->IsCrashed();
 }
 
-void WebContents::ExecuteJavaScript(const string16& code) {
-  web_contents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
-      string16(), code);
+void WebContents::ExecuteJavaScript(const base::string16& code) {
+  web_contents()->GetMainFrame()->ExecuteJavaScript(code);
 }
 
-bool WebContents::SendIPCMessage(const string16& channel,
+bool WebContents::SendIPCMessage(const base::string16& channel,
                                  const base::ListValue& args) {
   return Send(new AtomViewMsg_Message(routing_id(), channel, args));
 }
@@ -181,21 +186,21 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
       .SetMethod("getRoutingId", &WebContents::GetRoutingID)
       .SetMethod("getProcessId", &WebContents::GetProcessID)
       .SetMethod("isCrashed", &WebContents::IsCrashed)
-      .SetMethod("executeJavaScript", &WebContents::ExecuteJavaScript)
+      .SetMethod("_executeJavaScript", &WebContents::ExecuteJavaScript)
       .SetMethod("_send", &WebContents::SendIPCMessage);
 }
 
-void WebContents::OnRendererMessage(const string16& channel,
+void WebContents::OnRendererMessage(const base::string16& channel,
                                     const base::ListValue& args) {
   // webContents.emit(channel, new Event(), args...);
-  Emit(UTF16ToUTF8(channel), args, web_contents(), NULL);
+  Emit(base::UTF16ToUTF8(channel), args, web_contents(), NULL);
 }
 
-void WebContents::OnRendererMessageSync(const string16& channel,
+void WebContents::OnRendererMessageSync(const base::string16& channel,
                                         const base::ListValue& args,
                                         IPC::Message* message) {
   // webContents.emit(channel, new Event(sender, message), args...);
-  Emit(UTF16ToUTF8(channel), args, web_contents(), message);
+  Emit(base::UTF16ToUTF8(channel), args, web_contents(), message);
 }
 
 // static

atom/browser/api/atom_api_web_contents.h

@@ -22,7 +22,7 @@ class WebContents : public mate::EventEmitter,
   bool IsAlive() const;
   void LoadURL(const GURL& url);
   GURL GetURL() const;
-  string16 GetTitle() const;
+  base::string16 GetTitle() const;
   bool IsLoading() const;
   bool IsWaitingForResponse() const;
   void Stop();
@@ -38,8 +38,9 @@ class WebContents : public mate::EventEmitter,
   int GetRoutingID() const;
   int GetProcessID() const;
   bool IsCrashed() const;
-  void ExecuteJavaScript(const string16& code);
-  bool SendIPCMessage(const string16& channel, const base::ListValue& args);
+  void ExecuteJavaScript(const base::string16& code);
+  bool SendIPCMessage(const base::string16& channel,
+                      const base::ListValue& args);
 
  protected:
   explicit WebContents(content::WebContents* web_contents);
@@ -51,24 +52,22 @@ class WebContents : public mate::EventEmitter,
   // 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 DidFinishLoad(content::RenderFrameHost* render_frame_host,
+                             const GURL& validated_url) 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;
+  virtual void WebContentsDestroyed() OVERRIDE;
 
  private:
   // Called when received a message from renderer.
-  void OnRendererMessage(const string16& channel, const base::ListValue& args);
+  void OnRendererMessage(const base::string16& channel,
+                         const base::ListValue& args);
 
   // Called when received a synchronous message from renderer.
-  void OnRendererMessageSync(const string16& channel,
+  void OnRendererMessageSync(const base::string16& channel,
                              const base::ListValue& args,
                              IPC::Message* message);
 

atom/browser/api/atom_api_window.cc

@@ -6,11 +6,8 @@
 
 #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/callback.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
 #include "ui/gfx/point.h"
@@ -19,8 +16,30 @@
 
 #include "atom/common/node_includes.h"
 
+namespace {
+
+struct PrintSettings {
+  bool silent;
+  bool print_backgournd;
+};
+
+}  // namespace
+
 namespace mate {
 
+template<>
+struct Converter<PrintSettings> {
+  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+                     PrintSettings* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
+      return false;
+    dict.Get("silent", &(out->silent));
+    dict.Get("printBackground", &(out->print_backgournd));
+    return true;
+  }
+};
+
 template<>
 struct Converter<gfx::Rect> {
   static bool FromV8(v8::Isolate* isolate,
@@ -47,10 +66,11 @@ namespace api {
 namespace {
 
 void OnCapturePageDone(
+    v8::Isolate* isolate,
     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::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
 
   v8::Local<v8::Value> buffer = node::Buffer::New(
       reinterpret_cast<const char*>(data.data()),
@@ -61,7 +81,7 @@ void OnCapturePageDone(
 }  // namespace
 
 
-Window::Window(base::DictionaryValue* options)
+Window::Window(const mate::Dictionary& options)
     : window_(NativeWindow::Create(options)) {
   window_->InitFromOptions(options);
   window_->AddObserver(this);
@@ -95,6 +115,10 @@ void Window::OnWindowBlur() {
   Emit("blur");
 }
 
+void Window::OnWindowFocus() {
+  Emit("focus");
+}
+
 void Window::OnRendererUnresponsive() {
   Emit("unresponsive");
 }
@@ -104,16 +128,8 @@ void Window::OnRendererResponsive() {
 }
 
 // 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;
+mate::Wrappable* Window::New(const mate::Dictionary& options) {
+  return new Window(options);
 }
 
 void Window::Destroy() {
@@ -153,6 +169,10 @@ void Window::Unmaximize() {
   window_->Unmaximize();
 }
 
+bool Window::IsMaximized() {
+  return window_->IsMaximized();
+}
+
 void Window::Minimize() {
   window_->Minimize();
 }
@@ -161,6 +181,10 @@ void Window::Restore() {
   window_->Restore();
 }
 
+bool Window::IsMinimized() {
+  return window_->IsMinimized();
+}
+
 void Window::SetFullscreen(bool fullscreen) {
   window_->SetFullscreen(fullscreen);
 }
@@ -261,6 +285,10 @@ void Window::FlashFrame(bool flash) {
   window_->FlashFrame(flash);
 }
 
+void Window::SetSkipTaskbar(bool skip) {
+  window_->SetSkipTaskbar(skip);
+}
+
 void Window::SetKiosk(bool kiosk) {
   window_->SetKiosk(kiosk);
 }
@@ -285,11 +313,6 @@ 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();
 }
@@ -302,6 +325,22 @@ bool Window::IsWebViewFocused() {
   return window_->IsWebViewFocused();
 }
 
+void Window::SetRepresentedFilename(const std::string& filename) {
+  window_->SetRepresentedFilename(filename);
+}
+
+std::string Window::GetRepresentedFilename() {
+  return window_->GetRepresentedFilename();
+}
+
+void Window::SetDocumentEdited(bool edited) {
+  window_->SetDocumentEdited(edited);
+}
+
+bool Window::IsDocumentEdited() {
+  return window_->IsDocumentEdited();
+}
+
 void Window::CapturePage(mate::Arguments* args) {
   gfx::Rect rect;
   base::Callback<void(v8::Handle<v8::Value>)> callback;
@@ -313,7 +352,22 @@ void Window::CapturePage(mate::Arguments* args) {
     return;
   }
 
-  window_->CapturePage(rect, base::Bind(&OnCapturePageDone, callback));
+  window_->CapturePage(
+      rect, base::Bind(&OnCapturePageDone, args->isolate(), callback));
+}
+
+void Window::Print(mate::Arguments* args) {
+  PrintSettings settings = { false, false };;
+  if (args->Length() == 1 && !args->GetNext(&settings)) {
+    args->ThrowError();
+    return;
+  }
+
+  window_->Print(settings.silent, settings.print_backgournd);
+}
+
+void Window::SetProgressBar(double progress) {
+  window_->SetProgressBar(progress);
 }
 
 mate::Handle<WebContents> Window::GetWebContents(v8::Isolate* isolate) const {
@@ -338,8 +392,10 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("isVisible", &Window::IsVisible)
       .SetMethod("maximize", &Window::Maximize)
       .SetMethod("unmaximize", &Window::Unmaximize)
+      .SetMethod("isMaximized", &Window::IsMaximized)
       .SetMethod("minimize", &Window::Minimize)
       .SetMethod("restore", &Window::Restore)
+      .SetMethod("isMinimized", &Window::IsMinimized)
       .SetMethod("setFullScreen", &Window::SetFullscreen)
       .SetMethod("isFullScreen", &Window::IsFullscreen)
       .SetMethod("getSize", &Window::GetSize)
@@ -360,17 +416,23 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("setTitle", &Window::SetTitle)
       .SetMethod("getTitle", &Window::GetTitle)
       .SetMethod("flashFrame", &Window::FlashFrame)
+      .SetMethod("setSkipTaskbar", &Window::SetSkipTaskbar)
       .SetMethod("setKiosk", &Window::SetKiosk)
       .SetMethod("isKiosk", &Window::IsKiosk)
-      .SetMethod("openDevTools", &Window::OpenDevTools)
+      .SetMethod("setRepresentedFilename", &Window::SetRepresentedFilename)
+      .SetMethod("getRepresentedFilename", &Window::GetRepresentedFilename)
+      .SetMethod("setDocumentEdited", &Window::SetDocumentEdited)
+      .SetMethod("isDocumentEdited", &Window::IsDocumentEdited)
+      .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("print", &Window::Print)
+      .SetMethod("setProgressBar", &Window::SetProgressBar)
       .SetMethod("_getWebContents", &Window::GetWebContents)
       .SetMethod("_getDevToolsWebContents", &Window::GetDevToolsWebContents);
 }
@@ -382,14 +444,16 @@ void Window::BuildPrototype(v8::Isolate* isolate,
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports) {
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
   using atom::api::Window;
+  v8::Isolate* isolate = context->GetIsolate();
   v8::Local<v8::Function> constructor = mate::CreateConstructor<Window>(
-      node_isolate, "BrowserWindow", base::Bind(&Window::New));
-  mate::Dictionary dict(v8::Isolate::GetCurrent(), exports);
+      isolate, "BrowserWindow", base::Bind(&Window::New));
+  mate::Dictionary dict(isolate, exports);
   dict.Set("BrowserWindow", static_cast<v8::Handle<v8::Value>>(constructor));
 }
 
 }  // namespace
 
-NODE_MODULE(atom_browser_window, Initialize)
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_window, Initialize)

atom/browser/api/atom_api_window.h

@@ -15,10 +15,6 @@
 
 class GURL;
 
-namespace base {
-class DictionaryValue;
-}
-
 namespace mate {
 class Arguments;
 class Dictionary;
@@ -35,8 +31,7 @@ class WebContents;
 class Window : public mate::EventEmitter,
                public NativeWindowObserver {
  public:
-  static mate::Wrappable* New(mate::Arguments* args,
-                              const base::DictionaryValue& options);
+  static mate::Wrappable* New(const mate::Dictionary& options);
 
   static void BuildPrototype(v8::Isolate* isolate,
                              v8::Handle<v8::ObjectTemplate> prototype);
@@ -44,7 +39,7 @@ class Window : public mate::EventEmitter,
   NativeWindow* window() const { return window_.get(); }
 
  protected:
-  explicit Window(base::DictionaryValue* options);
+  explicit Window(const mate::Dictionary& options);
   virtual ~Window();
 
   // Implementations of NativeWindowObserver:
@@ -53,6 +48,7 @@ class Window : public mate::EventEmitter,
   virtual void WillCloseWindow(bool* prevent_default) OVERRIDE;
   virtual void OnWindowClosed() OVERRIDE;
   virtual void OnWindowBlur() OVERRIDE;
+  virtual void OnWindowFocus() OVERRIDE;
   virtual void OnRendererUnresponsive() OVERRIDE;
   virtual void OnRendererResponsive() OVERRIDE;
 
@@ -67,8 +63,10 @@ class Window : public mate::EventEmitter,
   bool IsVisible();
   void Maximize();
   void Unmaximize();
+  bool IsMaximized();
   void Minimize();
   void Restore();
+  bool IsMinimized();
   void SetFullscreen(bool fullscreen);
   bool IsFullscreen();
   void SetSize(int width, int height);
@@ -89,17 +87,23 @@ class Window : public mate::EventEmitter,
   void SetTitle(const std::string& title);
   std::string GetTitle();
   void FlashFrame(bool flash);
+  void SetSkipTaskbar(bool skip);
   void SetKiosk(bool kiosk);
   bool IsKiosk();
   void OpenDevTools();
   void CloseDevTools();
   bool IsDevToolsOpened();
   void InspectElement(int x, int y);
-  void DebugDevTools();
   void FocusOnWebView();
   void BlurWebView();
   bool IsWebViewFocused();
+  void SetRepresentedFilename(const std::string& filename);
+  std::string GetRepresentedFilename();
+  void SetDocumentEdited(bool edited);
+  bool IsDocumentEdited();
   void CapturePage(mate::Arguments* args);
+  void Print(mate::Arguments* args);
+  void SetProgressBar(double progress);
 
   // APIs for WebContents.
   mate::Handle<WebContents> GetWebContents(v8::Isolate* isolate) const;

atom/browser/api/event.cc

@@ -11,6 +11,12 @@
 
 namespace mate {
 
+namespace {
+
+v8::Persistent<v8::ObjectTemplate> template_;
+
+}  // namespace
+
 Event::Event()
     : sender_(NULL),
       message_(NULL),
@@ -21,9 +27,14 @@ Event::~Event() {
 }
 
 ObjectTemplateBuilder Event::GetObjectTemplateBuilder(v8::Isolate* isolate) {
-  return ObjectTemplateBuilder(isolate)
-      .SetMethod("preventDefault", &Event::PreventDefault)
-      .SetMethod("sendReply", &Event::SendReply);
+  if (template_.IsEmpty())
+    template_.Reset(isolate, ObjectTemplateBuilder(isolate)
+        .SetMethod("preventDefault", &Event::PreventDefault)
+        .SetMethod("sendReply", &Event::SendReply)
+        .Build());
+
+  return ObjectTemplateBuilder(
+      isolate, v8::Local<v8::ObjectTemplate>::New(isolate, template_));
 }
 
 void Event::SetSenderAndMessage(content::WebContents* sender,
@@ -36,7 +47,7 @@ void Event::SetSenderAndMessage(content::WebContents* sender,
   Observe(sender);
 }
 
-void Event::WebContentsDestroyed(content::WebContents* web_contents) {
+void Event::WebContentsDestroyed() {
   sender_ = NULL;
   message_ = NULL;
 }
@@ -45,7 +56,7 @@ void Event::PreventDefault() {
   prevent_default_ = true;
 }
 
-bool Event::SendReply(const string16& json) {
+bool Event::SendReply(const base::string16& json) {
   if (message_ == NULL || sender_ == NULL)
     return false;
 

atom/browser/api/event.h

@@ -27,7 +27,7 @@ class Event : public Wrappable,
   void PreventDefault();
 
   // event.sendReply(json), used for replying synchronous message.
-  bool SendReply(const string16& json);
+  bool SendReply(const base::string16& json);
 
   // Whether event.preventDefault() is called.
   bool prevent_default() const { return prevent_default_; }
@@ -40,7 +40,7 @@ class Event : public Wrappable,
   virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate);
 
   // content::WebContentsObserver implementations:
-  virtual void WebContentsDestroyed(content::WebContents*) OVERRIDE;
+  virtual void WebContentsDestroyed() OVERRIDE;
 
  private:
   // Replyer for the synchronous messages.

atom/browser/api/event_emitter.cc

@@ -10,11 +10,37 @@
 #include "atom/common/native_mate_converters/v8_value_converter.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
+#include "native_mate/arguments.h"
+#include "native_mate/object_template_builder.h"
 
 #include "atom/common/node_includes.h"
 
 namespace mate {
 
+namespace {
+
+v8::Persistent<v8::ObjectTemplate> event_template;
+
+void PreventDefault(mate::Arguments* args) {
+  args->GetThis()->SetHiddenValue(
+      StringToV8(args->isolate(), "prevent_default"),
+      v8::True(args->isolate()));
+}
+
+// Create a pure JavaScript Event object.
+v8::Local<v8::Object> CreateEventObject(v8::Isolate* isolate) {
+  if (event_template.IsEmpty()) {
+    event_template.Reset(isolate, ObjectTemplateBuilder(isolate)
+        .SetMethod("preventDefault", &PreventDefault)
+        .Build());
+  }
+
+  return v8::Local<v8::ObjectTemplate>::New(
+      isolate, event_template)->NewInstance();
+}
+
+}  // namespace
+
 EventEmitter::EventEmitter() {
 }
 
@@ -31,21 +57,29 @@ 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::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
 
-  v8::Handle<v8::Context> context = v8::Context::GetCurrent();
+  v8::Handle<v8::Context> context = isolate->GetCurrentContext();
   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::Handle<v8::Object> event;
+  bool use_native_event = sender && message;
+
+  if (use_native_event) {
+    mate::Handle<mate::Event> native_event = mate::Event::Create(isolate);
+    native_event->SetSenderAndMessage(sender, message);
+    event = v8::Handle<v8::Object>::Cast(native_event.ToV8());
+  } else {
+    event = CreateEventObject(isolate);
+  }
 
   // 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());
+  v8_args.push_back(mate::StringToV8(isolate, name));
+  v8_args.push_back(event);
   for (size_t i = 0; i < args.GetSize(); i++) {
     const base::Value* value(NULL);
     if (args.Get(i, &value))
@@ -53,10 +87,20 @@ bool EventEmitter::Emit(const base::StringPiece& name,
   }
 
   // this.emit.apply(this, v8_args);
-  node::MakeCallback(
-      GetWrapper(node_isolate), "emit", v8_args.size(), &v8_args[0]);
+  node::MakeCallback(isolate, GetWrapper(isolate), "emit", v8_args.size(),
+                     &v8_args[0]);
 
-  return event->prevent_default();
+  if (use_native_event) {
+    Handle<Event> native_event;
+    if (ConvertFromV8(isolate, event, &native_event))
+      return native_event->prevent_default();
+  }
+
+  v8::Handle<v8::Value> prevent_default =
+      event->GetHiddenValue(StringToSymbol(isolate, "prevent_default"));
+  if (prevent_default.IsEmpty())
+    return false;
+  return prevent_default->BooleanValue();
 }
 
 }  // namespace mate

atom/browser/api/lib/app.coffee

@@ -24,6 +24,8 @@ if process.platform is 'darwin'
     cancelBounce: bindings.dockCancelBounce
     setBadge: bindings.dockSetBadgeText
     getBadge: bindings.dockGetBadgeText
+    hide: bindings.dockHide
+    show: bindings.dockShow
 
 # Be compatible with old API.
 app.once 'ready', -> app.emit 'finish-launching'

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

@@ -18,29 +18,26 @@ BrowserWindow::_init = ->
   @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
+  # Remember the window ID.
+  Object.defineProperty this, 'id',
+    value: BrowserWindow.windows.add(this)
+    enumerable: true
 
   # Remove the window from weak map immediately when it's destroyed, since we
   # could be iterating windows before GC happened.
-  @once 'closed', ->
-    BrowserWindow.windows.remove id if BrowserWindow.windows.has id
+  @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::openDevTools = ->
+  @_openDevTools()
+
+  # Force devToolsWebContents to be created.
+  @devToolsWebContents = @getDevToolsWebContents()
+  @devToolsWebContents.once 'destroyed', => @devToolsWebContents = null
+
+  # Emit devtools events.
+  @devToolsWebContents.once 'did-finish-load', => @emit 'devtools-opened'
+  @devToolsWebContents.once 'destroyed', => @emit 'devtools-closed'
 
 BrowserWindow::toggleDevTools = ->
   if @isDevToolsOpened() then @closeDevTools() else @openDevTools()
@@ -76,6 +73,9 @@ BrowserWindow.fromDevToolsWebContents = (webContents) ->
   windows = BrowserWindow.getAllWindows()
   return window for window in windows when webContents.equal window.devToolsWebContents
 
+BrowserWindow.fromId = (id) ->
+  BrowserWindow.windows.get id
+
 # Helpers.
 BrowserWindow::loadUrl = -> @webContents.loadUrl.apply @webContents, arguments
 BrowserWindow::send = -> @webContents.send.apply @webContents, arguments

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

@@ -0,0 +1,7 @@
+module.exports = process.atomBinding 'content_tracing'
+
+# Mirrored from content::TracingController::Options
+module.exports.DEFAULT_OPTIONS = 0
+module.exports.ENABLE_SYSTRACE = 1 << 0
+module.exports.ENABLE_SAMPLING = 1 << 1
+module.exports.RECORD_CONTINUOUSLY = 1 << 2

atom/browser/api/lib/dialog.coffee

@@ -3,17 +3,28 @@ v8Util = process.atomBinding 'v8_util'
 BrowserWindow = require 'browser-window'
 
 fileDialogProperties =
-  openFile: 1, openDirectory: 2, multiSelections: 4, createDirectory: 8
+  openFile:        1 << 0
+  openDirectory:   1 << 1
+  multiSelections: 1 << 2
+  createDirectory: 1 << 3
 
 messageBoxTypes = ['none', 'info', 'warning']
 
+parseArgs = (window, options, callback) ->
+  unless window is null or window?.constructor is BrowserWindow
+    # Shift.
+    callback = options
+    options = window
+    window = null
+  if not callback? and typeof options is 'function'
+    # Shift.
+    callback = options
+    options = null
+  [window, options, callback]
+
 module.exports =
-  showOpenDialog: (window, options, callback) ->
-    unless window?.constructor is BrowserWindow
-      # Shift.
-      callback = options
-      options = window
-      window = null
+  showOpenDialog: (args...) ->
+    [window, options, callback] = parseArgs args...
 
     options ?= title: 'Open', properties: ['openFile']
     options.properties ?= ['openFile']
@@ -25,35 +36,43 @@ module.exports =
 
     options.title ?= ''
     options.defaultPath ?= ''
+    options.filters ?= []
+
+    wrappedCallback =
+      if typeof callback is 'function'
+        (success, result) -> callback(if success then result)
+      else
+        null
 
     binding.showOpenDialog String(options.title),
                            String(options.defaultPath),
+                           options.filters
                            properties,
                            window,
-                           (success, result) -> callback if success then result
+                           wrappedCallback
 
-  showSaveDialog: (window, options, callback) ->
-    unless window?.constructor is BrowserWindow
-      # Shift.
-      callback = options
-      options = window
-      window = null
+  showSaveDialog: (args...) ->
+    [window, options, callback] = parseArgs args...
 
     options ?= title: 'Save'
     options.title ?= ''
     options.defaultPath ?= ''
+    options.filters ?= []
+
+    wrappedCallback =
+      if typeof callback is 'function'
+        (success, result) -> callback(if success then result)
+      else
+        null
 
     binding.showSaveDialog String(options.title),
                            String(options.defaultPath),
+                           options.filters
                            window,
-                           (success, result) -> callback if success then result
+                           wrappedCallback
 
-  showMessageBox: (window, options, callback) ->
-    unless window?.constructor is BrowserWindow
-      # Shift.
-      callback = options
-      options = window
-      window = null
+  showMessageBox: (args...) ->
+    [window, options, callback] = parseArgs args...
 
     options ?= type: 'none'
     options.type ?= 'none'

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

@@ -0,0 +1,5 @@
+bindings = process.atomBinding 'global_shortcut'
+
+globalShortcut = bindings.globalShortcut
+
+module.exports = globalShortcut

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

@@ -1,4 +1,5 @@
 BrowserWindow = require 'browser-window'
+v8Util = process.atomBinding 'v8_util'
 
 nextCommandId = 0
 
@@ -8,28 +9,40 @@ class MenuItem
   constructor: (options) ->
     Menu = require 'menu'
 
-    {click, @selector, @type, @label, @sublabel, @accelerator, @enabled, @visible, @checked, @groupId, @submenu} = options
+    {click, @selector, @type, @label, @sublabel, @accelerator, @enabled, @visible, @checked, @submenu} = options
 
     @type = 'submenu' if not @type? and @submenu?
     throw new Error('Invalid submenu') if @type is 'submenu' and @submenu?.constructor isnt Menu
 
-    @type = @type ? 'normal'
-    @label = @label ? ''
-    @sublabel = @sublabel ? ''
-    @accelerator = @accelerator ? null
-    @enabled = @enabled ? true
-    @visible = @visible ? true
-    @checked = @checked ? false
-    @groupId = @groupId ? null
-    @submenu = @submenu ? null
+    @overrideReadOnlyProperty 'type', 'normal'
+    @overrideReadOnlyProperty 'accelerator'
+    @overrideReadOnlyProperty 'submenu'
+    @overrideProperty 'label', ''
+    @overrideProperty 'sublabel', ''
+    @overrideProperty 'enabled', true
+    @overrideProperty 'visible', true
+    @overrideProperty 'checked', false
 
-    throw new Error('Unknown menu type') if MenuItem.types.indexOf(@type) is -1
+    throw new Error("Unknown menu type #{@type}") if MenuItem.types.indexOf(@type) is -1
 
     @commandId = ++nextCommandId
     @click = =>
+      # Manually flip the checked flags when clicked.
+      @checked = !@checked if @type in ['checkbox', 'radio']
+
       if typeof click is 'function'
         click this, BrowserWindow.getFocusedWindow()
       else if typeof @selector is 'string'
         Menu.sendActionToFirstResponder @selector
 
+  overrideProperty: (name, defaultValue=null) ->
+    this[name] ?= defaultValue
+
+  overrideReadOnlyProperty: (name, defaultValue=null) ->
+    this[name] ?= defaultValue
+    Object.defineProperty this, name,
+      enumerable: true
+      writable: false
+      value: this[name]
+
 module.exports = MenuItem

atom/browser/api/lib/menu.coffee

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

atom/browser/api/lib/tray.coffee

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

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

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

atom/browser/atom_access_token_store.cc

@@ -0,0 +1,50 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_access_token_store.h"
+
+#include <utility>
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/common/google_api_key.h"
+
+namespace atom {
+
+namespace {
+
+// Notice that we just combined the api key with the url together here, because
+// if we use the standard {url: key} format Chromium would override our key with
+// the predefined one in common.gypi of libchromiumcontent, which is empty.
+const char* kGeolocationProviderUrl =
+    "https://www.googleapis.com/geolocation/v1/geolocate?key="
+    GOOGLEAPIS_API_KEY;
+
+}  // namespace
+
+AtomAccessTokenStore::AtomAccessTokenStore() {
+}
+
+AtomAccessTokenStore::~AtomAccessTokenStore() {
+}
+
+void AtomAccessTokenStore::LoadAccessTokens(
+    const LoadAccessTokensCallbackType& callback) {
+  AccessTokenSet access_token_set;
+
+  // Equivelent to access_token_set[kGeolocationProviderUrl].
+  // Somehow base::string16 is causing compilation errors when used in a pair
+  // of std::map on Linux, this can work around it.
+  std::pair<GURL, base::string16> token_pair;
+  token_pair.first = GURL(kGeolocationProviderUrl);
+  access_token_set.insert(token_pair);
+
+  callback.Run(access_token_set,
+               AtomBrowserContext::Get()->url_request_context_getter());
+}
+
+void AtomAccessTokenStore::SaveAccessToken(const GURL& server_url,
+                                           const base::string16& access_token) {
+}
+
+}  // namespace atom

atom/browser/atom_access_token_store.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_ACCESS_TOKEN_STORE_H_
+#define ATOM_BROWSER_ATOM_ACCESS_TOKEN_STORE_H_
+
+#include "content/public/browser/access_token_store.h"
+
+namespace atom {
+
+class AtomBrowserContext;
+
+class AtomAccessTokenStore : public content::AccessTokenStore {
+ public:
+  AtomAccessTokenStore();
+  virtual ~AtomAccessTokenStore();
+
+  // content::AccessTokenStore:
+  virtual void LoadAccessTokens(
+      const LoadAccessTokensCallbackType& callback) OVERRIDE;
+  virtual void SaveAccessToken(const GURL& server_url,
+                               const base::string16& access_token) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomAccessTokenStore);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_ACCESS_TOKEN_STORE_H_

atom/browser/atom_browser_client.cc

@@ -4,16 +4,22 @@
 
 #include "atom/browser/atom_browser_client.h"
 
+#include "atom/browser/atom_access_token_store.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/atom_resource_dispatcher_host_delegate.h"
+#include "atom/browser/atom_speech_recognition_manager_delegate.h"
 #include "atom/browser/native_window.h"
-#include "atom/browser/net/atom_url_request_context_getter.h"
 #include "atom/browser/window_list.h"
+#include "chrome/browser/printing/printing_message_filter.h"
+#include "chrome/browser/speech/tts_message_filter.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
-#include "webkit/common/webpreferences.h"
+#include "content/public/common/web_preferences.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace atom {
 
@@ -25,6 +31,10 @@ struct FindByProcessId {
   }
 
   bool operator() (NativeWindow* const window) {
+    content::WebContents* web_contents = window->GetWebContents();
+    if (!web_contents)
+      return false;
+
     int id = window->GetWebContents()->GetRenderProcessHost()->GetID();
     return id == child_process_id_;
   }
@@ -41,17 +51,32 @@ AtomBrowserClient::AtomBrowserClient()
 AtomBrowserClient::~AtomBrowserClient() {
 }
 
-net::URLRequestContextGetter* AtomBrowserClient::CreateRequestContext(
-    content::BrowserContext* browser_context,
-    content::ProtocolHandlerMap* protocol_handlers) {
-  return static_cast<AtomBrowserContext*>(browser_context)->
-      CreateRequestContext(protocol_handlers);
+void AtomBrowserClient::RenderProcessWillLaunch(
+    content::RenderProcessHost* host) {
+  int id = host->GetID();
+  host->AddFilter(new PrintingMessageFilter(host->GetID()));
+  host->AddFilter(new TtsMessageFilter(id, host->GetBrowserContext()));
+}
+
+void AtomBrowserClient::ResourceDispatcherHostCreated() {
+  resource_dispatcher_delegate_.reset(new AtomResourceDispatcherHostDelegate);
+  content::ResourceDispatcherHost::Get()->SetDelegate(
+      resource_dispatcher_delegate_.get());
+}
+
+content::SpeechRecognitionManagerDelegate*
+    AtomBrowserClient::GetSpeechRecognitionManagerDelegate() {
+  return new AtomSpeechRecognitionManagerDelegate;
+}
+
+content::AccessTokenStore* AtomBrowserClient::CreateAccessTokenStore() {
+  return new AtomAccessTokenStore;
 }
 
 void AtomBrowserClient::OverrideWebkitPrefs(
     content::RenderViewHost* render_view_host,
     const GURL& url,
-    WebPreferences* prefs) {
+    content::WebPreferences* prefs) {
   prefs->javascript_enabled = true;
   prefs->web_security_enabled = true;
   prefs->javascript_can_open_windows_automatically = true;
@@ -69,6 +94,12 @@ void AtomBrowserClient::OverrideWebkitPrefs(
   prefs->allow_displaying_insecure_content = true;
   prefs->allow_running_insecure_content = true;
 
+  // Turn off web security for devtools.
+  if (url.SchemeIs("chrome-devtools")) {
+    prefs->web_security_enabled = false;
+    return;
+  }
+
   NativeWindow* window = NativeWindow::FromRenderView(
       render_view_host->GetProcess()->GetID(),
       render_view_host->GetRoutingID());
@@ -76,7 +107,7 @@ void AtomBrowserClient::OverrideWebkitPrefs(
     window->OverrideWebkitPrefs(url, prefs);
 }
 
-bool AtomBrowserClient::ShouldSwapProcessesForNavigation(
+bool AtomBrowserClient::ShouldSwapBrowsingInstancesForNavigation(
     content::SiteInstance* site_instance,
     const GURL& current_url,
     const GURL& new_url) {
@@ -88,8 +119,12 @@ bool AtomBrowserClient::ShouldSwapProcessesForNavigation(
   return true;
 }
 
+std::string AtomBrowserClient::GetApplicationLocale() {
+  return l10n_util::GetApplicationLocale("");
+}
+
 void AtomBrowserClient::AppendExtraCommandLineSwitches(
-    CommandLine* command_line,
+    base::CommandLine* command_line,
     int child_process_id) {
   WindowList* list = WindowList::GetInstance();
   NativeWindow* window = NULL;
@@ -119,6 +154,7 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches(
 
 brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
     const content::MainFunctionParams&) {
+  v8::V8::Initialize();  // Init V8 before creating main parts.
   return new AtomBrowserMainParts;
 }
 

atom/browser/atom_browser_client.h

@@ -5,33 +5,44 @@
 #ifndef ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 #define ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 
+#include <string>
+
 #include "brightray/browser/browser_client.h"
 
 namespace atom {
 
+class AtomResourceDispatcherHostDelegate;
+
 class AtomBrowserClient : public brightray::BrowserClient {
  public:
   AtomBrowserClient();
   virtual ~AtomBrowserClient();
 
  protected:
-  net::URLRequestContextGetter* CreateRequestContext(
-      content::BrowserContext* browser_context,
-      content::ProtocolHandlerMap* protocol_handlers) OVERRIDE;
+  // content::ContentBrowserClient:
+  virtual void RenderProcessWillLaunch(
+      content::RenderProcessHost* host) OVERRIDE;
+  virtual void ResourceDispatcherHostCreated() OVERRIDE;
+  virtual content::SpeechRecognitionManagerDelegate*
+      GetSpeechRecognitionManagerDelegate() override;
+  virtual content::AccessTokenStore* CreateAccessTokenStore() OVERRIDE;
   virtual void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
                                    const GURL& url,
-                                   WebPreferences* prefs) OVERRIDE;
-  virtual bool ShouldSwapProcessesForNavigation(
+                                   content::WebPreferences* prefs) OVERRIDE;
+  virtual bool ShouldSwapBrowsingInstancesForNavigation(
       content::SiteInstance* site_instance,
       const GURL& current_url,
       const GURL& new_url) OVERRIDE;
-  virtual void AppendExtraCommandLineSwitches(CommandLine* command_line,
+  virtual std::string GetApplicationLocale() OVERRIDE;
+  virtual void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
                                               int child_process_id) OVERRIDE;
 
  private:
   virtual brightray::BrowserMainParts* OverrideCreateBrowserMainParts(
       const content::MainFunctionParams&) OVERRIDE;
 
+  scoped_ptr<AtomResourceDispatcherHostDelegate> resource_dispatcher_delegate_;
+
   // The render process which would be swapped out soon.
   content::RenderProcessHost* dying_render_process_;
 

atom/browser/atom_browser_context.cc

@@ -5,72 +5,67 @@
 #include "atom/browser/atom_browser_context.h"
 
 #include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/net/atom_url_request_context_getter.h"
+#include "atom/browser/net/atom_url_request_job_factory.h"
+#include "atom/browser/net/asar/asar_protocol_handler.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/worker_pool.h"
+#include "chrome/browser/browser_process.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/resource_context.h"
-#include "vendor/brightray/browser/network_delegate.h"
-
-namespace atom {
+#include "content/public/common/url_constants.h"
+#include "net/url_request/data_protocol_handler.h"
+#include "net/url_request/file_protocol_handler.h"
+#include "net/url_request/url_request_intercepting_job_factory.h"
+#include "url/url_constants.h"
 
 using content::BrowserThread;
 
-class AtomResourceContext : public content::ResourceContext {
- public:
-  AtomResourceContext() : getter_(NULL) {}
+namespace atom {
 
-  void set_url_request_context_getter(AtomURLRequestContextGetter* getter) {
-    getter_ = getter;
-  }
+namespace {
 
- protected:
-  virtual net::HostResolver* GetHostResolver() OVERRIDE {
-    DCHECK(getter_);
-    return getter_->host_resolver();
-  }
+const char* kAsarScheme = "asar";
 
-  virtual net::URLRequestContext* GetRequestContext() OVERRIDE {
-    DCHECK(getter_);
-    return getter_->GetURLRequestContext();
-  }
-
-  virtual bool AllowMicAccess(const GURL& origin) OVERRIDE {
-    return true;
-  }
-
-  virtual bool AllowCameraAccess(const GURL& origin) OVERRIDE {
-    return true;
-  }
-
- private:
-  AtomURLRequestContextGetter* getter_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomResourceContext);
-};
+}  // namespace
 
 AtomBrowserContext::AtomBrowserContext()
-    : resource_context_(new AtomResourceContext) {
+    : fake_browser_process_(new BrowserProcess),
+      job_factory_(new AtomURLRequestJobFactory) {
 }
 
 AtomBrowserContext::~AtomBrowserContext() {
 }
 
-AtomURLRequestContextGetter* AtomBrowserContext::CreateRequestContext(
-    content::ProtocolHandlerMap* protocol_handlers) {
-  DCHECK(!url_request_getter_);
-  url_request_getter_ = new AtomURLRequestContextGetter(
-      GetPath(),
-      BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::IO),
-      BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::FILE),
-      base::Bind(&AtomBrowserContext::CreateNetworkDelegate,
-                 base::Unretained(this)),
-      protocol_handlers);
+net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
+    content::ProtocolHandlerMap* handlers,
+    content::URLRequestInterceptorScopedVector* interceptors) {
+  scoped_ptr<AtomURLRequestJobFactory> job_factory(job_factory_);
 
-  resource_context_->set_url_request_context_getter(url_request_getter_.get());
-  return url_request_getter_.get();
-}
+  for (content::ProtocolHandlerMap::iterator it = handlers->begin();
+       it != handlers->end(); ++it)
+    job_factory->SetProtocolHandler(it->first, it->second.release());
+  handlers->clear();
 
-content::ResourceContext* AtomBrowserContext::GetResourceContext() {
-  return resource_context_.get();
+  job_factory->SetProtocolHandler(
+      url::kDataScheme, new net::DataProtocolHandler);
+  job_factory->SetProtocolHandler(
+      url::kFileScheme, new net::FileProtocolHandler(
+          BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
+  job_factory->SetProtocolHandler(
+      kAsarScheme, new asar::AsarProtocolHandler(
+          BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
+
+  // Set up interceptors in the reverse order.
+  scoped_ptr<net::URLRequestJobFactory> top_job_factory =
+      job_factory.PassAs<net::URLRequestJobFactory>();
+  content::URLRequestInterceptorScopedVector::reverse_iterator it;
+  for (it = interceptors->rbegin(); it != interceptors->rend(); ++it)
+    top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
+        top_job_factory.Pass(), make_scoped_ptr(*it)));
+  interceptors->weak_clear();
+
+  return top_job_factory.release();
 }
 
 // static

atom/browser/atom_browser_context.h

@@ -5,13 +5,13 @@
 #ifndef ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
 #define ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
 
-#include "base/memory/scoped_ptr.h"
 #include "brightray/browser/browser_context.h"
 
+class BrowserProcess;
+
 namespace atom {
 
-class AtomResourceContext;
-class AtomURLRequestContextGetter;
+class AtomURLRequestJobFactory;
 
 class AtomBrowserContext : public brightray::BrowserContext {
  public:
@@ -21,22 +21,19 @@ class AtomBrowserContext : public brightray::BrowserContext {
   // Returns the browser context singleton.
   static AtomBrowserContext* Get();
 
-  // Creates or returns the request context.
-  AtomURLRequestContextGetter* CreateRequestContext(
-      content::ProtocolHandlerMap*);
-
-  AtomURLRequestContextGetter* url_request_context_getter() const {
-    DCHECK(url_request_getter_);
-    return url_request_getter_.get();
-  }
+  AtomURLRequestJobFactory* job_factory() const { return job_factory_; }
 
  protected:
-  // content::BrowserContext implementations:
-  virtual content::ResourceContext* GetResourceContext() OVERRIDE;
+  // brightray::URLRequestContextGetter::Delegate:
+  virtual net::URLRequestJobFactory* CreateURLRequestJobFactory(
+      content::ProtocolHandlerMap* handlers,
+      content::URLRequestInterceptorScopedVector* interceptors) OVERRIDE;
 
  private:
-  scoped_ptr<AtomResourceContext> resource_context_;
-  scoped_refptr<AtomURLRequestContextGetter> url_request_getter_;
+  // A fake BrowserProcess object that used to feed the source code from chrome.
+  scoped_ptr<BrowserProcess> fake_browser_process_;
+
+  AtomURLRequestJobFactory* job_factory_;  // Weak reference.
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
 };

atom/browser/atom_browser_main_parts.cc

@@ -7,12 +7,15 @@
 #include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/browser.h"
+#include "atom/browser/javascript_environment.h"
+#include "atom/browser/node_debugger.h"
 #include "atom/common/api/atom_bindings.h"
 #include "atom/common/node_bindings.h"
-#include "net/proxy/proxy_resolver_v8.h"
+#include "base/command_line.h"
+#include "v8/include/v8-debug.h"
 
-#if defined(OS_WIN)
-#include "ui/gfx/win/dpi.h"
+#if defined(USE_X11)
+#include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
 #endif
 
 #include "atom/common/node_includes.h"
@@ -23,9 +26,10 @@ namespace atom {
 AtomBrowserMainParts* AtomBrowserMainParts::self_ = NULL;
 
 AtomBrowserMainParts::AtomBrowserMainParts()
-    : atom_bindings_(new AtomBindings),
-      browser_(new Browser),
-      node_bindings_(NodeBindings::Create(true)) {
+    : browser_(new Browser),
+      node_bindings_(NodeBindings::Create(true)),
+      atom_bindings_(new AtomBindings),
+      gc_timer_(true, true) {
   DCHECK(!self_) << "Cannot have two AtomBrowserMainParts";
   self_ = this;
 }
@@ -46,35 +50,44 @@ brightray::BrowserContext* AtomBrowserMainParts::CreateBrowserContext() {
 void AtomBrowserMainParts::PostEarlyInitialization() {
   brightray::BrowserMainParts::PostEarlyInitialization();
 
+  // The ProxyResolverV8 has setup a complete V8 environment, in order to avoid
+  // conflicts we only initialize our V8 environment after that.
+  js_env_.reset(new JavascriptEnvironment);
+
   node_bindings_->Initialize();
 
-  v8::V8::Initialize();
-
-  // Create context.
-  v8::Locker locker(node_isolate);
-  v8::HandleScope handle_scope(node_isolate);
-  v8::Local<v8::Context> context = v8::Context::New(node_isolate);
+  // Support the "--debug" switch.
+  node_debugger_.reset(new NodeDebugger(js_env_->isolate()));
 
   // Create the global environment.
-  global_env = node_bindings_->CreateEnvironment(context);
+  global_env = node_bindings_->CreateEnvironment(js_env_->context());
 
-  // Wrap whole process in one global context.
-  context->Enter();
+  // Make sure node can get correct environment when debugging.
+  if (node_debugger_->IsRunning())
+    global_env->AssignToContext(v8::Debug::GetDebugContext());
 
   // Add atom-shell extended APIs.
-  atom_bindings_->BindTo(global_env->process_object());
+  atom_bindings_->BindTo(js_env_->isolate(), global_env->process_object());
 }
 
 void AtomBrowserMainParts::PreMainMessageLoopRun() {
-  brightray::BrowserMainParts::PreMainMessageLoopRun();
-
+  // Run user's main script before most things get initialized, so we can have
+  // a chance to setup everything.
   node_bindings_->PrepareMessageLoop();
   node_bindings_->RunMessageLoop();
 
-  // Make sure the url request job factory is created before the
-  // will-finish-launching event.
-  static_cast<content::BrowserContext*>(AtomBrowserContext::Get())->
-      GetRequestContext();
+  // Start idle gc.
+  gc_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMinutes(1),
+      base::Bind(base::IgnoreResult(&v8::Isolate::IdleNotification),
+                 base::Unretained(js_env_->isolate()),
+                 1000));
+
+  brightray::BrowserMainParts::PreMainMessageLoopRun();
+
+#if defined(USE_X11)
+  libgtk2ui::GtkInitFromCommandLine(*CommandLine::ForCurrentProcess());
+#endif
 
 #if !defined(OS_MACOSX)
   // The corresponding call in OS X is in AtomApplicationDelegate.
@@ -83,19 +96,4 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
 #endif
 }
 
-int AtomBrowserMainParts::PreCreateThreads() {
-  // Note that we are overriding the PreCreateThreads of brightray, since we
-  // are integrating node in browser, we can just be sure that an V8 instance
-  // would be prepared, while the ProxyResolverV8::CreateIsolate() would
-  // try to create a V8 isolate, which messed everything on Windows, so we
-  // have to override and call RememberDefaultIsolate on Windows instead.
-  net::ProxyResolverV8::RememberDefaultIsolate();
-
-#if defined(OS_WIN)
-  gfx::EnableHighDPISupport();
-#endif
-
-  return 0;
-}
-
 }  // namespace atom

atom/browser/atom_browser_main_parts.h

@@ -5,13 +5,16 @@
 #ifndef ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
 #define ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
 
+#include "base/timer/timer.h"
 #include "brightray/browser/browser_main_parts.h"
 
 namespace atom {
 
 class AtomBindings;
 class Browser;
+class JavascriptEnvironment;
 class NodeBindings;
+class NodeDebugger;
 
 class AtomBrowserMainParts : public brightray::BrowserMainParts {
  public:
@@ -29,16 +32,19 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   // Implementations of content::BrowserMainParts.
   virtual void PostEarlyInitialization() OVERRIDE;
   virtual void PreMainMessageLoopRun() OVERRIDE;
-  virtual int PreCreateThreads() OVERRIDE;
 #if defined(OS_MACOSX)
   virtual void PreMainMessageLoopStart() OVERRIDE;
   virtual void PostDestroyThreads() OVERRIDE;
 #endif
 
  private:
-  scoped_ptr<AtomBindings> atom_bindings_;
   scoped_ptr<Browser> browser_;
+  scoped_ptr<JavascriptEnvironment> js_env_;
   scoped_ptr<NodeBindings> node_bindings_;
+  scoped_ptr<AtomBindings> atom_bindings_;
+  scoped_ptr<NodeDebugger> node_debugger_;
+
+  base::Timer gc_timer_;
 
   static AtomBrowserMainParts* self_;
 

atom/browser/atom_browser_main_parts_mac.mm

@@ -8,11 +8,15 @@
 #import "atom/browser/mac/atom_application_delegate.h"
 #include "base/files/file_path.h"
 #import "base/mac/foundation_util.h"
+#include "ui/base/l10n/l10n_util_mac.h"
 #import "vendor/brightray/common/mac/main_application_bundle.h"
 
 namespace atom {
 
 void AtomBrowserMainParts::PreMainMessageLoopStart() {
+  // Initialize locale setting.
+  l10n_util::OverrideLocaleWithCocoaLocale();
+
   // Force the NSApplication subclass to be used.
   NSApplication* application = [AtomApplication sharedApplication];
 

atom/browser/atom_javascript_dialog_manager.cc

@@ -15,21 +15,21 @@ void AtomJavaScriptDialogManager::RunJavaScriptDialog(
     const GURL& origin_url,
     const std::string& accept_lang,
     content::JavaScriptMessageType javascript_message_type,
-    const string16& message_text,
-    const string16& default_prompt_text,
+    const base::string16& message_text,
+    const base::string16& default_prompt_text,
     const DialogClosedCallback& callback,
     bool* did_suppress_message) {
-  callback.Run(false, string16());
+  callback.Run(false, base::string16());
 }
 
 void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(
     content::WebContents* web_contents,
-    const string16& message_text,
+    const base::string16& message_text,
     bool is_reload,
     const DialogClosedCallback& callback) {
 
   bool prevent_reload = message_text.empty() ||
-                        message_text == ASCIIToUTF16("false");
+                        message_text == base::ASCIIToUTF16("false");
   callback.Run(!prevent_reload, message_text);
 }
 

atom/browser/atom_javascript_dialog_manager.h

@@ -19,13 +19,13 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
       const GURL& origin_url,
       const std::string& accept_lang,
       content::JavaScriptMessageType javascript_message_type,
-      const string16& message_text,
-      const string16& default_prompt_text,
+      const base::string16& message_text,
+      const base::string16& default_prompt_text,
       const DialogClosedCallback& callback,
       bool* did_suppress_message) OVERRIDE;
   virtual void RunBeforeUnloadDialog(
       content::WebContents* web_contents,
-      const string16& message_text,
+      const base::string16& message_text,
       bool is_reload,
       const DialogClosedCallback& callback) OVERRIDE;
   virtual void CancelActiveAndPendingDialogs(

atom/browser/atom_resource_dispatcher_host_delegate.cc

@@ -0,0 +1,50 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_resource_dispatcher_host_delegate.h"
+
+#include <string>
+
+#include "base/logging.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/resource_request_info.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_request.h"
+
+namespace atom {
+
+namespace {
+
+const char* kDisableXFrameOptions = "disable-x-frame-options";
+
+}  // namespace
+
+AtomResourceDispatcherHostDelegate::AtomResourceDispatcherHostDelegate() {
+}
+
+AtomResourceDispatcherHostDelegate::~AtomResourceDispatcherHostDelegate() {
+}
+
+void AtomResourceDispatcherHostDelegate::OnResponseStarted(
+    net::URLRequest* request,
+    content::ResourceContext* resource_context,
+    content::ResourceResponse* response,
+    IPC::Sender* sender) {
+  // Check if frame's name contains "disable-x-frame-options"
+  int p, f;
+  if (!content::ResourceRequestInfo::GetRenderFrameForRequest(request, &p, &f))
+    return;
+  content::RenderFrameHost* frame = content::RenderFrameHost::FromID(p, f);
+  if (!frame)
+    return;
+  if (frame->GetFrameName().find(kDisableXFrameOptions) == std::string::npos)
+    return;
+
+  // Remove the "X-Frame-Options" from response headers.
+  net::HttpResponseHeaders* response_headers = request->response_headers();
+  if (response_headers && response_headers->HasHeader("x-frame-options"))
+    response_headers->RemoveHeader("x-frame-options");
+}
+
+}  // namespace atom

atom/browser/atom_resource_dispatcher_host_delegate.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
+#define ATOM_BROWSER_ATOM_RESOURCE_DISPATCHER_HOST_DELEGATE_H_
+
+#include "base/compiler_specific.h"
+#include "content/public/browser/resource_dispatcher_host_delegate.h"
+
+namespace atom {
+
+class AtomResourceDispatcherHostDelegate
+    : public content::ResourceDispatcherHostDelegate {
+ public:
+  AtomResourceDispatcherHostDelegate();
+  virtual ~AtomResourceDispatcherHostDelegate();
+
+  // content::ResourceDispatcherHostDelegate:
+  virtual void OnResponseStarted(net::URLRequest* request,
+                                 content::ResourceContext* resource_context,
+                                 content::ResourceResponse* response,
+                                 IPC::Sender* sender) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomResourceDispatcherHostDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_RESOURCE_DISPATCHER_HOST_DELEGATE_H_

atom/browser/atom_speech_recognition_manager_delegate.cc

@@ -0,0 +1,74 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_speech_recognition_manager_delegate.h"
+
+#include <string>
+
+#include "base/callback.h"
+
+namespace atom {
+
+AtomSpeechRecognitionManagerDelegate::AtomSpeechRecognitionManagerDelegate() {
+}
+
+AtomSpeechRecognitionManagerDelegate::~AtomSpeechRecognitionManagerDelegate() {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnRecognitionStart(int session_id) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnAudioStart(int session_id) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnEnvironmentEstimationComplete(
+    int session_id) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnSoundStart(int session_id) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnSoundEnd(int session_id) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnAudioEnd(int session_id) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnRecognitionEnd(int session_id) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnRecognitionResults(
+    int session_id, const content::SpeechRecognitionResults& result) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnRecognitionError(
+    int session_id, const content::SpeechRecognitionError& error) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::OnAudioLevelsChange(
+    int session_id, float volume, float noise_volume) {
+}
+
+void AtomSpeechRecognitionManagerDelegate::GetDiagnosticInformation(
+    bool* can_report_metrics, std::string* hardware_info) {
+  *can_report_metrics = false;
+}
+
+void AtomSpeechRecognitionManagerDelegate::CheckRecognitionIsAllowed(
+    int session_id,
+    base::Callback<void(bool ask_user, bool is_allowed)> callback) {
+  callback.Run(true, true);
+}
+
+content::SpeechRecognitionEventListener*
+AtomSpeechRecognitionManagerDelegate::GetEventListener() {
+  return this;
+}
+
+bool AtomSpeechRecognitionManagerDelegate::FilterProfanities(
+    int render_process_id) {
+  return false;
+}
+
+}  // namespace atom

atom/browser/atom_speech_recognition_manager_delegate.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_SPEECH_RECOGNITION_MANAGER_DELEGATE_H_
+#define ATOM_BROWSER_ATOM_SPEECH_RECOGNITION_MANAGER_DELEGATE_H_
+
+#include <string>
+
+#include "content/public/browser/speech_recognition_event_listener.h"
+#include "content/public/browser/speech_recognition_manager_delegate.h"
+
+namespace atom {
+
+class AtomSpeechRecognitionManagerDelegate
+    : public content::SpeechRecognitionManagerDelegate,
+      public content::SpeechRecognitionEventListener {
+ public:
+  AtomSpeechRecognitionManagerDelegate();
+  virtual ~AtomSpeechRecognitionManagerDelegate();
+
+  // content::SpeechRecognitionEventListener:
+  virtual void OnRecognitionStart(int session_id) override;
+  virtual void OnAudioStart(int session_id) override;
+  virtual void OnEnvironmentEstimationComplete(int session_id) override;
+  virtual void OnSoundStart(int session_id) override;
+  virtual void OnSoundEnd(int session_id) override;
+  virtual void OnAudioEnd(int session_id) override;
+  virtual void OnRecognitionEnd(int session_id) override;
+  virtual void OnRecognitionResults(
+      int session_id, const content::SpeechRecognitionResults& result) override;
+  virtual void OnRecognitionError(
+      int session_id, const content::SpeechRecognitionError& error) override;
+  virtual void OnAudioLevelsChange(int session_id, float volume,
+                                   float noise_volume) override;
+
+  // content::SpeechRecognitionManagerDelegate:
+  virtual void GetDiagnosticInformation(bool* can_report_metrics,
+                                        std::string* hardware_info) override;
+  virtual void CheckRecognitionIsAllowed(
+      int session_id,
+      base::Callback<void(bool ask_user, bool is_allowed)> callback) override;
+  virtual content::SpeechRecognitionEventListener* GetEventListener() override;
+  virtual bool FilterProfanities(int render_process_id) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomSpeechRecognitionManagerDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_SPEECH_RECOGNITION_MANAGER_DELEGATE_H_

atom/browser/auto_updater_mac.mm

@@ -48,11 +48,13 @@ void AutoUpdater::SetFeedURL(const std::string& feed) {
     [[g_updater rac_valuesForKeyPath:@"state" observer:g_updater]
       subscribeNext:^(NSNumber *stateNumber) {
         int state = [stateNumber integerValue];
-        if (state == SQRLUpdaterStateCheckingForUpdate) {
-          delegate->OnCheckingForUpdate();
-        } else if (state == SQRLUpdaterStateDownloadingUpdate) {
-          delegate->OnUpdateAvailable();
-        }
+        // Dispatching the event on main thread.
+        dispatch_async(dispatch_get_main_queue(), ^{
+          if (state == SQRLUpdaterStateCheckingForUpdate)
+            delegate->OnCheckingForUpdate();
+          else if (state == SQRLUpdaterStateDownloadingUpdate)
+            delegate->OnUpdateAvailable();
+        });
     }];
   }
 }
@@ -89,4 +91,5 @@ void AutoUpdater::CheckForUpdates() {
         delegate->OnError(base::SysNSStringToUTF8(error.localizedDescription));
       }];
 }
+
 }  // namespace auto_updater

atom/browser/browser.cc

@@ -37,6 +37,8 @@ void Browser::Quit() {
 }
 
 void Browser::Shutdown() {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnQuit());
+
   is_quiting_ = true;
   base::MessageLoop::current()->Quit();
 }

atom/browser/browser.h

@@ -56,6 +56,10 @@ class Browser : public WindowListObserver {
   // Set/Get dock's badge text.
   void DockSetBadgeText(const std::string& label);
   std::string DockGetBadgeText();
+
+  // Hide/Show dock.
+  void DockHide();
+  void DockShow();
 #endif  // defined(OS_MACOSX)
 
   // Tell the application to open a file.

atom/browser/browser_mac.mm

@@ -4,9 +4,11 @@
 
 #include "atom/browser/browser.h"
 
+#import "atom/browser/mac/atom_application.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/window_list.h"
 #import "base/mac/bundle_locations.h"
 #include "base/strings/sys_string_conversions.h"
-#import "atom/browser/mac/atom_application.h"
 
 namespace atom {
 
@@ -44,4 +46,18 @@ std::string Browser::DockGetBadgeText() {
   return base::SysNSStringToUTF8([tile badgeLabel]);
 }
 
+void Browser::DockHide() {
+  WindowList* list = WindowList::GetInstance();
+  for (WindowList::iterator it = list->begin(); it != list->end(); ++it)
+    [(*it)->GetNativeWindow() setCanHide:NO];
+
+  ProcessSerialNumber psn = { 0, kCurrentProcess };
+  TransformProcessType(&psn, kProcessTransformToUIElementApplication);
+}
+
+void Browser::DockShow() {
+  ProcessSerialNumber psn = { 0, kCurrentProcess };
+  TransformProcessType(&psn, kProcessTransformToForegroundApplication);
+}
+
 }  // namespace atom

atom/browser/browser_observer.h

@@ -18,6 +18,9 @@ class BrowserObserver {
   // method will not be called, instead it will call OnWillQuit.
   virtual void OnWindowAllClosed() {}
 
+  // The browser is quitting.
+  virtual void OnQuit() {}
+
   // The browser has opened a file by double clicking in Finder or dragging the
   // file to the Dock icon. (OS X only)
   virtual void OnOpenFile(bool* prevent_default,

atom/browser/browser_win.cc

@@ -44,7 +44,7 @@ std::string Browser::GetExecutableFileVersion() const {
   if (PathService::Get(base::FILE_EXE, &path)) {
     scoped_ptr<FileVersionInfo> version_info(
         FileVersionInfo::CreateFileVersionInfo(path));
-    return UTF16ToUTF8(version_info->product_version());
+    return base::UTF16ToUTF8(version_info->product_version());
   }
 
   return ATOM_VERSION_STRING;
@@ -55,7 +55,7 @@ std::string Browser::GetExecutableFileProductName() const {
   if (PathService::Get(base::FILE_EXE, &path)) {
     scoped_ptr<FileVersionInfo> version_info(
         FileVersionInfo::CreateFileVersionInfo(path));
-    return UTF16ToUTF8(version_info->product_name());
+    return base::UTF16ToUTF8(version_info->product_name());
   }
 
   return "Atom-Shell";

atom/browser/default_app/default_app.js

@@ -12,14 +12,15 @@ app.on('window-all-closed', function() {
 });
 
 app.on('ready', function() {
-  app.commandLine.appendSwitch('js-flags', '--harmony_collections');
-
   mainWindow = new BrowserWindow({
     width: 800,
     height: 600,
+    resizable: false,
+    'auto-hide-menu-bar': true,
     'use-content-size': true,
   });
   mainWindow.loadUrl('file://' + __dirname + '/index.html');
+  mainWindow.focus();
 
   if (process.platform == 'darwin') {
     var template = [
@@ -33,6 +34,13 @@ app.on('ready', function() {
           {
             type: 'separator'
           },
+          {
+            label: 'Services',
+            submenu: []
+          },
+          {
+            type: 'separator'
+          },
           {
             label: 'Hide Atom Shell',
             accelerator: 'Command+H',
@@ -105,7 +113,7 @@ app.on('ready', function() {
           },
           {
             label: 'Enter Fullscreen',
-            click: function() { mainWindow.setFullscreen(true); }
+            click: function() { mainWindow.setFullScreen(true); }
           },
           {
             label: 'Toggle DevTools',
@@ -143,33 +151,33 @@ app.on('ready', function() {
   } else {
     var template = [
       {
-        label: 'File',
+        label: '&File',
         submenu: [
           {
-            label: 'Open',
+            label: '&Open',
             accelerator: 'Ctrl+O',
           },
           {
-            label: 'Close',
+            label: '&Close',
             accelerator: 'Ctrl+W',
             click: function() { mainWindow.close(); }
           },
         ]
       },
       {
-        label: 'View',
+        label: '&View',
         submenu: [
           {
-            label: 'Reload',
+            label: '&Reload',
             accelerator: 'Ctrl+R',
             click: function() { mainWindow.restart(); }
           },
           {
-            label: 'Enter Fullscreen',
+            label: '&Enter Fullscreen',
             click: function() { mainWindow.setFullScreen(true); }
           },
           {
-            label: 'Toggle DevTools',
+            label: '&Toggle DevTools',
             accelerator: 'Alt+Ctrl+I',
             click: function() { mainWindow.toggleDevTools(); }
           },

atom/browser/default_app/index.html

@@ -2,12 +2,6 @@
 <head>
   <title>Atom Shell</title>
   <style>
-    html {
-      height: 100%;
-      width: 100%;
-      overflow: hidden;
-    }
-
     body {
       color: #555;
       font-family: 'Open Sans',Helvetica,Arial,sans-serif;
@@ -78,7 +72,7 @@
     };
   </script>
 
-  <h2>Welcome to Atom Shell</h2>
+  <h2 style="-webkit-app-region: drag">Welcome to Atom Shell</h2>
 
   <p>
   To run your app with atom-shell, execute the following command under your

atom/browser/default_app/main.js

@@ -1,7 +1,7 @@
 var app = require('app');
 var dialog = require('dialog');
+var fs = require('fs');
 var path = require('path');
-var optimist = require('optimist');
 
 // Quit when all windows are closed and no other one is listening to this.
 app.on('window-all-closed', function() {
@@ -9,16 +9,46 @@ app.on('window-all-closed', function() {
     app.quit();
 });
 
-var argv = optimist(process.argv.slice(1)).boolean('ci').argv;
+// Parse command line options.
+var argv = process.argv.slice(1);
+var option = { file: null, version: null, webdriver: null };
+for (var i in argv) {
+  if (argv[i] == '--version' || argv[i] == '-v') {
+    option.version = true;
+    break;
+  } else if (argv[i] == '--test-type=webdriver') {
+    option.webdriver = true;
+  } else if (argv[i][0] == '-') {
+    continue;
+  } else {
+    option.file = argv[i];
+    break;
+  }
+}
 
 // Start the specified app if there is one specified in command line, otherwise
 // start the default app.
-if (argv._.length > 0) {
+if (option.file && !option.webdriver) {
   try {
-    require(path.resolve(argv._[0]));
+    // Override app name and version.
+    var packagePath = path.resolve(option.file);
+    var packageJsonPath = path.join(packagePath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      var packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
+      if (packageJson.version)
+        app.setVersion(packageJson.version);
+      if (packageJson.productName)
+        app.setName(packageJson.productName);
+      else if (packageJson.name)
+        app.setName(packageJson.name);
+    }
+
+    // Run the app.
+    require('module')._load(packagePath, module, true);
   } catch(e) {
     if (e.code == 'MODULE_NOT_FOUND') {
       app.focus();
+      console.error(e.stack);
       dialog.showMessageBox({
         type: 'warning',
         buttons: ['OK'],
@@ -32,7 +62,7 @@ if (argv._.length > 0) {
       throw e;
     }
   }
-} else if (argv.version) {
+} else if (option.version) {
   console.log('v' + process.versions['atom-shell']);
   process.exit(0);
 } else {

atom/browser/default_app/package.json

@@ -2,8 +2,5 @@
   "name": "atom-shell-default-app",
   "productName": "Atom Shell Default App",
   "version": "0.1.0",
-  "main": "main.js",
-  "dependencies": {
-    "optimist": "*"
-  }
+  "main": "main.js"
 }

atom/browser/devtools_delegate.cc

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

@@ -1,87 +0,0 @@
-// Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_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/javascript_environment.cc

@@ -0,0 +1,19 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/javascript_environment.h"
+
+namespace atom {
+
+JavascriptEnvironment::JavascriptEnvironment()
+    : isolate_holder_(gin::IsolateHolder::kNonStrictMode),
+      isolate_(isolate_holder_.isolate()),
+      isolate_scope_(isolate_),
+      locker_(isolate_),
+      handle_scope_(isolate_),
+      context_(isolate_, v8::Context::New(isolate_)),
+      context_scope_(v8::Local<v8::Context>::New(isolate_, context_)) {
+}
+
+}  // namespace atom

atom/browser/javascript_environment.h

@@ -0,0 +1,36 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_JAVASCRIPT_ENVIRONMENT_H_
+#define ATOM_BROWSER_JAVASCRIPT_ENVIRONMENT_H_
+
+#include "base/basictypes.h"
+#include "gin/public/isolate_holder.h"
+
+namespace atom {
+
+class JavascriptEnvironment {
+ public:
+  JavascriptEnvironment();
+
+  v8::Isolate* isolate() const { return isolate_; }
+  v8::Local<v8::Context> context() const {
+    return v8::Local<v8::Context>::New(isolate_, context_);
+  }
+
+ private:
+  gin::IsolateHolder isolate_holder_;
+  v8::Isolate* isolate_;
+  v8::Isolate::Scope isolate_scope_;
+  v8::Locker locker_;
+  v8::HandleScope handle_scope_;
+  v8::UniquePersistent<v8::Context> context_;
+  v8::Context::Scope context_scope_;
+
+  DISALLOW_COPY_AND_ASSIGN(JavascriptEnvironment);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_JAVASCRIPT_ENVIRONMENT_H_

atom/browser/lib/chrome-extension.coffee

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

atom/browser/lib/init.coffee

@@ -1,9 +1,10 @@
-fs   = require 'fs'
-path = require 'path'
-util = require 'util'
+fs     = require 'fs'
+path   = require 'path'
+module = require 'module'
+util   = require 'util'
 
 # Expose information of current process.
-process.__atom_type = 'browser'
+process.type = 'browser'
 process.resourcesPath = path.resolve process.argv[1], '..', '..', '..', '..'
 
 # We modified the original process.argv to let node.js load the atom.js,
@@ -13,11 +14,11 @@ process.argv.splice 1, 1
 # Pick out switches appended by atom-shell.
 startMark = process.argv.indexOf '--atom-shell-switches-start'
 endMark = process.argv.indexOf '--atom-shell-switches-end'
-process.execArgv = process.argv.splice startMark, endMark - startMark + 1
+process.argv.splice startMark, endMark - startMark + 1
 
 # Add browser/api/lib to require's search paths,
 # which contains javascript part of Atom's built-in libraries.
-globalPaths = require('module').globalPaths
+globalPaths = module.globalPaths
 globalPaths.push path.join process.resourcesPath, 'atom', 'browser', 'api', 'lib'
 
 # Do loading in next tick since we still need some initialize work before
@@ -46,25 +47,31 @@ setImmediate ->
     message = error.stack ? "#{error.name}: #{error.message}"
     require('dialog').showMessageBox
       type: 'warning'
-      title: 'An javascript error occured in the browser'
+      title: 'A javascript error occured in the browser'
       message: 'uncaughtException'
       detail: message
       buttons: ['OK']
 
+  # Emit 'exit' event on quit.
+  require('app').on 'quit', ->
+    process.emit 'exit'
+
   # Load the RPC server.
   require './rpc-server.js'
 
   # Now we try to load app's package.json.
   packageJson = null
 
-  packagePath = path.join process.resourcesPath, 'app'
-  try
-    # First we try to load process.resourcesPath/app
-    packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
-  catch error
-    # If not found then we load browser/default_app
-    packagePath = path.join process.resourcesPath, 'default_app'
-    packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
+  searchPaths = [ 'app', 'app.asar', 'default_app' ]
+  for packagePath in searchPaths
+    try
+      packagePath = path.join process.resourcesPath, packagePath
+      packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
+      break
+    catch e
+      continue
+
+  throw new Error("Unable to find a valid app") unless packageJson?
 
   # Set application's version.
   app = require 'app'
@@ -76,5 +83,14 @@ setImmediate ->
   else if packageJson.name?
     app.setName packageJson.name
 
+  # Set application's desktop name.
+  if packageJson.desktopName?
+    app.setDesktopName packageJson.desktopName
+  else
+    app.setDesktopName '#{app.getName()}.desktop'
+
+  # Load the chrome extension support.
+  require './chrome-extension.js'
+
   # Finally load app's main.js and transfer control to C++.
-  require path.join(packagePath, packageJson.main)
+  module._load path.join(packagePath, packageJson.main), module, true

atom/browser/lib/rpc-server.coffee

@@ -84,7 +84,7 @@ process.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (id) ->
 
 ipc.on 'ATOM_BROWSER_REQUIRE', (event, module) ->
   try
-    event.returnValue = valueToMeta event.sender, require(module)
+    event.returnValue = valueToMeta event.sender, process.mainModule.require(module)
   catch e
     event.returnValue = errorToMeta e
 

atom/browser/native_window.cc

@@ -11,70 +11,101 @@
 #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/chrome_version.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/prefs/pref_service.h"
 #include "base/message_loop/message_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
+#include "brightray/browser/inspectable_web_contents.h"
+#include "brightray/browser/inspectable_web_contents_view.h"
+#include "chrome/browser/printing/print_view_manager_basic.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/plugin_service.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
-#include "content/public/browser/web_contents_view.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/renderer_preferences.h"
+#include "content/public/common/user_agent.h"
+#include "content/public/common/web_preferences.h"
 #include "ipc/ipc_message_macros.h"
+#include "native_mate/dictionary.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.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;
 
 namespace atom {
 
+namespace {
+
+// Array of available web runtime features.
+const char* kWebRuntimeFeatures[] = {
+  switches::kExperimentalFeatures,
+  switches::kExperimentalCanvasFeatures,
+  switches::kSubpixelFontScaling,
+  switches::kOverlayScrollbars,
+  switches::kOverlayFullscreenVideo,
+  switches::kSharedWorker,
+};
+
+std::string RemoveWhitespace(const std::string& str) {
+  std::string trimmed;
+  if (base::RemoveChars(str, " ", &trimmed))
+    return trimmed;
+  else
+    return str;
+}
+
+}  // namespace
+
 NativeWindow::NativeWindow(content::WebContents* web_contents,
-                           base::DictionaryValue* options)
+                           const mate::Dictionary& options)
     : content::WebContentsObserver(web_contents),
       has_frame_(true),
+      enable_larger_than_screen_(false),
       is_closed_(false),
       node_integration_("except-iframe"),
       has_dialog_attached_(false),
+      zoom_factor_(1.0),
       weak_factory_(this),
       inspectable_web_contents_(
           brightray::InspectableWebContents::Create(web_contents)) {
-  options->GetBoolean(switches::kFrame, &has_frame_);
+  printing::PrintViewManagerBasic::CreateForWebContents(web_contents);
 
-#if defined(OS_MACOSX)
-  // Temporary fix for flashing devtools, try removing this after upgraded to
-  // Chrome 32.
-  web_contents->GetView()->SetAllowOverlappingViews(false);
-#endif
+  options.Get(switches::kFrame, &has_frame_);
+  options.Get(switches::kEnableLargerThanScreen, &enable_larger_than_screen_);
 
   // Read icon before window is created.
-  std::string icon;
-  if (options->GetString(switches::kIcon, &icon) && !SetIcon(icon))
-    LOG(ERROR) << "Failed to set icon to " << icon;
+  options.Get(switches::kIcon, &icon_);
 
   // Read iframe security before any navigation.
-  options->GetString(switches::kNodeIntegration, &node_integration_);
+  options.Get(switches::kNodeIntegration, &node_integration_);
+
+  // Read the web preferences.
+  options.Get(switches::kWebPreferences, &web_preferences_);
+
+  // Read the zoom factor before any navigation.
+  options.Get(switches::kZoomFactor, &zoom_factor_);
 
   web_contents->SetDelegate(this);
   inspectable_web_contents()->SetDelegate(this);
@@ -84,11 +115,12 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
   // Override the user agent to contain application and atom-shell's version.
   Browser* browser = Browser::Get();
   std::string product_name = base::StringPrintf(
-      "%s/%s Atom-Shell/" ATOM_VERSION_STRING,
-      browser->GetName().c_str(),
-      browser->GetVersion().c_str());
+      "%s/%s Chrome/%s AtomShell/" ATOM_VERSION_STRING,
+      RemoveWhitespace(browser->GetName()).c_str(),
+      browser->GetVersion().c_str(),
+      CHROME_VERSION_STRING);
   web_contents->GetMutableRendererPrefs()->user_agent_override =
-      webkit_glue::BuildUserAgentFromProduct(product_name);
+      content::BuildUserAgentFromProduct(product_name);
 
   // Get notified of title updated message.
   registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED,
@@ -96,29 +128,17 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
 }
 
 NativeWindow::~NativeWindow() {
-  // Make sure we have the OnRenderViewDeleted message sent even when the window
-  // is destroyed directly.
-  DestroyWebContents();
-
   // It's possible that the windows gets destroyed before it's closed, in that
   // case we need to ensure the OnWindowClosed message is still notified.
   NotifyWindowClosed();
 }
 
 // static
-NativeWindow* NativeWindow::Create(base::DictionaryValue* options) {
+NativeWindow* NativeWindow::Create(const mate::Dictionary& options) {
   content::WebContents::CreateParams create_params(AtomBrowserContext::Get());
   return Create(content::WebContents::Create(create_params), options);
 }
 
-// static
-NativeWindow* NativeWindow::Debug(content::WebContents* web_contents) {
-  base::DictionaryValue options;
-  NativeWindow* window = NativeWindow::Create(&options);
-  window->devtools_delegate_.reset(new DevToolsDelegate(window, web_contents));
-  return window;
-}
-
 // static
 NativeWindow* NativeWindow::FromRenderView(int process_id, int routing_id) {
   // Stupid iterating.
@@ -135,90 +155,101 @@ NativeWindow* NativeWindow::FromRenderView(int process_id, int routing_id) {
   return NULL;
 }
 
-void NativeWindow::InitFromOptions(base::DictionaryValue* options) {
+void NativeWindow::InitFromOptions(const mate::Dictionary& options) {
   // Setup window from options.
   int x = -1, y = -1;
   bool center;
-  if (options->GetInteger(switches::kX, &x) &&
-      options->GetInteger(switches::kY, &y)) {
+  if (options.Get(switches::kX, &x) && options.Get(switches::kY, &y)) {
     int width = -1, height = -1;
-    options->GetInteger(switches::kWidth, &width);
-    options->GetInteger(switches::kHeight, &height);
+    options.Get(switches::kWidth, &width);
+    options.Get(switches::kHeight, &height);
     Move(gfx::Rect(x, y, width, height));
-  } else if (options->GetBoolean(switches::kCenter, &center) && center) {
+  } else if (options.Get(switches::kCenter, &center) && center) {
     Center();
   }
-  int min_height = -1, min_width = -1;
-  if (options->GetInteger(switches::kMinHeight, &min_height) &&
-      options->GetInteger(switches::kMinWidth, &min_width)) {
+  int min_height = 0, min_width = 0;
+  if (options.Get(switches::kMinHeight, &min_height) |
+      options.Get(switches::kMinWidth, &min_width)) {
     SetMinimumSize(gfx::Size(min_width, min_height));
   }
   int max_height = -1, max_width = -1;
-  if (options->GetInteger(switches::kMaxHeight, &max_height) &&
-      options->GetInteger(switches::kMaxWidth, &max_width)) {
+  if (options.Get(switches::kMaxHeight, &max_height) &&
+      options.Get(switches::kMaxWidth, &max_width)) {
     SetMaximumSize(gfx::Size(max_width, max_height));
   }
   bool resizable;
-  if (options->GetBoolean(switches::kResizable, &resizable)) {
+  if (options.Get(switches::kResizable, &resizable)) {
     SetResizable(resizable);
   }
   bool top;
-  if (options->GetBoolean(switches::kAlwaysOnTop, &top) && top) {
+  if (options.Get(switches::kAlwaysOnTop, &top) && top) {
     SetAlwaysOnTop(true);
   }
   bool fullscreen;
-  if (options->GetBoolean(switches::kFullscreen, &fullscreen) && fullscreen) {
+  if (options.Get(switches::kFullscreen, &fullscreen) && fullscreen) {
     SetFullscreen(true);
   }
+  bool skip;
+  if (options.Get(switches::kSkipTaskbar, &skip) && skip) {
+    SetSkipTaskbar(skip);
+  }
   bool kiosk;
-  if (options->GetBoolean(switches::kKiosk, &kiosk) && kiosk) {
+  if (options.Get(switches::kKiosk, &kiosk) && kiosk) {
     SetKiosk(kiosk);
   }
   std::string title("Atom Shell");
-  options->GetString(switches::kTitle, &title);
+  options.Get(switches::kTitle, &title);
   SetTitle(title);
 
   // Then show it.
   bool show = true;
-  options->GetBoolean(switches::kShow, &show);
+  options.Get(switches::kShow, &show);
   if (show)
     Show();
 }
 
+void NativeWindow::SetRepresentedFilename(const std::string& filename) {
+}
+
+std::string NativeWindow::GetRepresentedFilename() {
+  return "";
+}
+
+void NativeWindow::SetDocumentEdited(bool edited) {
+}
+
+bool NativeWindow::IsDocumentEdited() {
+  return false;
+}
+
+void NativeWindow::SetMenu(ui::MenuModel* menu) {
+}
+
+void NativeWindow::Print(bool silent, bool print_background) {
+  printing::PrintViewManagerBasic::FromWebContents(GetWebContents())->
+      PrintNow(silent, print_background);
+}
+
 bool NativeWindow::HasModalDialog() {
   return has_dialog_attached_;
 }
 
 void NativeWindow::OpenDevTools() {
-  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
-  }
+  inspectable_web_contents()->ShowDevTools();
 }
 
 void NativeWindow::CloseDevTools() {
-  if (devtools_window_)
-    devtools_window_->Close();
-  else
-    inspectable_web_contents()->CloseDevTools();
+  inspectable_web_contents()->CloseDevTools();
 }
 
 bool NativeWindow::IsDevToolsOpened() {
-  return (devtools_window_ && devtools_window_->IsFocused()) ||
-         inspectable_web_contents()->IsDevToolsViewShowing();
+  return inspectable_web_contents()->IsDevToolsViewShowing();
 }
 
 void NativeWindow::InspectElement(int x, int y) {
   OpenDevTools();
-  content::RenderViewHost* rvh = GetWebContents()->GetRenderViewHost();
   scoped_refptr<content::DevToolsAgentHost> agent(
-      content::DevToolsAgentHost::GetOrCreateFor(rvh));
+      content::DevToolsAgentHost::GetOrCreateFor(GetWebContents()));
   agent->InspectElement(x, y);
 }
 
@@ -236,30 +267,6 @@ bool NativeWindow::IsWebViewFocused() {
   return host_view && host_view->HasFocus();
 }
 
-bool NativeWindow::SetIcon(const std::string& str_path) {
-  base::FilePath path = base::FilePath::FromUTF8Unsafe(str_path);
-
-  // Read the file from disk.
-  std::string file_contents;
-  if (path.empty() || !base::ReadFileToString(path, &file_contents))
-    return false;
-
-  // Decode the bitmap using WebKit's image decoder.
-  const unsigned char* data =
-      reinterpret_cast<const unsigned char*>(file_contents.data());
-  scoped_ptr<SkBitmap> decoded(new SkBitmap());
-  gfx::PNGCodec::Decode(data, file_contents.length(), decoded.get());
-  if (decoded->empty())
-    return false;  // Unable to decode.
-
-  icon_ = gfx::Image::CreateFrom1xBitmap(*decoded.release());
-  return true;
-}
-
-base::ProcessHandle NativeWindow::GetRenderProcessHandle() {
-  return GetWebContents()->GetRenderProcessHost()->GetHandle();
-}
-
 void NativeWindow::CapturePage(const gfx::Rect& rect,
                                const CapturePageCallback& callback) {
   content::RenderViewHost* render_view_host =
@@ -272,21 +279,14 @@ void NativeWindow::CapturePage(const gfx::Rect& rect,
     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,
-      size,
+      rect,
+      rect.IsEmpty() ? render_widget_host_view->GetViewBounds().size() :
+                       rect.size(),
       base::Bind(&NativeWindow::OnCapturePageDone,
                  weak_factory_.GetWeakPtr(),
-                 callback));
+                 callback),
+      kAlpha_8_SkColorType);
 }
 
 void NativeWindow::DestroyWebContents() {
@@ -320,7 +320,7 @@ void NativeWindow::CloseWebContents() {
     ScheduleUnresponsiveEvent(5000);
 
   if (web_contents->NeedToFireBeforeUnload())
-    web_contents->GetRenderViewHost()->FirePageBeforeUnload(false);
+    web_contents->DispatchBeforeUnload(false);
   else
     web_contents->Close();
 }
@@ -337,17 +337,62 @@ content::WebContents* NativeWindow::GetDevToolsWebContents() const {
   return inspectable_web_contents()->devtools_web_contents();
 }
 
-void NativeWindow::AppendExtraCommandLineSwitches(CommandLine* command_line,
-                                                  int child_process_id) {
+void NativeWindow::AppendExtraCommandLineSwitches(
+    base::CommandLine* command_line, int child_process_id) {
   // Append --node-integration to renderer process.
   command_line->AppendSwitchASCII(switches::kNodeIntegration,
                                   node_integration_);
+
+  // Append --zoom-factor.
+  if (zoom_factor_ != 1.0)
+    command_line->AppendSwitchASCII(switches::kZoomFactor,
+                                    base::DoubleToString(zoom_factor_));
+
+  if (web_preferences_.IsEmpty())
+    return;
+
+  bool b;
+#if defined(OS_WIN)
+  // Check if DirectWrite is disabled.
+  if (web_preferences_.Get(switches::kDirectWrite, &b) && !b)
+    command_line->AppendSwitch(::switches::kDisableDirectWrite);
+#endif
+
+  // This set of options are not availabe in WebPreferences, so we have to pass
+  // them via command line and enable them in renderer procss.
+  for (size_t i = 0; i < arraysize(kWebRuntimeFeatures); ++i) {
+    const char* feature = kWebRuntimeFeatures[i];
+    if (web_preferences_.Get(feature, &b))
+      command_line->AppendSwitchASCII(feature, b ? "true" : "false");
+  }
 }
 
-void NativeWindow::OverrideWebkitPrefs(const GURL& url, WebPreferences* prefs) {
-  // FIXME Disable accelerated composition in frameless window.
-  if (!has_frame_)
-    prefs->accelerated_compositing_enabled = false;
+void NativeWindow::OverrideWebkitPrefs(const GURL& url,
+                                       content::WebPreferences* prefs) {
+  if (web_preferences_.IsEmpty())
+    return;
+
+  bool b;
+  std::vector<base::FilePath> list;
+  if (web_preferences_.Get("javascript", &b))
+    prefs->javascript_enabled = b;
+  if (web_preferences_.Get("web-security", &b))
+    prefs->web_security_enabled = b;
+  if (web_preferences_.Get("images", &b))
+    prefs->images_enabled = b;
+  if (web_preferences_.Get("java", &b))
+    prefs->java_enabled = b;
+  if (web_preferences_.Get("text-areas-are-resizable", &b))
+    prefs->text_areas_are_resizable = b;
+  if (web_preferences_.Get("webgl", &b))
+    prefs->experimental_webgl_enabled = b;
+  if (web_preferences_.Get("webaudio", &b))
+    prefs->webaudio_enabled = b;
+  if (web_preferences_.Get("plugins", &b))
+    prefs->plugins_enabled = b;
+  if (web_preferences_.Get("extra-plugin-dirs", &list))
+    for (size_t i = 0; i < list.size(); ++i)
+      content::PluginService::GetInstance()->AddExtraPluginDir(list[i]);
 }
 
 void NativeWindow::NotifyWindowClosed() {
@@ -368,6 +413,10 @@ void NativeWindow::NotifyWindowBlur() {
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowBlur());
 }
 
+void NativeWindow::NotifyWindowFocus() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowFocus());
+}
+
 // In atom-shell all reloads and navigations started by renderer process would
 // be redirected to this method, so we can have precise control of how we
 // would open the url (in our case, is to restart the renderer process). See
@@ -497,7 +546,7 @@ void NativeWindow::Observe(int type,
 
     if (title->first) {
       bool prevent_default = false;
-      std::string text = UTF16ToUTF8(title->first->GetTitle());
+      std::string text = base::UTF16ToUTF8(title->first->GetTitle());
       FOR_EACH_OBSERVER(NativeWindowObserver,
                         observers_,
                         OnPageTitleUpdated(&prevent_default, text));
@@ -508,22 +557,6 @@ void NativeWindow::Observe(int type,
   }
 }
 
-bool NativeWindow::DevToolsSetDockSide(const std::string& dock_side,
-                                       bool* succeed) {
-  if (dock_side == "undocked") {
-    *succeed = false;
-    return true;
-  } else {
-    return false;
-  }
-}
-
-bool NativeWindow::DevToolsShow(std::string* dock_side) {
-  if (*dock_side == "undocked")
-    *dock_side = "bottom";
-  return false;
-}
-
 void NativeWindow::DevToolsSaveToFile(const std::string& url,
                                       const std::string& content,
                                       bool save_as) {
@@ -532,20 +565,21 @@ void NativeWindow::DevToolsSaveToFile(const std::string& url,
   if (it != saved_files_.end() && !save_as) {
     path = it->second;
   } else {
+    file_dialog::Filters filters;
     base::FilePath default_path(base::FilePath::FromUTF8Unsafe(url));
-    if (!file_dialog::ShowSaveDialog(this, url, default_path, &path))
+    if (!file_dialog::ShowSaveDialog(this, url, default_path, filters, &path)) {
+      base::StringValue url_value(url);
+      CallDevToolsFunction("InspectorFrontendAPI.canceledSaveURL", &url_value);
       return;
+    }
   }
 
   saved_files_[url] = path;
-  file_util::WriteFile(path, content.data(), content.size());
+  base::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,
@@ -553,7 +587,7 @@ void NativeWindow::DevToolsAppendToFile(const std::string& url,
   PathsMap::iterator it = saved_files_.find(url);
   if (it == saved_files_.end())
     return;
-  file_util::AppendToFile(it->second, content.data(), content.size());
+  base::AppendToFile(it->second, content.data(), content.size());
 
   // Notify devtools.
   base::StringValue url_value(url);
@@ -609,8 +643,9 @@ void NativeWindow::CallDevToolsFunction(const std::string& function_name,
       }
     }
   }
-  GetDevToolsWebContents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
-      string16(), base::UTF8ToUTF16(function_name + "(" + params + ");"));
+  base::string16 javascript =
+      base::UTF8ToUTF16(function_name + "(" + params + ");");
+  GetDevToolsWebContents()->GetMainFrame()->ExecuteJavaScript(javascript);
 }
 
 }  // namespace atom

atom/browser/native_window.h

@@ -9,31 +9,28 @@
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
+#include "atom/browser/native_window_observer.h"
+#include "atom/browser/ui/accelerator_util.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 "atom/browser/native_window_observer.h"
+#include "brightray/browser/default_web_contents_delegate.h"
+#include "brightray/browser/inspectable_web_contents_delegate.h"
+#include "brightray/browser/inspectable_web_contents_impl.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_observer.h"
-#include "ui/gfx/image/image.h"
-#include "vendor/brightray/browser/default_web_contents_delegate.h"
-#include "vendor/brightray/browser/inspectable_web_contents_delegate.h"
-#include "vendor/brightray/browser/inspectable_web_contents_impl.h"
-
-class CommandLine;
-struct WebPreferences;
+#include "native_mate/persistent_dictionary.h"
+#include "ui/gfx/image/image_skia.h"
 
 namespace base {
-class DictionaryValue;
-class ListValue;
+class CommandLine;
 }
 
 namespace content {
 class BrowserContext;
 class WebContents;
+struct WebPreferences;
 }
 
 namespace gfx {
@@ -42,10 +39,17 @@ class Rect;
 class Size;
 }
 
+namespace mate {
+class Dictionary;
+}
+
+namespace ui {
+class MenuModel;
+}
+
 namespace atom {
 
 class AtomJavaScriptDialogManager;
-class DevToolsDelegate;
 struct DraggableRegion;
 
 class NativeWindow : public brightray::DefaultWebContentsDelegate,
@@ -80,20 +84,16 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   // Create window with existing WebContents, the caller is responsible for
   // managing the window's live.
   static NativeWindow* Create(content::WebContents* web_contents,
-                              base::DictionaryValue* options);
+                              const mate::Dictionary& options);
 
   // Create window with new WebContents, the caller is responsible for
   // managing the window's live.
-  static NativeWindow* Create(base::DictionaryValue* options);
-
-  // Creates a devtools window to debug the WebContents, the returned window
-  // will manage its own life.
-  static NativeWindow* Debug(content::WebContents* web_contents);
+  static NativeWindow* Create(const mate::Dictionary& options);
 
   // Find a window from its process id and routing id.
   static NativeWindow* FromRenderView(int process_id, int routing_id);
 
-  void InitFromOptions(base::DictionaryValue* options);
+  void InitFromOptions(const mate::Dictionary& options);
 
   virtual void Close() = 0;
   virtual void CloseImmediately() = 0;
@@ -105,8 +105,10 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   virtual bool IsVisible() = 0;
   virtual void Maximize() = 0;
   virtual void Unmaximize() = 0;
+  virtual bool IsMaximized() = 0;
   virtual void Minimize() = 0;
   virtual void Restore() = 0;
+  virtual bool IsMinimized() = 0;
   virtual void SetFullscreen(bool fullscreen) = 0;
   virtual bool IsFullscreen() = 0;
   virtual void SetSize(const gfx::Size& size) = 0;
@@ -127,10 +129,17 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   virtual void SetTitle(const std::string& title) = 0;
   virtual std::string GetTitle() = 0;
   virtual void FlashFrame(bool flash) = 0;
+  virtual void SetSkipTaskbar(bool skip) = 0;
   virtual void SetKiosk(bool kiosk) = 0;
   virtual bool IsKiosk() = 0;
+  virtual void SetRepresentedFilename(const std::string& filename);
+  virtual std::string GetRepresentedFilename();
+  virtual void SetDocumentEdited(bool edited);
+  virtual bool IsDocumentEdited();
+  virtual void SetMenu(ui::MenuModel* menu);
   virtual bool HasModalDialog();
   virtual gfx::NativeWindow GetNativeWindow() = 0;
+  virtual void SetProgressBar(double progress) = 0;
 
   virtual bool IsClosed() const { return is_closed_; }
   virtual void OpenDevTools();
@@ -142,17 +151,14 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   virtual void BlurWebView();
   virtual bool IsWebViewFocused();
 
-  virtual bool SetIcon(const std::string& path);
-
-  // Returns the process handle of render process, useful for killing the
-  // render process manually
-  virtual base::ProcessHandle GetRenderProcessHandle();
-
   // Captures the page with |rect|, |callback| would be called when capturing is
   // done.
   virtual void CapturePage(const gfx::Rect& rect,
                            const CapturePageCallback& callback);
 
+  // Print current page.
+  virtual void Print(bool silent, bool print_background);
+
   // The same with closing a tab in a real browser.
   //
   // Should be called by platform code when user want to close the window.
@@ -169,14 +175,15 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   content::WebContents* GetDevToolsWebContents() const;
 
   // Called when renderer process is going to be started.
-  void AppendExtraCommandLineSwitches(CommandLine* command_line,
+  void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
                                       int child_process_id);
-  void OverrideWebkitPrefs(const GURL& url, WebPreferences* prefs);
+  void OverrideWebkitPrefs(const GURL& url, content::WebPreferences* prefs);
 
   // Public API used by platform-dependent delegates and observers to send UI
   // related notifications.
   void NotifyWindowClosed();
   void NotifyWindowBlur();
+  void NotifyWindowFocus();
 
   void AddObserver(NativeWindowObserver* obs) {
     observers_.AddObserver(obs);
@@ -194,7 +201,7 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
 
  protected:
   explicit NativeWindow(content::WebContents* web_contents,
-                        base::DictionaryValue* options);
+                        const mate::Dictionary& options);
 
   brightray::InspectableWebContentsImpl* inspectable_web_contents() const {
     return static_cast<brightray::InspectableWebContentsImpl*>(
@@ -238,9 +245,6 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Implementations of brightray::InspectableWebContentsDelegate.
-  virtual bool DevToolsSetDockSide(const std::string& dock_side,
-                                   bool* succeed) OVERRIDE;
-  virtual bool DevToolsShow(std::string* dock_side) OVERRIDE;
   virtual void DevToolsSaveToFile(const std::string& url,
                                   const std::string& content,
                                   bool save_as) OVERRIDE;
@@ -250,8 +254,11 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   // Whether window has standard frame.
   bool has_frame_;
 
+  // Whether window can be resized larger than screen.
+  bool enable_larger_than_screen_;
+
   // Window icon.
-  gfx::Image icon_;
+  gfx::ImageSkia icon_;
 
  private:
   // Schedule a notification unresponsive event.
@@ -290,10 +297,13 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
   // it should be cancelled when we can prove that the window is responsive.
   base::CancelableClosure window_unresposive_closure_;
 
-  base::WeakPtrFactory<NativeWindow> weak_factory_;
+  // Web preferences.
+  mate::PersistentDictionary web_preferences_;
 
-  base::WeakPtr<NativeWindow> devtools_window_;
-  scoped_ptr<DevToolsDelegate> devtools_delegate_;
+  // Page's default zoom factor.
+  double zoom_factor_;
+
+  base::WeakPtrFactory<NativeWindow> weak_factory_;
 
   scoped_ptr<AtomJavaScriptDialogManager> dialog_manager_;
 

atom/browser/native_window_gtk.cc

@@ -1,603 +0,0 @@
-// Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/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 "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/font_render_params_linux.h"
-#include "ui/gfx/gtk_util.h"
-#include "ui/gfx/rect.h"
-#include "ui/gfx/skia_utils_gtk.h"
-
-namespace atom {
-
-namespace {
-
-// Dividing GTK's cursor blink cycle time (in milliseconds) by this value yields
-// an appropriate value for content::RendererPreferences::caret_blink_interval.
-// This matches the logic in the WebKit GTK port.
-const double kGtkCursorBlinkCycleFactor = 2000.0;
-
-// 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;
-  }
-}
-
-content::RendererPreferencesHintingEnum GetRendererPreferencesHintingEnum(
-    gfx::FontRenderParams::Hinting hinting) {
-  switch (hinting) {
-    case gfx::FontRenderParams::HINTING_NONE:
-      return content::RENDERER_PREFERENCES_HINTING_NONE;
-    case gfx::FontRenderParams::HINTING_SLIGHT:
-      return content::RENDERER_PREFERENCES_HINTING_SLIGHT;
-    case gfx::FontRenderParams::HINTING_MEDIUM:
-      return content::RENDERER_PREFERENCES_HINTING_MEDIUM;
-    case gfx::FontRenderParams::HINTING_FULL:
-      return content::RENDERER_PREFERENCES_HINTING_FULL;
-    default:
-      NOTREACHED() << "Unhandled hinting style " << hinting;
-      return content::RENDERER_PREFERENCES_HINTING_SYSTEM_DEFAULT;
-  }
-}
-
-content::RendererPreferencesSubpixelRenderingEnum
-GetRendererPreferencesSubpixelRenderingEnum(
-    gfx::FontRenderParams::SubpixelRendering subpixel_rendering) {
-  switch (subpixel_rendering) {
-    case gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE:
-      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_NONE;
-    case gfx::FontRenderParams::SUBPIXEL_RENDERING_RGB:
-      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_RGB;
-    case gfx::FontRenderParams::SUBPIXEL_RENDERING_BGR:
-      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_BGR;
-    case gfx::FontRenderParams::SUBPIXEL_RENDERING_VRGB:
-      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_VRGB;
-    case gfx::FontRenderParams::SUBPIXEL_RENDERING_VBGR:
-      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_VBGR;
-    default:
-      NOTREACHED() << "Unhandled subpixel rendering style "
-                   << subpixel_rendering;
-      return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_SYSTEM_DEFAULT;
-  }
-}
-
-}  // namespace
-
-NativeWindowGtk::NativeWindowGtk(content::WebContents* web_contents,
-                                 base::DictionaryValue* options)
-    : 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),
-      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);
-
-  bool use_content_size = false;
-  options->GetBoolean(switches::kUseContentSize, &use_content_size);
-  if (has_frame_ && !use_content_size)
-    SubstractBorderSize(&width, &height);
-
-  // Force a size allocation so the web page of hidden window can have correct
-  // 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
-  // compiz, suppress such raises, as they are not necessary in compiz anyway.
-  if (ui::GuessWindowManager() == ui::WM_COMPIZ)
-    suppress_window_raise_ = true;
-
-  g_signal_connect(window_, "delete-event",
-                   G_CALLBACK(OnWindowDeleteEventThunk), this);
-  g_signal_connect(window_, "focus-out-event",
-                   G_CALLBACK(OnFocusOutThunk), this);
-  g_signal_connect(window_, "window-state-event",
-                   G_CALLBACK(OnWindowStateThunk), this);
-
-  if (!has_frame_) {
-    gtk_window_set_decorated(window_, false);
-
-    g_signal_connect(window_, "motion-notify-event",
-                     G_CALLBACK(OnMouseMoveEventThunk), this);
-    g_signal_connect(window_, "button-press-event",
-                     G_CALLBACK(OnButtonPressThunk), this);
-  }
-
-  SetWebKitColorStyle();
-  SetFontRenderering();
-}
-
-NativeWindowGtk::~NativeWindowGtk() {
-  CloseImmediately();
-}
-
-void NativeWindowGtk::Close() {
-  CloseWebContents();
-}
-
-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());
-  SetSize(pos.size());
-}
-
-void NativeWindowGtk::Focus(bool focus) {
-  if (!IsVisible())
-    return;
-
-  if (focus)
-    gtk_window_present(window_);
-  else
-    gdk_window_lower(gtk_widget_get_window(GTK_WIDGET(window_)));
-}
-
-bool NativeWindowGtk::IsFocused() {
-  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_));
-}
-
-void NativeWindowGtk::Hide() {
-  gtk_widget_hide(GTK_WIDGET(window_));
-}
-
-bool NativeWindowGtk::IsVisible() {
-  return gtk_widget_get_visible(GTK_WIDGET(window_));
-}
-
-void NativeWindowGtk::Maximize() {
-  gtk_window_maximize(window_);
-}
-
-void NativeWindowGtk::Unmaximize() {
-  gtk_window_unmaximize(window_);
-}
-
-void NativeWindowGtk::Minimize() {
-  gtk_window_iconify(window_);
-}
-
-void NativeWindowGtk::Restore() {
-  gtk_window_present(window_);
-}
-
-void NativeWindowGtk::SetFullscreen(bool fullscreen) {
-  if (fullscreen)
-    gtk_window_fullscreen(window_);
-  else
-    gtk_window_unfullscreen(window_);
-}
-
-bool NativeWindowGtk::IsFullscreen() {
-  return state_ & GDK_WINDOW_STATE_FULLSCREEN;
-}
-
-void NativeWindowGtk::SetSize(const gfx::Size& size) {
-  // 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() {
-  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
-
-  GdkRectangle frame_extents;
-  gdk_window_get_frame_extents(gdk_window, &frame_extents);
-
-  return gfx::Size(frame_extents.width, frame_extents.height);
-}
-
-void NativeWindowGtk::SetContentSize(const gfx::Size& size) {
-  if (!has_frame_ || !has_ever_been_shown_) {
-    gtk_window_util::SetWindowSize(window_, size);
-  } else {
-    gfx::Size large = GetSize();
-    gfx::Size small = GetContentSize();
-    gfx::Size target(size.width() + large.width() - small.width(),
-                     size.height() + large.height() - small.height());
-    gtk_window_util::SetWindowSize(window_, target);
-  }
-}
-
-gfx::Size NativeWindowGtk::GetContentSize() {
-  gint width, height;
-  gtk_window_get_size(window_, &width, &height);
-  return gfx::Size(width, height);
-}
-
-void NativeWindowGtk::SetMinimumSize(const gfx::Size& size) {
-  minimum_size_ = size;
-
-  GdkGeometry geometry = { 0 };
-  geometry.min_width = size.width();
-  geometry.min_height = size.height();
-  int hints = GDK_HINT_POS | GDK_HINT_MIN_SIZE;
-  gtk_window_set_geometry_hints(
-      window_, GTK_WIDGET(window_), &geometry, (GdkWindowHints)hints);
-}
-
-gfx::Size NativeWindowGtk::GetMinimumSize() {
-  return minimum_size_;
-}
-
-void NativeWindowGtk::SetMaximumSize(const gfx::Size& size) {
-  maximum_size_ = size;
-
-  GdkGeometry geometry = { 0 };
-  geometry.max_width = size.width();
-  geometry.max_height = size.height();
-  int hints = GDK_HINT_POS | GDK_HINT_MAX_SIZE;
-  gtk_window_set_geometry_hints(
-      window_, GTK_WIDGET(window_), &geometry, (GdkWindowHints)hints);
-}
-
-gfx::Size NativeWindowGtk::GetMaximumSize() {
-  return maximum_size_;
-}
-
-void NativeWindowGtk::SetResizable(bool resizable) {
-  // Should request widget size after setting unresizable, otherwise the
-  // window will shrink to a very small size.
-  if (!IsResizable()) {
-    gint width, height;
-    gtk_window_get_size(window_, &width, &height);
-    gtk_widget_set_size_request(GTK_WIDGET(window_), width, height);
-  }
-
-  gtk_window_set_resizable(window_, resizable);
-}
-
-bool NativeWindowGtk::IsResizable() {
-  return gtk_window_get_resizable(window_);
-}
-
-void NativeWindowGtk::SetAlwaysOnTop(bool top) {
-  is_always_on_top_ = top;
-  gtk_window_set_keep_above(window_, top ? TRUE : FALSE);
-}
-
-bool NativeWindowGtk::IsAlwaysOnTop() {
-  return is_always_on_top_;
-}
-
-void NativeWindowGtk::Center() {
-  gtk_window_set_position(window_, GTK_WIN_POS_CENTER);
-}
-
-void NativeWindowGtk::SetPosition(const gfx::Point& position) {
-  gtk_window_move(window_, position.x(), position.y());
-}
-
-gfx::Point NativeWindowGtk::GetPosition() {
-  GdkWindow* gdk_window = gtk_widget_get_window(GTK_WIDGET(window_));
-
-  GdkRectangle frame_extents;
-  gdk_window_get_frame_extents(gdk_window, &frame_extents);
-
-  return gfx::Point(frame_extents.x, frame_extents.y);
-}
-
-void NativeWindowGtk::SetTitle(const std::string& title) {
-  gtk_window_set_title(window_, title.c_str());
-}
-
-std::string NativeWindowGtk::GetTitle() {
-  return gtk_window_get_title(window_);
-}
-
-void NativeWindowGtk::FlashFrame(bool flash) {
-  gtk_window_set_urgency_hint(window_, flash);
-}
-
-void NativeWindowGtk::SetKiosk(bool kiosk) {
-  SetFullscreen(kiosk);
-}
-
-bool NativeWindowGtk::IsKiosk() {
-  return IsFullscreen();
-}
-
-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);
-  gtk_widget_show_all(vbox_);
-  RegisterAccelerators();
-}
-
-void NativeWindowGtk::UpdateDraggableRegions(
-    const std::vector<DraggableRegion>& regions) {
-  // Draggable region is not supported for non-frameless window.
-  if (has_frame_)
-    return;
-
-  draggable_region_.reset(new SkRegion);
-
-  // By default, the whole window is non-draggable. We need to explicitly
-  // include those draggable regions.
-  for (std::vector<DraggableRegion>::const_iterator iter =
-           regions.begin();
-       iter != regions.end(); ++iter) {
-    const DraggableRegion& region = *iter;
-    draggable_region_->op(
-        region.bounds.x(),
-        region.bounds.y(),
-        region.bounds.right(),
-        region.bounds.bottom(),
-        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
-  }
-}
-
-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() {
-  content::RendererPreferences* prefs =
-      GetWebContents()->GetMutableRendererPrefs();
-  GtkStyle* frame_style = gtk_rc_get_style(GTK_WIDGET(window_));
-  prefs->focus_ring_color =
-      gfx::GdkColorToSkColor(frame_style->bg[GTK_STATE_SELECTED]);
-  prefs->thumb_active_color = SkColorSetRGB(244, 244, 244);
-  prefs->thumb_inactive_color = SkColorSetRGB(234, 234, 234);
-  prefs->track_color = SkColorSetRGB(211, 211, 211);
-
-  GtkWidget* url_entry = gtk_entry_new();
-  GtkStyle* entry_style = gtk_rc_get_style(url_entry);
-  prefs->active_selection_bg_color =
-      gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_SELECTED]);
-  prefs->active_selection_fg_color =
-      gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_SELECTED]);
-  prefs->inactive_selection_bg_color =
-      gfx::GdkColorToSkColor(entry_style->base[GTK_STATE_ACTIVE]);
-  prefs->inactive_selection_fg_color =
-      gfx::GdkColorToSkColor(entry_style->text[GTK_STATE_ACTIVE]);
-  gtk_widget_destroy(url_entry);
-
-  const base::TimeDelta cursor_blink_time = gfx::GetCursorBlinkCycle();
-  prefs->caret_blink_interval =
-      cursor_blink_time.InMilliseconds() ?
-      cursor_blink_time.InMilliseconds() / kGtkCursorBlinkCycleFactor :
-      0;
-}
-
-void NativeWindowGtk::SetFontRenderering() {
-  content::RendererPreferences* prefs =
-      GetWebContents()->GetMutableRendererPrefs();
-  const gfx::FontRenderParams& params = gfx::GetDefaultWebKitFontRenderParams();
-  prefs->should_antialias_text = params.antialiasing;
-  prefs->use_subpixel_positioning = params.subpixel_positioning;
-  prefs->hinting = GetRendererPreferencesHintingEnum(params.hinting);
-  prefs->use_autohinter = params.autohinter;
-  prefs->use_bitmaps = params.use_bitmaps;
-  prefs->subpixel_rendering =
-  GetRendererPreferencesSubpixelRenderingEnum(params.subpixel_rendering);
-}
-
-bool NativeWindowGtk::IsMaximized() const {
-  return state_ & GDK_WINDOW_STATE_MAXIMIZED;
-}
-
-bool NativeWindowGtk::GetWindowEdge(int x, int y, GdkWindowEdge* edge) {
-  if (has_frame_)
-    return false;
-
-  if (IsMaximized() || IsFullscreen())
-    return false;
-
-  return gtk_window_util::GetWindowEdge(GetSize(), 0, x, y, edge);
-}
-
-gboolean NativeWindowGtk::OnWindowDeleteEvent(GtkWidget* widget,
-                                              GdkEvent* event) {
-  Close();
-  return TRUE;
-}
-
-gboolean NativeWindowGtk::OnFocusOut(GtkWidget* window, GdkEventFocus*) {
-  NotifyWindowBlur();
-  return FALSE;
-}
-
-gboolean NativeWindowGtk::OnWindowState(GtkWidget* window,
-                                        GdkEventWindowState* event) {
-  state_ = event->new_window_state;
-  return FALSE;
-}
-
-gboolean NativeWindowGtk::OnMouseMoveEvent(GtkWidget* widget,
-                                           GdkEventMotion* event) {
-  if (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;
-
-  // Update the cursor if we're on the custom frame border.
-  GdkWindowEdge 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);
-
-  GdkCursorType last_cursor = GDK_LAST_CURSOR;
-  if (frame_cursor_)
-    last_cursor = frame_cursor_->type;
-
-  if (last_cursor != new_cursor) {
-    frame_cursor_ = has_hit_edge ? gfx::GetCursor(new_cursor) : NULL;
-    gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(window_)),
-                          frame_cursor_);
-  }
-  return FALSE;
-}
-
-gboolean NativeWindowGtk::OnButtonPress(GtkWidget* widget,
-                                        GdkEventButton* event) {
-  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);
-
-  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 = 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) {
-      // Raise the window after a click on either the titlebar or the border to
-      // match the behavior of most window managers, unless that behavior has
-      // been suppressed.
-      if ((has_hit_titlebar || has_hit_edge) && !suppress_window_raise_)
-        gdk_window_raise(GTK_WIDGET(widget)->window);
-
-      if (has_hit_edge) {
-        gtk_window_begin_resize_drag(window_, edge, event->button,
-                                     static_cast<gint>(event->x_root),
-                                     static_cast<gint>(event->y_root),
-                                     event->time);
-        return TRUE;
-      } else if (has_hit_titlebar) {
-        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_, bounds, event);
-      }
-    } else if (GDK_2BUTTON_PRESS == event->type) {
-      if (has_hit_titlebar && IsResizable()) {
-        // Maximize/restore on double click.
-        if (IsMaximized())
-          gtk_window_unmaximize(window_);
-        else
-          gtk_window_maximize(window_);
-        return TRUE;
-      }
-    }
-  } else if (event->button == 2) {
-    if (has_hit_titlebar || has_hit_edge)
-      gdk_window_lower(gdk_window);
-    return TRUE;
-  }
-
-  return FALSE;
-}
-
-// static
-NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
-                                   base::DictionaryValue* options) {
-  return new NativeWindowGtk(web_contents, options);
-}
-
-}  // namespace atom

atom/browser/native_window_gtk.h

@@ -1,155 +0,0 @@
-// Copyright (c) 2014 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_NATIVE_WINDOW_GTK_H_
-#define ATOM_BROWSER_NATIVE_WINDOW_GTK_H_
-
-#include <gtk/gtk.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,
-                        public MenuGtk::Delegate,
-                        public ui::ActiveWindowWatcherXObserver {
- public:
-  explicit NativeWindowGtk(content::WebContents* web_contents,
-                           base::DictionaryValue* options);
-  virtual ~NativeWindowGtk();
-
-  // NativeWindow implementation.
-  virtual void Close() OVERRIDE;
-  virtual void CloseImmediately() OVERRIDE;
-  virtual void Move(const gfx::Rect& pos) OVERRIDE;
-  virtual void Focus(bool focus) OVERRIDE;
-  virtual bool IsFocused() OVERRIDE;
-  virtual void Show() OVERRIDE;
-  virtual void Hide() OVERRIDE;
-  virtual bool IsVisible() OVERRIDE;
-  virtual void Maximize() OVERRIDE;
-  virtual void Unmaximize() OVERRIDE;
-  virtual void Minimize() OVERRIDE;
-  virtual void Restore() OVERRIDE;
-  virtual void SetFullscreen(bool fullscreen) OVERRIDE;
-  virtual bool IsFullscreen() OVERRIDE;
-  virtual void SetSize(const gfx::Size& size) OVERRIDE;
-  virtual gfx::Size GetSize() OVERRIDE;
-  virtual void SetContentSize(const gfx::Size& size) OVERRIDE;
-  virtual gfx::Size GetContentSize() OVERRIDE;
-  virtual void SetMinimumSize(const gfx::Size& size) OVERRIDE;
-  virtual gfx::Size GetMinimumSize() OVERRIDE;
-  virtual void SetMaximumSize(const gfx::Size& size) OVERRIDE;
-  virtual gfx::Size GetMaximumSize() OVERRIDE;
-  virtual void SetResizable(bool resizable) OVERRIDE;
-  virtual bool IsResizable() OVERRIDE;
-  virtual void SetAlwaysOnTop(bool top) OVERRIDE;
-  virtual bool IsAlwaysOnTop() OVERRIDE;
-  virtual void Center() OVERRIDE;
-  virtual void SetPosition(const gfx::Point& position) OVERRIDE;
-  virtual gfx::Point GetPosition() OVERRIDE;
-  virtual void SetTitle(const std::string& title) OVERRIDE;
-  virtual std::string GetTitle() OVERRIDE;
-  virtual void FlashFrame(bool flash) OVERRIDE;
-  virtual void SetKiosk(bool kiosk) OVERRIDE;
-  virtual bool IsKiosk() OVERRIDE;
-  virtual 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();
-
-  // Set how font is renderered.
-  void SetFontRenderering();
-
-  // Whether window is maximized.
-  bool IsMaximized() const;
-
-  // If the point (|x|, |y|) is within the resize border area of the window,
-  // returns true and sets |edge| to the appropriate GdkWindowEdge value.
-  // Otherwise, returns false.
-  bool GetWindowEdge(int x, int y, GdkWindowEdge* edge);
-
-  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnWindowDeleteEvent,
-                       GdkEvent*);
-  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnFocusOut, GdkEventFocus*);
-  CHROMEGTK_CALLBACK_1(NativeWindowGtk, gboolean, OnWindowState,
-                       GdkEventWindowState*);
-
-  // 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.
-  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);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_NATIVE_WINDOW_GTK_H_

atom/browser/native_window_mac.h

@@ -18,7 +18,7 @@ namespace atom {
 class NativeWindowMac : public NativeWindow {
  public:
   explicit NativeWindowMac(content::WebContents* web_contents,
-                           base::DictionaryValue* options);
+                           const mate::Dictionary& options);
   virtual ~NativeWindowMac();
 
   // NativeWindow implementation.
@@ -32,8 +32,10 @@ class NativeWindowMac : public NativeWindow {
   virtual bool IsVisible() OVERRIDE;
   virtual void Maximize() OVERRIDE;
   virtual void Unmaximize() OVERRIDE;
+  virtual bool IsMaximized() OVERRIDE;
   virtual void Minimize() OVERRIDE;
   virtual void Restore() OVERRIDE;
+  virtual bool IsMinimized() OVERRIDE;
   virtual void SetFullscreen(bool fullscreen) OVERRIDE;
   virtual bool IsFullscreen() OVERRIDE;
   virtual void SetSize(const gfx::Size& size) OVERRIDE;
@@ -54,10 +56,16 @@ class NativeWindowMac : public NativeWindow {
   virtual void SetTitle(const std::string& title) OVERRIDE;
   virtual std::string GetTitle() OVERRIDE;
   virtual void FlashFrame(bool flash) OVERRIDE;
+  virtual void SetSkipTaskbar(bool skip) OVERRIDE;
   virtual void SetKiosk(bool kiosk) OVERRIDE;
   virtual bool IsKiosk() OVERRIDE;
+  virtual void SetRepresentedFilename(const std::string& filename) OVERRIDE;
+  virtual std::string GetRepresentedFilename() OVERRIDE;
+  virtual void SetDocumentEdited(bool edited) OVERRIDE;
+  virtual bool IsDocumentEdited() OVERRIDE;
   virtual bool HasModalDialog() OVERRIDE;
   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE;
+  virtual void SetProgressBar(double progress) OVERRIDE;
 
   // Returns true if |point| in local Cocoa coordinate system falls within
   // the draggable region.
@@ -93,6 +101,9 @@ class NativeWindowMac : public NativeWindow {
 
   NSInteger attention_request_id_;  // identifier from requestUserAttention
 
+  // The presentation options before entering kiosk mode.
+  NSApplicationPresentationOptions kiosk_options_;
+
   // For system drag, the whole window is draggable and the non-draggable areas
   // have to been explicitly excluded.
   std::vector<gfx::Rect> system_drag_exclude_areas_;

atom/browser/native_window_mac.mm

@@ -11,11 +11,11 @@
 #include "atom/common/options_switches.h"
 #include "base/mac/mac_util.h"
 #include "base/strings/sys_string_conversions.h"
-#include "base/values.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "native_mate/dictionary.h"
 #include "vendor/brightray/browser/inspectable_web_contents.h"
 #include "vendor/brightray/browser/inspectable_web_contents_view.h"
 
@@ -48,7 +48,31 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
   acceptsFirstMouse_ = accept;
 }
 
+- (void)windowDidBecomeMain:(NSNotification*)notification {
+  content::WebContents* web_contents = shell_->GetWebContents();
+  if (!web_contents)
+    return;
+
+  web_contents->RestoreFocus();
+
+  content::RenderWidgetHostView* rwhv = web_contents->GetRenderWidgetHostView();
+  if (rwhv)
+    rwhv->SetActive(true);
+
+  shell_->NotifyWindowFocus();
+}
+
 - (void)windowDidResignMain:(NSNotification*)notification {
+  content::WebContents* web_contents = shell_->GetWebContents();
+  if (!web_contents)
+    return;
+
+  web_contents->StoreFocus();
+
+  content::RenderWidgetHostView* rwhv = web_contents->GetRenderWidgetHostView();
+  if (rwhv)
+    rwhv->SetActive(false);
+
   shell_->NotifyWindowBlur();
 }
 
@@ -84,10 +108,12 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
 @end
 
 @interface AtomNSWindow : EventProcessingWindow {
- @protected
+ @private
   atom::NativeWindowMac* shell_;
+  bool enable_larger_than_screen_;
 }
 - (void)setShell:(atom::NativeWindowMac*)shell;
+- (void)setEnableLargerThanScreen:(bool)enable;
 @end
 
 @implementation AtomNSWindow
@@ -96,6 +122,18 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
   shell_ = shell;
 }
 
+- (void)setEnableLargerThanScreen:(bool)enable {
+  enable_larger_than_screen_ = enable;
+}
+
+// Enable the window to be larger than screen.
+- (NSRect)constrainFrameRect:(NSRect)frameRect toScreen:(NSScreen*)screen {
+  if (enable_larger_than_screen_)
+    return frameRect;
+  else
+    return [super constrainFrameRect:frameRect toScreen:screen];
+}
+
 - (IBAction)reload:(id)sender {
   shell_->GetWebContents()->GetController().ReloadIgnoringCache(false);
 }
@@ -104,6 +142,20 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
   shell_->OpenDevTools();
 }
 
+// Returns an empty array for AXChildren attribute, this will force the
+// SpeechSynthesisServer to use its classical way of speaking the selected text:
+// by invoking the "Command+C" for current application and then speak out
+// what's in the clipboard. Otherwise the "Text to Speech" would always speak
+// out window's title.
+// This behavior is taken by both FireFox and Chrome, see also FireFox's bug on
+// more of how SpeechSynthesisServer chose which text to read:
+// https://bugzilla.mozilla.org/show_bug.cgi?id=674612
+- (id)accessibilityAttributeValue:(NSString*)attribute {
+  if ([attribute isEqualToString:@"AXChildren"])
+    return [NSArray array];
+  return [super accessibilityAttributeValue:attribute];
+}
+
 @end
 
 @interface ControlRegionView : NSView {
@@ -141,16 +193,49 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
 
 @end
 
+@interface AtomProgressBar : NSProgressIndicator
+@end
+
+@implementation AtomProgressBar
+
+- (void)drawRect:(NSRect)dirtyRect {
+  if (self.style != NSProgressIndicatorBarStyle)
+    return;
+  // Draw edges of rounded rect.
+  NSRect rect = NSInsetRect([self bounds], 1.0, 1.0);
+  CGFloat radius = rect.size.height / 2;
+  NSBezierPath* bezier_path = [NSBezierPath bezierPathWithRoundedRect:rect xRadius:radius yRadius:radius];
+  [bezier_path setLineWidth:2.0];
+  [[NSColor grayColor] set];
+  [bezier_path stroke];
+
+  // Fill the rounded rect.
+  rect = NSInsetRect(rect, 2.0, 2.0);
+  radius = rect.size.height / 2;
+  bezier_path = [NSBezierPath bezierPathWithRoundedRect:rect xRadius:radius yRadius:radius];
+  [bezier_path setLineWidth:1.0];
+  [bezier_path addClip];
+
+  // Calculate the progress width.
+  rect.size.width = floor(rect.size.width * ([self doubleValue] / [self maxValue]));
+
+  // Fill the progress bar with color blue.
+  [[NSColor colorWithSRGBRed:0.2 green:0.6 blue:1 alpha:1] set];
+  NSRectFill(rect);
+}
+
+@end
+
 namespace atom {
 
 NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
-                                 base::DictionaryValue* options)
+                                 const mate::Dictionary& options)
     : NativeWindow(web_contents, options),
       is_kiosk_(false),
       attention_request_id_(0) {
   int width = 800, height = 600;
-  options->GetInteger(switches::kWidth, &width);
-  options->GetInteger(switches::kHeight, &height);
+  options.Get(switches::kWidth, &width);
+  options.Get(switches::kHeight, &height);
 
   NSRect main_screen_rect = [[[NSScreen screens] objectAtIndex:0] frame];
   NSRect cocoa_bounds = NSMakeRect(
@@ -170,6 +255,7 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
                     defer:YES];
 
   [atomWindow setShell:this];
+  [atomWindow setEnableLargerThanScreen:enable_larger_than_screen_];
   window_.reset(atomWindow);
 
   AtomNSWindowDelegate* delegate =
@@ -181,18 +267,18 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
 
   // On OS X the initial window size doesn't include window frame.
   bool use_content_size = false;
-  options->GetBoolean(switches::kUseContentSize, &use_content_size);
+  options.Get(switches::kUseContentSize, &use_content_size);
   if (has_frame_ && !use_content_size)
     SetSize(gfx::Size(width, height));
 
   // Enable the NSView to accept first mouse event.
   bool acceptsFirstMouse = false;
-  options->GetBoolean(switches::kAcceptFirstMouse, &acceptsFirstMouse);
+  options.Get(switches::kAcceptFirstMouse, &acceptsFirstMouse);
   [delegate setAcceptsFirstMouse:acceptsFirstMouse];
 
   // Disable fullscreen button when 'fullscreen' is specified to false.
   bool fullscreen;
-  if (!(options->GetBoolean(switches::kFullscreen, &fullscreen) &&
+  if (!(options.Get(switches::kFullscreen, &fullscreen) &&
         !fullscreen)) {
     NSUInteger collectionBehavior = [window_ collectionBehavior];
     collectionBehavior |= NSWindowCollectionBehaviorFullScreenPrimary;
@@ -248,7 +334,7 @@ bool NativeWindowMac::IsFocused() {
 }
 
 void NativeWindowMac::Show() {
-  [window_ makeKeyAndOrderFront:nil];
+  [window_ orderFrontRegardless];
 }
 
 void NativeWindowMac::Hide() {
@@ -267,6 +353,10 @@ void NativeWindowMac::Unmaximize() {
   [window_ zoom:nil];
 }
 
+bool NativeWindowMac::IsMaximized() {
+  return [window_ isZoomed];
+}
+
 void NativeWindowMac::Minimize() {
   [window_ miniaturize:nil];
 }
@@ -275,6 +365,10 @@ void NativeWindowMac::Restore() {
   [window_ deminiaturize:nil];
 }
 
+bool NativeWindowMac::IsMinimized() {
+  return [window_ isMiniaturized];
+}
+
 void NativeWindowMac::SetFullscreen(bool fullscreen) {
   if (fullscreen == IsFullscreen())
     return;
@@ -404,8 +498,12 @@ void NativeWindowMac::FlashFrame(bool flash) {
   }
 }
 
+void NativeWindowMac::SetSkipTaskbar(bool skip) {
+}
+
 void NativeWindowMac::SetKiosk(bool kiosk) {
-  if (kiosk) {
+  if (kiosk && !is_kiosk_) {
+    kiosk_options_ = [NSApp currentSystemPresentationOptions];
     NSApplicationPresentationOptions options =
         NSApplicationPresentationHideDock +
         NSApplicationPresentationHideMenuBar +
@@ -417,10 +515,10 @@ void NativeWindowMac::SetKiosk(bool kiosk) {
     [NSApp setPresentationOptions:options];
     is_kiosk_ = true;
     SetFullscreen(true);
-  } else {
-    [NSApp setPresentationOptions:[NSApp currentSystemPresentationOptions]];
-    is_kiosk_  = false;
+  } else if (!kiosk && is_kiosk_) {
+    is_kiosk_ = false;
     SetFullscreen(false);
+    [NSApp setPresentationOptions:kiosk_options_];
   }
 }
 
@@ -428,6 +526,22 @@ bool NativeWindowMac::IsKiosk() {
   return is_kiosk_;
 }
 
+void NativeWindowMac::SetRepresentedFilename(const std::string& filename) {
+  [window_ setRepresentedFilename:base::SysUTF8ToNSString(filename)];
+}
+
+std::string NativeWindowMac::GetRepresentedFilename() {
+  return base::SysNSStringToUTF8([window_ representedFilename]);
+}
+
+void NativeWindowMac::SetDocumentEdited(bool edited) {
+  [window_ setDocumentEdited:edited];
+}
+
+bool NativeWindowMac::IsDocumentEdited() {
+  return [window_ isDocumentEdited];
+}
+
 bool NativeWindowMac::HasModalDialog() {
   return [window_ attachedSheet] != nil;
 }
@@ -436,10 +550,46 @@ gfx::NativeWindow NativeWindowMac::GetNativeWindow() {
   return window_;
 }
 
+void NativeWindowMac::SetProgressBar(double progress) {
+  NSDockTile* dock_tile = [NSApp dockTile];
+
+  // For the first time API invoked, we need to create a ContentView in DockTile.
+  if (dock_tile.contentView == NULL) {
+    NSImageView* image_view = [[NSImageView alloc] init];
+    [image_view setImage:[NSApp applicationIconImage]];
+    [dock_tile setContentView:image_view];
+
+    NSProgressIndicator* progress_indicator = [[AtomProgressBar alloc]
+        initWithFrame:NSMakeRect(0.0f, 0.0f, dock_tile.size.width, 15.0)];
+    [progress_indicator setStyle:NSProgressIndicatorBarStyle];
+    [progress_indicator setIndeterminate:NO];
+    [progress_indicator setBezeled:YES];
+    [progress_indicator setMinValue:0];
+    [progress_indicator setMaxValue:1];
+    [progress_indicator setHidden:NO];
+    [image_view addSubview:progress_indicator];
+  }
+
+  NSProgressIndicator* progress_indicator =
+      static_cast<NSProgressIndicator*>([[[dock_tile contentView] subviews]
+           objectAtIndex:0]);
+  if (progress < 0) {
+    [progress_indicator setHidden:YES];
+  } else if (progress > 1) {
+    [progress_indicator setHidden:NO];
+    [progress_indicator setIndeterminate:YES];
+    [progress_indicator setDoubleValue:1];
+  } else {
+    [progress_indicator setHidden:NO];
+    [progress_indicator setDoubleValue:progress];
+  }
+  [dock_tile display];
+}
+
 bool NativeWindowMac::IsWithinDraggableRegion(NSPoint point) const {
   if (!draggable_region_)
     return false;
-  NSView* webView = GetWebContents()->GetView()->GetNativeView();
+  NSView* webView = GetWebContents()->GetNativeView();
   NSInteger webViewHeight = NSHeight([webView bounds]);
   // |draggable_region_| is stored in local platform-indepdent coordiate system
   // while |point| is in local Cocoa coordinate system. Do the conversion
@@ -480,15 +630,30 @@ void NativeWindowMac::HandleKeyboardEvent(
       event.type == content::NativeWebKeyboardEvent::Char)
     return;
 
-  EventProcessingWindow* event_window =
-      static_cast<EventProcessingWindow*>(window_);
-  DCHECK([event_window isKindOfClass:[EventProcessingWindow class]]);
-  [event_window redispatchKeyEvent:event.os_event];
+  if (event.os_event.window == window_) {
+    EventProcessingWindow* event_window =
+        static_cast<EventProcessingWindow*>(window_);
+    DCHECK([event_window isKindOfClass:[EventProcessingWindow class]]);
+    [event_window redispatchKeyEvent:event.os_event];
+  } else {
+    // The event comes from detached devtools view, and it has already been
+    // handled by the devtools itself, we now send it to application menu to
+    // make menu acclerators work.
+    BOOL handled = [[NSApp mainMenu] performKeyEquivalent:event.os_event];
+    // Handle the cmd+~ shortcut.
+    if (!handled && (event.os_event.modifierFlags & NSCommandKeyMask) &&
+        (event.os_event.keyCode == 50  /* ~ key */))
+      Focus(true);
+  }
 }
 
 void NativeWindowMac::InstallView() {
   NSView* view = inspectable_web_contents()->GetView()->GetNativeView();
   if (has_frame_) {
+    // Add layer with white background for the contents view.
+    base::scoped_nsobject<CALayer> layer([[CALayer alloc] init]);
+    [layer setBackgroundColor:CGColorGetConstantColor(kCGColorWhite)];
+    [view setLayer:layer];
     [view setFrame:[[window_ contentView] bounds]];
     [[window_ contentView] addSubview:view];
   } else {
@@ -511,9 +676,7 @@ void NativeWindowMac::UninstallView() {
 }
 
 void NativeWindowMac::ClipWebView() {
-  NSView* view = GetWebContents()->GetView()->GetNativeView();
-
-  view.wantsLayer = YES;
+  NSView* view = GetWebContents()->GetNativeView();
   view.layer.masksToBounds = YES;
   view.layer.cornerRadius = kAtomWindowCornerRadius;
 }
@@ -524,7 +687,7 @@ void NativeWindowMac::InstallDraggableRegionViews() {
   // All ControlRegionViews should be added as children of the WebContentsView,
   // because WebContentsView will be removed and re-added when entering and
   // leaving fullscreen mode.
-  NSView* webView = GetWebContents()->GetView()->GetNativeView();
+  NSView* webView = GetWebContents()->GetNativeView();
   NSInteger webViewHeight = NSHeight([webView bounds]);
 
   // Remove all ControlRegionViews that are added last time.
@@ -556,7 +719,7 @@ void NativeWindowMac::UpdateDraggableRegionsForCustomDrag(
     const std::vector<DraggableRegion>& regions) {
   // We still need one ControlRegionView to cover the whole window such that
   // mouse events could be captured.
-  NSView* web_view = GetWebContents()->GetView()->GetNativeView();
+  NSView* web_view = GetWebContents()->GetNativeView();
   gfx::Rect window_bounds(
       0, 0, NSWidth([web_view bounds]), NSHeight([web_view bounds]));
   system_drag_exclude_areas_.clear();
@@ -581,7 +744,7 @@ void NativeWindowMac::UpdateDraggableRegionsForCustomDrag(
 
 // static
 NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
-                                   base::DictionaryValue* options) {
+                                   const mate::Dictionary& options) {
   return new NativeWindowMac(web_contents, options);
 }
 

atom/browser/native_window_observer.h

@@ -26,6 +26,9 @@ class NativeWindowObserver {
   // Called when window loses focus.
   virtual void OnWindowBlur() {}
 
+  // Called when window gains focus.
+  virtual void OnWindowFocus() {}
+
   // Called when renderer is hung.
   virtual void OnRendererUnresponsive() {}
 

atom/browser/native_window_views.cc

@@ -0,0 +1,764 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/native_window_views.h"
+
+#if defined(OS_WIN)
+#include <shobjidl.h>
+#endif
+
+#include <string>
+#include <vector>
+
+#include "atom/browser/ui/views/menu_bar.h"
+#include "atom/browser/ui/views/menu_layout.h"
+#include "atom/common/draggable_region.h"
+#include "atom/common/options_switches.h"
+#include "base/strings/utf_string_conversions.h"
+#include "browser/inspectable_web_contents_view.h"
+#include "content/public/browser/native_web_keyboard_event.h"
+#include "native_mate/dictionary.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
+#include "ui/base/hit_test.h"
+#include "ui/views/background.h"
+#include "ui/views/controls/webview/unhandled_keyboard_event_handler.h"
+#include "ui/views/controls/webview/webview.h"
+#include "ui/views/window/client_view.h"
+#include "ui/views/widget/widget.h"
+
+#if defined(USE_X11)
+#include "atom/browser/browser.h"
+#include "atom/browser/ui/views/global_menu_bar_x11.h"
+#include "atom/browser/ui/views/frameless_view.h"
+#include "atom/browser/ui/x/x_window_utils.h"
+#include "base/environment.h"
+#include "base/nix/xdg_util.h"
+#include "base/strings/stringprintf.h"
+#include "chrome/browser/ui/libgtk2ui/unity_service.h"
+#include "ui/base/x/x11_util.h"
+#include "ui/gfx/x/x11_types.h"
+#include "ui/views/window/native_frame_view.h"
+#elif defined(OS_WIN)
+#include "atom/browser/ui/views/win_frame_view.h"
+#include "base/win/scoped_comptr.h"
+#include "base/win/windows_version.h"
+#include "ui/base/win/shell.h"
+#include "ui/views/win/hwnd_util.h"
+#endif
+
+namespace atom {
+
+namespace {
+
+// The menu bar height in pixels.
+#if defined(OS_WIN)
+const int kMenuBarHeight = 20;
+#else
+const int kMenuBarHeight = 25;
+#endif
+
+#if defined(USE_X11)
+// Counts how many window has already been created, it will be used to set the
+// window role for X11.
+int kWindowsCreated = 0;
+
+bool ShouldUseGlobalMenuBar() {
+  // Some DE would pretend to be Unity but don't have global application menu,
+  // so we can not trust unity::IsRunning().
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  bool is_unity = unity::IsRunning() &&
+                  base::nix::GetDesktopEnvironment(env.get()) ==
+                      base::nix::DESKTOP_ENVIRONMENT_UNITY;
+  std::string menu_proxy;
+  return is_unity && env->GetVar("UBUNTU_MENUPROXY", &menu_proxy) &&
+         menu_proxy.length() > 1;
+}
+#endif
+
+bool IsAltKey(const content::NativeWebKeyboardEvent& event) {
+#if defined(USE_X11)
+  // 164 and 165 represent VK_LALT and VK_RALT.
+  return event.windowsKeyCode == 164 || event.windowsKeyCode == 165;
+#else
+  return event.windowsKeyCode == ui::VKEY_MENU;
+#endif
+}
+
+bool IsAltModifier(const content::NativeWebKeyboardEvent& event) {
+  typedef content::NativeWebKeyboardEvent::Modifiers Modifiers;
+  return (event.modifiers == Modifiers::AltKey) ||
+         (event.modifiers == (Modifiers::AltKey | Modifiers::IsLeft)) ||
+         (event.modifiers == (Modifiers::AltKey | Modifiers::IsRight));
+}
+
+class NativeWindowClientView : public views::ClientView {
+ public:
+  NativeWindowClientView(views::Widget* widget,
+                         NativeWindowViews* contents_view)
+      : views::ClientView(widget, contents_view) {
+  }
+  virtual ~NativeWindowClientView() {}
+
+  virtual bool CanClose() OVERRIDE {
+    static_cast<NativeWindowViews*>(contents_view())->CloseWebContents();
+    return false;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeWindowClientView);
+};
+
+}  // namespace
+
+NativeWindowViews::NativeWindowViews(content::WebContents* web_contents,
+                                     const mate::Dictionary& options)
+    : NativeWindow(web_contents, options),
+      window_(new views::Widget),
+      web_view_(inspectable_web_contents()->GetView()->GetView()),
+      menu_bar_autohide_(false),
+      menu_bar_visible_(false),
+      menu_bar_alt_pressed_(false),
+      keyboard_event_handler_(new views::UnhandledKeyboardEventHandler),
+      use_content_size_(false),
+      resizable_(true) {
+  options.Get(switches::kTitle, &title_);
+  options.Get(switches::kAutoHideMenuBar, &menu_bar_autohide_);
+
+#if defined(OS_WIN)
+  // On Windows we rely on the CanResize() to indicate whether window can be
+  // resized, and it should be set before window is created.
+  options.Get(switches::kResizable, &resizable_);
+#endif
+
+  if (enable_larger_than_screen_)
+    // We need to set a default maximum window size here otherwise Windows
+    // will not allow us to resize the window larger than scree.
+    // Setting directly to INT_MAX somehow doesn't work, so we just devide
+    // by 10, which should still be large enough.
+    maximum_size_.SetSize(INT_MAX / 10, INT_MAX / 10);
+
+  int width = 800, height = 600;
+  options.Get(switches::kWidth, &width);
+  options.Get(switches::kHeight, &height);
+  gfx::Rect bounds(0, 0, width, height);
+
+  window_->AddObserver(this);
+
+  views::Widget::InitParams params;
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.bounds = bounds;
+  params.delegate = this;
+  params.type = views::Widget::InitParams::TYPE_WINDOW;
+  params.remove_standard_frame = !has_frame_;
+
+#if defined(USE_X11)
+  // Set WM_WINDOW_ROLE.
+  params.wm_role_name = base::StringPrintf(
+      "%s/%s/%d", "Atom Shell", Browser::Get()->GetName().c_str(),
+      ++kWindowsCreated);
+  // Set WM_CLASS.
+  params.wm_class_name = "atom";
+  params.wm_class_class = "Atom";
+#endif
+
+  window_->Init(params);
+
+#if defined(USE_X11)
+  // Set _GTK_THEME_VARIANT to dark if we have "dark-theme" option set.
+  bool use_dark_theme = false;
+  if (options.Get(switches::kDarkTheme, &use_dark_theme) && use_dark_theme) {
+    XDisplay* xdisplay = gfx::GetXDisplay();
+    XChangeProperty(xdisplay, GetAcceleratedWidget(),
+                    XInternAtom(xdisplay, "_GTK_THEME_VARIANT", False),
+                    XInternAtom(xdisplay, "UTF8_STRING", False),
+                    8, PropModeReplace,
+                    reinterpret_cast<const unsigned char*>("dark"),
+                    4);
+  }
+
+  // Before the window is mapped the SetWMSpecState can not work, so we have
+  // to manually set the _NET_WM_STATE.
+  bool skip_taskbar = false;
+  if (options.Get(switches::kSkipTaskbar, &skip_taskbar) && skip_taskbar) {
+    std::vector<::Atom> state_atom_list;
+    state_atom_list.push_back(GetAtom("_NET_WM_STATE_SKIP_TASKBAR"));
+    ui::SetAtomArrayProperty(GetAcceleratedWidget(), "_NET_WM_STATE", "ATOM",
+                             state_atom_list);
+  }
+#endif
+
+  // Add web view.
+  SetLayoutManager(new MenuLayout(kMenuBarHeight));
+  set_background(views::Background::CreateStandardPanelBackground());
+  AddChildView(web_view_);
+
+  if (has_frame_ &&
+      options.Get(switches::kUseContentSize, &use_content_size_) &&
+      use_content_size_)
+    bounds = ContentBoundsToWindowBounds(bounds);
+
+  window_->UpdateWindowIcon();
+  window_->CenterWindow(bounds.size());
+  Layout();
+}
+
+NativeWindowViews::~NativeWindowViews() {
+  window_->RemoveObserver(this);
+}
+
+void NativeWindowViews::Close() {
+  window_->Close();
+}
+
+void NativeWindowViews::CloseImmediately() {
+  window_->CloseNow();
+}
+
+void NativeWindowViews::Move(const gfx::Rect& bounds) {
+  window_->SetBounds(bounds);
+}
+
+void NativeWindowViews::Focus(bool focus) {
+  if (focus)
+    window_->Activate();
+  else
+    window_->Deactivate();
+}
+
+bool NativeWindowViews::IsFocused() {
+  return window_->IsActive();
+}
+
+void NativeWindowViews::Show() {
+  window_->ShowInactive();
+}
+
+void NativeWindowViews::Hide() {
+  window_->Hide();
+}
+
+bool NativeWindowViews::IsVisible() {
+  return window_->IsVisible();
+}
+
+void NativeWindowViews::Maximize() {
+  window_->Maximize();
+}
+
+void NativeWindowViews::Unmaximize() {
+  window_->Restore();
+}
+
+bool NativeWindowViews::IsMaximized() {
+  return window_->IsMaximized();
+}
+
+void NativeWindowViews::Minimize() {
+  window_->Minimize();
+}
+
+void NativeWindowViews::Restore() {
+  window_->Restore();
+}
+
+bool NativeWindowViews::IsMinimized() {
+  return window_->IsMinimized();
+}
+
+void NativeWindowViews::SetFullscreen(bool fullscreen) {
+  window_->SetFullscreen(fullscreen);
+}
+
+bool NativeWindowViews::IsFullscreen() {
+  return window_->IsFullscreen();
+}
+
+void NativeWindowViews::SetSize(const gfx::Size& size) {
+#if defined(USE_X11)
+  // On Linux the minimum and maximum size should be updated with window size
+  // when window is not resizable.
+  if (!resizable_) {
+    SetMaximumSize(size);
+    SetMinimumSize(size);
+  }
+#endif
+
+  window_->SetSize(size);
+}
+
+gfx::Size NativeWindowViews::GetSize() {
+#if defined(OS_WIN)
+  if (IsMinimized())
+    return window_->GetRestoredBounds().size();
+#endif
+
+  return window_->GetWindowBoundsInScreen().size();
+}
+
+void NativeWindowViews::SetContentSize(const gfx::Size& size) {
+  if (!has_frame_) {
+    SetSize(size);
+    return;
+  }
+
+  gfx::Rect bounds = window_->GetWindowBoundsInScreen();
+  SetSize(ContentBoundsToWindowBounds(gfx::Rect(bounds.origin(), size)).size());
+}
+
+gfx::Size NativeWindowViews::GetContentSize() {
+  if (!has_frame_)
+    return GetSize();
+
+  gfx::Size content_size =
+      window_->non_client_view()->frame_view()->GetBoundsForClientView().size();
+  if (menu_bar_ && menu_bar_visible_)
+    content_size.set_height(content_size.height() - kMenuBarHeight);
+  return content_size;
+}
+
+void NativeWindowViews::SetMinimumSize(const gfx::Size& size) {
+  minimum_size_ = size;
+
+#if defined(USE_X11)
+  XSizeHints size_hints;
+  size_hints.flags = PMinSize;
+  size_hints.min_width = size.width();
+  size_hints.min_height = size.height();
+  XSetWMNormalHints(gfx::GetXDisplay(), GetAcceleratedWidget(), &size_hints);
+#endif
+}
+
+gfx::Size NativeWindowViews::GetMinimumSize() {
+  return minimum_size_;
+}
+
+void NativeWindowViews::SetMaximumSize(const gfx::Size& size) {
+  maximum_size_ = size;
+
+#if defined(USE_X11)
+  XSizeHints size_hints;
+  size_hints.flags = PMaxSize;
+  size_hints.max_width = size.width();
+  size_hints.max_height = size.height();
+  XSetWMNormalHints(gfx::GetXDisplay(), GetAcceleratedWidget(), &size_hints);
+#endif
+}
+
+gfx::Size NativeWindowViews::GetMaximumSize() {
+  return maximum_size_;
+}
+
+void NativeWindowViews::SetResizable(bool resizable) {
+#if defined(OS_WIN)
+  if (has_frame_) {
+    // WS_MAXIMIZEBOX => Maximize button
+    // WS_MINIMIZEBOX => Minimize button
+    // WS_THICKFRAME => Resize handle
+    DWORD style = ::GetWindowLong(GetAcceleratedWidget(), GWL_STYLE);
+    if (resizable)
+      style |= WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_THICKFRAME;
+    else
+      style = (style & ~(WS_MAXIMIZEBOX | WS_THICKFRAME)) | WS_MINIMIZEBOX;
+    ::SetWindowLong(GetAcceleratedWidget(), GWL_STYLE, style);
+  }
+#elif defined(USE_X11)
+  if (resizable != resizable_) {
+    // On Linux there is no "resizable" property of a window, we have to set
+    // both the minimum and maximum size to the window size to achieve it.
+    if (resizable) {
+      SetMaximumSize(gfx::Size());
+      SetMinimumSize(gfx::Size());
+    } else {
+      SetMaximumSize(GetSize());
+      SetMinimumSize(GetSize());
+    }
+  }
+#endif
+
+  resizable_ = resizable;
+}
+
+bool NativeWindowViews::IsResizable() {
+  return resizable_;
+}
+
+void NativeWindowViews::SetAlwaysOnTop(bool top) {
+  window_->SetAlwaysOnTop(top);
+}
+
+bool NativeWindowViews::IsAlwaysOnTop() {
+  return window_->IsAlwaysOnTop();
+}
+
+void NativeWindowViews::Center() {
+  window_->CenterWindow(GetSize());
+}
+
+void NativeWindowViews::SetPosition(const gfx::Point& position) {
+  window_->SetBounds(gfx::Rect(position, GetSize()));
+}
+
+gfx::Point NativeWindowViews::GetPosition() {
+#if defined(OS_WIN)
+  if (IsMinimized())
+    return window_->GetRestoredBounds().origin();
+#endif
+
+  return window_->GetWindowBoundsInScreen().origin();
+}
+
+void NativeWindowViews::SetTitle(const std::string& title) {
+  title_ = title;
+  window_->UpdateWindowTitle();
+}
+
+std::string NativeWindowViews::GetTitle() {
+  return title_;
+}
+
+void NativeWindowViews::FlashFrame(bool flash) {
+  window_->FlashFrame(flash);
+}
+
+void NativeWindowViews::SetSkipTaskbar(bool skip) {
+#if defined(OS_WIN)
+  base::win::ScopedComPtr<ITaskbarList> taskbar;
+  if (FAILED(taskbar.CreateInstance(CLSID_TaskbarList, NULL,
+                                    CLSCTX_INPROC_SERVER)) ||
+      FAILED(taskbar->HrInit()))
+    return;
+  if (skip)
+    taskbar->DeleteTab(GetAcceleratedWidget());
+  else
+    taskbar->AddTab(GetAcceleratedWidget());
+#elif defined(USE_X11)
+  SetWMSpecState(GetAcceleratedWidget(), skip,
+                 GetAtom("_NET_WM_STATE_SKIP_TASKBAR"));
+#endif
+}
+
+void NativeWindowViews::SetKiosk(bool kiosk) {
+  SetFullscreen(kiosk);
+}
+
+bool NativeWindowViews::IsKiosk() {
+  return IsFullscreen();
+}
+
+void NativeWindowViews::SetMenu(ui::MenuModel* menu_model) {
+  RegisterAccelerators(menu_model);
+
+#if defined(USE_X11)
+  if (!global_menu_bar_ && ShouldUseGlobalMenuBar())
+    global_menu_bar_.reset(new GlobalMenuBarX11(this));
+
+  // Use global application menu bar when possible.
+  if (global_menu_bar_ && global_menu_bar_->IsServerStarted()) {
+    global_menu_bar_->SetMenu(menu_model);
+    return;
+  }
+#endif
+
+  // Do not show menu bar in frameless window.
+  if (!has_frame_)
+    return;
+
+  if (!menu_bar_) {
+    gfx::Size content_size = GetContentSize();
+    menu_bar_.reset(new MenuBar);
+    menu_bar_->set_owned_by_client();
+
+    if (!menu_bar_autohide_) {
+      SetMenuBarVisibility(true);
+      if (use_content_size_)
+        SetContentSize(content_size);
+    }
+  }
+
+  menu_bar_->SetMenu(menu_model);
+  Layout();
+}
+
+gfx::NativeWindow NativeWindowViews::GetNativeWindow() {
+  return window_->GetNativeWindow();
+}
+
+void NativeWindowViews::SetProgressBar(double progress) {
+#if defined(OS_WIN)
+  if (base::win::GetVersion() < base::win::VERSION_WIN7)
+    return;
+  base::win::ScopedComPtr<ITaskbarList3> taskbar;
+  if (FAILED(taskbar.CreateInstance(CLSID_TaskbarList, NULL,
+                                    CLSCTX_INPROC_SERVER) ||
+      FAILED(taskbar->HrInit()))) {
+    return;
+  }
+  HWND frame = views::HWNDForNativeWindow(GetNativeWindow());
+  if (progress > 1.0) {
+    taskbar->SetProgressState(frame, TBPF_INDETERMINATE);
+  } else if (progress < 0) {
+    taskbar->SetProgressState(frame, TBPF_NOPROGRESS);
+  } else if (progress >= 0) {
+    taskbar->SetProgressValue(frame,
+                              static_cast<int>(progress * 100),
+                              100);
+  }
+#elif defined(USE_X11)
+  if (unity::IsRunning()) {
+    unity::SetProgressFraction(progress);
+  }
+#endif
+}
+
+gfx::AcceleratedWidget NativeWindowViews::GetAcceleratedWidget() {
+  return GetNativeWindow()->GetHost()->GetAcceleratedWidget();
+}
+
+void NativeWindowViews::UpdateDraggableRegions(
+    const std::vector<DraggableRegion>& regions) {
+  if (has_frame_)
+    return;
+
+  SkRegion* draggable_region = new SkRegion;
+
+  // By default, the whole window is non-draggable. We need to explicitly
+  // include those draggable regions.
+  for (std::vector<DraggableRegion>::const_iterator iter = regions.begin();
+       iter != regions.end(); ++iter) {
+    const DraggableRegion& region = *iter;
+    draggable_region->op(
+        region.bounds.x(),
+        region.bounds.y(),
+        region.bounds.right(),
+        region.bounds.bottom(),
+        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
+  }
+
+  draggable_region_.reset(draggable_region);
+}
+
+void NativeWindowViews::OnWidgetActivationChanged(
+    views::Widget* widget, bool active) {
+  if (widget != window_.get())
+    return;
+
+  if (active)
+    NotifyWindowFocus();
+  else
+    NotifyWindowBlur();
+
+  if (active && GetWebContents() && !IsDevToolsOpened())
+    GetWebContents()->Focus();
+
+  // Hide menu bar when window is blured.
+  if (!active && menu_bar_autohide_ && menu_bar_visible_) {
+    SetMenuBarVisibility(false);
+    Layout();
+  }
+}
+
+void NativeWindowViews::DeleteDelegate() {
+  NotifyWindowClosed();
+}
+
+views::View* NativeWindowViews::GetInitiallyFocusedView() {
+  return inspectable_web_contents()->GetView()->GetWebView();
+}
+
+bool NativeWindowViews::CanResize() const {
+  return resizable_;
+}
+
+bool NativeWindowViews::CanMaximize() const {
+  return resizable_;
+}
+
+base::string16 NativeWindowViews::GetWindowTitle() const {
+  return base::UTF8ToUTF16(title_);
+}
+
+bool NativeWindowViews::ShouldHandleSystemCommands() const {
+  return true;
+}
+
+gfx::ImageSkia NativeWindowViews::GetWindowAppIcon() {
+  return icon_;
+}
+
+gfx::ImageSkia NativeWindowViews::GetWindowIcon() {
+  return GetWindowAppIcon();
+}
+
+views::Widget* NativeWindowViews::GetWidget() {
+  return window_.get();
+}
+
+const views::Widget* NativeWindowViews::GetWidget() const {
+  return window_.get();
+}
+
+views::View* NativeWindowViews::GetContentsView() {
+  return this;
+}
+
+bool NativeWindowViews::ShouldDescendIntoChildForEventHandling(
+    gfx::NativeView child,
+    const gfx::Point& location) {
+  // App window should claim mouse events that fall within the draggable region.
+  if (draggable_region_ &&
+      draggable_region_->contains(location.x(), location.y()))
+    return false;
+
+  // And the events on border for dragging resizable frameless window.
+  if (!has_frame_ && CanResize()) {
+    FramelessView* frame = static_cast<FramelessView*>(
+        window_->non_client_view()->frame_view());
+    return frame->ResizingBorderHitTest(location) == HTNOWHERE;
+  }
+
+  return true;
+}
+
+views::ClientView* NativeWindowViews::CreateClientView(views::Widget* widget) {
+  return new NativeWindowClientView(widget, this);
+}
+
+views::NonClientFrameView* NativeWindowViews::CreateNonClientFrameView(
+    views::Widget* widget) {
+#if defined(OS_WIN)
+  if (ui::win::IsAeroGlassEnabled()) {
+    WinFrameView* frame_view =  new WinFrameView;
+    frame_view->Init(this, widget);
+    return frame_view;
+  }
+#elif defined(OS_LINUX)
+  if (has_frame_) {
+    return new views::NativeFrameView(widget);
+  } else {
+    FramelessView* frame_view =  new FramelessView;
+    frame_view->Init(this, widget);
+    return frame_view;
+  }
+#endif
+
+  return NULL;
+}
+
+gfx::ImageSkia NativeWindowViews::GetDevToolsWindowIcon() {
+  return GetWindowAppIcon();
+}
+
+void NativeWindowViews::HandleMouseDown() {
+  // Hide menu bar when web view is clicked.
+  if (menu_bar_autohide_ && menu_bar_visible_) {
+    SetMenuBarVisibility(false);
+    Layout();
+  }
+}
+
+void NativeWindowViews::HandleKeyboardEvent(
+    content::WebContents*,
+    const content::NativeWebKeyboardEvent& event) {
+  keyboard_event_handler_->HandleKeyboardEvent(event, GetFocusManager());
+
+  if (!menu_bar_)
+    return;
+
+  // Show accelerator when "Alt" is pressed.
+  if (menu_bar_visible_ && IsAltKey(event))
+    menu_bar_->SetAcceleratorVisibility(
+        event.type == blink::WebInputEvent::RawKeyDown);
+
+  // Show the submenu when "Alt+Key" is pressed.
+  if (event.type == blink::WebInputEvent::RawKeyDown && !IsAltKey(event) &&
+      IsAltModifier(event)) {
+    if (!menu_bar_visible_ &&
+        (menu_bar_->GetAcceleratorIndex(event.windowsKeyCode) != -1)) {
+      SetMenuBarVisibility(true);
+      Layout();
+    }
+    menu_bar_->ActivateAccelerator(event.windowsKeyCode);
+    return;
+  }
+
+  if (!menu_bar_autohide_)
+    return;
+
+  // Toggle the menu bar only when a single Alt is released.
+  if (event.type == blink::WebInputEvent::RawKeyDown && IsAltKey(event) &&
+      IsAltModifier(event)) {
+    // When a single Alt is pressed:
+    menu_bar_alt_pressed_ = true;
+  } else if (event.type == blink::WebInputEvent::KeyUp && IsAltKey(event) &&
+#if defined(USE_X11)
+             event.modifiers == 0 &&
+#endif
+             menu_bar_alt_pressed_) {
+    // When a single Alt is released right after a Alt is pressed:
+    menu_bar_alt_pressed_ = false;
+    SetMenuBarVisibility(!menu_bar_visible_);
+    Layout();
+  } else {
+    // When any other keys except single Alt have been pressed/released:
+    menu_bar_alt_pressed_ = false;
+  }
+}
+
+bool NativeWindowViews::AcceleratorPressed(const ui::Accelerator& accelerator) {
+  return accelerator_util::TriggerAcceleratorTableCommand(
+      &accelerator_table_, accelerator);
+}
+
+void NativeWindowViews::RegisterAccelerators(ui::MenuModel* menu_model) {
+  // Clear previous accelerators.
+  views::FocusManager* focus_manager = GetFocusManager();
+  accelerator_table_.clear();
+  focus_manager->UnregisterAccelerators(this);
+
+  // Register accelerators with focus manager.
+  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);
+  }
+}
+
+gfx::Rect NativeWindowViews::ContentBoundsToWindowBounds(
+    const gfx::Rect& bounds) {
+  gfx::Rect window_bounds =
+      window_->non_client_view()->GetWindowBoundsForClientBounds(bounds);
+  if (menu_bar_ && menu_bar_visible_)
+    window_bounds.set_height(window_bounds.height() + kMenuBarHeight);
+  return window_bounds;
+}
+
+void NativeWindowViews::SetMenuBarVisibility(bool visible) {
+  if (!menu_bar_)
+    return;
+
+  // Always show the accelerator when the auto-hide menu bar shows.
+  if (menu_bar_autohide_)
+    menu_bar_->SetAcceleratorVisibility(visible);
+
+  menu_bar_visible_ = visible;
+  if (visible) {
+    DCHECK_EQ(child_count(), 1);
+    AddChildView(menu_bar_.get());
+  } else {
+    DCHECK_EQ(child_count(), 2);
+    RemoveChildView(menu_bar_.get());
+  }
+}
+
+// static
+NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
+                                   const mate::Dictionary& options) {
+  return new NativeWindowViews(web_contents, options);
+}
+
+}  // namespace atom

atom/browser/native_window_views.h

@@ -1,42 +1,37 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
-#define ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
+#ifndef ATOM_BROWSER_NATIVE_WINDOW_VIEWS_H_
+#define ATOM_BROWSER_NATIVE_WINDOW_VIEWS_H_
+
+#include "atom/browser/native_window.h"
 
-#include <map>
 #include <string>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
-#include "base/strings/string16.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"
-
-namespace ui {
-class MenuModel;
-}
+#include "ui/views/widget/widget_observer.h"
 
 namespace views {
-class WebView;
-class Widget;
+class UnhandledKeyboardEventHandler;
 }
 
 namespace atom {
 
-class Menu2;
+class GlobalMenuBarX11;
+class MenuBar;
 
-class NativeWindowWin : public NativeWindow,
-                        public views::WidgetDelegateView {
+class NativeWindowViews : public NativeWindow,
+                          public views::WidgetDelegateView,
+                          public views::WidgetObserver {
  public:
-  explicit NativeWindowWin(content::WebContents* web_contents,
-                           base::DictionaryValue* options);
-  virtual ~NativeWindowWin();
+  explicit NativeWindowViews(content::WebContents* web_contents,
+                            const mate::Dictionary& options);
+  virtual ~NativeWindowViews();
 
-  // NativeWindow implementation.
+  // NativeWindow:
   virtual void Close() OVERRIDE;
   virtual void CloseImmediately() OVERRIDE;
   virtual void Move(const gfx::Rect& pos) OVERRIDE;
@@ -47,8 +42,10 @@ class NativeWindowWin : public NativeWindow,
   virtual bool IsVisible() OVERRIDE;
   virtual void Maximize() OVERRIDE;
   virtual void Unmaximize() OVERRIDE;
+  virtual bool IsMaximized() OVERRIDE;
   virtual void Minimize() OVERRIDE;
   virtual void Restore() OVERRIDE;
+  virtual bool IsMinimized() OVERRIDE;
   virtual void SetFullscreen(bool fullscreen) OVERRIDE;
   virtual bool IsFullscreen() OVERRIDE;
   virtual void SetSize(const gfx::Size& size) OVERRIDE;
@@ -69,80 +66,97 @@ class NativeWindowWin : public NativeWindow,
   virtual void SetTitle(const std::string& title) OVERRIDE;
   virtual std::string GetTitle() OVERRIDE;
   virtual void FlashFrame(bool flash) OVERRIDE;
+  virtual void SetSkipTaskbar(bool skip) OVERRIDE;
   virtual void SetKiosk(bool kiosk) OVERRIDE;
   virtual bool IsKiosk() OVERRIDE;
+  virtual void SetMenu(ui::MenuModel* menu_model) OVERRIDE;
   virtual gfx::NativeWindow GetNativeWindow() OVERRIDE;
+  virtual void SetProgressBar(double value) OVERRIDE;
 
-  void OnMenuCommand(int position, HMENU menu);
+  gfx::AcceleratedWidget GetAcceleratedWidget();
 
-  // Set the native window menu.
-  void SetMenu(ui::MenuModel* menu_model);
+  SkRegion* draggable_region() const { return draggable_region_.get(); }
+  views::Widget* widget() const { return window_.get(); }
 
-  views::Widget* window() const { return window_.get(); }
-  SkRegion* draggable_region() { return draggable_region_.get(); }
-
- protected:
+ private:
+  // NativeWindow:
   virtual void UpdateDraggableRegions(
       const std::vector<DraggableRegion>& regions) OVERRIDE;
 
-  // Overridden from content::WebContentsDelegate:
-  virtual void HandleKeyboardEvent(
-      content::WebContents*,
-      const content::NativeWebKeyboardEvent&) OVERRIDE;
+  // views::WidgetObserver:
+  virtual void OnWidgetActivationChanged(
+      views::Widget* widget, bool active) OVERRIDE;
 
-  // Overridden from views::View:
-  virtual void Layout() OVERRIDE;
-  virtual void ViewHierarchyChanged(
-      const ViewHierarchyChangedDetails& details) OVERRIDE;
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
-
-  // Overridden from views::WidgetDelegate:
+  // views::WidgetDelegate:
   virtual void DeleteDelegate() OVERRIDE;
   virtual views::View* GetInitiallyFocusedView() OVERRIDE;
   virtual bool CanResize() const OVERRIDE;
   virtual bool CanMaximize() const OVERRIDE;
-  virtual string16 GetWindowTitle() const OVERRIDE;
+  virtual base::string16 GetWindowTitle() const OVERRIDE;
   virtual bool ShouldHandleSystemCommands() const OVERRIDE;
   virtual gfx::ImageSkia GetWindowAppIcon() OVERRIDE;
   virtual gfx::ImageSkia GetWindowIcon() OVERRIDE;
   virtual views::Widget* GetWidget() OVERRIDE;
   virtual const views::Widget* GetWidget() const OVERRIDE;
+  virtual views::View* GetContentsView() OVERRIDE;
+  virtual bool ShouldDescendIntoChildForEventHandling(
+     gfx::NativeView child,
+     const gfx::Point& location) OVERRIDE;
   virtual views::ClientView* CreateClientView(views::Widget* widget) OVERRIDE;
   virtual views::NonClientFrameView* CreateNonClientFrameView(
       views::Widget* widget) OVERRIDE;
 
- private:
-  typedef struct { int position; ui::MenuModel* model; } MenuItem;
-  typedef std::map<ui::Accelerator, MenuItem> AcceleratorTable;
+  // brightray::InspectableWebContentsDelegate:
+  virtual gfx::ImageSkia GetDevToolsWindowIcon() OVERRIDE;
 
-  void ClientAreaSizeToWindowSize(gfx::Size* size);
+  // content::WebContentsDelegate:
+  virtual void HandleMouseDown() OVERRIDE;
+  virtual void HandleKeyboardEvent(
+      content::WebContents*,
+      const content::NativeWebKeyboardEvent& event) OVERRIDE;
 
-  void OnViewWasResized();
+  // views::View:
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
 
   // Register accelerators supported by the menu model.
-  void RegisterAccelerators();
+  void RegisterAccelerators(ui::MenuModel* menu_model);
+
+  // Converts between client area and window area, since we include the menu bar
+  // in client area we need to substract/add menu bar's height in convertions.
+  gfx::Rect ContentBoundsToWindowBounds(const gfx::Rect& content_bounds);
+
+  // Show/Hide the menu bar.
+  void SetMenuBarVisibility(bool visible);
 
   scoped_ptr<views::Widget> window_;
-  views::WebView* web_view_;  // managed by window_.
+  views::View* web_view_;  // Managed by inspectable_web_contents_.
 
-  // The window menu.
-  scoped_ptr<atom::Menu2> menu_;
+  scoped_ptr<MenuBar> menu_bar_;
+  bool menu_bar_autohide_;
+  bool menu_bar_visible_;
+  bool menu_bar_alt_pressed_;
+
+#if defined(USE_X11)
+  scoped_ptr<GlobalMenuBarX11> global_menu_bar_;
+#endif
+
+  // Handles unhandled keyboard messages coming back from the renderer process.
+  scoped_ptr<views::UnhandledKeyboardEventHandler> keyboard_event_handler_;
 
   // Map from accelerator to menu item's command id.
   accelerator_util::AcceleratorTable accelerator_table_;
 
-  scoped_ptr<SkRegion> draggable_region_;
-
   bool use_content_size_;
-
   bool resizable_;
-  string16 title_;
+  std::string title_;
   gfx::Size minimum_size_;
   gfx::Size maximum_size_;
 
-  DISALLOW_COPY_AND_ASSIGN(NativeWindowWin);
+  scoped_ptr<SkRegion> draggable_region_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeWindowViews);
 };
 
 }  // namespace atom
 
-#endif  // ATOM_BROWSER_NATIVE_WINDOW_WIN_H_
+#endif  // ATOM_BROWSER_NATIVE_WINDOW_VIEWS_H_

atom/browser/native_window_win.cc

@@ -1,575 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/native_window_win.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 "content/public/browser/native_web_keyboard_event.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/render_widget_host_view.h"
-#include "content/public/browser/web_contents.h"
-#include "content/public/browser/web_contents_view.h"
-#include "ui/gfx/path.h"
-#include "ui/base/models/simple_menu_model.h"
-#include "ui/views/controls/webview/webview.h"
-#include "ui/views/widget/widget.h"
-#include "ui/views/widget/native_widget_win.h"
-#include "ui/views/window/client_view.h"
-#include "ui/views/window/native_frame_view.h"
-
-namespace atom {
-
-namespace {
-
-const int kResizeInsideBoundsSize = 5;
-const int kResizeAreaCornerSize = 16;
-
-// Wrapper of NativeWidgetWin to handle WM_MENUCOMMAND messages, which are
-// triggered by window menus.
-class MenuCommandNativeWidget : public views::NativeWidgetWin {
- public:
-  explicit MenuCommandNativeWidget(NativeWindowWin* delegate)
-      : views::NativeWidgetWin(delegate->window()),
-        delegate_(delegate) {}
-  virtual ~MenuCommandNativeWidget() {}
-
- protected:
-  virtual bool PreHandleMSG(UINT message,
-                            WPARAM w_param,
-                            LPARAM l_param,
-                            LRESULT* result) OVERRIDE {
-    if (message == WM_MENUCOMMAND) {
-      delegate_->OnMenuCommand(w_param, reinterpret_cast<HMENU>(l_param));
-      *result = 0;
-      return true;
-    } else {
-      return false;
-    }
-  }
-
- private:
-  NativeWindowWin* delegate_;
-
-  DISALLOW_COPY_AND_ASSIGN(MenuCommandNativeWidget);
-};
-
-class NativeWindowClientView : public views::ClientView {
- public:
-  NativeWindowClientView(views::Widget* widget,
-                         NativeWindowWin* contents_view)
-      : views::ClientView(widget, contents_view) {
-  }
-  virtual ~NativeWindowClientView() {}
-
-  virtual bool CanClose() OVERRIDE {
-    static_cast<NativeWindowWin*>(contents_view())->CloseWebContents();
-    return false;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(NativeWindowClientView);
-};
-
-class NativeWindowFrameView : public views::NativeFrameView {
- public:
-  explicit NativeWindowFrameView(views::Widget* frame, NativeWindowWin* shell)
-      : NativeFrameView(frame),
-        shell_(shell) {
-  }
-  virtual ~NativeWindowFrameView() {}
-
-  virtual gfx::Size GetMinimumSize() OVERRIDE {
-    return shell_->GetMinimumSize();
-  }
-
-  virtual gfx::Size GetMaximumSize() OVERRIDE {
-    return shell_->GetMaximumSize();
-  }
-
- private:
-  NativeWindowWin* shell_;
-
-  DISALLOW_COPY_AND_ASSIGN(NativeWindowFrameView);
-};
-
-class NativeWindowFramelessView : public views::NonClientFrameView {
- public:
-  explicit NativeWindowFramelessView(views::Widget* frame,
-                                     NativeWindowWin* shell)
-      : frame_(frame),
-        shell_(shell) {
-  }
-  virtual ~NativeWindowFramelessView() {}
-
-  // views::NonClientFrameView implementations:
-  virtual gfx::Rect NativeWindowFramelessView::GetBoundsForClientView() const
-      OVERRIDE {
-    return bounds();
-  }
-
-  virtual gfx::Rect NativeWindowFramelessView::GetWindowBoundsForClientBounds(
-        const gfx::Rect& client_bounds) const OVERRIDE {
-    gfx::Rect window_bounds = client_bounds;
-    // Enforce minimum size (1, 1) in case that client_bounds is passed with
-    // empty size. This could occur when the frameless window is being
-    // initialized.
-    if (window_bounds.IsEmpty()) {
-      window_bounds.set_width(1);
-      window_bounds.set_height(1);
-    }
-    return window_bounds;
-  }
-
-  virtual int NonClientHitTest(const gfx::Point& point) OVERRIDE {
-    if (frame_->IsFullscreen())
-      return HTCLIENT;
-
-    // Check the frame first, as we allow a small area overlapping the contents
-    // to be used for resize handles.
-    bool can_ever_resize = frame_->widget_delegate() ?
-        frame_->widget_delegate()->CanResize() :
-        false;
-    // Don't allow overlapping resize handles when the window is maximized or
-    // fullscreen, as it can't be resized in those states.
-    int resize_border =
-        frame_->IsMaximized() || frame_->IsFullscreen() ? 0 :
-        kResizeInsideBoundsSize;
-    int frame_component = GetHTComponentForFrame(point,
-                                                 resize_border,
-                                                 resize_border,
-                                                 kResizeAreaCornerSize,
-                                                 kResizeAreaCornerSize,
-                                                 can_ever_resize);
-    if (frame_component != HTNOWHERE)
-      return frame_component;
-
-    // Check for possible draggable region in the client area for the frameless
-    // window.
-    if (shell_->draggable_region() &&
-        shell_->draggable_region()->contains(point.x(), point.y()))
-      return HTCAPTION;
-
-    int client_component = frame_->client_view()->NonClientHitTest(point);
-    if (client_component != HTNOWHERE)
-      return client_component;
-
-    // Caption is a safe default.
-    return HTCAPTION;
-  }
-
-  virtual void GetWindowMask(const gfx::Size& size,
-                             gfx::Path* window_mask) OVERRIDE {}
-  virtual void ResetWindowControls() OVERRIDE {}
-  virtual void UpdateWindowIcon() OVERRIDE {}
-  virtual void UpdateWindowTitle() OVERRIDE {}
-
-  // views::View implementations:
-  virtual gfx::Size NativeWindowFramelessView::GetPreferredSize() OVERRIDE {
-    gfx::Size pref = frame_->client_view()->GetPreferredSize();
-    gfx::Rect bounds(0, 0, pref.width(), pref.height());
-    return frame_->non_client_view()->GetWindowBoundsForClientBounds(
-        bounds).size();
-  }
-
-  virtual gfx::Size GetMinimumSize() OVERRIDE {
-    return shell_->GetMinimumSize();
-  }
-
-  virtual gfx::Size GetMaximumSize() OVERRIDE {
-    return shell_->GetMaximumSize();
-  }
-
- private:
-  views::Widget* frame_;
-  NativeWindowWin* shell_;
-
-  DISALLOW_COPY_AND_ASSIGN(NativeWindowFramelessView);
-};
-
-}  // namespace
-
-NativeWindowWin::NativeWindowWin(content::WebContents* web_contents,
-                                 base::DictionaryValue* options)
-    : NativeWindow(web_contents, options),
-      window_(new views::Widget),
-      web_view_(new views::WebView(NULL)),
-      use_content_size_(false),
-      resizable_(true) {
-  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
-  params.delegate = this;
-  params.native_widget = new MenuCommandNativeWidget(this);
-  params.remove_standard_frame = !has_frame_;
-  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  window_->set_frame_type(views::Widget::FRAME_TYPE_FORCE_NATIVE);
-  window_->Init(params);
-
-  int width = 800, height = 600;
-  options->GetInteger(switches::kWidth, &width);
-  options->GetInteger(switches::kHeight, &height);
-
-  gfx::Size size(width, height);
-  options->GetBoolean(switches::kUseContentSize, &use_content_size_);
-  if (has_frame_ && use_content_size_)
-    ClientAreaSizeToWindowSize(&size);
-
-  window_->CenterWindow(size);
-  window_->UpdateWindowIcon();
-
-  web_view_->SetWebContents(web_contents);
-  OnViewWasResized();
-}
-
-NativeWindowWin::~NativeWindowWin() {
-}
-
-void NativeWindowWin::Close() {
-  window_->Close();
-}
-
-void NativeWindowWin::CloseImmediately() {
-  window_->CloseNow();
-}
-
-void NativeWindowWin::Move(const gfx::Rect& bounds) {
-  window_->SetBounds(bounds);
-}
-
-void NativeWindowWin::Focus(bool focus) {
-  if (focus)
-    window_->Activate();
-  else
-    window_->Deactivate();
-}
-
-bool NativeWindowWin::IsFocused() {
-  return window_->IsActive();
-}
-
-void NativeWindowWin::Show() {
-  window_->Show();
-}
-
-void NativeWindowWin::Hide() {
-  window_->Hide();
-}
-
-void NativeWindowWin::Maximize() {
-  window_->Maximize();
-}
-
-void NativeWindowWin::Unmaximize() {
-  window_->Restore();
-}
-
-bool NativeWindowWin::IsVisible() {
-  return window_->IsVisible();
-}
-
-void NativeWindowWin::Minimize() {
-  window_->Minimize();
-}
-
-void NativeWindowWin::Restore() {
-  window_->Restore();
-}
-
-void NativeWindowWin::SetFullscreen(bool fullscreen) {
-  window_->SetFullscreen(fullscreen);
-}
-
-bool NativeWindowWin::IsFullscreen() {
-  return window_->IsFullscreen();
-}
-
-void NativeWindowWin::SetSize(const gfx::Size& size) {
-  window_->SetSize(size);
-}
-
-gfx::Size NativeWindowWin::GetSize() {
-  return window_->GetWindowBoundsInScreen().size();
-}
-
-void NativeWindowWin::SetContentSize(const gfx::Size& size) {
-  gfx::Size resized(size);
-  ClientAreaSizeToWindowSize(&resized);
-  SetSize(resized);
-}
-
-gfx::Size NativeWindowWin::GetContentSize() {
-  return window_->GetClientAreaBoundsInScreen().size();
-}
-
-void NativeWindowWin::SetMinimumSize(const gfx::Size& size) {
-  minimum_size_ = size;
-}
-
-gfx::Size NativeWindowWin::GetMinimumSize() {
-  return minimum_size_;
-}
-
-void NativeWindowWin::SetMaximumSize(const gfx::Size& size) {
-  maximum_size_ = size;
-}
-
-gfx::Size NativeWindowWin::GetMaximumSize() {
-  return maximum_size_;
-}
-
-void NativeWindowWin::SetResizable(bool resizable) {
-  resizable_ = resizable;
-}
-
-bool NativeWindowWin::IsResizable() {
-  return resizable_;
-}
-
-void NativeWindowWin::SetAlwaysOnTop(bool top) {
-  window_->SetAlwaysOnTop(top);
-}
-
-bool NativeWindowWin::IsAlwaysOnTop() {
-  DWORD style = ::GetWindowLong(window_->GetNativeView(), GWL_EXSTYLE);
-  return style & WS_EX_TOPMOST;
-}
-
-void NativeWindowWin::Center() {
-  window_->CenterWindow(GetSize());
-}
-
-void NativeWindowWin::SetPosition(const gfx::Point& position) {
-  window_->SetBounds(gfx::Rect(position, GetSize()));
-}
-
-gfx::Point NativeWindowWin::GetPosition() {
-  return window_->GetWindowBoundsInScreen().origin();
-}
-
-void NativeWindowWin::SetTitle(const std::string& title) {
-  title_ = UTF8ToUTF16(title);
-  window_->UpdateWindowTitle();
-}
-
-std::string NativeWindowWin::GetTitle() {
-  return UTF16ToUTF8(title_);
-}
-
-void NativeWindowWin::FlashFrame(bool flash) {
-  window_->FlashFrame(flash);
-}
-
-void NativeWindowWin::SetKiosk(bool kiosk) {
-  SetFullscreen(kiosk);
-}
-
-bool NativeWindowWin::IsKiosk() {
-  return IsFullscreen();
-}
-
-gfx::NativeWindow NativeWindowWin::GetNativeWindow() {
-  return window_->GetNativeView();
-}
-
-void NativeWindowWin::OnMenuCommand(int position, HMENU menu) {
-  DCHECK(menu_);
-  menu_->wrapper()->OnMenuCommand(position, menu);
-}
-
-void NativeWindowWin::SetMenu(ui::MenuModel* menu_model) {
-  menu_.reset(new atom::Menu2(menu_model, true));
-  ::SetMenu(GetNativeWindow(), menu_->GetNativeMenu());
-  RegisterAccelerators();
-
-  // Resize the window so SetMenu won't change client area size.
-  if (use_content_size_) {
-    gfx::Size size = GetSize();
-    size.set_height(size.height() + GetSystemMetrics(SM_CYMENU));
-    SetSize(size);
-  }
-}
-
-void NativeWindowWin::UpdateDraggableRegions(
-    const std::vector<DraggableRegion>& regions) {
-  if (has_frame_)
-    return;
-
-  SkRegion* draggable_region = new SkRegion;
-
-  // By default, the whole window is non-draggable. We need to explicitly
-  // include those draggable regions.
-  for (std::vector<DraggableRegion>::const_iterator iter = regions.begin();
-       iter != regions.end(); ++iter) {
-    const DraggableRegion& region = *iter;
-    draggable_region->op(
-        region.bounds.x(),
-        region.bounds.y(),
-        region.bounds.right(),
-        region.bounds.bottom(),
-        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
-  }
-
-  draggable_region_.reset(draggable_region);
-  OnViewWasResized();
-}
-
-void NativeWindowWin::HandleKeyboardEvent(
-    content::WebContents*,
-    const content::NativeWebKeyboardEvent& event) {
-  if (event.type == WebKit::WebInputEvent::RawKeyDown) {
-    ui::Accelerator accelerator(
-        static_cast<ui::KeyboardCode>(event.windowsKeyCode),
-        content::GetModifiersFromNativeWebKeyboardEvent(event));
-
-    if (GetFocusManager()->ProcessAccelerator(accelerator)) {
-      return;
-    }
-  }
-
-  // Any unhandled keyboard/character messages should be defproced.
-  // This allows stuff like F10, etc to work correctly.
-  DefWindowProc(event.os_event.hwnd, event.os_event.message,
-                event.os_event.wParam, event.os_event.lParam);
-}
-
-void NativeWindowWin::Layout() {
-  DCHECK(web_view_);
-  web_view_->SetBounds(0, 0, width(), height());
-  OnViewWasResized();
-}
-
-void NativeWindowWin::ViewHierarchyChanged(
-  const ViewHierarchyChangedDetails& details) {
-  if (details.is_add && details.child == this)
-    AddChildView(web_view_);
-}
-
-bool NativeWindowWin::AcceleratorPressed(
-    const ui::Accelerator& accelerator) {
-  return accelerator_util::TriggerAcceleratorTableCommand(
-      &accelerator_table_, accelerator);
-}
-
-void NativeWindowWin::DeleteDelegate() {
-  NotifyWindowClosed();
-}
-
-views::View* NativeWindowWin::GetInitiallyFocusedView() {
-  return web_view_;
-}
-
-bool NativeWindowWin::CanResize() const {
-  return resizable_;
-}
-
-bool NativeWindowWin::CanMaximize() const {
-  return resizable_;
-}
-
-string16 NativeWindowWin::GetWindowTitle() const {
-  return title_;
-}
-
-bool NativeWindowWin::ShouldHandleSystemCommands() const {
-  return true;
-}
-
-gfx::ImageSkia NativeWindowWin::GetWindowAppIcon() {
-  if (icon_.IsEmpty())
-    return gfx::ImageSkia();
-  else
-    return *icon_.ToImageSkia();
-}
-
-gfx::ImageSkia NativeWindowWin::GetWindowIcon() {
-  return GetWindowAppIcon();
-}
-
-views::Widget* NativeWindowWin::GetWidget() {
-  return window_.get();
-}
-
-const views::Widget* NativeWindowWin::GetWidget() const {
-  return window_.get();
-}
-
-views::ClientView* NativeWindowWin::CreateClientView(views::Widget* widget) {
-  return new NativeWindowClientView(widget, this);
-}
-
-views::NonClientFrameView* NativeWindowWin::CreateNonClientFrameView(
-    views::Widget* widget) {
-  if (has_frame_)
-    return new NativeWindowFrameView(widget, this);
-
-  return new NativeWindowFramelessView(widget, this);
-}
-
-void NativeWindowWin::ClientAreaSizeToWindowSize(gfx::Size* size) {
-  gfx::Size window = window_->GetWindowBoundsInScreen().size();
-  gfx::Size client = window_->GetClientAreaBoundsInScreen().size();
-  size->set_width(size->width() + window.width() - client.width());
-  size->set_height(size->height() + window.height() - client.height());
-}
-
-void NativeWindowWin::OnViewWasResized() {
-  // Set the window shape of the RWHV.
-  gfx::Size sz = web_view_->size();
-  int height = sz.height(), width = sz.width();
-  gfx::Path path;
-  path.addRect(0, 0, width, height);
-  SetWindowRgn(web_contents()->GetView()->GetNativeView(),
-               path.CreateNativeRegion(),
-               1);
-
-  SkRegion* rgn = new SkRegion;
-  if (!window_->IsFullscreen() && !window_->IsMaximized()) {
-    if (draggable_region())
-      rgn->op(*draggable_region(), SkRegion::kUnion_Op);
-
-    if (!has_frame_ && CanResize()) {
-      rgn->op(0, 0, width, kResizeInsideBoundsSize, SkRegion::kUnion_Op);
-      rgn->op(0, 0, kResizeInsideBoundsSize, height, SkRegion::kUnion_Op);
-      rgn->op(width - kResizeInsideBoundsSize, 0, width, height,
-          SkRegion::kUnion_Op);
-      rgn->op(0, height - kResizeInsideBoundsSize, width, height,
-          SkRegion::kUnion_Op);
-    }
-  }
-
-  content::WebContents* web_contents = GetWebContents();
-  if (web_contents->GetRenderViewHost()->GetView())
-    web_contents->GetRenderViewHost()->GetView()->SetClickthroughRegion(rgn);
-}
-
-void NativeWindowWin::RegisterAccelerators() {
-  views::FocusManager* focus_manager = GetFocusManager();
-  accelerator_table_.clear();
-  focus_manager->UnregisterAccelerators(this);
-
-  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);
-  }
-}
-
-// static
-NativeWindow* NativeWindow::Create(content::WebContents* web_contents,
-                                   base::DictionaryValue* options) {
-  return new NativeWindowWin(web_contents, options);
-}
-
-}  // namespace atom

atom/browser/net/asar/asar_protocol_handler.cc

@@ -0,0 +1,91 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/net/asar/asar_protocol_handler.h"
+
+#include "atom/browser/net/asar/url_request_asar_job.h"
+#include "atom/common/asar/archive.h"
+#include "net/base/filename_util.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_file_job.h"
+
+namespace asar {
+
+namespace {
+
+const base::FilePath::CharType kAsarExtension[] = FILE_PATH_LITERAL(".asar");
+
+// Get the relative path in asar archive.
+bool GetAsarPath(const base::FilePath& full_path,
+                 base::FilePath* asar_path,
+                 base::FilePath* relative_path) {
+  base::FilePath iter = full_path;
+  while (true) {
+    base::FilePath dirname = iter.DirName();
+    if (iter.MatchesExtension(kAsarExtension))
+      break;
+    else if (iter == dirname)
+      return false;
+    iter = dirname;
+  }
+
+  base::FilePath tail;
+  if (!iter.AppendRelativePath(full_path, &tail))
+    return false;
+
+  *asar_path = iter;
+  *relative_path = tail;
+  return true;
+}
+
+}  // namespace
+
+AsarProtocolHandler::AsarProtocolHandler(
+    const scoped_refptr<base::TaskRunner>& file_task_runner)
+    : file_task_runner_(file_task_runner) {}
+
+AsarProtocolHandler::~AsarProtocolHandler() {
+}
+
+Archive* AsarProtocolHandler::GetOrCreateAsarArchive(
+    const base::FilePath& path) const {
+  if (!archives_.contains(path)) {
+    scoped_ptr<Archive> archive(new Archive(path));
+    if (!archive->Init())
+      return nullptr;
+
+    archives_.set(path, archive.Pass());
+  }
+
+  return archives_.get(path);
+}
+
+net::URLRequestJob* AsarProtocolHandler::MaybeCreateJob(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  base::FilePath full_path;
+  net::FileURLToFilePath(request->url(), &full_path);
+
+  // Create asar:// job when the path contains "xxx.asar/", otherwise treat the
+  // URL request as file://.
+  base::FilePath asar_path, relative_path;
+  if (!GetAsarPath(full_path, &asar_path, &relative_path))
+    return new net::URLRequestFileJob(request, network_delegate, full_path,
+                                      file_task_runner_);
+
+  Archive* archive = GetOrCreateAsarArchive(asar_path);
+  if (!archive)
+    return new net::URLRequestErrorJob(request, network_delegate,
+                                       net::ERR_FILE_NOT_FOUND);
+
+  return new URLRequestAsarJob(request, network_delegate, archive,
+                               relative_path, file_task_runner_);
+}
+
+bool AsarProtocolHandler::IsSafeRedirectTarget(const GURL& location) const {
+  return false;
+}
+
+}  // namespace asar

atom/browser/net/asar/asar_protocol_handler.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_NET_ASAR_ASAR_PROTOCOL_HANDLER_H_
+#define ATOM_BROWSER_NET_ASAR_ASAR_PROTOCOL_HANDLER_H_
+
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "net/url_request/url_request_job_factory.h"
+
+namespace base {
+class TaskRunner;
+}
+
+namespace asar {
+
+class Archive;
+
+class AsarProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  explicit AsarProtocolHandler(
+      const scoped_refptr<base::TaskRunner>& file_task_runner);
+  virtual ~AsarProtocolHandler();
+
+  Archive* GetOrCreateAsarArchive(const base::FilePath& path) const;
+
+  // net::URLRequestJobFactory::ProtocolHandler:
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE;
+  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+
+ private:
+  const scoped_refptr<base::TaskRunner> file_task_runner_;
+
+  mutable base::ScopedPtrHashMap<base::FilePath, Archive> archives_;
+
+  DISALLOW_COPY_AND_ASSIGN(AsarProtocolHandler);
+};
+
+}  // namespace asar
+
+#endif  // ATOM_BROWSER_NET_ASAR_ASAR_PROTOCOL_HANDLER_H_

atom/browser/net/asar/url_request_asar_job.cc

@@ -0,0 +1,142 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/net/asar/url_request_asar_job.h"
+
+#include <string>
+
+#include "net/base/file_stream.h"
+#include "net/base/io_buffer.h"
+#include "net/base/mime_util.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/url_request_status.h"
+
+namespace asar {
+
+URLRequestAsarJob::URLRequestAsarJob(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    Archive* archive,
+    const base::FilePath& file_path,
+    const scoped_refptr<base::TaskRunner>& file_task_runner)
+    : net::URLRequestJob(request, network_delegate),
+      archive_(archive),
+      file_path_(file_path),
+      stream_(new net::FileStream(file_task_runner)),
+      remaining_bytes_(0),
+      file_task_runner_(file_task_runner),
+      weak_ptr_factory_(this) {}
+
+URLRequestAsarJob::~URLRequestAsarJob() {}
+
+void URLRequestAsarJob::Start() {
+  if (!archive_ || !archive_->GetFileInfo(file_path_, &file_info_)) {
+    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                     net::ERR_FILE_NOT_FOUND));
+    return;
+  }
+
+  remaining_bytes_ = static_cast<int64>(file_info_.size);
+
+  int flags = base::File::FLAG_OPEN |
+              base::File::FLAG_READ |
+              base::File::FLAG_ASYNC;
+  int rv = stream_->Open(archive_->path(), flags,
+                         base::Bind(&URLRequestAsarJob::DidOpen,
+                                    weak_ptr_factory_.GetWeakPtr()));
+  if (rv != net::ERR_IO_PENDING)
+    DidOpen(rv);
+}
+
+void URLRequestAsarJob::Kill() {
+  weak_ptr_factory_.InvalidateWeakPtrs();
+  URLRequestJob::Kill();
+}
+
+bool URLRequestAsarJob::ReadRawData(net::IOBuffer* dest,
+                                    int dest_size,
+                                    int* bytes_read) {
+  if (remaining_bytes_ < dest_size)
+    dest_size = static_cast<int>(remaining_bytes_);
+
+  // If we should copy zero bytes because |remaining_bytes_| is zero, short
+  // circuit here.
+  if (!dest_size) {
+    *bytes_read = 0;
+    return true;
+  }
+
+  int rv = stream_->Read(dest,
+                         dest_size,
+                         base::Bind(&URLRequestAsarJob::DidRead,
+                                    weak_ptr_factory_.GetWeakPtr(),
+                                    make_scoped_refptr(dest)));
+  if (rv >= 0) {
+    // Data is immediately available.
+    *bytes_read = rv;
+    remaining_bytes_ -= rv;
+    DCHECK_GE(remaining_bytes_, 0);
+    return true;
+  }
+
+  // Otherwise, a read error occured.  We may just need to wait...
+  if (rv == net::ERR_IO_PENDING) {
+    SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
+  } else {
+    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, rv));
+  }
+  return false;
+}
+
+bool URLRequestAsarJob::GetMimeType(std::string* mime_type) const {
+  return net::GetMimeTypeFromFile(file_path_, mime_type);
+}
+
+void URLRequestAsarJob::DidOpen(int result) {
+  if (result != net::OK) {
+    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
+    return;
+  }
+
+  int rv = stream_->Seek(base::File::FROM_BEGIN,
+                         file_info_.offset,
+                         base::Bind(&URLRequestAsarJob::DidSeek,
+                                    weak_ptr_factory_.GetWeakPtr()));
+  if (rv != net::ERR_IO_PENDING) {
+    // stream_->Seek() failed, so pass an intentionally erroneous value
+    // into DidSeek().
+    DidSeek(-1);
+  }
+}
+
+void URLRequestAsarJob::DidSeek(int64 result) {
+  if (result != static_cast<int64>(file_info_.offset)) {
+    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                     net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
+    return;
+  }
+
+  set_expected_content_size(remaining_bytes_);
+  NotifyHeadersComplete();
+}
+
+void URLRequestAsarJob::DidRead(scoped_refptr<net::IOBuffer> buf, int result) {
+  if (result > 0) {
+    SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status
+    remaining_bytes_ -= result;
+    DCHECK_GE(remaining_bytes_, 0);
+  }
+
+  buf = NULL;
+
+  if (result == 0) {
+    NotifyDone(net::URLRequestStatus());
+  } else if (result < 0) {
+    NotifyDone(net::URLRequestStatus(net::URLRequestStatus::FAILED, result));
+  }
+
+  NotifyReadComplete(result);
+}
+
+}  // namespace asar

atom/browser/net/asar/url_request_asar_job.h

@@ -0,0 +1,72 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_NET_ASAR_URL_REQUEST_ASAR_JOB_H_
+#define ATOM_BROWSER_NET_ASAR_URL_REQUEST_ASAR_JOB_H_
+
+#include <string>
+
+#include "atom/common/asar/archive.h"
+#include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "net/url_request/url_request_job.h"
+
+namespace base {
+class TaskRunner;
+}
+
+namespace net {
+class FileStream;
+}
+
+namespace asar {
+
+class URLRequestAsarJob : public net::URLRequestJob {
+ public:
+  URLRequestAsarJob(net::URLRequest* request,
+                    net::NetworkDelegate* network_delegate,
+                    Archive* archive,
+                    const base::FilePath& file_path,
+                    const scoped_refptr<base::TaskRunner>& file_task_runner);
+
+  // net::URLRequestJob:
+  virtual void Start() OVERRIDE;
+  virtual void Kill() OVERRIDE;
+  virtual bool ReadRawData(net::IOBuffer* buf,
+                           int buf_size,
+                           int* bytes_read) OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+
+ protected:
+  virtual ~URLRequestAsarJob();
+
+ private:
+  // Callback after opening file on a background thread.
+  void DidOpen(int result);
+
+  // Callback after seeking to the beginning of |byte_range_| in the file
+  // on a background thread.
+  void DidSeek(int64 result);
+
+  // Callback after data is asynchronously read from the file into |buf|.
+  void DidRead(scoped_refptr<net::IOBuffer> buf, int result);
+
+  Archive* archive_;
+  Archive::FileInfo file_info_;
+  base::FilePath file_path_;
+
+  scoped_ptr<net::FileStream> stream_;
+  int64 remaining_bytes_;
+
+  const scoped_refptr<base::TaskRunner> file_task_runner_;
+
+  base::WeakPtrFactory<URLRequestAsarJob> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestAsarJob);
+};
+
+}  // namespace asar
+
+#endif  // ATOM_BROWSER_NET_ASAR_URL_REQUEST_ASAR_JOB_H_

atom/browser/net/atom_url_request_context_getter.cc

@@ -1,185 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/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 "content/public/browser/browser_thread.h"
-#include "content/public/browser/cookie_store_factory.h"
-#include "content/public/common/url_constants.h"
-#include "net/cert/cert_verifier.h"
-#include "net/cookies/cookie_monster.h"
-#include "net/http/http_auth_handler_factory.h"
-#include "net/http/http_cache.h"
-#include "net/http/http_server_properties_impl.h"
-#include "net/proxy/dhcp_proxy_script_fetcher_factory.h"
-#include "net/proxy/proxy_config_service.h"
-#include "net/proxy/proxy_script_fetcher_impl.h"
-#include "net/proxy/proxy_service.h"
-#include "net/proxy/proxy_service_v8.h"
-#include "net/ssl/default_server_bound_cert_store.h"
-#include "net/ssl/server_bound_cert_service.h"
-#include "net/ssl/ssl_config_service_defaults.h"
-#include "net/url_request/data_protocol_handler.h"
-#include "net/url_request/file_protocol_handler.h"
-#include "net/url_request/static_http_user_agent_settings.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_storage.h"
-#include "vendor/brightray/browser/network_delegate.h"
-
-namespace atom {
-
-using content::BrowserThread;
-
-AtomURLRequestContextGetter::AtomURLRequestContextGetter(
-    const base::FilePath& base_path,
-    base::MessageLoop* io_loop,
-    base::MessageLoop* file_loop,
-    base::Callback<scoped_ptr<brightray::NetworkDelegate>(void)> factory,
-    content::ProtocolHandlerMap* protocol_handlers)
-    : base_path_(base_path),
-      io_loop_(io_loop),
-      file_loop_(file_loop),
-      job_factory_(NULL),
-      network_delegate_factory_(factory) {
-  // Must first be created on the UI thread.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  std::swap(protocol_handlers_, *protocol_handlers);
-
-  // We must create the proxy config service on the UI loop on Linux because it
-  // must synchronously run on the glib message loop. This will be passed to
-  // the URLRequestContextStorage on the IO thread in GetURLRequestContext().
-  proxy_config_service_.reset(
-      net::ProxyService::CreateSystemProxyConfigService(
-          io_loop_->message_loop_proxy(),
-          file_loop_));
-}
-
-AtomURLRequestContextGetter::~AtomURLRequestContextGetter() {
-}
-
-net::URLRequestContext* AtomURLRequestContextGetter::GetURLRequestContext() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  base::AutoLock auto_lock(lock_);
-  if (!url_request_context_.get()) {
-    url_request_context_.reset(new net::URLRequestContext());
-    network_delegate_ = network_delegate_factory_.Run().Pass();
-    url_request_context_->set_network_delegate(network_delegate_.get());
-    storage_.reset(
-        new net::URLRequestContextStorage(url_request_context_.get()));
-    storage_->set_cookie_store(content::CreatePersistentCookieStore(
-        base_path_.Append(FILE_PATH_LITERAL("Cookies")),
-        false,
-        nullptr,
-        nullptr,
-        nullptr));
-    storage_->set_server_bound_cert_service(new net::ServerBoundCertService(
-        new net::DefaultServerBoundCertStore(NULL),
-        base::WorkerPool::GetTaskRunner(true)));
-    storage_->set_http_user_agent_settings(
-        new net::StaticHttpUserAgentSettings(
-            "en-us,en", EmptyString()));
-
-    scoped_ptr<net::HostResolver> host_resolver(
-        net::HostResolver::CreateDefaultResolver(NULL));
-    net::DhcpProxyScriptFetcherFactory dhcp_factory;
-
-    storage_->set_cert_verifier(net::CertVerifier::CreateDefault());
-    storage_->set_transport_security_state(new net::TransportSecurityState);
-    storage_->set_proxy_service(
-        net::CreateProxyServiceUsingV8ProxyResolver(
-            proxy_config_service_.release(),
-            new net::ProxyScriptFetcherImpl(url_request_context_.get()),
-            dhcp_factory.Create(url_request_context_.get()),
-            host_resolver.get(),
-            NULL,
-            url_request_context_->network_delegate()));
-    storage_->set_ssl_config_service(new net::SSLConfigServiceDefaults);
-    storage_->set_http_auth_handler_factory(
-        net::HttpAuthHandlerFactory::CreateDefault(host_resolver.get()));
-    scoped_ptr<net::HttpServerProperties> server_properties(
-        new net::HttpServerPropertiesImpl);
-    storage_->set_http_server_properties(server_properties.Pass());
-
-    base::FilePath cache_path = base_path_.Append(FILE_PATH_LITERAL("Cache"));
-    net::HttpCache::DefaultBackend* main_backend =
-        new net::HttpCache::DefaultBackend(
-            net::DISK_CACHE,
-            net::CACHE_BACKEND_DEFAULT,
-            cache_path,
-            0,
-            BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
-
-    net::HttpNetworkSession::Params network_session_params;
-    network_session_params.cert_verifier =
-        url_request_context_->cert_verifier();
-    network_session_params.transport_security_state =
-        url_request_context_->transport_security_state();
-    network_session_params.server_bound_cert_service =
-        url_request_context_->server_bound_cert_service();
-    network_session_params.proxy_service =
-        url_request_context_->proxy_service();
-    network_session_params.ssl_config_service =
-        url_request_context_->ssl_config_service();
-    network_session_params.http_auth_handler_factory =
-        url_request_context_->http_auth_handler_factory();
-    network_session_params.network_delegate =
-        url_request_context_->network_delegate();
-    network_session_params.http_server_properties =
-        url_request_context_->http_server_properties();
-    network_session_params.ignore_certificate_errors = false;
-
-    // Give |storage_| ownership at the end in case it's |mapped_host_resolver|.
-    storage_->set_host_resolver(host_resolver.Pass());
-    network_session_params.host_resolver =
-        url_request_context_->host_resolver();
-
-    net::HttpCache* main_cache = new net::HttpCache(
-        network_session_params, main_backend);
-    storage_->set_http_transaction_factory(main_cache);
-
-    DCHECK(!job_factory_);
-    job_factory_ = new AtomURLRequestJobFactory;
-    for (content::ProtocolHandlerMap::iterator it = protocol_handlers_.begin();
-         it != protocol_handlers_.end();
-         ++it) {
-      bool set_protocol = job_factory_->SetProtocolHandler(
-          it->first,
-          it->second.release());
-      DCHECK(set_protocol);
-    }
-    protocol_handlers_.clear();
-
-    scoped_ptr<net::FileProtocolHandler> file_protocol_handler(
-        new net::FileProtocolHandler(
-            content::BrowserThread::GetBlockingPool()->
-                GetTaskRunnerWithShutdownBehavior(
-                    base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
-    job_factory_->SetProtocolHandler(chrome::kDataScheme,
-                                     new net::DataProtocolHandler);
-    job_factory_->SetProtocolHandler(chrome::kFileScheme,
-                                     file_protocol_handler.release());
-    storage_->set_job_factory(job_factory_);
-  }
-
-  return url_request_context_.get();
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-    AtomURLRequestContextGetter::GetNetworkTaskRunner() const {
-  return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
-}
-
-net::HostResolver* AtomURLRequestContextGetter::host_resolver() {
-  return url_request_context_->host_resolver();
-}
-
-}  // namespace atom

atom/browser/net/atom_url_request_context_getter.h

@@ -1,76 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_NET_ATOM_URL_REQUEST_CONTEXT_GETTER_H_
-#define ATOM_BROWSER_NET_ATOM_URL_REQUEST_CONTEXT_GETTER_H_
-
-#include "base/callback.h"
-#include "base/files/file_path.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/synchronization/lock.h"
-#include "content/public/browser/content_browser_client.h"
-#include "net/url_request/url_request_context_getter.h"
-
-namespace base {
-class MessageLoop;
-}
-
-namespace brightray {
-class NetworkDelegate;
-}
-
-namespace net {
-class HostResolver;
-class ProxyConfigService;
-class URLRequestContextStorage;
-}
-
-namespace atom {
-
-class AtomURLRequestJobFactory;
-
-class AtomURLRequestContextGetter : public net::URLRequestContextGetter {
- public:
-  AtomURLRequestContextGetter(
-      const base::FilePath& base_path,
-      base::MessageLoop* io_loop,
-      base::MessageLoop* file_loop,
-      base::Callback<scoped_ptr<brightray::NetworkDelegate>(void)>,
-      content::ProtocolHandlerMap* protocol_handlers);
-
-  // net::URLRequestContextGetter implementations:
-  virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE;
-  virtual scoped_refptr<base::SingleThreadTaskRunner>
-      GetNetworkTaskRunner() const OVERRIDE;
-
-  net::HostResolver* host_resolver();
-  net::URLRequestContextStorage* storage() const { return storage_.get(); }
-  AtomURLRequestJobFactory* job_factory() const { return job_factory_; }
-
- protected:
-  virtual ~AtomURLRequestContextGetter();
-
- private:
-  base::FilePath base_path_;
-  base::MessageLoop* io_loop_;
-  base::MessageLoop* file_loop_;
-
-  AtomURLRequestJobFactory* job_factory_;
-  base::Callback<scoped_ptr<brightray::NetworkDelegate>(void)>
-      network_delegate_factory_;
-
-  base::Lock lock_;
-
-  scoped_ptr<net::ProxyConfigService> proxy_config_service_;
-  scoped_ptr<brightray::NetworkDelegate> network_delegate_;
-  scoped_ptr<net::URLRequestContextStorage> storage_;
-  scoped_ptr<net::URLRequestContext> url_request_context_;
-  content::ProtocolHandlerMap protocol_handlers_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomURLRequestContextGetter);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_NET_ATOM_URL_REQUEST_CONTEXT_GETTER_H_

atom/browser/node_debugger.cc

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

atom/browser/node_debugger.h

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

atom/browser/resources/mac/Info.plist

@@ -2,20 +2,28 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-	<key>CFBundleIdentifier</key>
-	<string>com.github.atom</string>
-	<key>CFBundleName</key>
-	<string>${PRODUCT_NAME}</string>
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
+  <key>CFBundleDisplayName</key>
+  <string>${PRODUCT_NAME}</string>
+  <key>CFBundleExecutable</key>
+  <string>${PRODUCT_NAME}</string>
+  <key>CFBundleIdentifier</key>
+  <string>com.github.atom</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>${PRODUCT_NAME}</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
   <key>CFBundleIconFile</key>
   <string>atom.icns</string>
   <key>CFBundleVersion</key>
-  <string>0.12.5</string>
-	<key>NSMainNibFile</key>
-	<string>MainMenu</string>
-	<key>NSPrincipalClass</key>
-	<string>AtomApplication</string>
+  <string>0.18.1</string>
+  <key>LSMinimumSystemVersion</key>
+  <string>10.8.0</string>
+  <key>NSMainNibFile</key>
+  <string>MainMenu</string>
+  <key>NSPrincipalClass</key>
+  <string>AtomApplication</string>
   <key>NSSupportsAutomaticGraphicsSwitching</key>
   <true/>
 </dict>

atom/browser/resources/win/atom.rc

@@ -50,8 +50,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 0,12,5,0
- PRODUCTVERSION 0,12,5,0
+ FILEVERSION 0,18,1,0
+ PRODUCTVERSION 0,18,1,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -68,12 +68,13 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "GitHub, Inc."
             VALUE "FileDescription", "Atom-Shell"
-            VALUE "FileVersion", "0.12.5"
+            VALUE "FileVersion", "0.18.1"
             VALUE "InternalName", "atom.exe"
             VALUE "LegalCopyright", "Copyright (C) 2013 GitHub, Inc. All rights reserved."
             VALUE "OriginalFilename", "atom.exe"
             VALUE "ProductName", "Atom-Shell"
-            VALUE "ProductVersion", "0.12.5"
+            VALUE "ProductVersion", "0.18.1"
+            VALUE "SquirrelAwareVersion", "1"
         END
     END
     BLOCK "VarFileInfo"

atom/browser/ui/accelerator_util.cc

@@ -87,11 +87,11 @@ ui::KeyboardCode KeyboardCodeFromCharCode(char c, bool* shifted) {
 
 bool StringToAccelerator(const std::string& description,
                          ui::Accelerator* accelerator) {
-  if (!IsStringASCII(description)) {
+  if (!base::IsStringASCII(description)) {
     LOG(ERROR) << "The accelerator string can only contain ASCII characters";
     return false;
   }
-  std::string shortcut(StringToLowerASCII(description));
+  std::string shortcut(base::StringToLowerASCII(description));
 
   std::vector<std::string> tokens;
   base::SplitString(shortcut, '+', &tokens);
@@ -129,6 +129,8 @@ bool StringToAccelerator(const std::string& description,
       key = ui::VKEY_BACK;
     } else if (tokens[i] == "delete") {
       key = ui::VKEY_DELETE;
+    } else if (tokens[i] == "insert") {
+      key = ui::VKEY_INSERT;
     } else if (tokens[i] == "enter" || tokens[i] == "return") {
       key = ui::VKEY_RETURN;
     } else if (tokens[i] == "up") {
@@ -147,7 +149,7 @@ bool StringToAccelerator(const std::string& description,
       key = ui::VKEY_PRIOR;
     } else if (tokens[i] == "pageup") {
       key = ui::VKEY_NEXT;
-    } else if (tokens[i] == "esc") {
+    } else if (tokens[i] == "esc" || tokens[i] == "escape") {
       key = ui::VKEY_ESCAPE;
     } else if (tokens[i] == "volumemute") {
       key = ui::VKEY_VOLUME_MUTE;

atom/browser/ui/accelerator_util_gtk.cc

@@ -1,20 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/ui/accelerator_util.h"
-
-#include "ui/base/accelerators/accelerator.h"
-#include "ui/base/accelerators/platform_accelerator_gtk.h"
-
-namespace accelerator_util {
-
-void SetPlatformAccelerator(ui::Accelerator* accelerator) {
-  scoped_ptr<ui::PlatformAccelerator> platform_accelerator(
-      new ui::PlatformAcceleratorGtk(
-          GetGdkKeyCodeForAccelerator(*accelerator),
-          GetGdkModifierForAccelerator(*accelerator)));
-  accelerator->set_platform_accelerator(platform_accelerator.Pass());
-}
-
-}  // namespace accelerator_util