Bump v0.22.0

Merge pull request #1254 from austinmoore-/master
Add check for root in script/bootstrap.py
2026-02-26 03:01:17 -05:00 · 2015-03-18 20:57:21 +08:00 · 2015-03-18 20:36:29 +08:00 · 2015-03-18 18:01:37 +08:00 · 2015-03-18 18:01:14 +08:00 · 2015-03-18 13:58:33 +08:00
337 changed files with 9877 additions and 5166 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,4 @@ node_modules/
 *.xcodeproj
 *.swp
 *.pyc
+npm-debug.log
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,6 @@
 [submodule "vendor/brightray"]
 	path = vendor/brightray
-	url = https://github.com/brightray/brightray.git
+	url = https://github.com/atom/brightray.git
 [submodule "vendor/node"]
 	path = vendor/node
 	url = https://github.com/atom/node.git
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # Atom Shell [![Build Status](https://travis-ci.org/atom/atom-shell.svg?branch=master)](https://travis-ci.org/atom/atom-shell)

 The Atom Shell framework lets you write cross-platform desktop applications
-using JavaScript, HTML and CSS. It is based on [node.js](http://nodejs.org) and
+using JavaScript, HTML and CSS. It is based on [io.js](http://iojs.org) and
 [Chromium](http://www.chromium.org) and is used in the [Atom
 editor](https://github.com/atom/atom).

@@ -10,6 +10,20 @@ editor](https://github.com/atom/atom).
 Prebuilt binaries of atom-shell for Linux, Windows and Mac can be found on the
 [releases](https://github.com/atom/atom-shell/releases) page.

+You can also use [`npm`](https://docs.npmjs.com/) to install prebuilt atom-shell binaries:
+
+```
+# Install globally in your $PATH
+npm install atom-shell -g
+
+# Install as a development dependency
+npm install atom-shell --save-dev
+```
+
+### Mirrors
+
+- [China Mirror](https://npm.taobao.org/mirrors/atom-shell): Improve download speeds for Chinese user.
+
 ## Documentation

 Guides and the API reference are located in the
--- a/atom.gyp
+++ b/atom.gyp
@@ -3,9 +3,8 @@
    'includes': [
      'vendor/native_mate/native_mate_files.gypi',
    ],
-    'project_name': 'atom',
-    'product_name': 'Atom',
-    'framework_name': 'Atom Framework',
+    'project_name%': 'atom',
+    'product_name%': 'Atom',
    'app_sources': [
      'atom/app/atom_main.cc',
      'atom/app/atom_main.h',
@@ -26,6 +25,7 @@
      'atom/browser/api/lib/menu-item.coffee',
      'atom/browser/api/lib/power-monitor.coffee',
      'atom/browser/api/lib/protocol.coffee',
+      'atom/browser/api/lib/screen.coffee',
      'atom/browser/api/lib/tray.coffee',
      'atom/browser/api/lib/web-contents.coffee',
      'atom/browser/lib/chrome-extension.coffee',
@@ -38,26 +38,35 @@
      'atom/common/api/lib/clipboard.coffee',
      'atom/common/api/lib/crash-reporter.coffee',
      'atom/common/api/lib/id-weak-map.coffee',
-      'atom/common/api/lib/screen.coffee',
+      'atom/common/api/lib/native-image.coffee',
+      'atom/common/api/lib/original-fs.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/guest-view-internal.coffee',
      'atom/renderer/lib/init.coffee',
      'atom/renderer/lib/inspector.coffee',
      'atom/renderer/lib/override.coffee',
-      'atom/renderer/lib/web-view.coffee',
+      'atom/renderer/lib/web-view/guest-view-internal.coffee',
+      'atom/renderer/lib/web-view/web-view.coffee',
+      'atom/renderer/lib/web-view/web-view-attributes.coffee',
+      'atom/renderer/lib/web-view/web-view-constants.coffee',
      'atom/renderer/api/lib/ipc.coffee',
      'atom/renderer/api/lib/remote.coffee',
+      'atom/renderer/api/lib/screen.coffee',
      'atom/renderer/api/lib/web-frame.coffee',
    ],
+    'coffee2c_sources': [
+      'atom/common/lib/asar.coffee',
+      'atom/common/lib/asar_init.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',
+      'atom/app/node_main.cc',
+      'atom/app/node_main.h',
      'atom/browser/api/atom_api_app.cc',
      'atom/browser/api/atom_api_app.h',
      'atom/browser/api/atom_api_auto_updater.cc',
@@ -76,10 +85,13 @@
      '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_screen.cc',
+      'atom/browser/api/atom_api_screen.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_web_view_manager.cc',
      'atom/browser/api/atom_api_window.cc',
      'atom/browser/api/atom_api_window.h',
      'atom/browser/api/event.cc',
@@ -104,6 +116,8 @@
      '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',
@@ -178,12 +192,12 @@
      '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/window_state_watcher.cc',
+      'atom/browser/ui/x/window_state_watcher.h',
      'atom/browser/ui/x/x_window_utils.cc',
      'atom/browser/ui/x/x_window_utils.h',
-      'atom/browser/web_view/web_view_manager.cc',
-      'atom/browser/web_view/web_view_manager.h',
-      'atom/browser/web_view/web_view_renderer_state.cc',
-      'atom/browser/web_view/web_view_renderer_state.h',
+      'atom/browser/web_view_manager.cc',
+      'atom/browser/web_view_manager.h',
      'atom/browser/web_dialog_helper.cc',
      'atom/browser/web_dialog_helper.h',
      'atom/browser/window_list.cc',
@@ -195,8 +209,9 @@
      'atom/common/api/atom_api_crash_reporter.cc',
      'atom/common/api/atom_api_id_weak_map.cc',
      'atom/common/api/atom_api_id_weak_map.h',
-      'atom/common/api/atom_api_screen.cc',
-      'atom/common/api/atom_api_screen.h',
+      'atom/common/api/atom_api_native_image.cc',
+      'atom/common/api/atom_api_native_image.h',
+      'atom/common/api/atom_api_native_image_mac.mm',
      'atom/common/api/atom_api_shell.cc',
      'atom/common/api/atom_api_v8_util.cc',
      'atom/common/api/atom_bindings.cc',
@@ -205,6 +220,8 @@
      'atom/common/api/object_life_monitor.h',
      'atom/common/asar/archive.cc',
      'atom/common/asar/archive.h',
+      'atom/common/asar/asar_util.cc',
+      'atom/common/asar/asar_util.h',
      'atom/common/asar/scoped_temporary_file.cc',
      'atom/common/asar/scoped_temporary_file.h',
      'atom/common/common_message_generator.cc',
@@ -230,6 +247,7 @@
      '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/gfx_converter.cc',
      'atom/common/native_mate_converters/gfx_converter.h',
      'atom/common/native_mate_converters/gurl_converter.h',
      'atom/common/native_mate_converters/image_converter.cc',
@@ -255,14 +273,16 @@
      'atom/common/platform_util_mac.mm',
      'atom/common/platform_util_win.cc',
      'atom/renderer/api/atom_api_renderer_ipc.cc',
-      'atom/renderer/api/atom_renderer_bindings.cc',
-      'atom/renderer/api/atom_renderer_bindings.h',
+      'atom/renderer/api/atom_api_spell_check_client.cc',
+      'atom/renderer/api/atom_api_spell_check_client.h',
      'atom/renderer/api/atom_api_web_frame.cc',
      'atom/renderer/api/atom_api_web_frame.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',
+      'atom/renderer/guest_view_container.cc',
+      'atom/renderer/guest_view_container.h',
      'chromium_src/chrome/browser/browser_process.cc',
      'chromium_src/chrome/browser/browser_process.h',
      'chromium_src/chrome/browser/chrome_notification_types.h',
@@ -280,6 +300,7 @@
      '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.cc',
      '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',
@@ -290,8 +311,6 @@
      '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',
@@ -306,14 +325,8 @@
      'chromium_src/chrome/browser/ui/cocoa/color_chooser_mac.mm',
      'chromium_src/chrome/browser/ui/views/color_chooser_aura.cc',
      'chromium_src/chrome/browser/ui/views/color_chooser_aura.h',
-      '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',
@@ -322,8 +335,10 @@
      '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_pdf_win.cc',
      'chromium_src/chrome/renderer/printing/print_web_view_helper.h',
+      'chromium_src/chrome/renderer/spellchecker/spellcheck_worditerator.cc',
+      'chromium_src/chrome/renderer/spellchecker/spellcheck_worditerator.h',
      'chromium_src/chrome/renderer/tts_dispatcher.cc',
      'chromium_src/chrome/renderer/tts_dispatcher.h',
      'chromium_src/library_loaders/libgio_loader.cc',
@@ -331,6 +346,7 @@
      'chromium_src/library_loaders/libspeechd_loader.cc',
      'chromium_src/library_loaders/libspeechd.h',
      '<@(native_mate_files)',
+      '<(SHARED_INTERMEDIATE_DIR)/atom_natives.h',
    ],
    'lib_sources_win': [
      'chromium_src/chrome/browser/ui/views/color_chooser_dialog.cc',
@@ -338,8 +354,8 @@
      'chromium_src/chrome/browser/ui/views/color_chooser_win.cc',
    ],
    'framework_sources': [
-      'atom/app/atom_library_main.cc',
      'atom/app/atom_library_main.h',
+      'atom/app/atom_library_main.mm',
    ],
    'locales': [
      'am', 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en-GB',
@@ -349,7 +365,7 @@
      'sk', 'sl', 'sr', 'sv', 'sw', 'ta', 'te', 'th', 'tr', 'uk',
      'vi', 'zh-CN', 'zh-TW',
    ],
-    'atom_source_root': '<!(python tools/atom_source_root.py)',
+    'atom_source_root': '<!(["python", "tools/atom_source_root.py"])',
    'conditions': [
      ['OS=="win"', {
        'app_sources': [
@@ -384,7 +400,7 @@
      'target_name': '<(project_name)',
      'type': 'executable',
      'dependencies': [
-        'generated_sources',
+        'compile_coffee',
        '<(project_name)_lib',
      ],
      'sources': [
@@ -418,7 +434,7 @@
              'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Frameworks',
              'files': [
                '<(PRODUCT_DIR)/<(product_name) Helper.app',
-                '<(PRODUCT_DIR)/<(framework_name).framework',
+                '<(PRODUCT_DIR)/<(product_name) Framework.framework',
                'external_binaries/Squirrel.framework',
                'external_binaries/ReactiveCocoa.framework',
                'external_binaries/Mantle.framework',
@@ -479,10 +495,12 @@
                '<(libchromiumcontent_library_dir)/libEGL.dll',
                '<(libchromiumcontent_library_dir)/libGLESv2.dll',
                '<(libchromiumcontent_resources_dir)/icudtl.dat',
+                '<(libchromiumcontent_resources_dir)/content_resources_200_percent.pak',
                '<(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',
+                '<(libchromiumcontent_resources_dir)/natives_blob.bin',
+                '<(libchromiumcontent_resources_dir)/snapshot_blob.bin',
+                'external_binaries/d3dcompiler_46.dll',
                'external_binaries/msvcp120.dll',
                'external_binaries/msvcr120.dll',
                'external_binaries/vccorlib120.dll',
@@ -506,6 +524,8 @@
                '<(libchromiumcontent_library_dir)/libffmpegsumo.so',
                '<(libchromiumcontent_resources_dir)/icudtl.dat',
                '<(libchromiumcontent_resources_dir)/content_shell.pak',
+                '<(libchromiumcontent_resources_dir)/natives_blob.bin',
+                '<(libchromiumcontent_resources_dir)/snapshot_blob.bin',
              ],
            },
            {
@@ -522,12 +542,19 @@
      'target_name': '<(project_name)_lib',
      'type': 'static_library',
      'dependencies': [
+        'atom_coffee2c',
        'vendor/brightray/brightray.gyp:brightray',
        'vendor/node/node.gyp:node_lib',
      ],
      'defines': [
+        'PRODUCT_NAME="<(product_name)"',
        # This is defined in skia/skia_common.gypi.
        'SK_SUPPORT_LEGACY_GETTOPDEVICE',
+        # Disable warnings for g_settings_list_schemas.
+        'GLIB_DISABLE_DEPRECATION_WARNINGS',
+        # Defined in Chromium but not exposed in its gyp file.
+        'V8_USE_EXTERNAL_STARTUP_DATA',
+        'ENABLE_PLUGINS',
      ],
      'sources': [
        '<@(lib_sources)',
@@ -537,6 +564,8 @@
        'chromium_src',
        'vendor/brightray',
        'vendor/native_mate',
+        # Include atom_natives.h.
+        '<(SHARED_INTERMEDIATE_DIR)',
        # Include directories for uv and node.
        'vendor/node/src',
        'vendor/node/deps/http_parser',
@@ -545,6 +574,8 @@
        'vendor/brightray/vendor/download/libchromiumcontent/src/v8/include',
        # The `node.h` is using `#include"ares.h"`.
        'vendor/node/deps/cares/include',
+        # The `third_party/WebKit/Source/platform/weborigin/SchemeRegistry.h` is using `platform/PlatformExport.h`.
+        'vendor/brightray/vendor/download/libchromiumcontent/src/third_party/WebKit/Source',
      ],
      'direct_dependent_settings': {
        'include_dirs': [
@@ -586,10 +617,6 @@
              '-rpath \$$ORIGIN',
              # Make native module dynamic loading work.
              '-rdynamic',
-              '<!@(pkg-config --libs-only-L --libs-only-other dbus-1)',
-            ],
-            'libraries': [
-              '<!@(pkg-config --libs-only-l dbus-1)',
            ],
          },
          # Required settings of using breakpad.
@@ -609,44 +636,56 @@
      ],
    },  # target <(product_name)_lib
    {
-      'target_name': 'generated_sources',
+      'target_name': 'compile_coffee',
      'type': 'none',
-      'sources': [
-        '<@(coffee_sources)',
-      ],
-      'rules': [
+      'actions': [
        {
-          'rule_name': 'coffee',
-          'extension': 'coffee',
+          'action_name': 'compile_coffee',
+          'variables': {
+            'conditions': [
+              ['OS=="mac"', {
+                'resources_path': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources',
+              },{
+                'resources_path': '<(PRODUCT_DIR)/resources',
+              }],
+            ],
+          },
          'inputs': [
-            'script/compile-coffee.py',
+            '<@(coffee_sources)',
          ],
-          'conditions': [
-            ['OS=="mac"', {
-              'outputs': [
-                '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
-              ],
-              'action': [
-                'python',
-                'script/compile-coffee.py',
-                '<(RULE_INPUT_PATH)',
-                '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
-              ],
-            },{  # OS=="mac"
-              'outputs': [
-                '<(PRODUCT_DIR)/resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
-              ],
-              'action': [
-                'python',
-                'script/compile-coffee.py',
-                '<(RULE_INPUT_PATH)',
-                '<(PRODUCT_DIR)/resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
-              ],
-            }],  # OS=="win" or OS=="linux"
+          'outputs': [
+            '<(resources_path)/atom.asar',
          ],
-        },
+          'action': [
+            'python',
+            'tools/coffee2asar.py',
+            '<@(_outputs)',
+            '<@(_inputs)',
+          ],
+        }
      ],
-    },  # target generated_sources
+    },  # target compile_coffee
+    {
+      'target_name': 'atom_coffee2c',
+      'type': 'none',
+      'actions': [
+        {
+          'action_name': 'atom_coffee2c',
+          'inputs': [
+            '<@(coffee2c_sources)',
+          ],
+          'outputs': [
+            '<(SHARED_INTERMEDIATE_DIR)/atom_natives.h',
+          ],
+          'action': [
+            'python',
+            'tools/coffee2c.py',
+            '<@(_outputs)',
+            '<@(_inputs)',
+          ],
+        }
+      ],
+    },  # target atom_coffee2c
    {
      'target_name': '<(project_name)_dump_symbols',
      'type': 'none',
@@ -785,7 +824,7 @@
      'targets': [
        {
          'target_name': '<(project_name)_framework',
-          'product_name': '<(framework_name)',
+          'product_name': '<(product_name) Framework',
          'type': 'shared_library',
          'dependencies': [
            '<(project_name)_lib',
@@ -798,6 +837,9 @@
            'vendor',
            '<(libchromiumcontent_include_dir)',
          ],
+          'defines': [
+            'PRODUCT_NAME="<(product_name)"',
+          ],
          'export_dependent_settings': [
            '<(project_name)_lib',
          ],
@@ -815,13 +857,15 @@
            'atom/common/resources/mac/MainMenu.xib',
            '<(libchromiumcontent_resources_dir)/content_shell.pak',
            '<(libchromiumcontent_resources_dir)/icudtl.dat',
+            '<(libchromiumcontent_resources_dir)/natives_blob.bin',
+            '<(libchromiumcontent_resources_dir)/snapshot_blob.bin',
          ],
          'xcode_settings': {
            'INFOPLIST_FILE': 'atom/common/resources/mac/Info.plist',
            'LIBRARY_SEARCH_PATHS': [
              '<(libchromiumcontent_library_dir)',
            ],
-            'LD_DYLIB_INSTALL_NAME': '@rpath/<(framework_name).framework/<(framework_name)',
+            'LD_DYLIB_INSTALL_NAME': '@rpath/<(product_name) Framework.framework/<(product_name) Framework',
            'LD_RUNPATH_SEARCH_PATHS': [
              '@loader_path/Libraries',
            ],
@@ -831,14 +875,14 @@
          },
          'copies': [
            {
-              'destination': '<(PRODUCT_DIR)/<(framework_name).framework/Versions/A/Libraries',
+              'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Libraries',
              'files': [
                '<(libchromiumcontent_library_dir)/ffmpegsumo.so',
                '<(libchromiumcontent_library_dir)/libchromiumcontent.dylib',
              ],
            },
            {
-              'destination': '<(PRODUCT_DIR)/<(framework_name).framework/Versions/A/Resources',
+              'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Resources',
              'files': [
                '<(PRODUCT_DIR)/Inspector',
                '<(PRODUCT_DIR)/crash_report_sender.app',
@@ -850,7 +894,7 @@
              'postbuild_name': 'Add symlinks for framework subdirectories',
              'action': [
                'tools/mac/create-framework-subdir-symlinks.sh',
-                '<(framework_name)',
+                '<(product_name) Framework',
                'Libraries',
                'Frameworks',
              ],
@@ -888,13 +932,14 @@
            {
              'action_name': 'Make Empty Paks',
              'inputs': [
-                'tools/posix/make_locale_paks.sh',
+                'tools/make_locale_paks.py',
              ],
              'outputs': [
                '<(PRODUCT_DIR)/locales'
              ],
              'action': [
-                'tools/posix/make_locale_paks.sh',
+                'python',
+                'tools/make_locale_paks.py',
                '<(PRODUCT_DIR)',
                '<@(locales)',
              ],
@@ -936,31 +981,5 @@
        },  # 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
  ],
 }
--- a/atom/app/atom_content_client.h
+++ b/atom/app/atom_content_client.h
@@ -19,10 +19,10 @@ class AtomContentClient : public brightray::ContentClient {

 protected:
  // content::ContentClient:
-  virtual std::string GetProduct() const OVERRIDE;
-  virtual void AddAdditionalSchemes(
+  std::string GetProduct() const override;
+  void AddAdditionalSchemes(
      std::vector<std::string>* standard_schemes,
-      std::vector<std::string>* savable_schemes) OVERRIDE;
+      std::vector<std::string>* savable_schemes) override;

 private:
  DISALLOW_COPY_AND_ASSIGN(AtomContentClient);
--- a/atom/app/atom_library_main.cc
+++ b/atom/app/atom_library_main.cc
@@ -1,18 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/app/atom_library_main.h"
-
-#include "atom/app/atom_main_delegate.h"
-#include "content/public/app/content_main.h"
-
-#if defined(OS_MACOSX)
-int AtomMain(int argc, const char* argv[]) {
-  atom::AtomMainDelegate delegate;
-  content::ContentMainParams params(&delegate);
-  params.argc = argc;
-  params.argv = argv;
-  return content::ContentMain(params);
-}
-#endif  // OS_MACOSX
--- a/atom/app/atom_library_main.h
+++ b/atom/app/atom_library_main.h
@@ -11,6 +11,9 @@
 extern "C" {
 __attribute__((visibility("default")))
 int AtomMain(int argc, const char* argv[]);
+
+__attribute__((visibility("default")))
+int AtomInitializeICUandStartNode(int argc, char *argv[]);
 }
 #endif  // OS_MACOSX

--- a/atom/app/atom_library_main.mm
+++ b/atom/app/atom_library_main.mm
@@ -0,0 +1,34 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/app/atom_library_main.h"
+
+#include "atom/app/atom_main_delegate.h"
+#include "atom/app/node_main.h"
+#include "base/at_exit.h"
+#include "base/i18n/icu_util.h"
+#include "base/mac/bundle_locations.h"
+#include "brightray/common/mac/main_application_bundle.h"
+#include "content/public/app/content_main.h"
+
+#if defined(OS_MACOSX)
+int AtomMain(int argc, const char* argv[]) {
+  atom::AtomMainDelegate delegate;
+  content::ContentMainParams params(&delegate);
+  params.argc = argc;
+  params.argv = argv;
+  return content::ContentMain(params);
+}
+
+int AtomInitializeICUandStartNode(int argc, char *argv[]) {
+  base::AtExitManager atexit_manager;
+  base::mac::SetOverrideFrameworkBundlePath(
+      brightray::MainApplicationBundlePath()
+          .Append("Contents")
+          .Append("Frameworks")
+          .Append(PRODUCT_NAME " Framework.framework"));
+  base::i18n::InitializeICU();
+  return atom::NodeMain(argc, argv);
+}
+#endif  // OS_MACOSX
--- a/atom/app/atom_main.cc
+++ b/atom/app/atom_main.cc
@@ -13,11 +13,14 @@
 #include <fcntl.h>

 #include <windows.h>
+#include <shellscalingapi.h>
+#include <tchar.h>
 #include <shellapi.h>

 #include "atom/app/atom_main_delegate.h"
 #include "atom/common/crash_reporter/win/crash_service_main.h"
 #include "base/environment.h"
+#include "base/win/windows_version.h"
 #include "content/public/app/startup_helper_win.h"
 #include "sandbox/win/src/sandbox_types.h"
 #include "ui/gfx/win/dpi.h"
@@ -28,13 +31,53 @@
 #include "atom/app/atom_library_main.h"
 #endif  // defined(OS_MACOSX)

-// Declaration of node::Start.
-namespace node {
-int Start(int argc, char *argv[]);
-}
+#include "atom/app/node_main.h"
+#include "base/i18n/icu_util.h"

 #if defined(OS_WIN)

+namespace {
+
+// Win8.1 supports monitor-specific DPI scaling.
+bool SetProcessDpiAwarenessWrapper(PROCESS_DPI_AWARENESS value) {
+  typedef HRESULT(WINAPI *SetProcessDpiAwarenessPtr)(PROCESS_DPI_AWARENESS);
+  SetProcessDpiAwarenessPtr set_process_dpi_awareness_func =
+      reinterpret_cast<SetProcessDpiAwarenessPtr>(
+          GetProcAddress(GetModuleHandleA("user32.dll"),
+                         "SetProcessDpiAwarenessInternal"));
+  if (set_process_dpi_awareness_func) {
+    HRESULT hr = set_process_dpi_awareness_func(value);
+    if (SUCCEEDED(hr)) {
+      VLOG(1) << "SetProcessDpiAwareness succeeded.";
+      return true;
+    } else if (hr == E_ACCESSDENIED) {
+      LOG(ERROR) << "Access denied error from SetProcessDpiAwareness. "
+          "Function called twice, or manifest was used.";
+    }
+  }
+  return false;
+}
+
+// This function works for Windows Vista through Win8. Win8.1 must use
+// SetProcessDpiAwareness[Wrapper].
+BOOL SetProcessDPIAwareWrapper() {
+  typedef BOOL(WINAPI *SetProcessDPIAwarePtr)(VOID);
+  SetProcessDPIAwarePtr set_process_dpi_aware_func =
+      reinterpret_cast<SetProcessDPIAwarePtr>(
+      GetProcAddress(GetModuleHandleA("user32.dll"),
+                      "SetProcessDPIAware"));
+  return set_process_dpi_aware_func &&
+    set_process_dpi_aware_func();
+}
+
+void EnableHighDPISupport() {
+  if (!SetProcessDpiAwarenessWrapper(PROCESS_SYSTEM_DPI_AWARE)) {
+    SetProcessDPIAwareWrapper();
+  }
+}
+
+}  // namespace
+
 int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
  int argc = 0;
  wchar_t** wargv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
@@ -89,7 +132,8 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
      }
    }
    // Now that conversion is done, we can finally start.
-    return node::Start(argc, argv);
+    base::i18n::InitializeICU();
+    return atom::NodeMain(argc, argv);
  } else if (env->GetVar("ATOM_SHELL_INTERNAL_CRASH_SERVICE",
                         &crash_service_indicator) &&
      crash_service_indicator == "1") {
@@ -100,8 +144,11 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
  content::InitializeSandboxInfo(&sandbox_info);
  atom::AtomMainDelegate delegate;

-  // Now chrome relies on a regkey to enable high dpi support.
-  gfx::EnableHighDPISupport();
+  // We don't want to set DPI awareness on pre-Win7 because we don't support
+  // DirectWrite there. GDI fonts are kerned very badly, so better to leave
+  // DPI-unaware and at effective 1.0. See also ShouldUseDirectWrite().
+  if (base::win::GetVersion() >= base::win::VERSION_WIN7)
+    EnableHighDPISupport();

  content::ContentMainParams params(&delegate);
  params.instance = instance;
@@ -113,8 +160,10 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {

 int main(int argc, const char* argv[]) {
  char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
-  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0)
-    return node::Start(argc, const_cast<char**>(argv));
+  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0) {
+    base::i18n::InitializeICU();
+    return atom::NodeMain(argc, const_cast<char**>(argv));
+  }

  atom::AtomMainDelegate delegate;
  content::ContentMainParams params(&delegate);
@@ -127,8 +176,9 @@ int main(int argc, const char* argv[]) {

 int main(int argc, const char* argv[]) {
  char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
-  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0)
-    return node::Start(argc, const_cast<char**>(argv));
+  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0) {
+    return AtomInitializeICUandStartNode(argc, const_cast<char**>(argv));
+  }

  return AtomMain(argc, argv);
 }
--- a/atom/app/atom_main_delegate.cc
+++ b/atom/app/atom_main_delegate.cc
@@ -59,7 +59,7 @@ void AtomMainDelegate::PreSandboxStartup() {
  if (!env->HasVar("GOOGLE_API_KEY"))
    env->SetVar("GOOGLE_API_KEY", GOOGLEAPIS_API_KEY);

-  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  auto command_line = base::CommandLine::ForCurrentProcess();
  std::string process_type = command_line->GetSwitchValueASCII(
      switches::kProcessType);

@@ -111,7 +111,7 @@ void AtomMainDelegate::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")),
+      pak_dir.Append(FILE_PATH_LITERAL("content_resources_200_percent.pak")),
      ui::SCALE_FACTOR_200P);
 #endif
 }
--- a/atom/app/atom_main_delegate.h
+++ b/atom/app/atom_main_delegate.h
@@ -17,19 +17,18 @@ class AtomMainDelegate : public brightray::MainDelegate {

 protected:
  // content::ContentMainDelegate:
-  virtual bool BasicStartupComplete(int* exit_code) OVERRIDE;
-  virtual void PreSandboxStartup() OVERRIDE;
-  virtual content::ContentBrowserClient* CreateContentBrowserClient() OVERRIDE;
-  virtual content::ContentRendererClient*
-      CreateContentRendererClient() OVERRIDE;
+  bool BasicStartupComplete(int* exit_code) override;
+  void PreSandboxStartup() override;
+  content::ContentBrowserClient* CreateContentBrowserClient() override;
+  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;
+  scoped_ptr<brightray::ContentClient> CreateContentClient() override;
+  void AddDataPackFromPath(
+      ui::ResourceBundle* bundle, const base::FilePath& pak_dir) override;
 #if defined(OS_MACOSX)
-  virtual void OverrideChildProcessPath() OVERRIDE;
-  virtual void OverrideFrameworkBundlePath() OVERRIDE;
+  void OverrideChildProcessPath() override;
+  void OverrideFrameworkBundlePath() override;
 #endif

 private:
--- a/atom/app/atom_main_delegate_mac.mm
+++ b/atom/app/atom_main_delegate_mac.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2013 GitHub, Inc.
+// Copyright (c) 2014 GitHub, Inc.
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.

@@ -23,14 +23,15 @@ base::FilePath GetFrameworksPath() {

 void AtomMainDelegate::OverrideFrameworkBundlePath() {
  base::mac::SetOverrideFrameworkBundlePath(
-      GetFrameworksPath().Append("Atom Framework.framework"));
+      GetFrameworksPath().Append(PRODUCT_NAME " Framework.framework"));
 }

 void AtomMainDelegate::OverrideChildProcessPath() {
-  base::FilePath helper_path = GetFrameworksPath().Append("Atom Helper.app")
-                                                  .Append("Contents")
-                                                  .Append("MacOS")
-                                                  .Append("Atom Helper");
+  base::FilePath helper_path =
+      GetFrameworksPath().Append(PRODUCT_NAME " Helper.app")
+                         .Append("Contents")
+                         .Append("MacOS")
+                         .Append(PRODUCT_NAME " Helper");
  PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
 }

--- a/atom/app/node_main.cc
+++ b/atom/app/node_main.cc
@@ -0,0 +1,56 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/app/node_main.h"
+
+#include "atom/browser/javascript_environment.h"
+#include "atom/common/node_includes.h"
+#include "gin/array_buffer.h"
+#include "gin/public/isolate_holder.h"
+
+namespace atom {
+
+int NodeMain(int argc, char *argv[]) {
+  argv = uv_setup_args(argc, argv);
+  int exec_argc;
+  const char** exec_argv;
+  node::Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv);
+
+  int exit_code = 1;
+  {
+    gin::IsolateHolder::LoadV8Snapshot();
+    gin::IsolateHolder::Initialize(
+        gin::IsolateHolder::kNonStrictMode,
+        gin::ArrayBufferAllocator::SharedInstance());
+
+    JavascriptEnvironment gin_env;
+    node::Environment* env = node::CreateEnvironment(
+        gin_env.isolate(), gin_env.context(), argc, argv, exec_argc, exec_argv);
+
+    bool more;
+    do {
+      more = uv_run(env->event_loop(), UV_RUN_ONCE);
+      if (more == false) {
+        node::EmitBeforeExit(env);
+
+        // Emit `beforeExit` if the loop became alive either after emitting
+        // event, or after running some callbacks.
+        more = uv_loop_alive(env->event_loop());
+        if (uv_run(env->event_loop(), UV_RUN_NOWAIT) != 0)
+          more = true;
+      }
+    } while (more == true);
+
+    exit_code = node::EmitExit(env);
+    node::RunAtExit(env);
+
+    env->Dispose();
+  }
+
+  v8::V8::Dispose();
+
+  return exit_code;
+}
+
+}  // namespace atom
--- a/atom/app/node_main.h
+++ b/atom/app/node_main.h
@@ -0,0 +1,14 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_NODE_MAIN_H_
+#define ATOM_APP_NODE_MAIN_H_
+
+namespace atom {
+
+int NodeMain(int argc, char *argv[]);
+
+}  // namespace atom
+
+#endif  // ATOM_APP_NODE_MAIN_H_
--- a/atom/browser/api/atom_api_app.cc
+++ b/atom/browser/api/atom_api_app.cc
@@ -7,15 +7,16 @@
 #include <string>
 #include <vector>

+#include "atom/browser/api/atom_api_menu.h"
 #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 "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
+#include "brightray/browser/brightray_paths.h"
 #include "native_mate/callback.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
@@ -26,11 +27,33 @@

 #include "atom/common/node_includes.h"

-#if defined(OS_LINUX)
-#include "base/nix/xdg_util.h"
+using atom::Browser;
+
+namespace mate {
+
+#if defined(OS_WIN)
+template<>
+struct Converter<Browser::UserTask> {
+  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+                     Browser::UserTask* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
+      return false;
+    if (!dict.Get("program", &(out->program)) ||
+        !dict.Get("title", &(out->title)))
+      return false;
+    if (dict.Get("iconPath", &(out->icon_path)) &&
+        !dict.Get("iconIndex", &(out->icon_index)))
+      return false;
+    dict.Get("arguments", &(out->arguments));
+    dict.Get("description", &(out->description));
+    return true;
+  }
+};
 #endif

-using atom::Browser;
+}  // namespace mate
+

 namespace atom {

@@ -38,6 +61,30 @@ namespace api {

 namespace {

+// Return the path constant from string.
+int GetPathConstant(const std::string& name) {
+  if (name == "appData")
+    return brightray::DIR_APP_DATA;
+  else if (name == "userData")
+    return brightray::DIR_USER_DATA;
+  else if (name == "cache")
+    return brightray::DIR_CACHE;
+  else if (name == "userCache")
+    return brightray::DIR_USER_CACHE;
+  else if (name == "home")
+    return base::DIR_HOME;
+  else if (name == "temp")
+    return base::DIR_TEMP;
+  else if (name == "userDesktop")
+    return base::DIR_USER_DESKTOP;
+  else if (name == "exe")
+    return base::FILE_EXE;
+  else if (name == "module")
+    return base::FILE_MODULE;
+  else
+    return -1;
+}
+
 class ResolveProxyHelper {
 public:
  ResolveProxyHelper(const GURL& url, App::ResolveProxyCallback callback)
@@ -84,6 +131,10 @@ App::~App() {
  Browser::Get()->RemoveObserver(this);
 }

+void App::OnBeforeQuit(bool* prevent_default) {
+  *prevent_default = Emit("before-quit");
+}
+
 void App::OnWillQuit(bool* prevent_default) {
  *prevent_default = Emit("will-quit");
 }
@@ -97,15 +148,11 @@ void App::OnQuit() {
 }

 void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
-  base::ListValue args;
-  args.AppendString(file_path);
-  *prevent_default = Emit("open-file", args);
+  *prevent_default = Emit("open-file", file_path);
 }

 void App::OnOpenURL(const std::string& url) {
-  base::ListValue args;
-  args.AppendString(url);
-  Emit("open-url", args);
+  Emit("open-url", url);
 }

 void App::OnActivateWithNoOpenWindows() {
@@ -120,19 +167,26 @@ void App::OnFinishLaunching() {
  Emit("ready");
 }

-base::FilePath App::GetDataPath() {
+base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
+  bool succeed = false;
  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
+  int key = GetPathConstant(name);
+  if (key >= 0)
+    succeed = PathService::Get(key, &path);
+  if (!succeed)
+    args->ThrowError("Failed to get path");
+  return path;
+}

-  return path.Append(base::FilePath::FromUTF8Unsafe(
-      Browser::Get()->GetName()));
+void App::SetPath(mate::Arguments* args,
+                  const std::string& name,
+                  const base::FilePath& path) {
+  bool succeed = false;
+  int key = GetPathConstant(name);
+  if (key >= 0)
+    succeed = PathService::Override(key, path);
+  if (!succeed)
+    args->ThrowError("Failed to set path");
 }

 void App::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
@@ -157,7 +211,16 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
      .SetMethod("getName", base::Bind(&Browser::GetName, browser))
      .SetMethod("setName", base::Bind(&Browser::SetName, browser))
      .SetMethod("isReady", base::Bind(&Browser::is_ready, browser))
-      .SetMethod("getDataPath", &App::GetDataPath)
+      .SetMethod("addRecentDocument",
+                 base::Bind(&Browser::AddRecentDocument, browser))
+      .SetMethod("clearRecentDocuments",
+                 base::Bind(&Browser::ClearRecentDocuments, browser))
+#if defined(OS_WIN)
+      .SetMethod("setUserTasks",
+                 base::Bind(&Browser::SetUserTasks, browser))
+#endif
+      .SetMethod("setPath", &App::SetPath)
+      .SetMethod("getPath", &App::GetPath)
      .SetMethod("resolveProxy", &App::ResolveProxy)
      .SetMethod("setDesktopName", &App::SetDesktopName);
 }
@@ -175,11 +238,12 @@ mate::Handle<App> App::Create(v8::Isolate* isolate) {
 namespace {

 void AppendSwitch(const std::string& switch_string, mate::Arguments* args) {
+  auto command_line = base::CommandLine::ForCurrentProcess();
  std::string value;
  if (args->GetNext(&value))
-    CommandLine::ForCurrentProcess()->AppendSwitchASCII(switch_string, value);
+    command_line->AppendSwitchASCII(switch_string, value);
  else
-    CommandLine::ForCurrentProcess()->AppendSwitch(switch_string);
+    command_line->AppendSwitch(switch_string);
 }

 #if defined(OS_MACOSX)
@@ -191,35 +255,35 @@ int DockBounce(const std::string& type) {
    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_INFORMATIONAL);
  return request_id;
 }
+
+void DockSetMenu(atom::api::Menu* menu) {
+  Browser::Get()->DockSetMenu(menu->model());
+}
 #endif

 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();
+  auto command_line = base::CommandLine::ForCurrentProcess();

  mate::Dictionary dict(isolate, exports);
  dict.Set("app", atom::api::App::Create(isolate));
  dict.SetMethod("appendSwitch", &AppendSwitch);
  dict.SetMethod("appendArgument",
-                 base::Bind(&CommandLine::AppendArg,
+                 base::Bind(&base::CommandLine::AppendArg,
                            base::Unretained(command_line)));
 #if defined(OS_MACOSX)
+  auto browser = base::Unretained(Browser::Get());
  dict.SetMethod("dockBounce", &DockBounce);
  dict.SetMethod("dockCancelBounce",
-                 base::Bind(&Browser::DockCancelBounce,
-                            base::Unretained(browser)));
+                 base::Bind(&Browser::DockCancelBounce, browser));
  dict.SetMethod("dockSetBadgeText",
-                 base::Bind(&Browser::DockSetBadgeText,
-                            base::Unretained(browser)));
+                 base::Bind(&Browser::DockSetBadgeText, browser));
  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)));
+                 base::Bind(&Browser::DockGetBadgeText, browser));
+  dict.SetMethod("dockHide", base::Bind(&Browser::DockHide, browser));
+  dict.SetMethod("dockShow", base::Bind(&Browser::DockShow, browser));
+  dict.SetMethod("dockSetMenu", &DockSetMenu);
 #endif
 }

--- a/atom/browser/api/atom_api_app.h
+++ b/atom/browser/api/atom_api_app.h
@@ -18,6 +18,10 @@ namespace base {
 class FilePath;
 }

+namespace mate {
+class Arguments;
+}
+
 namespace atom {

 namespace api {
@@ -33,23 +37,28 @@ class App : public mate::EventEmitter,
  App();
  virtual ~App();

-  // 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;
-  virtual void OnActivateWithNoOpenWindows() OVERRIDE;
-  virtual void OnWillFinishLaunching() OVERRIDE;
-  virtual void OnFinishLaunching() OVERRIDE;
+  // BrowserObserver:
+  void OnBeforeQuit(bool* prevent_default) override;
+  void OnWillQuit(bool* prevent_default) override;
+  void OnWindowAllClosed() override;
+  void OnQuit() override;
+  void OnOpenFile(bool* prevent_default, const std::string& file_path) override;
+  void OnOpenURL(const std::string& url) override;
+  void OnActivateWithNoOpenWindows() override;
+  void OnWillFinishLaunching() override;
+  void OnFinishLaunching() override;

-  // mate::Wrappable implementations:
-  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate);
+  // mate::Wrappable:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;

 private:
-  base::FilePath GetDataPath();
+  // Get/Set the pre-defined path in PathService.
+  base::FilePath GetPath(mate::Arguments* args, const std::string& name);
+  void SetPath(mate::Arguments* args,
+               const std::string& name,
+               const base::FilePath& path);
+
  void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
  void SetDesktopName(const std::string& desktop_name);

--- a/atom/browser/api/atom_api_auto_updater.cc
+++ b/atom/browser/api/atom_api_auto_updater.cc
@@ -5,7 +5,6 @@
 #include "atom/browser/api/atom_api_auto_updater.h"

 #include "base/time/time.h"
-#include "base/values.h"
 #include "atom/browser/auto_updater.h"
 #include "atom/browser/browser.h"
 #include "native_mate/dictionary.h"
@@ -26,9 +25,7 @@ AutoUpdater::~AutoUpdater() {
 }

 void AutoUpdater::OnError(const std::string& error) {
-  base::ListValue args;
-  args.AppendString(error);
-  Emit("error", args);
+  Emit("error", error);
 }

 void AutoUpdater::OnCheckingForUpdate() {
@@ -49,13 +46,8 @@ void AutoUpdater::OnUpdateDownloaded(const std::string& release_notes,
                                     const std::string& update_url,
                                     const base::Closure& quit_and_install) {
  quit_and_install_ = quit_and_install;
-
-  base::ListValue args;
-  args.AppendString(release_notes);
-  args.AppendString(release_name);
-  args.AppendDouble(release_date.ToJsTime());
-  args.AppendString(update_url);
-  Emit("update-downloaded-raw", args);
+  Emit("update-downloaded-raw", release_notes, release_name,
+       release_date.ToJsTime(), update_url);
 }

 mate::ObjectTemplateBuilder AutoUpdater::GetObjectTemplateBuilder(
--- a/atom/browser/api/atom_api_auto_updater.h
+++ b/atom/browser/api/atom_api_auto_updater.h
@@ -26,20 +26,20 @@ class AutoUpdater : public mate::EventEmitter,
  virtual ~AutoUpdater();

  // AutoUpdaterDelegate implementations.
-  virtual void OnError(const std::string& error) OVERRIDE;
-  virtual void OnCheckingForUpdate() OVERRIDE;
-  virtual void OnUpdateAvailable() OVERRIDE;
-  virtual void OnUpdateNotAvailable() OVERRIDE;
-  virtual void OnUpdateDownloaded(
+  void OnError(const std::string& error) override;
+  void OnCheckingForUpdate() override;
+  void OnUpdateAvailable() override;
+  void OnUpdateNotAvailable() override;
+  void OnUpdateDownloaded(
      const std::string& release_notes,
      const std::string& release_name,
      const base::Time& release_date,
      const std::string& update_url,
-      const base::Closure& quit_and_install) OVERRIDE;
+      const base::Closure& quit_and_install) override;

  // mate::Wrappable implementations:
-  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate);
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;

 private:
  void QuitAndInstall();
--- a/atom/browser/api/atom_api_content_tracing.cc
+++ b/atom/browser/api/atom_api_content_tracing.cc
@@ -62,28 +62,26 @@ namespace {

 void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
                v8::Handle<v8::Context> context, void* priv) {
-  TracingController* controller = TracingController::GetInstance();
+  auto controller = base::Unretained(TracingController::GetInstance());
  mate::Dictionary dict(context->GetIsolate(), exports);
  dict.SetMethod("getCategories", base::Bind(
-      &TracingController::GetCategories, base::Unretained(controller)));
+      &TracingController::GetCategories, controller));
  dict.SetMethod("startRecording", base::Bind(
-      &TracingController::EnableRecording, base::Unretained(controller)));
+      &TracingController::EnableRecording, controller));
  dict.SetMethod("stopRecording", base::Bind(
-      &TracingController::DisableRecording, base::Unretained(controller)));
+      &TracingController::DisableRecording, controller, nullptr));
  dict.SetMethod("startMonitoring", base::Bind(
-      &TracingController::EnableMonitoring, base::Unretained(controller)));
+      &TracingController::EnableMonitoring, controller));
  dict.SetMethod("stopMonitoring", base::Bind(
-      &TracingController::DisableMonitoring, base::Unretained(controller)));
+      &TracingController::DisableMonitoring, controller));
  dict.SetMethod("captureMonitoringSnapshot", base::Bind(
-      &TracingController::CaptureMonitoringSnapshot,
-      base::Unretained(controller)));
-  dict.SetMethod("getTraceBufferPercentFull", base::Bind(
-      &TracingController::GetTraceBufferPercentFull,
-      base::Unretained(controller)));
+      &TracingController::CaptureMonitoringSnapshot, controller, nullptr));
+  dict.SetMethod("getTraceBufferUsage", base::Bind(
+      &TracingController::GetTraceBufferUsage, controller));
  dict.SetMethod("setWatchEvent", base::Bind(
-      &TracingController::SetWatchEvent, base::Unretained(controller)));
+      &TracingController::SetWatchEvent, controller));
  dict.SetMethod("cancelWatchEvent", base::Bind(
-      &TracingController::CancelWatchEvent, base::Unretained(controller)));
+      &TracingController::CancelWatchEvent, controller));
 }

 }  // namespace
--- a/atom/browser/api/atom_api_dialog.cc
+++ b/atom/browser/api/atom_api_dialog.cc
@@ -11,6 +11,7 @@
 #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/image_converter.h"
 #include "native_mate/callback.h"
 #include "native_mate/dictionary.h"

@@ -40,21 +41,27 @@ namespace {

 void ShowMessageBox(int type,
                    const std::vector<std::string>& buttons,
-                    const std::string& title,
-                    const std::string& message,
-                    const std::string& detail,
+                    const std::vector<std::string>& texts,
+                    const gfx::ImageSkia& icon,
                    atom::NativeWindow* window,
                    mate::Arguments* args) {
+  // FIXME We are exceeding the parameters limit of base::Bind here, so we have
+  // to pass some parameters in an array. We should remove this once we have
+  // variadic template support in base::Bind.
+  const std::string& title = texts[0];
+  const std::string& message = texts[1];
+  const std::string& detail = texts[2];
+
  v8::Handle<v8::Value> peek = args->PeekNext();
  atom::MessageBoxCallback callback;
  if (mate::Converter<atom::MessageBoxCallback>::FromV8(args->isolate(),
                                                        peek,
                                                        &callback)) {
    atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons, title,
-                         message, detail, callback);
+                         message, detail, icon, callback);
  } else {
    int chosen = atom::ShowMessageBox(window, (atom::MessageBoxType)type,
-                                      buttons, title, message, detail);
+                                      buttons, title, message, detail, icon);
    args->Return(chosen);
  }
 }
@@ -103,6 +110,7 @@ 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("showErrorBox", &atom::ShowErrorBox);
  dict.SetMethod("showOpenDialog", &ShowOpenDialog);
  dict.SetMethod("showSaveDialog", &ShowSaveDialog);
 }
--- a/atom/browser/api/atom_api_global_shortcut.h
+++ b/atom/browser/api/atom_api_global_shortcut.h
@@ -28,8 +28,8 @@ class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
  virtual ~GlobalShortcut();

  // mate::Wrappable implementations:
-  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) OVERRIDE;
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;

 private:
  typedef std::map<ui::Accelerator, base::Closure> AcceleratorCallbackMap;
@@ -41,7 +41,7 @@ class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
  void UnregisterAll();

  // GlobalShortcutListener::Observer implementation.
-  virtual void OnKeyPressed(const ui::Accelerator& accelerator) OVERRIDE;
+  void OnKeyPressed(const ui::Accelerator& accelerator) override;

  AcceleratorCallbackMap accelerator_callback_map_;

--- a/atom/browser/api/atom_api_menu.cc
+++ b/atom/browser/api/atom_api_menu.cc
@@ -6,7 +6,9 @@

 #include "atom/browser/native_window.h"
 #include "atom/common/native_mate_converters/accelerator_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
+#include "native_mate/callback.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
@@ -17,30 +19,6 @@ namespace atom {

 namespace api {

-namespace {
-
-// Call method of delegate object.
-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::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(MATE_STRING_NEW(isolate, method)));
-  if (!function->IsFunction())
-    return default_value;
-
-  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)),
      parent_(NULL) {
@@ -49,37 +27,30 @@ Menu::Menu()
 Menu::~Menu() {
 }

+void Menu::AfterInit(v8::Isolate* isolate) {
+  mate::Dictionary wrappable(isolate, GetWrapper(isolate));
+  mate::Dictionary delegate;
+  if (!wrappable.Get("delegate", &delegate))
+    return;
+
+  delegate.Get("isCommandIdChecked", &is_checked_);
+  delegate.Get("isCommandIdEnabled", &is_enabled_);
+  delegate.Get("isCommandIdVisible", &is_visible_);
+  delegate.Get("getAcceleratorForCommandId", &get_accelerator_);
+  delegate.Get("executeCommand", &execute_command_);
+  delegate.Get("menuWillShow", &menu_will_show_);
+}
+
 bool Menu::IsCommandIdChecked(int command_id) const {
-  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();
+  return is_checked_.Run(command_id);
 }

 bool Menu::IsCommandIdEnabled(int command_id) const {
-  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();
+  return is_enabled_.Run(command_id);
 }

 bool Menu::IsCommandIdVisible(int command_id) const {
-  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();
+  return is_visible_.Run(command_id);
 }

 bool Menu::GetAcceleratorForCommandId(int command_id,
@@ -87,69 +58,16 @@ bool Menu::GetAcceleratorForCommandId(int command_id,
  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);
-  return mate::ConvertFromV8(isolate, shortcut, accelerator);
-}
-
-bool Menu::IsItemForCommandIdDynamic(int command_id) const {
-  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();
-}
-
-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(
-      isolate,
-      MATE_FALSE(isolate),
-      const_cast<Menu*>(this)->GetWrapper(isolate),
-      "getLabelForCommandId",
-      command_id);
-  base::string16 label;
-  mate::ConvertFromV8(isolate, result, &label);
-  return label;
-}
-
-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(
-      isolate,
-      MATE_FALSE(isolate),
-      const_cast<Menu*>(this)->GetWrapper(isolate),
-      "getSubLabelForCommandId",
-      command_id);
-  base::string16 label;
-  mate::ConvertFromV8(isolate, result, &label);
-  return label;
+  v8::Handle<v8::Value> val = get_accelerator_.Run(command_id);
+  return mate::ConvertFromV8(isolate, val, accelerator);
 }

 void Menu::ExecuteCommand(int command_id, int event_flags) {
-  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);
+  execute_command_.Run(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);
+  menu_will_show_.Run();
 }

 void Menu::AttachToWindow(Window* window) {
@@ -186,6 +104,10 @@ void Menu::InsertSubMenuAt(int index,
  model_->InsertSubMenuAt(index, command_id, label, menu->model_.get());
 }

+void Menu::SetIcon(int index, const gfx::Image& image) {
+  model_->SetIcon(index, image);
+}
+
 void Menu::SetSublabel(int index, const base::string16& sublabel) {
  model_->SetSublabel(index, sublabel);
 }
@@ -235,6 +157,7 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
      .SetMethod("insertRadioItem", &Menu::InsertRadioItemAt)
      .SetMethod("insertSeparator", &Menu::InsertSeparatorAt)
      .SetMethod("insertSubMenu", &Menu::InsertSubMenuAt)
+      .SetMethod("setIcon", &Menu::SetIcon)
      .SetMethod("setSublabel", &Menu::SetSublabel)
      .SetMethod("clear", &Menu::Clear)
      .SetMethod("getIndexOfCommandId", &Menu::GetIndexOfCommandId)
@@ -246,7 +169,8 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
      .SetMethod("isEnabledAt", &Menu::IsEnabledAt)
      .SetMethod("isVisibleAt", &Menu::IsVisibleAt)
      .SetMethod("attachToWindow", &Menu::AttachToWindow)
-      .SetMethod("_popup", &Menu::Popup);
+      .SetMethod("_popup", &Menu::Popup)
+      .SetMethod("_popupAt", &Menu::PopupAt);
 }

 }  // namespace api
--- a/atom/browser/api/atom_api_menu.h
+++ b/atom/browser/api/atom_api_menu.h
@@ -8,6 +8,7 @@
 #include <string>

 #include "atom/browser/api/atom_api_window.h"
+#include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "native_mate/wrappable.h"
@@ -16,8 +17,6 @@ namespace atom {

 namespace api {

-class MenuMac;
-
 class Menu : public mate::Wrappable,
             public ui::SimpleMenuModel::Delegate {
 public:
@@ -40,21 +39,21 @@ class Menu : public mate::Wrappable,
  Menu();
  virtual ~Menu();

+  // mate::Wrappable:
+  void AfterInit(v8::Isolate* isolate) override;
+
  // ui::SimpleMenuModel::Delegate implementations:
-  virtual bool IsCommandIdChecked(int command_id) const OVERRIDE;
-  virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE;
-  virtual bool IsCommandIdVisible(int command_id) const OVERRIDE;
-  virtual bool GetAcceleratorForCommandId(
-      int command_id,
-      ui::Accelerator* accelerator) OVERRIDE;
-  virtual bool IsItemForCommandIdDynamic(int command_id) const OVERRIDE;
-  virtual 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;
+  bool IsCommandIdChecked(int command_id) const override;
+  bool IsCommandIdEnabled(int command_id) const override;
+  bool IsCommandIdVisible(int command_id) const override;
+  bool GetAcceleratorForCommandId(int command_id,
+                                  ui::Accelerator* accelerator) override;
+  void ExecuteCommand(int command_id, int event_flags) override;
+  void MenuWillShow(ui::SimpleMenuModel* source) override;

  virtual void AttachToWindow(Window* window);
  virtual void Popup(Window* window) = 0;
+  virtual void PopupAt(Window* window, int x, int y) = 0;

  scoped_ptr<ui::SimpleMenuModel> model_;
  Menu* parent_;
@@ -73,6 +72,7 @@ class Menu : public mate::Wrappable,
                       int command_id,
                       const base::string16& label,
                       Menu* menu);
+  void SetIcon(int index, const gfx::Image& image);
  void SetSublabel(int index, const base::string16& sublabel);
  void Clear();
  int GetIndexOfCommandId(int command_id);
@@ -84,6 +84,14 @@ class Menu : public mate::Wrappable,
  bool IsEnabledAt(int index) const;
  bool IsVisibleAt(int index) const;

+  // Stored delegate methods.
+  base::Callback<bool(int)> is_checked_;
+  base::Callback<bool(int)> is_enabled_;
+  base::Callback<bool(int)> is_visible_;
+  base::Callback<v8::Handle<v8::Value>(int)> get_accelerator_;
+  base::Callback<void(int)> execute_command_;
+  base::Callback<void()> menu_will_show_;
+
  DISALLOW_COPY_AND_ASSIGN(Menu);
 };

--- a/atom/browser/api/atom_api_menu_mac.h
+++ b/atom/browser/api/atom_api_menu_mac.h
@@ -19,7 +19,8 @@ class MenuMac : public Menu {
 protected:
  MenuMac();

-  virtual void Popup(Window* window) OVERRIDE;
+  void Popup(Window* window) override;
+  void PopupAt(Window* window, int x, int y) override;

  base::scoped_nsobject<AtomMenuController> menu_controller_;

--- a/atom/browser/api/atom_api_menu_mac.mm
+++ b/atom/browser/api/atom_api_menu_mac.mm
@@ -19,13 +19,17 @@ MenuMac::MenuMac() {
 }

 void MenuMac::Popup(Window* window) {
+  NativeWindow* native_window = window->window();
+  if (!native_window)
+    return;
+  content::WebContents* web_contents = native_window->GetWebContents();
+  if (!web_contents)
+    return;
+
+  NSWindow* nswindow = native_window->GetNativeWindow();
  base::scoped_nsobject<AtomMenuController> menu_controller(
      [[AtomMenuController alloc] initWithModel:model_.get()]);

-  NativeWindow* native_window = window->window();
-  NSWindow* nswindow = native_window->GetNativeWindow();
-  content::WebContents* web_contents = native_window->GetWebContents();
-
  // Fake out a context menu event.
  NSEvent* currentEvent = [NSApp currentEvent];
  NSPoint position = [nswindow mouseLocationOutsideOfEventStream];
@@ -46,6 +50,25 @@ void MenuMac::Popup(Window* window) {
                   forView:web_contents->GetContentNativeView()];
 }

+void MenuMac::PopupAt(Window* window, int x, int y) {
+  NativeWindow* native_window = window->window();
+  if (!native_window)
+    return;
+  content::WebContents* web_contents = native_window->GetWebContents();
+  if (!web_contents)
+    return;
+
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:model_.get()]);
+  NSMenu* menu = [menu_controller menu];
+  NSView* view = web_contents->GetContentNativeView();
+
+  // Show the menu.
+  [menu popUpMenuPositioningItem:[menu itemAtIndex:0]
+                      atLocation:NSMakePoint(x, [view frame].size.height - y)
+                          inView:view];
+}
+
 // static
 void Menu::SetApplicationMenu(Menu* base_menu) {
  MenuMac* menu = static_cast<MenuMac*>(base_menu);
--- a/atom/browser/api/atom_api_menu_views.cc
+++ b/atom/browser/api/atom_api_menu_views.cc
@@ -5,6 +5,7 @@
 #include "atom/browser/api/atom_api_menu_views.h"

 #include "atom/browser/native_window_views.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/controls/menu/menu_runner.h"

@@ -16,14 +17,32 @@ MenuViews::MenuViews() {
 }

 void MenuViews::Popup(Window* window) {
-  gfx::Point cursor = gfx::Screen::GetNativeScreen()->GetCursorScreenPoint();
+  PopupAtPoint(window, gfx::Screen::GetNativeScreen()->GetCursorScreenPoint());
+}
+
+void MenuViews::PopupAt(Window* window, int x, int y) {
+  NativeWindow* native_window = static_cast<NativeWindow*>(window->window());
+  if (!native_window)
+    return;
+  content::WebContents* web_contents = native_window->GetWebContents();
+  if (!web_contents)
+    return;
+  content::RenderWidgetHostView* view = web_contents->GetRenderWidgetHostView();
+  if (!view)
+    return;
+
+  gfx::Point origin = view->GetViewBounds().origin();
+  PopupAtPoint(window, gfx::Point(origin.x() + x, origin.y() + y));
+}
+
+void MenuViews::PopupAtPoint(Window* window, const gfx::Point& point) {
  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()),
+      gfx::Rect(point, gfx::Size()),
      views::MENU_ANCHOR_TOPLEFT,
      ui::MENU_SOURCE_MOUSE));
 }
--- a/atom/browser/api/atom_api_menu_views.h
+++ b/atom/browser/api/atom_api_menu_views.h
@@ -6,6 +6,7 @@
 #define ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_

 #include "atom/browser/api/atom_api_menu.h"
+#include "ui/gfx/screen.h"

 namespace atom {

@@ -16,9 +17,12 @@ class MenuViews : public Menu {
  MenuViews();

 protected:
-  virtual void Popup(Window* window) OVERRIDE;
+  void Popup(Window* window) override;
+  void PopupAt(Window* window, int x, int y) override;

 private:
+  void PopupAtPoint(Window* window, const gfx::Point& point);
+
  DISALLOW_COPY_AND_ASSIGN(MenuViews);
 };

--- a/atom/browser/api/atom_api_power_monitor.h
+++ b/atom/browser/api/atom_api_power_monitor.h
@@ -24,9 +24,9 @@ class PowerMonitor : public mate::EventEmitter,
  virtual ~PowerMonitor();

  // base::PowerObserver implementations:
-  virtual void OnPowerStateChange(bool on_battery_power) OVERRIDE;
-  virtual void OnSuspend() OVERRIDE;
-  virtual void OnResume() OVERRIDE;
+  void OnPowerStateChange(bool on_battery_power) override;
+  void OnSuspend() override;
+  void OnResume() override;

 private:
  DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
--- a/atom/browser/api/atom_api_protocol.cc
+++ b/atom/browser/api/atom_api_protocol.cc
@@ -53,7 +53,7 @@ class CustomProtocolRequestJob : public AdapterRequestJob {
  }

  // AdapterRequestJob:
-  virtual void GetJobTypeInUI() OVERRIDE {
+  void GetJobTypeInUI() override {
    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

    v8::Isolate* isolate = v8::Isolate::GetCurrent();
@@ -128,9 +128,9 @@ class CustomProtocolHandler : public ProtocolHandler {
      : registry_(registry), protocol_handler_(protocol_handler) {
  }

-  virtual net::URLRequestJob* MaybeCreateJob(
+  net::URLRequestJob* MaybeCreateJob(
      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
    return new CustomProtocolRequestJob(registry_, protocol_handler_.get(),
                                        request, network_delegate);
  }
@@ -305,9 +305,7 @@ void Protocol::UninterceptProtocolInIO(const std::string& scheme) {

 void Protocol::EmitEventInUI(const std::string& event,
                             const std::string& parameter) {
-  base::ListValue args;
-  args.AppendString(parameter);
-  Emit(event, args);
+  Emit(event, parameter);
 }

 // static
--- a/atom/browser/api/atom_api_screen.cc
+++ b/atom/browser/api/atom_api_screen.cc
@@ -0,0 +1,149 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_screen.h"
+
+#include <algorithm>
+#include <string>
+
+#include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "base/bind.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+#include "ui/gfx/screen.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+// Find an item in container according to its ID.
+template<class T>
+typename T::iterator FindById(T* container, int id) {
+  auto predicate = [id] (const typename T::value_type& item) -> bool {
+    return item.id() == id;
+  };
+  return std::find_if(container->begin(), container->end(), predicate);
+}
+
+// Convert the changed_metrics bitmask to string array.
+std::vector<std::string> MetricsToArray(uint32_t metrics) {
+  std::vector<std::string> array;
+  if (metrics & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS)
+    array.push_back("bounds");
+  if (metrics & gfx::DisplayObserver::DISPLAY_METRIC_WORK_AREA)
+    array.push_back("workArea");
+  if (metrics & gfx::DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR)
+    array.push_back("scaleFactor");
+  if (metrics & gfx::DisplayObserver::DISPLAY_METRIC_ROTATION)
+    array.push_back("rotaion");
+  return array;
+}
+
+}  // namespace
+
+Screen::Screen(gfx::Screen* screen) : screen_(screen) {
+  screen_->AddObserver(this);
+}
+
+Screen::~Screen() {
+  screen_->RemoveObserver(this);
+}
+
+gfx::Point Screen::GetCursorScreenPoint() {
+  return screen_->GetCursorScreenPoint();
+}
+
+gfx::Display Screen::GetPrimaryDisplay() {
+  return screen_->GetPrimaryDisplay();
+}
+
+std::vector<gfx::Display> Screen::GetAllDisplays() {
+  // The Screen::GetAllDisplays doesn't update when there is display added or
+  // removed, so we have to manually maintain the displays_ to make it up to
+  // date.
+  if (displays_.size() == 0)
+    displays_ = screen_->GetAllDisplays();
+  return displays_;
+}
+
+gfx::Display Screen::GetDisplayNearestPoint(const gfx::Point& point) {
+  return screen_->GetDisplayNearestPoint(point);
+}
+
+gfx::Display Screen::GetDisplayMatching(const gfx::Rect& match_rect) {
+  return screen_->GetDisplayMatching(match_rect);
+}
+
+void Screen::OnDisplayAdded(const gfx::Display& new_display) {
+  displays_.push_back(new_display);
+  Emit("display-added", new_display);
+}
+
+void Screen::OnDisplayRemoved(const gfx::Display& old_display) {
+  auto iter = FindById(&displays_, old_display.id());
+  if (iter == displays_.end())
+    return;
+
+  displays_.erase(iter);
+  Emit("display-removed", old_display);
+}
+
+void Screen::OnDisplayMetricsChanged(const gfx::Display& display,
+                                     uint32_t changed_metrics) {
+  auto iter = FindById(&displays_, display.id());
+  if (iter == displays_.end())
+    return;
+
+  *iter = display;
+  Emit("display-metrics-changed", display, MetricsToArray(changed_metrics));
+}
+
+mate::ObjectTemplateBuilder Screen::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("getCursorScreenPoint", &Screen::GetCursorScreenPoint)
+      .SetMethod("getPrimaryDisplay", &Screen::GetPrimaryDisplay)
+      .SetMethod("getAllDisplays", &Screen::GetAllDisplays)
+      .SetMethod("getDisplayNearestPoint", &Screen::GetDisplayNearestPoint)
+      .SetMethod("getDisplayMatching", &Screen::GetDisplayMatching);
+}
+
+// static
+v8::Handle<v8::Value> Screen::Create(v8::Isolate* isolate) {
+  if (!Browser::Get()->is_ready()) {
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Can not initialize \"screen\" module before app is ready")));
+    return v8::Undefined(isolate);
+  }
+
+  gfx::Screen* screen = gfx::Screen::GetNativeScreen();
+  if (!screen) {
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Failed to get screen information")));
+    return v8::Undefined(isolate);
+  }
+
+  return mate::CreateHandle(isolate, new Screen(screen)).ToV8();
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+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.Set("screen", atom::api::Screen::Create(context->GetIsolate()));
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_screen, Initialize)
--- a/atom/browser/api/atom_api_screen.h
+++ b/atom/browser/api/atom_api_screen.h
@@ -0,0 +1,60 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_SCREEN_H_
+#define ATOM_BROWSER_API_ATOM_API_SCREEN_H_
+
+#include <vector>
+
+#include "atom/browser/api/event_emitter.h"
+#include "native_mate/handle.h"
+#include "ui/gfx/display_observer.h"
+
+namespace gfx {
+class Point;
+class Rect;
+class Screen;
+}
+
+namespace atom {
+
+namespace api {
+
+class Screen : public mate::EventEmitter,
+               public gfx::DisplayObserver {
+ public:
+  static v8::Handle<v8::Value> Create(v8::Isolate* isolate);
+
+ protected:
+  explicit Screen(gfx::Screen* screen);
+  virtual ~Screen();
+
+  gfx::Point GetCursorScreenPoint();
+  gfx::Display GetPrimaryDisplay();
+  std::vector<gfx::Display> GetAllDisplays();
+  gfx::Display GetDisplayNearestPoint(const gfx::Point& point);
+  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect);
+
+  // gfx::DisplayObserver:
+  void OnDisplayAdded(const gfx::Display& new_display) override;
+  void OnDisplayRemoved(const gfx::Display& old_display) override;
+  void OnDisplayMetricsChanged(const gfx::Display& display,
+                               uint32_t changed_metrics) override;
+
+  // mate::Wrappable:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+
+ private:
+  gfx::Screen* screen_;
+  std::vector<gfx::Display> displays_;
+
+  DISALLOW_COPY_AND_ASSIGN(Screen);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_SCREEN_H_
--- a/atom/browser/api/atom_api_tray.cc
+++ b/atom/browser/api/atom_api_tray.cc
@@ -9,8 +9,10 @@
 #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 "atom/common/native_mate_converters/string16_converter.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
+#include "ui/gfx/image/image.h"

 #include "atom/common/node_includes.h"

@@ -18,7 +20,7 @@ namespace atom {

 namespace api {

-Tray::Tray(const gfx::ImageSkia& image)
+Tray::Tray(const gfx::Image& image)
    : tray_icon_(TrayIcon::Create()) {
  tray_icon_->SetImage(image);
  tray_icon_->AddObserver(this);
@@ -28,7 +30,7 @@ Tray::~Tray() {
 }

 // static
-mate::Wrappable* Tray::New(const gfx::ImageSkia& image) {
+mate::Wrappable* Tray::New(const gfx::Image& image) {
  return new Tray(image);
 }

@@ -40,39 +42,95 @@ void Tray::OnDoubleClicked() {
  Emit("double-clicked");
 }

-void Tray::SetImage(const gfx::ImageSkia& image) {
+void Tray::OnBalloonShow() {
+  Emit("balloon-show");
+}
+
+void Tray::OnBalloonClicked() {
+  Emit("balloon-clicked");
+}
+
+void Tray::OnBalloonClosed() {
+  Emit("balloon-closed");
+}
+
+void Tray::Destroy() {
+  tray_icon_.reset();
+}
+
+void Tray::SetImage(mate::Arguments* args, const gfx::Image& image) {
+  if (!CheckTrayLife(args))
+    return;
  tray_icon_->SetImage(image);
 }

-void Tray::SetPressedImage(const gfx::ImageSkia& image) {
+void Tray::SetPressedImage(mate::Arguments* args, const gfx::Image& image) {
+  if (!CheckTrayLife(args))
+    return;
  tray_icon_->SetPressedImage(image);
 }

-void Tray::SetToolTip(const std::string& tool_tip) {
+void Tray::SetToolTip(mate::Arguments* args, const std::string& tool_tip) {
+  if (!CheckTrayLife(args))
+    return;
  tray_icon_->SetToolTip(tool_tip);
 }

-void Tray::SetTitle(const std::string& title) {
+void Tray::SetTitle(mate::Arguments* args, const std::string& title) {
+  if (!CheckTrayLife(args))
+    return;
  tray_icon_->SetTitle(title);
 }

-void Tray::SetHighlightMode(bool highlight) {
+void Tray::SetHighlightMode(mate::Arguments* args, bool highlight) {
+  if (!CheckTrayLife(args))
+    return;
  tray_icon_->SetHighlightMode(highlight);
 }

-void Tray::SetContextMenu(Menu* menu) {
+void Tray::DisplayBalloon(mate::Arguments* args,
+                          const mate::Dictionary& options) {
+  if (!CheckTrayLife(args))
+    return;
+
+  gfx::Image icon;
+  options.Get("icon", &icon);
+  base::string16 title, content;
+  if (!options.Get("title", &title) ||
+      !options.Get("content", &content)) {
+    args->ThrowError("'title' and 'content' must be defined");
+    return;
+  }
+
+  tray_icon_->DisplayBalloon(icon, title, content);
+}
+
+void Tray::SetContextMenu(mate::Arguments* args, Menu* menu) {
+  if (!CheckTrayLife(args))
+    return;
  tray_icon_->SetContextMenu(menu->model());
 }

+bool Tray::CheckTrayLife(mate::Arguments* args) {
+  if (!tray_icon_) {
+    args->ThrowError("Tray is already destroyed");
+    return false;
+  } else {
+    return true;
+  }
+}
+
 // static
 void Tray::BuildPrototype(v8::Isolate* isolate,
                          v8::Handle<v8::ObjectTemplate> prototype) {
  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("destroy", &Tray::Destroy)
      .SetMethod("setImage", &Tray::SetImage)
      .SetMethod("setPressedImage", &Tray::SetPressedImage)
      .SetMethod("setToolTip", &Tray::SetToolTip)
      .SetMethod("setTitle", &Tray::SetTitle)
      .SetMethod("setHighlightMode", &Tray::SetHighlightMode)
+      .SetMethod("displayBalloon", &Tray::DisplayBalloon)
      .SetMethod("_setContextMenu", &Tray::SetContextMenu);
 }

--- a/atom/browser/api/atom_api_tray.h
+++ b/atom/browser/api/atom_api_tray.h
@@ -12,7 +12,12 @@
 #include "base/memory/scoped_ptr.h"

 namespace gfx {
-class ImageSkia;
+class Image;
+}
+
+namespace mate {
+class Arguments;
+class Dictionary;
 }

 namespace atom {
@@ -26,27 +31,34 @@ class Menu;
 class Tray : public mate::EventEmitter,
             public TrayIconObserver {
 public:
-  static mate::Wrappable* New(const gfx::ImageSkia& image);
+  static mate::Wrappable* New(const gfx::Image& image);

  static void BuildPrototype(v8::Isolate* isolate,
                             v8::Handle<v8::ObjectTemplate> prototype);

 protected:
-  explicit Tray(const gfx::ImageSkia& image);
+  explicit Tray(const gfx::Image& image);
  virtual ~Tray();

-  // TrayIcon implementations:
-  virtual void OnClicked() OVERRIDE;
-  virtual void OnDoubleClicked() OVERRIDE;
+  // TrayIconObserver:
+  void OnClicked() override;
+  void OnDoubleClicked() override;
+  void OnBalloonShow() override;
+  void OnBalloonClicked() override;
+  void OnBalloonClosed() 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);
+  void Destroy();
+  void SetImage(mate::Arguments* args, const gfx::Image& image);
+  void SetPressedImage(mate::Arguments* args, const gfx::Image& image);
+  void SetToolTip(mate::Arguments* args, const std::string& tool_tip);
+  void SetTitle(mate::Arguments* args, const std::string& title);
+  void SetHighlightMode(mate::Arguments* args, bool highlight);
+  void DisplayBalloon(mate::Arguments* args, const mate::Dictionary& options);
+  void SetContextMenu(mate::Arguments* args, Menu* menu);

 private:
+  bool CheckTrayLife(mate::Arguments* args);
+
  scoped_ptr<TrayIcon> tray_icon_;

  DISALLOW_COPY_AND_ASSIGN(Tray);
--- a/atom/browser/api/atom_api_web_contents.cc
+++ b/atom/browser/api/atom_api_web_contents.cc
@@ -5,6 +5,9 @@
 #include "atom/browser/api/atom_api_web_contents.h"

 #include "atom/browser/atom_browser_context.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/web_dialog_helper.h"
+#include "atom/browser/web_view_manager.h"
 #include "atom/common/api/api_messages.h"
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
@@ -12,6 +15,8 @@
 #include "atom/common/native_mate_converters/value_converter.h"
 #include "base/strings/utf_string_conversions.h"
 #include "brightray/browser/inspectable_web_contents.h"
+#include "content/public/browser/navigation_details.h"
+#include "content/public/browser/navigation_entry.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"
@@ -21,6 +26,7 @@
 #include "content/public/browser/web_contents.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
+#include "vendor/brightray/browser/media/media_stream_devices_controller.h"

 #include "atom/common/node_includes.h"

@@ -32,18 +38,33 @@ namespace {

 v8::Persistent<v8::ObjectTemplate> template_;

+// Get the window that has the |guest| embedded.
+NativeWindow* GetWindowFromGuest(const content::WebContents* guest) {
+  WebViewManager::WebViewInfo info;
+  if (WebViewManager::GetInfoForProcess(guest->GetRenderProcessHost(), &info))
+    return NativeWindow::FromRenderView(
+        info.embedder->GetRenderProcessHost()->GetID(),
+        info.embedder->GetRoutingID());
+  else
+    return nullptr;
+}
+
 }  // namespace

 WebContents::WebContents(content::WebContents* web_contents)
    : content::WebContentsObserver(web_contents),
      guest_instance_id_(-1),
+      element_instance_id_(-1),
      guest_opaque_(true),
+      guest_sizer_(nullptr),
      auto_size_enabled_(false) {
 }

 WebContents::WebContents(const mate::Dictionary& options)
    : guest_instance_id_(-1),
+      element_instance_id_(-1),
      guest_opaque_(true),
+      guest_sizer_(nullptr),
      auto_size_enabled_(false) {
  options.Get("guestInstanceId", &guest_instance_id_);

@@ -70,28 +91,23 @@ bool WebContents::AddMessageToConsole(content::WebContents* source,
                                      const base::string16& message,
                                      int32 line_no,
                                      const base::string16& source_id) {
-  base::ListValue args;
-  args.AppendInteger(level);
-  args.AppendString(message);
-  args.AppendInteger(line_no);
-  args.AppendString(source_id);
-  Emit("console-message", args);
+  Emit("console-message", level, message, line_no, source_id);
  return true;
 }

 bool WebContents::ShouldCreateWebContents(
    content::WebContents* web_contents,
    int route_id,
+    int main_frame_route_id,
    WindowContainerType window_container_type,
    const base::string16& frame_name,
    const GURL& target_url,
    const std::string& partition_id,
    content::SessionStorageNamespace* session_storage_namespace) {
-  base::ListValue args;
-  args.AppendString(target_url.spec());
-  args.AppendString(frame_name);
-  args.AppendInteger(NEW_FOREGROUND_TAB);
-  Emit("-new-window", args);
+  Emit("-new-window",
+       target_url,
+       frame_name,
+       static_cast<int>(NEW_FOREGROUND_TAB));
  return false;
 }

@@ -103,14 +119,14 @@ content::WebContents* WebContents::OpenURLFromTab(
    content::WebContents* source,
    const content::OpenURLParams& params) {
  if (params.disposition != CURRENT_TAB) {
-    base::ListValue args;
-    args.AppendString(params.url.spec());
-    args.AppendString("");
-    args.AppendInteger(params.disposition);
-    Emit("-new-window", args);
-    return NULL;
+    Emit("-new-window", params.url, "", static_cast<int>(params.disposition));
+    return nullptr;
  }

+  // Give user a chance to cancel navigation.
+  if (Emit("will-navigate", params.url))
+    return nullptr;
+
  content::NavigationController::LoadURLParams load_url_params(params.url);
  load_url_params.referrer = params.referrer;
  load_url_params.transition_type = params.transition;
@@ -125,6 +141,35 @@ content::WebContents* WebContents::OpenURLFromTab(
  return web_contents();
 }

+void WebContents::RunFileChooser(content::WebContents* guest,
+                                 const content::FileChooserParams& params) {
+  if (!web_dialog_helper_)
+    web_dialog_helper_.reset(new WebDialogHelper(GetWindowFromGuest(guest)));
+  web_dialog_helper_->RunFileChooser(guest, params);
+}
+
+void WebContents::EnumerateDirectory(content::WebContents* guest,
+                                     int request_id,
+                                     const base::FilePath& path) {
+  if (!web_dialog_helper_)
+    web_dialog_helper_.reset(new WebDialogHelper(GetWindowFromGuest(guest)));
+  web_dialog_helper_->EnumerateDirectory(guest, request_id, path);
+}
+
+bool WebContents::CheckMediaAccessPermission(content::WebContents* web_contents,
+                                             const GURL& security_origin,
+                                             content::MediaStreamType type) {
+  return true;
+}
+
+void WebContents::RequestMediaAccessPermission(
+    content::WebContents*,
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback) {
+  brightray::MediaStreamDevicesController controller(request, callback);
+  controller.TakeAction();
+}
+
 void WebContents::HandleKeyboardEvent(
    content::WebContents* source,
    const content::NativeWebKeyboardEvent& event) {
@@ -137,10 +182,9 @@ void WebContents::HandleKeyboardEvent(
 }

 void WebContents::RenderViewDeleted(content::RenderViewHost* render_view_host) {
-  base::ListValue args;
-  args.AppendInteger(render_view_host->GetProcess()->GetID());
-  args.AppendInteger(render_view_host->GetRoutingID());
-  Emit("render-view-deleted", args);
+  Emit("render-view-deleted",
+       render_view_host->GetProcess()->GetID(),
+       render_view_host->GetRoutingID());
 }

 void WebContents::RenderProcessGone(base::TerminationStatus status) {
@@ -150,23 +194,26 @@ void WebContents::RenderProcessGone(base::TerminationStatus status) {
 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);
+  Emit("did-frame-finish-load", is_main_frame);

  if (is_main_frame)
    Emit("did-finish-load");
 }

+// this error occurs when host could not be found
+void WebContents::DidFailProvisionalLoad(
+    content::RenderFrameHost* render_frame_host,
+    const GURL& validated_url,
+    int error_code,
+    const base::string16& error_description) {
+  Emit("did-fail-load", error_code, error_description);
+}
+
 void WebContents::DidFailLoad(content::RenderFrameHost* render_frame_host,
                              const GURL& validated_url,
                              int error_code,
                              const base::string16& error_description) {
-  base::ListValue args;
-  args.AppendInteger(error_code);
-  args.AppendString(error_description);
-  Emit("did-fail-load", args);
+  Emit("did-fail-load", error_code, error_description);
 }

 void WebContents::DidStartLoading(content::RenderViewHost* render_view_host) {
@@ -178,14 +225,19 @@ void WebContents::DidStopLoading(content::RenderViewHost* render_view_host) {
 }

 void WebContents::DidGetRedirectForResourceRequest(
-    content::RenderViewHost* render_view_host,
+    content::RenderFrameHost* render_frame_host,
    const content::ResourceRedirectDetails& details) {
-  base::ListValue args;
-  args.AppendString(details.url.spec());
-  args.AppendString(details.new_url.spec());
-  args.AppendBoolean(
-      details.resource_type == content::RESOURCE_TYPE_MAIN_FRAME);
-  Emit("did-get-redirect-request", args);
+  Emit("did-get-redirect-request",
+       details.url,
+       details.new_url,
+       (details.resource_type == content::RESOURCE_TYPE_MAIN_FRAME));
+}
+
+void WebContents::DidNavigateMainFrame(
+    const content::LoadCommittedDetails& details,
+    const content::FrameNavigateParams& params) {
+  if (details.is_navigation_to_different_page())
+    Emit("did-navigate-to-different-page");
 }

 bool WebContents::OnMessageReceived(const IPC::Message& message) {
@@ -208,14 +260,14 @@ void WebContents::RenderViewReady() {
  // WebContents::GetRenderWidgetHostView will return the RWHV of an
  // interstitial page if one is showing at this time. We only want opacity
  // to apply to web pages.
-  web_contents()->GetRenderViewHost()->GetView()->
-      SetBackgroundOpaque(guest_opaque_);
-
-  content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
-  if (auto_size_enabled_) {
-    rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
+  if (guest_opaque_) {
+    web_contents()
+        ->GetRenderViewHost()
+        ->GetView()
+        ->SetBackgroundColorToDefault();
  } else {
-    rvh->DisableAutoResize(element_size_);
+    web_contents()->GetRenderViewHost()->GetView()->SetBackgroundColor(
+        SK_ColorTRANSPARENT);
  }
 }

@@ -225,31 +277,26 @@ void WebContents::WebContentsDestroyed() {
  Emit("destroyed");
 }

-void WebContents::WillAttach(content::WebContents* embedder_web_contents,
-                             const base::DictionaryValue& extra_params) {
-  embedder_web_contents_ = embedder_web_contents;
-  extra_params_.reset(extra_params.DeepCopy());
+void WebContents::NavigationEntryCommitted(
+    const content::LoadCommittedDetails& load_details) {
+  auto entry = web_contents()->GetController().GetLastCommittedEntry();
+  entry->SetVirtualURL(load_details.entry->GetOriginalRequestURL());
 }

-content::WebContents* WebContents::CreateNewGuestWindow(
-    const content::WebContents::CreateParams& create_params) {
-  NOTREACHED() << "Should not create new window from guest";
-  return nullptr;
+void WebContents::DidAttach(int guest_proxy_routing_id) {
+  Emit("did-attach");
 }

-void WebContents::DidAttach() {
-  base::ListValue args;
-  args.Append(extra_params_.release());
-  Emit("did-attach", args);
+void WebContents::ElementSizeChanged(const gfx::Size& size) {
+  element_size_ = size;
+
+  // Only resize if needed.
+  if (!size.IsEmpty())
+    guest_sizer_->SizeContents(size);
 }

-int WebContents::GetGuestInstanceID() const {
-  return guest_instance_id_;
-}
-
-void WebContents::ElementSizeChanged(const gfx::Size& old_size,
-                                     const gfx::Size& new_size) {
-  element_size_ = new_size;
+content::WebContents* WebContents::GetOwnerWebContents() const {
+  return embedder_web_contents_;
 }

 void WebContents::GuestSizeChanged(const gfx::Size& old_size,
@@ -260,23 +307,30 @@ void WebContents::GuestSizeChanged(const gfx::Size& old_size,
  GuestSizeChangedDueToAutoSize(old_size, new_size);
 }

-void WebContents::RequestPointerLockPermission(
-    bool user_gesture,
-    bool last_unlocked_by_target,
-    const base::Callback<void(bool enabled)>& callback) {
-  callback.Run(true);
-}
-
 void WebContents::RegisterDestructionCallback(
    const DestructionCallback& callback) {
  destruction_callback_ = callback;
 }

+void WebContents::SetGuestSizer(content::GuestSizer* guest_sizer) {
+  guest_sizer_ = guest_sizer;
+}
+
+void WebContents::WillAttach(content::WebContents* embedder_web_contents,
+                             int element_instance_id,
+                             bool is_full_page_plugin) {
+  embedder_web_contents_ = embedder_web_contents;
+  element_instance_id_ = element_instance_id;
+}
+
 void WebContents::Destroy() {
  if (storage_) {
    if (!destruction_callback_.is_null())
      destruction_callback_.Run();

+    // When force destroying the "destroyed" event is not emitted.
+    WebContentsDestroyed();
+
    Observe(nullptr);
    storage_.reset();
  }
@@ -286,15 +340,22 @@ bool WebContents::IsAlive() const {
  return web_contents() != NULL;
 }

-void WebContents::LoadURL(const GURL& url) {
+void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
  content::NavigationController::LoadURLParams params(url);
-  params.transition_type = content::PAGE_TRANSITION_TYPED;
+
+  GURL http_referrer;
+  if (options.Get("httpreferrer", &http_referrer))
+    params.referrer = content::Referrer(http_referrer.GetAsReferrer(),
+                                        blink::WebReferrerPolicyDefault);
+
+  params.transition_type = ui::PAGE_TRANSITION_TYPED;
  params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
  web_contents()->GetController().LoadURLWithParams(params);
 }

 GURL WebContents::GetURL() const {
-  return web_contents()->GetURL();
+  auto entry = web_contents()->GetController().GetLastCommittedEntry();
+  return entry->GetVirtualURL();
 }

 base::string16 WebContents::GetTitle() const {
@@ -313,15 +374,15 @@ void WebContents::Stop() {
  web_contents()->Stop();
 }

-void WebContents::Reload() {
+void WebContents::Reload(const mate::Dictionary& options) {
  // Navigating to a URL would always restart the renderer process, we want this
  // because normal reloading will break our node integration.
  // This is done by AtomBrowserClient::ShouldSwapProcessesForNavigation.
-  LoadURL(GetURL());
+  LoadURL(GetURL(), options);
 }

-void WebContents::ReloadIgnoringCache() {
-  Reload();
+void WebContents::ReloadIgnoringCache(const mate::Dictionary& options) {
+  Reload(options);
 }

 bool WebContents::CanGoBack() const {
@@ -389,6 +450,46 @@ bool WebContents::IsDevToolsOpened() {
  return storage_->IsDevToolsViewShowing();
 }

+void WebContents::Undo() {
+  web_contents()->Undo();
+}
+
+void WebContents::Redo() {
+  web_contents()->Redo();
+}
+
+void WebContents::Cut() {
+  web_contents()->Cut();
+}
+
+void WebContents::Copy() {
+  web_contents()->Copy();
+}
+
+void WebContents::Paste() {
+  web_contents()->Paste();
+}
+
+void WebContents::Delete() {
+  web_contents()->Delete();
+}
+
+void WebContents::SelectAll() {
+  web_contents()->SelectAll();
+}
+
+void WebContents::Unselect() {
+  web_contents()->Unselect();
+}
+
+void WebContents::Replace(const base::string16& word) {
+  web_contents()->Replace(word);
+}
+
+void WebContents::ReplaceMisspelling(const base::string16& word) {
+  web_contents()->ReplaceMisspelling(word);
+}
+
 bool WebContents::SendIPCMessage(const base::string16& channel,
                                 const base::ListValue& args) {
  return Send(new AtomViewMsg_Message(routing_id(), channel, args));
@@ -429,7 +530,15 @@ void WebContents::SetAllowTransparency(bool allow) {
  if (!web_contents()->GetRenderViewHost()->GetView())
    return;

-  web_contents()->GetRenderViewHost()->GetView()->SetBackgroundOpaque(!allow);
+  if (guest_opaque_) {
+    web_contents()
+        ->GetRenderViewHost()
+        ->GetView()
+        ->SetBackgroundColorToDefault();
+  } else {
+    web_contents()->GetRenderViewHost()->GetView()->SetBackgroundColor(
+        SK_ColorTRANSPARENT);
+  }
 }

 mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
@@ -438,14 +547,14 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
    template_.Reset(isolate, mate::ObjectTemplateBuilder(isolate)
        .SetMethod("destroy", &WebContents::Destroy)
        .SetMethod("isAlive", &WebContents::IsAlive)
-        .SetMethod("loadUrl", &WebContents::LoadURL)
+        .SetMethod("_loadUrl", &WebContents::LoadURL)
        .SetMethod("getUrl", &WebContents::GetURL)
        .SetMethod("getTitle", &WebContents::GetTitle)
        .SetMethod("isLoading", &WebContents::IsLoading)
        .SetMethod("isWaitingForResponse", &WebContents::IsWaitingForResponse)
        .SetMethod("stop", &WebContents::Stop)
-        .SetMethod("reload", &WebContents::Reload)
-        .SetMethod("reloadIgnoringCache", &WebContents::ReloadIgnoringCache)
+        .SetMethod("_reload", &WebContents::Reload)
+        .SetMethod("_reloadIgnoringCache", &WebContents::ReloadIgnoringCache)
        .SetMethod("canGoBack", &WebContents::CanGoBack)
        .SetMethod("canGoForward", &WebContents::CanGoForward)
        .SetMethod("canGoToOffset", &WebContents::CanGoToOffset)
@@ -459,13 +568,23 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
        .SetMethod("setUserAgent", &WebContents::SetUserAgent)
        .SetMethod("insertCSS", &WebContents::InsertCSS)
        .SetMethod("_executeJavaScript", &WebContents::ExecuteJavaScript)
+        .SetMethod("openDevTools", &WebContents::OpenDevTools)
+        .SetMethod("closeDevTools", &WebContents::CloseDevTools)
+        .SetMethod("isDevToolsOpened", &WebContents::IsDevToolsOpened)
+        .SetMethod("undo", &WebContents::Undo)
+        .SetMethod("redo", &WebContents::Redo)
+        .SetMethod("cut", &WebContents::Cut)
+        .SetMethod("copy", &WebContents::Copy)
+        .SetMethod("paste", &WebContents::Paste)
+        .SetMethod("delete", &WebContents::Delete)
+        .SetMethod("selectAll", &WebContents::SelectAll)
+        .SetMethod("unselect", &WebContents::Unselect)
+        .SetMethod("replace", &WebContents::Replace)
+        .SetMethod("replaceMisspelling", &WebContents::ReplaceMisspelling)
        .SetMethod("_send", &WebContents::SendIPCMessage)
        .SetMethod("setAutoSize", &WebContents::SetAutoSize)
        .SetMethod("setAllowTransparency", &WebContents::SetAllowTransparency)
        .SetMethod("isGuest", &WebContents::is_guest)
-        .SetMethod("openDevTools", &WebContents::OpenDevTools)
-        .SetMethod("closeDevTools", &WebContents::CloseDevTools)
-        .SetMethod("isDevToolsOpened", &WebContents::IsDevToolsOpened)
        .Build());

  return mate::ObjectTemplateBuilder(
@@ -482,17 +601,14 @@ void WebContents::OnRendererMessageSync(const base::string16& channel,
                                        const base::ListValue& args,
                                        IPC::Message* message) {
  // webContents.emit(channel, new Event(sender, message), args...);
-  Emit(base::UTF16ToUTF8(channel), args, web_contents(), message);
+  EmitWithSender(base::UTF16ToUTF8(channel), web_contents(), message, args);
 }

 void WebContents::GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
                                                const gfx::Size& new_size) {
-  base::ListValue args;
-  args.AppendInteger(old_size.width());
-  args.AppendInteger(old_size.height());
-  args.AppendInteger(new_size.width());
-  args.AppendInteger(new_size.height());
-  Emit("size-changed", args);
+  Emit("size-changed",
+       old_size.width(), old_size.height(),
+       new_size.width(), new_size.height());
 }

 // static
--- a/atom/browser/api/atom_api_web_contents.h
+++ b/atom/browser/api/atom_api_web_contents.h
@@ -24,6 +24,8 @@ class Dictionary;

 namespace atom {

+class WebDialogHelper;
+
 namespace api {

 class WebContents : public mate::EventEmitter,
@@ -41,14 +43,14 @@ class WebContents : public mate::EventEmitter,

  void Destroy();
  bool IsAlive() const;
-  void LoadURL(const GURL& url);
+  void LoadURL(const GURL& url, const mate::Dictionary& options);
  GURL GetURL() const;
  base::string16 GetTitle() const;
  bool IsLoading() const;
  bool IsWaitingForResponse() const;
  void Stop();
-  void Reload();
-  void ReloadIgnoringCache();
+  void Reload(const mate::Dictionary& options);
+  void ReloadIgnoringCache(const mate::Dictionary& options);
  bool CanGoBack() const;
  bool CanGoForward() const;
  bool CanGoToOffset(int offset) const;
@@ -65,6 +67,20 @@ class WebContents : public mate::EventEmitter,
  void OpenDevTools();
  void CloseDevTools();
  bool IsDevToolsOpened();
+
+  // Editing commands.
+  void Undo();
+  void Redo();
+  void Cut();
+  void Copy();
+  void Paste();
+  void Delete();
+  void SelectAll();
+  void Unselect();
+  void Replace(const base::string16& word);
+  void ReplaceMisspelling(const base::string16& word);
+
+  // Sending messages to browser.
  bool SendIPCMessage(const base::string16& channel,
                      const base::ListValue& args);

@@ -92,7 +108,7 @@ class WebContents : public mate::EventEmitter,
  ~WebContents();

  // mate::Wrappable:
-  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
      v8::Isolate* isolate) override;

  // content::WebContentsDelegate:
@@ -104,6 +120,7 @@ class WebContents : public mate::EventEmitter,
  bool ShouldCreateWebContents(
      content::WebContents* web_contents,
      int route_id,
+      int main_frame_route_id,
      WindowContainerType window_container_type,
      const base::string16& frame_name,
      const GURL& target_url,
@@ -113,47 +130,60 @@ class WebContents : public mate::EventEmitter,
  content::WebContents* OpenURLFromTab(
      content::WebContents* source,
      const content::OpenURLParams& params) override;
+  void RunFileChooser(content::WebContents* web_contents,
+                      const content::FileChooserParams& params) override;
+  void EnumerateDirectory(content::WebContents* web_contents,
+                          int request_id,
+                          const base::FilePath& path) override;
+  bool CheckMediaAccessPermission(content::WebContents* web_contents,
+                                  const GURL& security_origin,
+                                  content::MediaStreamType type) override;
+  void RequestMediaAccessPermission(
+      content::WebContents*,
+      const content::MediaStreamRequest&,
+      const content::MediaResponseCallback&) override;
  void HandleKeyboardEvent(
      content::WebContents* source,
      const content::NativeWebKeyboardEvent& event) override;

  // content::WebContentsObserver:
-  virtual void RenderViewDeleted(content::RenderViewHost*) override;
-  virtual void RenderProcessGone(base::TerminationStatus status) override;
-  virtual void DidFinishLoad(content::RenderFrameHost* render_frame_host,
-                             const GURL& validated_url) override;
-  virtual void DidFailLoad(content::RenderFrameHost* render_frame_host,
-                           const GURL& validated_url,
-                           int error_code,
-                           const base::string16& error_description) override;
-  virtual void DidStartLoading(
-      content::RenderViewHost* render_view_host) override;
-  virtual void DidStopLoading(
-      content::RenderViewHost* render_view_host) override;
-  virtual void DidGetRedirectForResourceRequest(
-      content::RenderViewHost* render_view_host,
+  void RenderViewDeleted(content::RenderViewHost*) override;
+  void RenderProcessGone(base::TerminationStatus status) override;
+  void DidFinishLoad(content::RenderFrameHost* render_frame_host,
+                     const GURL& validated_url) override;
+  void DidFailLoad(content::RenderFrameHost* render_frame_host,
+                   const GURL& validated_url,
+                   int error_code,
+                   const base::string16& error_description) override;
+  void DidFailProvisionalLoad(content::RenderFrameHost* render_frame_host,
+                              const GURL& validated_url,
+                              int error_code,
+                              const base::string16& error_description) override;
+  void DidStartLoading(content::RenderViewHost* render_view_host) override;
+  void DidStopLoading(content::RenderViewHost* render_view_host) override;
+  void DidGetRedirectForResourceRequest(
+      content::RenderFrameHost* render_frame_host,
      const content::ResourceRedirectDetails& details) override;
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
-  virtual void RenderViewReady() override;
-  virtual void WebContentsDestroyed() override;
+  void DidNavigateMainFrame(
+      const content::LoadCommittedDetails& details,
+      const content::FrameNavigateParams& params) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void RenderViewReady() override;
+  void WebContentsDestroyed() override;
+  void NavigationEntryCommitted(
+      const content::LoadCommittedDetails& load_details) override;

  // content::BrowserPluginGuestDelegate:
-  virtual void WillAttach(content::WebContents* embedder_web_contents,
-                          const base::DictionaryValue& extra_params) override;
-  virtual content::WebContents* CreateNewGuestWindow(
-      const content::WebContents::CreateParams& create_params) override;
-  virtual void DidAttach() override;
-  virtual int GetGuestInstanceID() const override;
-  virtual void ElementSizeChanged(const gfx::Size& old_size,
-                                  const gfx::Size& new_size) override;
-  virtual void GuestSizeChanged(const gfx::Size& old_size,
-                                const gfx::Size& new_size) override;
-  virtual void RequestPointerLockPermission(
-      bool user_gesture,
-      bool last_unlocked_by_target,
-      const base::Callback<void(bool enabled)>& callback) override;
-  virtual void RegisterDestructionCallback(
-      const DestructionCallback& callback) override;
+  void DidAttach(int guest_proxy_routing_id) final;
+  void ElementSizeChanged(const gfx::Size& size) final;
+  content::WebContents* GetOwnerWebContents() const final;
+  void GuestSizeChanged(const gfx::Size& old_size,
+                        const gfx::Size& new_size) final;
+  void RegisterDestructionCallback(const DestructionCallback& callback) final;
+  void SetGuestSizer(content::GuestSizer* guest_sizer) final;
+  void WillAttach(content::WebContents* embedder_web_contents,
+                  int element_instance_id,
+                  bool is_full_page_plugin) final;

 private:
  // Called when received a message from renderer.
@@ -168,20 +198,20 @@ class WebContents : public mate::EventEmitter,
  void GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
                                     const gfx::Size& new_size);

+  scoped_ptr<WebDialogHelper> web_dialog_helper_;
+
  // Unique ID for a guest WebContents.
  int guest_instance_id_;

+  // |element_instance_id_| is an identifer that's unique to a particular
+  // element.
+  int element_instance_id_;
+
  DestructionCallback destruction_callback_;

  // Stores whether the contents of the guest can be transparent.
  bool guest_opaque_;

-  // The extra parameters associated with this guest view passed
-  // in from JavaScript. This will typically be the view instance ID,
-  // the API to use, and view-specific parameters. These parameters
-  // are passed along to new guests that are created from this guest.
-  scoped_ptr<base::DictionaryValue> extra_params_;
-
  // Stores the WebContents that managed by this class.
  scoped_ptr<brightray::InspectableWebContents> storage_;

@@ -195,6 +225,9 @@ class WebContents : public mate::EventEmitter,
  // element may not match the size of the guest.
  gfx::Size guest_size_;

+  // A pointer to the guest_sizer.
+  content::GuestSizer* guest_sizer_;
+
  // Indicates whether autosize mode is enabled or not.
  bool auto_size_enabled_;

--- a/atom/browser/api/atom_api_web_view_manager.cc
+++ b/atom/browser/api/atom_api_web_view_manager.cc
@@ -0,0 +1,93 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/web_view_manager.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "content/public/browser/browser_context.h"
+#include "native_mate/dictionary.h"
+#include "net/base/filename_util.h"
+
+#include "atom/common/node_includes.h"
+
+namespace mate {
+
+template<>
+struct Converter<content::WebContents*> {
+  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+                     content::WebContents** out) {
+    atom::api::WebContents* contents;
+    if (!Converter<atom::api::WebContents*>::FromV8(isolate, val, &contents))
+      return false;
+    *out = contents->web_contents();
+    return true;
+  }
+};
+
+template<>
+struct Converter<atom::WebViewManager::WebViewInfo> {
+  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+                     atom::WebViewManager::WebViewInfo* out) {
+    Dictionary options;
+    if (!ConvertFromV8(isolate, val, &options))
+      return false;
+
+    GURL preload_url;
+    if (!options.Get("preloadUrl", &preload_url))
+      return false;
+
+    if (!preload_url.is_empty() &&
+        !net::FileURLToFilePath(preload_url, &(out->preload_script)))
+      return false;
+
+    return options.Get("nodeIntegration", &(out->node_integration)) &&
+           options.Get("plugins", &(out->plugins)) &&
+           options.Get("disableWebSecurity", &(out->disable_web_security));
+  }
+};
+
+}  // namespace mate
+
+namespace {
+
+atom::WebViewManager* GetWebViewManager(content::WebContents* web_contents) {
+  auto context = web_contents->GetBrowserContext();
+  if (context) {
+    auto manager = context->GetGuestManager();
+    return static_cast<atom::WebViewManager*>(manager);
+  } else {
+    return nullptr;
+  }
+}
+
+void AddGuest(int guest_instance_id,
+              int element_instance_id,
+              content::WebContents* embedder,
+              content::WebContents* guest_web_contents,
+              atom::WebViewManager::WebViewInfo info) {
+  auto manager = GetWebViewManager(embedder);
+  if (manager) {
+    info.guest_instance_id = guest_instance_id;
+    info.embedder = embedder;
+    manager->AddGuest(guest_instance_id, element_instance_id, embedder,
+                      guest_web_contents, info);
+  }
+}
+
+void RemoveGuest(content::WebContents* embedder, int guest_instance_id) {
+  auto manager = GetWebViewManager(embedder);
+  if (manager)
+    manager->RemoveGuest(guest_instance_id);
+}
+
+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("addGuest", &AddGuest);
+  dict.SetMethod("removeGuest", &RemoveGuest);
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_web_view_manager, Initialize)
--- a/atom/browser/api/atom_api_window.cc
+++ b/atom/browser/api/atom_api_window.cc
@@ -8,6 +8,9 @@
 #include "atom/browser/browser.h"
 #include "atom/browser/native_window.h"
 #include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
 #include "content/public/browser/render_process_host.h"
 #include "native_mate/callback.h"
 #include "native_mate/constructor.h"
@@ -19,7 +22,7 @@ namespace {

 struct PrintSettings {
  bool silent;
-  bool print_backgournd;
+  bool print_background;
 };

 }  // namespace
@@ -34,7 +37,7 @@ struct Converter<PrintSettings> {
    if (!ConvertFromV8(isolate, val, &dict))
      return false;
    dict.Get("silent", &(out->silent));
-    dict.Get("printBackground", &(out->print_backgournd));
+    dict.Get("printBackground", &(out->print_background));
    return true;
  }
 };
@@ -49,15 +52,11 @@ namespace {

 void OnCapturePageDone(
    v8::Isolate* isolate,
-    const base::Callback<void(v8::Handle<v8::Value>)>& callback,
+    const base::Callback<void(const gfx::Image&)>& callback,
    const std::vector<unsigned char>& data) {
  v8::Locker locker(isolate);
  v8::HandleScope handle_scope(isolate);
-
-  v8::Local<v8::Value> buffer = node::Buffer::New(
-      reinterpret_cast<const char*>(data.data()),
-      data.size());
-  callback.Run(buffer);
+  callback.Run(gfx::Image::CreateFrom1xPNGBytes(&data.front(), data.size()));
 }

 }  // namespace
@@ -72,26 +71,22 @@ Window::Window(const mate::Dictionary& options)
 Window::~Window() {
  if (window_)
    Destroy();
-
-  Emit("destroyed");
 }

 void Window::OnPageTitleUpdated(bool* prevent_default,
                                const std::string& title) {
-  base::ListValue args;
-  args.AppendString(title);
-  *prevent_default = Emit("page-title-updated", args);
+  *prevent_default = Emit("page-title-updated", title);
 }

 void Window::WillCreatePopupWindow(const base::string16& frame_name,
                                   const GURL& target_url,
                                   const std::string& partition_id,
                                   WindowOpenDisposition disposition) {
-  base::ListValue args;
-  args.AppendString(target_url.spec());
-  args.AppendString(frame_name);
-  args.AppendInteger(disposition);
-  Emit("-new-window", args);
+  Emit("-new-window", target_url, frame_name, static_cast<int>(disposition));
+}
+
+void Window::WillNavigate(bool* prevent_default, const GURL& url) {
+  *prevent_default = Emit("-will-navigate", url);
 }

 void Window::WillCloseWindow(bool* prevent_default) {
@@ -112,6 +107,30 @@ void Window::OnWindowFocus() {
  Emit("focus");
 }

+void Window::OnWindowMaximize() {
+  Emit("maximize");
+}
+
+void Window::OnWindowUnmaximize() {
+  Emit("unmaximize");
+}
+
+void Window::OnWindowMinimize() {
+  Emit("minimize");
+}
+
+void Window::OnWindowRestore() {
+  Emit("restore");
+}
+
+void Window::OnWindowEnterFullScreen() {
+  Emit("enter-full-screen");
+}
+
+void Window::OnWindowLeaveFullScreen() {
+  Emit("leave-full-screen");
+}
+
 void Window::OnRendererUnresponsive() {
  Emit("unresponsive");
 }
@@ -193,8 +212,8 @@ bool Window::IsMinimized() {
  return window_->IsMinimized();
 }

-void Window::SetFullscreen(bool fullscreen) {
-  window_->SetFullscreen(fullscreen);
+void Window::SetFullScreen(bool fullscreen) {
+  window_->SetFullScreen(fullscreen);
 }

 bool Window::IsFullscreen() {
@@ -351,7 +370,7 @@ bool Window::IsDocumentEdited() {

 void Window::CapturePage(mate::Arguments* args) {
  gfx::Rect rect;
-  base::Callback<void(v8::Handle<v8::Value>)> callback;
+  base::Callback<void(const gfx::Image&)> callback;

  if (!(args->Length() == 1 && args->GetNext(&callback)) &&
      !(args->Length() == 2 && args->GetNext(&rect)
@@ -371,13 +390,40 @@ void Window::Print(mate::Arguments* args) {
    return;
  }

-  window_->Print(settings.silent, settings.print_backgournd);
+  window_->Print(settings.silent, settings.print_background);
 }

 void Window::SetProgressBar(double progress) {
  window_->SetProgressBar(progress);
 }

+void Window::SetOverlayIcon(const gfx::Image& overlay,
+                            const std::string& description) {
+  window_->SetOverlayIcon(overlay, description);
+}
+
+void Window::SetAutoHideMenuBar(bool auto_hide) {
+  window_->SetAutoHideMenuBar(auto_hide);
+}
+
+bool Window::IsMenuBarAutoHide() {
+  return window_->IsMenuBarAutoHide();
+}
+
+void Window::SetMenuBarVisibility(bool visible) {
+  window_->SetMenuBarVisibility(visible);
+}
+
+bool Window::IsMenuBarVisible() {
+  return window_->IsMenuBarVisible();
+}
+
+#if defined(OS_MACOSX)
+void Window::ShowDefinitionForSelection() {
+  window_->ShowDefinitionForSelection();
+}
+#endif
+
 mate::Handle<WebContents> Window::GetWebContents(v8::Isolate* isolate) const {
  return WebContents::CreateFrom(isolate, window_->GetWebContents());
 }
@@ -406,7 +452,7 @@ void Window::BuildPrototype(v8::Isolate* isolate,
      .SetMethod("minimize", &Window::Minimize)
      .SetMethod("restore", &Window::Restore)
      .SetMethod("isMinimized", &Window::IsMinimized)
-      .SetMethod("setFullScreen", &Window::SetFullscreen)
+      .SetMethod("setFullScreen", &Window::SetFullScreen)
      .SetMethod("isFullScreen", &Window::IsFullscreen)
      .SetMethod("getSize", &Window::GetSize)
      .SetMethod("setSize", &Window::SetSize)
@@ -443,6 +489,15 @@ void Window::BuildPrototype(v8::Isolate* isolate,
      .SetMethod("capturePage", &Window::CapturePage)
      .SetMethod("print", &Window::Print)
      .SetMethod("setProgressBar", &Window::SetProgressBar)
+      .SetMethod("setOverlayIcon", &Window::SetOverlayIcon)
+      .SetMethod("setAutoHideMenuBar", &Window::SetAutoHideMenuBar)
+      .SetMethod("isMenuBarAutoHide", &Window::IsMenuBarAutoHide)
+      .SetMethod("setMenuBarVisibility", &Window::SetMenuBarVisibility)
+      .SetMethod("isMenuBarVisible", &Window::IsMenuBarVisible)
+#if defined(OS_MACOSX)
+      .SetMethod("showDefinitionForSelection",
+                 &Window::ShowDefinitionForSelection)
+#endif
      .SetMethod("_getWebContents", &Window::GetWebContents)
      .SetMethod("_getDevToolsWebContents", &Window::GetDevToolsWebContents);
 }
--- a/atom/browser/api/atom_api_window.h
+++ b/atom/browser/api/atom_api_window.h
@@ -9,6 +9,7 @@
 #include <vector>

 #include "base/memory/scoped_ptr.h"
+#include "ui/gfx/image/image.h"
 #include "atom/browser/native_window_observer.h"
 #include "atom/browser/api/event_emitter.h"
 #include "native_mate/handle.h"
@@ -43,17 +44,24 @@ class Window : public mate::EventEmitter,
  explicit Window(const mate::Dictionary& options);
  virtual ~Window();

-  // Implementations of NativeWindowObserver:
+  // NativeWindowObserver:
  void OnPageTitleUpdated(bool* prevent_default,
                          const std::string& title) override;
  void WillCreatePopupWindow(const base::string16& frame_name,
                             const GURL& target_url,
                             const std::string& partition_id,
                             WindowOpenDisposition disposition) override;
+  void WillNavigate(bool* prevent_default, const GURL& url) override;
  void WillCloseWindow(bool* prevent_default) override;
  void OnWindowClosed() override;
  void OnWindowBlur() override;
  void OnWindowFocus() override;
+  void OnWindowMaximize() override;
+  void OnWindowUnmaximize() override;
+  void OnWindowMinimize() override;
+  void OnWindowRestore() override;
+  void OnWindowEnterFullScreen() override;
+  void OnWindowLeaveFullScreen() override;
  void OnRendererUnresponsive() override;
  void OnRendererResponsive() override;

@@ -74,7 +82,7 @@ class Window : public mate::EventEmitter,
  void Minimize();
  void Restore();
  bool IsMinimized();
-  void SetFullscreen(bool fullscreen);
+  void SetFullScreen(bool fullscreen);
  bool IsFullscreen();
  void SetSize(int width, int height);
  std::vector<int> GetSize();
@@ -111,6 +119,16 @@ class Window : public mate::EventEmitter,
  void CapturePage(mate::Arguments* args);
  void Print(mate::Arguments* args);
  void SetProgressBar(double progress);
+  void SetOverlayIcon(const gfx::Image& overlay,
+                      const std::string& description);
+  void SetAutoHideMenuBar(bool auto_hide);
+  bool IsMenuBarAutoHide();
+  void SetMenuBarVisibility(bool visible);
+  bool IsMenuBarVisible();
+
+#if defined(OS_MACOSX)
+  void ShowDefinitionForSelection();
+#endif

  // APIs for WebContents.
  mate::Handle<WebContents> GetWebContents(v8::Isolate* isolate) const;
--- a/atom/browser/api/event.h
+++ b/atom/browser/api/event.h
@@ -34,10 +34,10 @@ class Event : public Wrappable,
  virtual ~Event();

  // Wrappable implementations:
-  virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate);
+  ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate) override;

  // content::WebContentsObserver implementations:
-  virtual void WebContentsDestroyed() OVERRIDE;
+  void WebContentsDestroyed() override;

 private:
  // Replyer for the synchronous messages.
--- a/atom/browser/api/event_emitter.cc
+++ b/atom/browser/api/event_emitter.cc
@@ -5,9 +5,6 @@
 #include "atom/browser/api/event_emitter.h"

 #include "atom/browser/api/event.h"
-#include "atom/common/native_mate_converters/v8_value_converter.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/values.h"
 #include "native_mate/arguments.h"
 #include "native_mate/object_template_builder.h"

@@ -41,43 +38,11 @@ v8::Local<v8::Object> CreateEventObject(v8::Isolate* isolate) {
 EventEmitter::EventEmitter() {
 }

-bool EventEmitter::Emit(const base::StringPiece& name) {
-  return Emit(name, base::ListValue());
-}
-
-bool EventEmitter::Emit(const base::StringPiece& name,
-                        const base::ListValue& args) {
-  return Emit(name, args, NULL, NULL);
-}
-
-bool EventEmitter::Emit(const base::StringPiece& name,
-                        const base::ListValue& args,
-                        content::WebContents* sender,
-                        IPC::Message* message) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  v8::Locker locker(isolate);
-  v8::HandleScope handle_scope(isolate);
-
-  v8::Handle<v8::Context> context = isolate->GetCurrentContext();
-  scoped_ptr<atom::V8ValueConverter> converter(new atom::V8ValueConverter);
-
-  // v8_args = [args...];
-  Arguments v8_args;
-  v8_args.reserve(args.GetSize());
-  for (size_t i = 0; i < args.GetSize(); i++) {
-    const base::Value* value(NULL);
-    if (args.Get(i, &value))
-      v8_args.push_back(converter->ToV8Value(value, context));
-  }
-
-  return Emit(isolate, name, v8_args, sender, message);
-}
-
-bool EventEmitter::Emit(v8::Isolate* isolate,
-                        const base::StringPiece& name,
-                        Arguments args,
-                        content::WebContents* sender,
-                        IPC::Message* message) {
+bool EventEmitter::CallEmit(v8::Isolate* isolate,
+                            const base::StringPiece& name,
+                            content::WebContents* sender,
+                            IPC::Message* message,
+                            ValueArray args) {
  v8::Handle<v8::Object> event;
  bool use_native_event = sender && message;

--- a/atom/browser/api/event_emitter.h
+++ b/atom/browser/api/event_emitter.h
@@ -9,10 +9,6 @@

 #include "native_mate/wrappable.h"

-namespace base {
-class ListValue;
-}
-
 namespace content {
 class WebContents;
 }
@@ -26,29 +22,39 @@ namespace mate {
 // Provide helperers to emit event in JavaScript.
 class EventEmitter : public Wrappable {
 public:
-  typedef std::vector<v8::Handle<v8::Value>> Arguments;
+  typedef std::vector<v8::Handle<v8::Value>> ValueArray;

 protected:
  EventEmitter();

-  // this.emit(name, new Event());
-  bool Emit(const base::StringPiece& name);
-
  // this.emit(name, new Event(), args...);
-  bool Emit(const base::StringPiece& name, const base::ListValue& args);
+  template<typename... Args>
+  bool Emit(const base::StringPiece& name, const Args&... args) {
+    return EmitWithSender(name, nullptr, nullptr, args...);
+  }

  // this.emit(name, new Event(sender, message), args...);
-  bool Emit(const base::StringPiece& name, const base::ListValue& args,
-            content::WebContents* sender, IPC::Message* message);
+  template<typename... Args>
+  bool EmitWithSender(const base::StringPiece& name,
+                      content::WebContents* sender,
+                      IPC::Message* message,
+                      const Args&... args) {
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);

-  // Lower level implementations.
-  bool Emit(v8::Isolate* isolate,
-            const base::StringPiece& name,
-            Arguments args,
-            content::WebContents* sender = nullptr,
-            IPC::Message* message = nullptr);
+    ValueArray converted = { ConvertToV8(isolate, args)... };
+    return CallEmit(isolate, name, sender, message, converted);
+  }

 private:
+  // Lower level implementations.
+  bool CallEmit(v8::Isolate* isolate,
+                const base::StringPiece& name,
+                content::WebContents* sender,
+                IPC::Message* message,
+                ValueArray args);
+
  DISALLOW_COPY_AND_ASSIGN(EventEmitter);
 };

--- a/atom/browser/api/lib/app.coffee
+++ b/atom/browser/api/lib/app.coffee
@@ -5,9 +5,6 @@ bindings = process.atomBinding 'app'
 app = bindings.app
 app.__proto__ = EventEmitter.prototype

-app.getHomeDir = ->
-  process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
-
 app.setApplicationMenu = (menu) ->
  require('menu').setApplicationMenu menu

@@ -26,11 +23,15 @@ if process.platform is 'darwin'
    getBadge: bindings.dockGetBadgeText
    hide: bindings.dockHide
    show: bindings.dockShow
+    setMenu: bindings.dockSetMenu

 # Be compatible with old API.
 app.once 'ready', -> app.emit 'finish-launching'
 app.terminate = app.quit
 app.exit = process.exit
+app.getHomeDir = -> app.getPath 'home'
+app.getDataPath = -> app.getPath 'userData'
+app.setDataPath = (path) -> app.setPath 'userData', path

 # Only one App object pemitted.
 module.exports = app
--- a/atom/browser/api/lib/browser-window.coffee
+++ b/atom/browser/api/lib/browser-window.coffee
@@ -17,6 +17,7 @@ BrowserWindow::_init = ->
    @setMenu menu if menu?

  @webContents = @getWebContents()
+  @devToolsWebContents = null
  @webContents.once 'destroyed', => @webContents = null

  # Remember the window ID.
@@ -30,6 +31,10 @@ BrowserWindow::_init = ->
    options = show: true, width: 800, height: 600
    ipc.emit 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', event, url, frameName, options

+  # Redirect "will-navigate" to webContents.
+  @on '-will-navigate', (event, url) =>
+    @webContents.emit 'will-navigate', event, url
+
  # Remove the window from weak map immediately when it's destroyed, since we
  # could be iterating windows before GC happened.
  @once 'closed', =>
@@ -90,8 +95,8 @@ BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
 # Be compatible with old API.
 BrowserWindow::restart = -> @webContents.reload()
 BrowserWindow::getUrl = -> @webContents.getUrl()
-BrowserWindow::reload = -> @webContents.reload()
-BrowserWindow::reloadIgnoringCache = -> @webContents.reloadIgnoringCache()
+BrowserWindow::reload = -> @webContents.reload.apply @webContents, arguments
+BrowserWindow::reloadIgnoringCache = -> @webContents.reloadIgnoringCache.apply @webContents, arguments
 BrowserWindow::getPageTitle = -> @webContents.getTitle()
 BrowserWindow::isLoading = -> @webContents.isLoading()
 BrowserWindow::isWaitingForResponse = -> @webContents.isWaitingForResponse()
--- a/atom/browser/api/lib/dialog.coffee
+++ b/atom/browser/api/lib/dialog.coffee
@@ -1,5 +1,6 @@
 binding = process.atomBinding 'dialog'
 v8Util = process.atomBinding 'v8_util'
+app = require 'app'
 BrowserWindow = require 'browser-window'

 fileDialogProperties =
@@ -22,8 +23,12 @@ parseArgs = (window, options, callback) ->
    options = null
  [window, options, callback]

+checkAppInitialized = ->
+  throw new Error('dialog module can only be used after app is ready') unless app.isReady()
+
 module.exports =
  showOpenDialog: (args...) ->
+    checkAppInitialized()
    [window, options, callback] = parseArgs args...

    options ?= title: 'Open', properties: ['openFile']
@@ -52,6 +57,7 @@ module.exports =
                           wrappedCallback

  showSaveDialog: (args...) ->
+    checkAppInitialized()
    [window, options, callback] = parseArgs args...

    options ?= title: 'Save'
@@ -72,26 +78,30 @@ module.exports =
                           wrappedCallback

  showMessageBox: (args...) ->
+    checkAppInitialized()
    [window, options, callback] = parseArgs args...

    options ?= type: 'none'
    options.type ?= 'none'
-    options.type = messageBoxTypes.indexOf options.type
-    throw new TypeError('Invalid message box type') unless options.type > -1
+    messageBoxType = messageBoxTypes.indexOf options.type
+    throw new TypeError('Invalid message box type') unless messageBoxType > -1

    throw new TypeError('Buttons need to be array') unless Array.isArray options.buttons

    options.title ?= ''
    options.message ?= ''
    options.detail ?= ''
+    options.icon ?= null

-    binding.showMessageBox options.type,
+    binding.showMessageBox messageBoxType,
                           options.buttons,
-                           String(options.title),
-                           String(options.message),
-                           String(options.detail),
+                           [options.title, options.message, options.detail],
+                           options.icon,
                           window,
                           callback

+  showErrorBox: (args...) ->
+    binding.showErrorBox args...
+
 # Mark standard asynchronous functions.
 v8Util.setHiddenValue f, 'asynchronous', true for k, f of module.exports
--- a/atom/browser/api/lib/menu-item.coffee
+++ b/atom/browser/api/lib/menu-item.coffee
@@ -9,13 +9,14 @@ class MenuItem
  constructor: (options) ->
    Menu = require 'menu'

-    {click, @selector, @type, @label, @sublabel, @accelerator, @enabled, @visible, @checked, @submenu} = options
+    {click, @selector, @type, @label, @sublabel, @accelerator, @icon, @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

    @overrideReadOnlyProperty 'type', 'normal'
    @overrideReadOnlyProperty 'accelerator'
+    @overrideReadOnlyProperty 'icon'
    @overrideReadOnlyProperty 'submenu'
    @overrideProperty 'label', ''
    @overrideProperty 'sublabel', ''
--- a/atom/browser/api/lib/menu.coffee
+++ b/atom/browser/api/lib/menu.coffee
@@ -35,6 +35,7 @@ Menu::_init = ->
    isCommandIdEnabled: (commandId) => @commandsMap[commandId]?.enabled
    isCommandIdVisible: (commandId) => @commandsMap[commandId]?.visible
    getAcceleratorForCommandId: (commandId) => @commandsMap[commandId]?.accelerator
+    getIconForCommandId: (commandId) => @commandsMap[commandId]?.icon
    executeCommand: (commandId) => @commandsMap[commandId]?.click()
    menuWillShow: =>
      # Make sure radio groups have at least one menu item seleted.
@@ -45,9 +46,12 @@ Menu::_init = ->
          break
        v8Util.setHiddenValue group[0], 'checked', true unless checked

-Menu::popup = (window) ->
+Menu::popup = (window, x, y) ->
  throw new TypeError('Invalid window') unless window?.constructor is BrowserWindow
-  @_popup window
+  if x? and y?
+    @_popupAt(window, x, y)
+  else
+    @_popup window

 Menu::append = (item) ->
  @insert @getItemCount(), item
@@ -79,6 +83,7 @@ Menu::insert = (pos, item) ->
      @insertRadioItem pos, item.commandId, item.label, item.groupId

  @setSublabel pos, item.sublabel if item.sublabel?
+  @setIcon pos, item.icon if item.icon?

  # Make menu accessable to items.
  item.overrideReadOnlyProperty 'menu', this
--- a/atom/browser/api/lib/screen.coffee
+++ b/atom/browser/api/lib/screen.coffee
@@ -0,0 +1,6 @@
+EventEmitter = require('events').EventEmitter
+
+screen = process.atomBinding('screen').screen
+screen.__proto__ = EventEmitter.prototype
+
+module.exports = screen
--- a/atom/browser/api/lib/web-contents.coffee
+++ b/atom/browser/api/lib/web-contents.coffee
@@ -9,8 +9,8 @@ module.exports.wrap = (webContents) ->
  webContents.__proto__ = EventEmitter.prototype

  # WebContents::send(channel, args..)
-  webContents.send = (args...) ->
-    @_send 'ATOM_INTERNAL_MESSAGE', [args...]
+  webContents.send = (channel, args...) ->
+    @_send channel, [args...]

  # Make sure webContents.executeJavaScript would run the code only when the
  # web contents has been loaded.
@@ -26,6 +26,11 @@ module.exports.wrap = (webContents) ->
  webContents.getId = -> "#{@getProcessId()}-#{@getRoutingId()}"
  webContents.equal = (other) -> @getId() is other.getId()

+  # Provide a default parameter for |urlOptions|.
+  webContents.loadUrl = (url, urlOptions={}) -> @_loadUrl url, urlOptions
+  webContents.reload = (urlOptions={}) -> @_reload urlOptions
+  webContents.reloadIgnoringCache = (urlOptions={}) -> @_reloadIgnoringCache urlOptions
+
  # Translate |disposition| to string for 'new-window' event.
  webContents.on '-new-window', (args..., disposition) ->
    disposition =
@@ -43,10 +48,12 @@ module.exports.wrap = (webContents) ->
    process.emit 'ATOM_BROWSER_RELEASE_RENDER_VIEW', "#{processId}-#{routingId}"

  # Dispatch IPC messages to the ipc module.
-  webContents.on 'ipc-message', (event, channel, args...) ->
+  webContents.on 'ipc-message', (event, packed) ->
+    [channel, args...] = packed
    Object.defineProperty event, 'sender', value: webContents
    ipc.emit channel, event, args...
-  webContents.on 'ipc-message-sync', (event, channel, args...) ->
+  webContents.on 'ipc-message-sync', (event, packed) ->
+    [channel, args...] = packed
    Object.defineProperty event, 'returnValue', set: (value) -> event.sendReply JSON.stringify(value)
    Object.defineProperty event, 'sender', value: webContents
    ipc.emit channel, event, args...
--- a/atom/browser/atom_access_token_store.h
+++ b/atom/browser/atom_access_token_store.h
@@ -17,10 +17,10 @@ class AtomAccessTokenStore : public content::AccessTokenStore {
  virtual ~AtomAccessTokenStore();

  // content::AccessTokenStore:
-  virtual void LoadAccessTokens(
-      const LoadAccessTokensCallbackType& callback) OVERRIDE;
-  virtual void SaveAccessToken(const GURL& server_url,
-                               const base::string16& access_token) OVERRIDE;
+  void LoadAccessTokens(
+      const LoadAccessTokensCallbackType& callback) override;
+  void SaveAccessToken(const GURL& server_url,
+                       const base::string16& access_token) override;

 private:
  DISALLOW_COPY_AND_ASSIGN(AtomAccessTokenStore);
--- a/atom/browser/atom_browser_client.cc
+++ b/atom/browser/atom_browser_client.cc
@@ -7,9 +7,10 @@
 #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/web_view/web_view_renderer_state.h"
+#include "atom/browser/web_view_manager.h"
 #include "atom/browser/window_list.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
@@ -18,6 +19,7 @@
 #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 "content/public/common/web_preferences.h"
@@ -56,12 +58,12 @@ AtomBrowserClient::~AtomBrowserClient() {
 void AtomBrowserClient::RenderProcessWillLaunch(
    content::RenderProcessHost* host) {
  int id = host->GetID();
-  host->AddFilter(new PrintingMessageFilter(host->GetID()));
+  host->AddFilter(new printing::PrintingMessageFilter(host->GetID()));
  host->AddFilter(new TtsMessageFilter(id, host->GetBrowserContext()));
 }

 content::SpeechRecognitionManagerDelegate*
-    AtomBrowserClient::GetSpeechRecognitionManagerDelegate() {
+    AtomBrowserClient::CreateSpeechRecognitionManagerDelegate() {
  return new AtomSpeechRecognitionManagerDelegate;
 }

@@ -69,6 +71,12 @@ content::AccessTokenStore* AtomBrowserClient::CreateAccessTokenStore() {
  return new AtomAccessTokenStore;
 }

+void AtomBrowserClient::ResourceDispatcherHostCreated() {
+  resource_dispatcher_delegate_.reset(new AtomResourceDispatcherHostDelegate);
+  content::ResourceDispatcherHost::Get()->SetDelegate(
+      resource_dispatcher_delegate_.get());
+}
+
 void AtomBrowserClient::OverrideWebkitPrefs(
    content::RenderViewHost* render_view_host,
    const GURL& url,
@@ -87,8 +95,8 @@ void AtomBrowserClient::OverrideWebkitPrefs(
  prefs->allow_universal_access_from_file_urls = true;
  prefs->allow_file_access_from_file_urls = true;
  prefs->experimental_webgl_enabled = true;
-  prefs->allow_displaying_insecure_content = true;
-  prefs->allow_running_insecure_content = true;
+  prefs->allow_displaying_insecure_content = false;
+  prefs->allow_running_insecure_content = false;

  // Turn off web security for devtools.
  if (url.SchemeIs("chrome-devtools")) {
@@ -96,9 +104,16 @@ void AtomBrowserClient::OverrideWebkitPrefs(
    return;
  }

+  // Custom preferences of guest page.
+  auto process = render_view_host->GetProcess();
+  WebViewManager::WebViewInfo info;
+  if (WebViewManager::GetInfoForProcess(process, &info)) {
+    prefs->web_security_enabled = !info.disable_web_security;
+    return;
+  }
+
  NativeWindow* window = NativeWindow::FromRenderView(
-      render_view_host->GetProcess()->GetID(),
-      render_view_host->GetRoutingID());
+      process->GetID(), render_view_host->GetRoutingID());
  if (window)
    window->OverrideWebkitPrefs(url, prefs);
 }
@@ -146,14 +161,21 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches(
    window->AppendExtraCommandLineSwitches(command_line, child_process_id);
  } else {
    // Append commnad line arguments for guest web view.
-    WebViewRendererState::WebViewInfo info;
-    if (WebViewRendererState::GetInstance()->GetInfo(child_process_id, &info)) {
+    auto child_process = content::RenderProcessHost::FromID(child_process_id);
+    WebViewManager::WebViewInfo info;
+    if (WebViewManager::GetInfoForProcess(child_process, &info)) {
      command_line->AppendSwitchASCII(
          switches::kGuestInstanceID,
          base::IntToString(info.guest_instance_id));
      command_line->AppendSwitchASCII(
          switches::kNodeIntegration,
          info.node_integration ? "true" : "false");
+      if (info.plugins)
+        command_line->AppendSwitch(switches::kEnablePlugins);
+      if (!info.preload_script.empty())
+        command_line->AppendSwitchPath(
+            switches::kPreloadScript,
+            info.preload_script);
    }
  }

--- a/atom/browser/atom_browser_client.h
+++ b/atom/browser/atom_browser_client.h
@@ -11,6 +11,8 @@

 namespace atom {

+class AtomResourceDispatcherHostDelegate;
+
 class AtomBrowserClient : public brightray::BrowserClient {
 public:
  AtomBrowserClient();
@@ -20,8 +22,9 @@ class AtomBrowserClient : public brightray::BrowserClient {
  // content::ContentBrowserClient:
  void RenderProcessWillLaunch(content::RenderProcessHost* host) override;
  content::SpeechRecognitionManagerDelegate*
-      GetSpeechRecognitionManagerDelegate() override;
+      CreateSpeechRecognitionManagerDelegate() override;
  content::AccessTokenStore* CreateAccessTokenStore() override;
+  void ResourceDispatcherHostCreated() override;
  void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
                           const GURL& url,
                           content::WebPreferences* prefs) override;
@@ -37,6 +40,8 @@ class AtomBrowserClient : public brightray::BrowserClient {
  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_;

--- a/atom/browser/atom_browser_context.cc
+++ b/atom/browser/atom_browser_context.cc
@@ -7,14 +7,15 @@
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/net/atom_url_request_job_factory.h"
 #include "atom/browser/net/asar/asar_protocol_handler.h"
-#include "atom/browser/web_view/web_view_manager.h"
+#include "atom/browser/web_view_manager.h"
+#include "atom/common/options_switches.h"
+#include "base/command_line.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/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"

@@ -24,7 +25,13 @@ namespace atom {

 namespace {

-const char* kAsarScheme = "asar";
+class NoCacheBackend : public net::HttpCache::BackendFactory {
+  int CreateBackend(net::NetLog* net_log,
+                    scoped_ptr<disk_cache::Backend>* backend,
+                    const net::CompletionCallback& callback) override {
+    return net::ERR_FAILED;
+  }
+};

 }  // namespace

@@ -49,17 +56,12 @@ net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
  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(
+      url::kFileScheme, 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>();
+  scoped_ptr<net::URLRequestJobFactory> top_job_factory = job_factory.Pass();
  content::URLRequestInterceptorScopedVector::reverse_iterator it;
  for (it = interceptors->rbegin(); it != interceptors->rend(); ++it)
    top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
@@ -69,6 +71,16 @@ net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
  return top_job_factory.release();
 }

+net::HttpCache::BackendFactory*
+AtomBrowserContext::CreateHttpCacheBackendFactory(
+    const base::FilePath& base_path) {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kDisableHttpCache))
+    return new NoCacheBackend;
+  else
+    return brightray::BrowserContext::CreateHttpCacheBackendFactory(base_path);
+}
+
 content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
  if (!guest_manager_)
    guest_manager_.reset(new WebViewManager(this));
--- a/atom/browser/atom_browser_context.h
+++ b/atom/browser/atom_browser_context.h
@@ -23,12 +23,14 @@ class AtomBrowserContext : public brightray::BrowserContext {
  static AtomBrowserContext* Get();

  // brightray::URLRequestContextGetter::Delegate:
-  virtual net::URLRequestJobFactory* CreateURLRequestJobFactory(
+  net::URLRequestJobFactory* CreateURLRequestJobFactory(
      content::ProtocolHandlerMap* handlers,
      content::URLRequestInterceptorScopedVector* interceptors) override;
+  net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
+      const base::FilePath& base_path) override;

  // content::BrowserContext:
-  virtual content::BrowserPluginGuestManager* GetGuestManager() override;
+  content::BrowserPluginGuestManager* GetGuestManager() override;

  AtomURLRequestJobFactory* job_factory() const { return job_factory_; }

--- a/atom/browser/atom_browser_main_parts.cc
+++ b/atom/browser/atom_browser_main_parts.cc
@@ -72,6 +72,9 @@ void AtomBrowserMainParts::PostEarlyInitialization() {

  // Add atom-shell extended APIs.
  atom_bindings_->BindTo(js_env_->isolate(), global_env->process_object());
+
+  // Load everything.
+  node_bindings_->LoadEnvironment(global_env);
 }

 void AtomBrowserMainParts::PreMainMessageLoopRun() {
@@ -90,7 +93,7 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
  brightray::BrowserMainParts::PreMainMessageLoopRun();

 #if defined(USE_X11)
-  libgtk2ui::GtkInitFromCommandLine(*CommandLine::ForCurrentProcess());
+  libgtk2ui::GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
 #endif

 #if !defined(OS_MACOSX)
--- a/atom/browser/atom_browser_main_parts.h
+++ b/atom/browser/atom_browser_main_parts.h
@@ -27,14 +27,14 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {

 protected:
  // Implementations of brightray::BrowserMainParts.
-  virtual brightray::BrowserContext* CreateBrowserContext() OVERRIDE;
+  brightray::BrowserContext* CreateBrowserContext() override;

  // Implementations of content::BrowserMainParts.
-  virtual void PostEarlyInitialization() OVERRIDE;
-  virtual void PreMainMessageLoopRun() OVERRIDE;
+  void PostEarlyInitialization() override;
+  void PreMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
-  virtual void PreMainMessageLoopStart() OVERRIDE;
-  virtual void PostDestroyThreads() OVERRIDE;
+  void PreMainMessageLoopStart() override;
+  void PostDestroyThreads() override;
 #endif

 private:
--- a/atom/browser/atom_browser_main_parts_mac.mm
+++ b/atom/browser/atom_browser_main_parts_mac.mm
@@ -20,13 +20,13 @@ void AtomBrowserMainParts::PreMainMessageLoopStart() {
  // Force the NSApplication subclass to be used.
  NSApplication* application = [AtomApplication sharedApplication];

-  AtomApplicationDelegate* delegate = [AtomApplicationDelegate alloc];
+  AtomApplicationDelegate* delegate = [[AtomApplicationDelegate alloc] init];
  [NSApp setDelegate:(id<NSFileManagerDelegate>)delegate];

  base::FilePath frameworkPath = brightray::MainApplicationBundlePath()
      .Append("Contents")
      .Append("Frameworks")
-      .Append("Atom Framework.framework");
+      .Append(PRODUCT_NAME " Framework.framework");
  NSBundle* frameworkBundle = [NSBundle
       bundleWithPath:base::mac::FilePathToNSString(frameworkPath)];
  NSNib* mainNib = [[NSNib alloc] initWithNibNamed:@"MainMenu"
@@ -41,7 +41,8 @@ void AtomBrowserMainParts::PreMainMessageLoopStart() {
 }

 void AtomBrowserMainParts::PostDestroyThreads() {
-  [[AtomApplication sharedApplication] setDelegate:nil];
+  [[NSApp delegate] release];
+  [NSApp setDelegate:nil];
 }

 }  // namespace atom
--- a/atom/browser/atom_javascript_dialog_manager.h
+++ b/atom/browser/atom_javascript_dialog_manager.h
@@ -14,7 +14,7 @@ namespace atom {
 class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
 public:
  // content::JavaScriptDialogManager implementations.
-  virtual void RunJavaScriptDialog(
+  void RunJavaScriptDialog(
      content::WebContents* web_contents,
      const GURL& origin_url,
      const std::string& accept_lang,
@@ -22,16 +22,15 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
      const base::string16& message_text,
      const base::string16& default_prompt_text,
      const DialogClosedCallback& callback,
-      bool* did_suppress_message) OVERRIDE;
-  virtual void RunBeforeUnloadDialog(
+      bool* did_suppress_message) override;
+  void RunBeforeUnloadDialog(
      content::WebContents* web_contents,
      const base::string16& message_text,
      bool is_reload,
-      const DialogClosedCallback& callback) OVERRIDE;
-  virtual void CancelActiveAndPendingDialogs(
-      content::WebContents* web_contents) OVERRIDE {}
-  virtual void WebContentsDestroyed(
-      content::WebContents* web_contents) OVERRIDE {}
+      const DialogClosedCallback& callback) override;
+  void CancelActiveAndPendingDialogs(
+      content::WebContents* web_contents) override {}
+  void WebContentsDestroyed(content::WebContents* web_contents) override {}
 };

 }  // namespace atom
--- a/atom/browser/atom_resource_dispatcher_host_delegate.cc
+++ b/atom/browser/atom_resource_dispatcher_host_delegate.cc
@@ -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.
+
+#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 {
+
+AtomResourceDispatcherHostDelegate::AtomResourceDispatcherHostDelegate() {
+}
+
+void AtomResourceDispatcherHostDelegate::OnResponseStarted(
+    net::URLRequest* request,
+    content::ResourceContext* resource_context,
+    content::ResourceResponse* response,
+    IPC::Sender* sender) {
+  // Remove the "X-Frame-Options" from response headers for devtools.
+  if (request->url().SchemeIs("chrome-devtools")) {
+    net::HttpResponseHeaders* response_headers = request->response_headers();
+    if (response_headers && response_headers->HasHeader("x-frame-options"))
+      response_headers->RemoveHeader("x-frame-options");
+  }
+}
+
+}  // namespace atom
--- a/atom/browser/atom_resource_dispatcher_host_delegate.h
+++ b/atom/browser/atom_resource_dispatcher_host_delegate.h
@@ -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.
+
+#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();
+
+  // content::ResourceDispatcherHostDelegate:
+  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_
--- a/atom/browser/atom_speech_recognition_manager_delegate.h
+++ b/atom/browser/atom_speech_recognition_manager_delegate.h
@@ -20,28 +20,28 @@ class 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(
+  void OnRecognitionStart(int session_id) override;
+  void OnAudioStart(int session_id) override;
+  void OnEnvironmentEstimationComplete(int session_id) override;
+  void OnSoundStart(int session_id) override;
+  void OnSoundEnd(int session_id) override;
+  void OnAudioEnd(int session_id) override;
+  void OnRecognitionEnd(int session_id) override;
+  void OnRecognitionResults(
      int session_id, const content::SpeechRecognitionResults& result) override;
-  virtual void OnRecognitionError(
+  void OnRecognitionError(
      int session_id, const content::SpeechRecognitionError& error) override;
-  virtual void OnAudioLevelsChange(int session_id, float volume,
-                                   float noise_volume) override;
+  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(
+  void GetDiagnosticInformation(bool* can_report_metrics,
+                                std::string* hardware_info) override;
+  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;
+  content::SpeechRecognitionEventListener* GetEventListener() override;
+  bool FilterProfanities(int render_process_id) override;

 private:
  DISALLOW_COPY_AND_ASSIGN(AtomSpeechRecognitionManagerDelegate);
--- a/atom/browser/browser.cc
+++ b/atom/browser/browser.cc
@@ -28,7 +28,9 @@ Browser* Browser::Get() {
 }

 void Browser::Quit() {
-  is_quiting_ = true;
+  is_quiting_ = HandleBeforeQuit();
+  if (!is_quiting_)
+    return;

  atom::WindowList* window_list = atom::WindowList::GetInstance();
  if (window_list->size() == 0)
@@ -70,6 +72,10 @@ std::string Browser::GetName() const {

 void Browser::SetName(const std::string& name) {
  name_override_ = name;
+
+#if defined(OS_WIN)
+  SetAppUserModelID(name);
+#endif
 }

 bool Browser::OpenFile(const std::string& file_path) {
@@ -110,6 +116,15 @@ void Browser::NotifyAndShutdown() {
  Shutdown();
 }

+bool Browser::HandleBeforeQuit() {
+  bool prevent_default = false;
+  FOR_EACH_OBSERVER(BrowserObserver,
+                    observers_,
+                    OnBeforeQuit(&prevent_default));
+
+  return !prevent_default;
+}
+
 void Browser::OnWindowCloseCancelled(NativeWindow* window) {
  if (is_quiting_)
    // Once a beforeunload handler has prevented the closing, we think the quit
--- a/atom/browser/browser.h
+++ b/atom/browser/browser.h
@@ -6,6 +6,7 @@
 #define ATOM_BROWSER_BROWSER_H_

 #include <string>
+#include <vector>

 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ -13,6 +14,19 @@
 #include "atom/browser/browser_observer.h"
 #include "atom/browser/window_list_observer.h"

+#if defined(OS_WIN)
+#include "base/files/file_path.h"
+#include "base/strings/string16.h"
+#endif
+
+namespace base {
+class FilePath;
+}
+
+namespace ui {
+class MenuModel;
+}
+
 namespace atom {

 // This class is used for control application-wide operations.
@@ -44,6 +58,12 @@ class Browser : public WindowListObserver {
  // Overrides the application name.
  void SetName(const std::string& name);

+  // Add the |path| to recent documents list.
+  void AddRecentDocument(const base::FilePath& path);
+
+  // Clear the recent documents list.
+  void ClearRecentDocuments();
+
 #if defined(OS_MACOSX)
  // Bounce the dock icon.
  enum BounceType {
@@ -60,8 +80,28 @@ class Browser : public WindowListObserver {
  // Hide/Show dock.
  void DockHide();
  void DockShow();
+
+  // Set docks' menu.
+  void DockSetMenu(ui::MenuModel* model);
 #endif  // defined(OS_MACOSX)

+#if defined(OS_WIN)
+  struct UserTask {
+    base::FilePath program;
+    base::string16 arguments;
+    base::string16 title;
+    base::string16 description;
+    base::FilePath icon_path;
+    int icon_index;
+  };
+
+  // Add a custom task to jump list.
+  void SetUserTasks(const std::vector<UserTask>& tasks);
+
+  // Set the application user model ID, called when "SetName" is called.
+  void SetAppUserModelID(const std::string& name);
+#endif
+
  // Tell the application to open a file.
  bool OpenFile(const std::string& file_path);

@@ -96,12 +136,15 @@ class Browser : public WindowListObserver {
  // Send the will-quit message and then shutdown the application.
  void NotifyAndShutdown();

+  // Send the before-quit message and start closing windows.
+  bool HandleBeforeQuit();
+
  bool is_quiting_;

 private:
  // WindowListObserver implementations:
-  virtual void OnWindowCloseCancelled(NativeWindow* window) OVERRIDE;
-  virtual void OnWindowAllClosed() OVERRIDE;
+  void OnWindowCloseCancelled(NativeWindow* window) override;
+  void OnWindowAllClosed() override;

  // Observers of the browser.
  ObserverList<BrowserObserver> observers_;
@@ -112,6 +155,10 @@ class Browser : public WindowListObserver {
  std::string version_override_;
  std::string name_override_;

+#if defined(OS_WIN)
+  base::string16 app_user_model_id_;
+#endif
+
  DISALLOW_COPY_AND_ASSIGN(Browser);
 };

--- a/atom/browser/browser_linux.cc
+++ b/atom/browser/browser_linux.cc
@@ -24,6 +24,12 @@ void Browser::Focus() {
  }
 }

+void Browser::AddRecentDocument(const base::FilePath& path) {
+}
+
+void Browser::ClearRecentDocuments() {
+}
+
 std::string Browser::GetExecutableFileVersion() const {
  return ATOM_VERSION_STRING;
 }
--- a/atom/browser/browser_mac.mm
+++ b/atom/browser/browser_mac.mm
@@ -5,9 +5,11 @@
 #include "atom/browser/browser.h"

 #import "atom/browser/mac/atom_application.h"
+#import "atom/browser/mac/atom_application_delegate.h"
 #include "atom/browser/native_window.h"
 #include "atom/browser/window_list.h"
 #import "base/mac/bundle_locations.h"
+#import "base/mac/foundation_util.h"
 #include "base/strings/sys_string_conversions.h"

 namespace atom {
@@ -16,6 +18,14 @@ void Browser::Focus() {
  [[AtomApplication sharedApplication] activateIgnoringOtherApps:YES];
 }

+void Browser::AddRecentDocument(const base::FilePath& path) {
+  NSURL* u = [NSURL fileURLWithPath:base::mac::FilePathToNSString(path)];
+  [[NSDocumentController sharedDocumentController] noteNewRecentDocumentURL:u];
+}
+
+void Browser::ClearRecentDocuments() {
+}
+
 std::string Browser::GetExecutableFileVersion() const {
  NSDictionary* infoDictionary = base::mac::OuterBundle().infoDictionary;
  NSString *version = [infoDictionary objectForKey:@"CFBundleVersion"];
@@ -60,4 +70,9 @@ void Browser::DockShow() {
  TransformProcessType(&psn, kProcessTransformToForegroundApplication);
 }

+void Browser::DockSetMenu(ui::MenuModel* model) {
+  AtomApplicationDelegate* delegate = (AtomApplicationDelegate*)[NSApp delegate];
+  [delegate setApplicationDockMenu:model];
+}
+
 }  // namespace atom
--- a/atom/browser/browser_observer.h
+++ b/atom/browser/browser_observer.h
@@ -11,6 +11,9 @@ namespace atom {

 class BrowserObserver {
 public:
+  // The browser is about to close all windows.
+  virtual void OnBeforeQuit(bool* prevent_default) {}
+
  // The browser has closed all windows and will quit.
  virtual void OnWillQuit(bool* prevent_default) {}

--- a/atom/browser/browser_win.cc
+++ b/atom/browser/browser_win.cc
@@ -4,14 +4,21 @@

 #include "atom/browser/browser.h"

+#include <atlbase.h>
+#include <propkey.h>
 #include <windows.h>
+#include <shlobj.h>
+#include <shobjidl.h>

 #include "base/base_paths.h"
 #include "base/file_version_info.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/win/win_util.h"
+#include "base/win/windows_version.h"
 #include "atom/common/atom_version.h"

 namespace atom {
@@ -39,6 +46,83 @@ void Browser::Focus() {
  EnumWindows(&WindowsEnumerationHandler, reinterpret_cast<LPARAM>(&pid));
 }

+void Browser::AddRecentDocument(const base::FilePath& path) {
+  if (base::win::GetVersion() < base::win::VERSION_WIN7)
+    return;
+
+  CComPtr<IShellItem> item;
+  HRESULT hr = SHCreateItemFromParsingName(
+      path.value().c_str(), NULL, IID_PPV_ARGS(&item));
+  if (SUCCEEDED(hr)) {
+    SHARDAPPIDINFO info;
+    info.psi = item;
+    info.pszAppID = app_user_model_id_.c_str();
+    SHAddToRecentDocs(SHARD_APPIDINFO, &info);
+  }
+}
+
+void Browser::ClearRecentDocuments() {
+  CComPtr<IApplicationDestinations> destinations;
+  if (FAILED(destinations.CoCreateInstance(CLSID_ApplicationDestinations,
+                                           NULL, CLSCTX_INPROC_SERVER)))
+    return;
+  if (FAILED(destinations->SetAppID(app_user_model_id_.c_str())))
+    return;
+  destinations->RemoveAllDestinations();
+}
+
+void Browser::SetUserTasks(const std::vector<UserTask>& tasks) {
+  CComPtr<ICustomDestinationList> destinations;
+  if (FAILED(destinations.CoCreateInstance(CLSID_DestinationList)))
+    return;
+  if (FAILED(destinations->SetAppID(app_user_model_id_.c_str())))
+    return;
+
+  // Start a transaction that updates the JumpList of this application.
+  UINT max_slots;
+  CComPtr<IObjectArray> removed;
+  if (FAILED(destinations->BeginList(&max_slots, IID_PPV_ARGS(&removed))))
+    return;
+
+  CComPtr<IObjectCollection> collection;
+  if (FAILED(collection.CoCreateInstance(CLSID_EnumerableObjectCollection)))
+    return;
+
+  for (auto& task : tasks) {
+    CComPtr<IShellLink> link;
+    if (FAILED(link.CoCreateInstance(CLSID_ShellLink)) ||
+        FAILED(link->SetPath(task.program.value().c_str())) ||
+        FAILED(link->SetArguments(task.arguments.c_str())) ||
+        FAILED(link->SetDescription(task.description.c_str())))
+      return;
+
+    if (!task.icon_path.empty() &&
+        FAILED(link->SetIconLocation(task.icon_path.value().c_str(),
+                                     task.icon_index)))
+      return;
+
+    CComQIPtr<IPropertyStore> property_store = link;
+    if (!base::win::SetStringValueForPropertyStore(property_store, PKEY_Title,
+                                                   task.title.c_str()))
+      return;
+
+    if (FAILED(collection->AddObject(link)))
+      return;
+  }
+
+  // When the list is empty "AddUserTasks" could fail, so we don't check return
+  // value for it.
+  CComQIPtr<IObjectArray> task_array = collection;
+  destinations->AddUserTasks(task_array);
+  destinations->CommitList();
+}
+
+void Browser::SetAppUserModelID(const std::string& name) {
+  app_user_model_id_ = base::string16(L"atom-shell.app.");
+  app_user_model_id_ += base::UTF8ToUTF16(name);
+  SetCurrentProcessExplicitAppUserModelID(app_user_model_id_.c_str());
+}
+
 std::string Browser::GetExecutableFileVersion() const {
  base::FilePath path;
  if (PathService::Get(base::FILE_EXE, &path)) {
--- a/atom/browser/default_app/main.js
+++ b/atom/browser/default_app/main.js
@@ -41,6 +41,8 @@ if (option.file && !option.webdriver) {
        app.setName(packageJson.productName);
      else if (packageJson.name)
        app.setName(packageJson.name);
+      app.setPath('userData', path.join(app.getPath('appData'), app.getName()));
+      app.setPath('userCache', path.join(app.getPath('cache'), app.getName()));
    }

    // Run the app.
@@ -48,17 +50,10 @@ if (option.file && !option.webdriver) {
  } catch(e) {
    if (e.code == 'MODULE_NOT_FOUND') {
      app.focus();
-      console.error(e.stack);
-      dialog.showMessageBox({
-        type: 'warning',
-        buttons: ['OK'],
-        title: 'Error opening app',
-        message: 'The app provided is not a valid atom-shell app, please read the docs on how to write one:',
-        detail: 'https://github.com/atom/atom-shell/tree/master/docs'
-      });
+      dialog.showErrorBox('Error opening app', 'The app provided is not a valid atom-shell app, please read the docs on how to write one:\nhttps://github.com/atom/atom-shell/tree/master/docs');
      process.exit(1);
    } else {
-      console.error('App throwed an error when running', e);
+      console.error('App threw an error when running', e);
      throw e;
    }
  }
--- a/atom/browser/javascript_environment.cc
+++ b/atom/browser/javascript_environment.cc
@@ -7,8 +7,7 @@
 namespace atom {

 JavascriptEnvironment::JavascriptEnvironment()
-    : isolate_holder_(gin::IsolateHolder::kNonStrictMode),
-      isolate_(isolate_holder_.isolate()),
+    : isolate_(isolate_holder_.isolate()),
      isolate_scope_(isolate_),
      locker_(isolate_),
      handle_scope_(isolate_),
--- a/atom/browser/lib/chrome-extension.coffee
+++ b/atom/browser/lib/chrome-extension.coffee
@@ -32,17 +32,11 @@ getExtensionInfoFromPath = (srcDirectory) ->
      startPage: page
      name: manifest.name
      srcDirectory: srcDirectory
-  extensionInfoMap[manifest.name]
+    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
+# The loaded extensions cache and its persistent path.
+loadedExtensions = null
+loadedExtensionsPath = null

 # Persistent loaded extensions.
 app.on 'will-quit', ->
@@ -59,6 +53,16 @@ app.once 'ready', ->
  protocol = require 'protocol'
  BrowserWindow = require 'browser-window'

+  # 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
+
  # The chrome-extension: can map a extension URL request to real file path.
  protocol.registerProtocol 'chrome-extension', (request) ->
    parsed = url.parse request.url
@@ -70,12 +74,13 @@ app.once 'ready', ->
    return new protocol.RequestFileJob(path.join(directory, parsed.path))

  BrowserWindow::_loadDevToolsExtensions = (extensionInfoArray) ->
-    @devToolsWebContents?.executeJavaScript "WebInspector.addExtensions(#{JSON.stringify(extensionInfoArray)});"
+    @devToolsWebContents?.executeJavaScript "DevToolsAPI.addExtensions(#{JSON.stringify(extensionInfoArray)});"

  BrowserWindow.addDevToolsExtension = (srcDirectory) ->
    extensionInfo = getExtensionInfoFromPath srcDirectory
-    window._loadDevToolsExtensions [extensionInfo] for window in BrowserWindow.getAllWindows()
-    extensionInfo.name
+    if extensionInfo
+      window._loadDevToolsExtensions [extensionInfo] for window in BrowserWindow.getAllWindows()
+      extensionInfo.name

  BrowserWindow.removeDevToolsExtension = (name) ->
    delete extensionInfoMap[name]
--- a/atom/browser/lib/guest-view-manager.coffee
+++ b/atom/browser/lib/guest-view-manager.coffee
@@ -18,6 +18,8 @@ supportedWebViewEvents = [

 nextInstanceId = 0
 guestInstances = {}
+embedderElementsMap = {}
+reverseEmbedderElementsMap = {}

 # Generate guestInstanceId.
 getNextInstanceId = (webContents) ->
@@ -33,20 +35,29 @@ createGuest = (embedder, params) ->
    guestInstanceId: id
    storagePartitionId: params.storagePartitionId
  guestInstances[id] = {guest, embedder}
-  webViewManager.addGuest id, embedder, guest, params.nodeIntegration

-  # Destroy guest when the embedder is gone.
-  embedder.once 'render-view-deleted', ->
-    destroyGuest id if guestInstances[id]?
+  # Destroy guest when the embedder is gone or navigated.
+  destroyEvents = ['destroyed', 'crashed', 'did-navigate-to-different-page']
+  destroy = ->
+    destroyGuest embedder, id if guestInstances[id]?
+  embedder.once event, destroy for event in destroyEvents
+  guest.once 'destroyed', ->
+    embedder.removeListener event, destroy for event in destroyEvents

  # Init guest web view after attached.
-  guest.once 'did-attach', (event, params) ->
+  guest.once 'did-attach', ->
+    params = @attachParams
+    delete @attachParams
+
    @viewInstanceId = params.instanceId
    min = width: params.minwidth, height: params.minheight
    max = width: params.maxwidth, height: params.maxheight
    @setAutoSize params.autosize, min, max
    if params.src
-      @loadUrl params.src
+      if params.httpreferrer
+        @loadUrl params.src, {httpreferrer: params.httpreferrer}
+      else
+        @loadUrl params.src
    if params.allowtransparency?
      @setAllowTransparency params.allowtransparency

@@ -56,23 +67,60 @@ createGuest = (embedder, params) ->
      guest.on event, (_, args...) ->
        embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-#{guest.viewInstanceId}", event, args...

+  # Dispatch guest's IPC messages to embedder.
+  guest.on 'ipc-message-host', (_, packed) ->
+    [channel, args...] = packed
+    embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_IPC_MESSAGE-#{guest.viewInstanceId}", channel, args...
+
  # Autosize.
  guest.on 'size-changed', (_, args...) ->
-    embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_SIZE_CHANGED", args...
+    embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_SIZE_CHANGED-#{guest.viewInstanceId}", args...

  id

+# Attach the guest to an element of embedder.
+attachGuest = (embedder, elementInstanceId, guestInstanceId, params) ->
+  guest = guestInstances[guestInstanceId].guest
+
+  # Destroy the old guest when attaching.
+  key = "#{embedder.getId()}-#{elementInstanceId}"
+  oldGuestInstanceId = embedderElementsMap[key]
+  if oldGuestInstanceId?
+    # Reattachment to the same guest is not currently supported.
+    return unless oldGuestInstanceId != guestInstanceId
+
+    return unless guestInstances[oldGuestInstanceId]?
+    destroyGuest embedder, oldGuestInstanceId
+
+  webViewManager.addGuest guestInstanceId, elementInstanceId, embedder, guest,
+    nodeIntegration: params.nodeintegration
+    plugins: params.plugins
+    disableWebSecurity: params.disablewebsecurity
+    preloadUrl: params.preload ? ''
+
+  guest.attachParams = params
+  embedderElementsMap[key] = guestInstanceId
+  reverseEmbedderElementsMap[guestInstanceId] = key
+
 # Destroy an existing guest instance.
-destroyGuest = (id) ->
-  webViewManager.removeGuest id
+destroyGuest = (embedder, id) ->
+  webViewManager.removeGuest embedder, id
  guestInstances[id].guest.destroy()
  delete guestInstances[id]

+  key = reverseEmbedderElementsMap[id]
+  if key?
+    delete reverseEmbedderElementsMap[id]
+    delete embedderElementsMap[key]
+
 ipc.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_CREATE_GUEST', (event, type, params, requestId) ->
  event.sender.send "ATOM_SHELL_RESPONSE_#{requestId}", createGuest(event.sender, params)

+ipc.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_ATTACH_GUEST', (event, elementInstanceId, guestInstanceId, params) ->
+  attachGuest event.sender, elementInstanceId, guestInstanceId, params
+
 ipc.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_DESTROY_GUEST', (event, id) ->
-  destroyGuest id
+  destroyGuest event.sender, id

 ipc.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_SET_AUTO_SIZE', (event, id, params) ->
  guestInstances[id]?.guest.setAutoSize params.enableAutoSize, params.min, params.max
--- a/atom/browser/lib/guest-window-manager.coffee
+++ b/atom/browser/lib/guest-window-manager.coffee
@@ -1,4 +1,5 @@
 ipc = require 'ipc'
+v8Util = process.atomBinding 'v8_util'
 BrowserWindow = require 'browser-window'

 frameToGuest = {}
@@ -13,13 +14,18 @@ createGuest = (embedder, url, frameName, options) ->
  guest = new BrowserWindow(options)
  guest.loadUrl url

+  # Remember the embedder, will be used by window.opener methods.
+  v8Util.setHiddenValue guest.webContents, 'embedder', embedder
+
  # When |embedder| is destroyed we should also destroy attached guest, and if
  # guest is closed by user then we should prevent |embedder| from double
  # closing guest.
  closedByEmbedder = ->
+    embedder.send 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSED', guest.id
    guest.removeListener 'closed', closedByUser
    guest.destroy() unless guest.isClosed()
  closedByUser = ->
+    embedder.send 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSED', guest.id
    embedder.removeListener 'render-view-deleted', closedByEmbedder
  embedder.once 'render-view-deleted', closedByEmbedder
  guest.once 'closed', closedByUser
@@ -49,6 +55,17 @@ ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', (event, guestId, method,
  return unless BrowserWindow.windows.has guestId
  BrowserWindow.windows.get(guestId)[method] args...

+ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', (event, guestId, message, targetOrigin) ->
+  return unless BrowserWindow.windows.has guestId
+  guestContents = BrowserWindow.windows.get(guestId).webContents
+  if guestContents.getUrl().indexOf(targetOrigin) is 0 or targetOrigin is '*'
+    guestContents.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', message, targetOrigin
+
+ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPENER_POSTMESSAGE', (event, message, targetOrigin) ->
+  embedder = v8Util.getHiddenValue event.sender, 'embedder'
+  if embedder?.getUrl().indexOf(targetOrigin) is 0 or targetOrigin is '*'
+    embedder.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', message, targetOrigin
+
 ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', (event, guestId, method, args...) ->
  return unless BrowserWindow.windows.has guestId
  BrowserWindow.windows.get(guestId).webContents?[method] args...
--- a/atom/browser/lib/init.coffee
+++ b/atom/browser/lib/init.coffee
@@ -3,10 +3,6 @@ path   = require 'path'
 module = require 'module'
 util   = require 'util'

-# Expose information of current process.
-process.type = 'browser'
-process.resourcesPath = path.resolve process.argv[1], '..', '..', '..', '..'
-
 # We modified the original process.argv to let node.js load the atom.js,
 # we need to restore it here.
 process.argv.splice 1, 1
@@ -21,81 +17,83 @@ 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 = module.globalPaths
-globalPaths.push path.join process.resourcesPath, 'atom', 'browser', 'api', 'lib'
+globalPaths.push path.resolve(__dirname, '..', 'api', 'lib')

-# Following operations need extra bindings by AtomBindings.
-process.once 'BIND_DONE', ->
-  # Import common settings.
-  require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init.js')
+# Import common settings.
+require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init')

-  if process.platform is 'win32'
-    # Redirect node's console to use our own implementations, since node can not
-    # handle console output when running as GUI program.
-    print = (args...) ->
-      process.log util.format(args...)
-    console.log = console.error = console.warn = print
-    process.stdout.write = process.stderr.write = print
+if process.platform is 'win32'
+  # Redirect node's console to use our own implementations, since node can not
+  # handle console output when running as GUI program.
+  print = (args...) ->
+    process.log util.format(args...)
+  console.log = console.error = console.warn = print
+  process.stdout.write = process.stderr.write = print

-    # Always returns EOF for stdin stream.
-    Readable = require('stream').Readable
-    stdin = new Readable
-    stdin.push null
-    process.__defineGetter__ 'stdin', -> stdin
+  # Always returns EOF for stdin stream.
+  Readable = require('stream').Readable
+  stdin = new Readable
+  stdin.push null
+  process.__defineGetter__ 'stdin', -> stdin

-  # Don't quit on fatal error.
-  process.on 'uncaughtException', (error) ->
-    # Show error in GUI.
-    message = error.stack ? "#{error.name}: #{error.message}"
-    require('dialog').showMessageBox
-      type: 'warning'
-      title: 'A javascript error occured in the browser'
-      message: 'uncaughtException'
-      detail: message
-      buttons: ['OK']
+# Don't quit on fatal error.
+process.on 'uncaughtException', (error) ->
+  # Do nothing if the user has a custom uncaught exception handler.
+  if process.listeners('uncaughtException').length > 1
+    return

-  # Emit 'exit' event on quit.
-  require('app').on 'quit', ->
-    process.emit 'exit'
+  # Show error in GUI.
+  stack = error.stack ? "#{error.name}: #{error.message}"
+  message = "Uncaught Exception:\n#{stack}"
+  require('dialog').showErrorBox 'A JavaScript error occured in the browser process', message

-  # Load the RPC server.
-  require './rpc-server'
+# Emit 'exit' event on quit.
+app = require 'app'
+app.on 'quit', ->
+  process.emit 'exit'

-  # Load the guest view manager.
-  require './guest-view-manager'
-  require './guest-window-manager'
+# Load the RPC server.
+require './rpc-server'

-  # Now we try to load app's package.json.
-  packageJson = null
+# Load the guest view manager.
+require './guest-view-manager'
+require './guest-window-manager'

-  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
+# Now we try to load app's package.json.
+packageJson = null

-  throw new Error("Unable to find a valid app") unless packageJson?
+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

-  # Set application's version.
-  app = require 'app'
-  app.setVersion packageJson.version if packageJson.version?
+throw new Error("Unable to find a valid app") unless packageJson?

-  # Set application's name.
-  if packageJson.productName?
-    app.setName packageJson.productName
-  else if packageJson.name?
-    app.setName packageJson.name
+# Set application's version.
+app.setVersion packageJson.version if packageJson.version?

-  # Set application's desktop name.
-  if packageJson.desktopName?
-    app.setDesktopName packageJson.desktopName
-  else
-    app.setDesktopName '#{app.getName()}.desktop'
+# Set application's name.
+if packageJson.productName?
+  app.setName packageJson.productName
+else if packageJson.name?
+  app.setName packageJson.name

-  # Load the chrome extension support.
-  require './chrome-extension.js'
+# Set application's desktop name.
+if packageJson.desktopName?
+  app.setDesktopName packageJson.desktopName
+else
+  app.setDesktopName "#{app.getName()}.desktop"

-  # Finally load app's main.js and transfer control to C++.
-  module._load path.join(packagePath, packageJson.main), module, true
+# Set the user path according to application's name.
+app.setPath 'userData', path.join(app.getPath('appData'), app.getName())
+app.setPath 'userCache', path.join(app.getPath('cache'), app.getName())
+
+# Load the chrome extension support.
+require './chrome-extension'
+
+# Finally load app's main.js and transfer control to C++.
+module._load path.join(packagePath, packageJson.main), module, true
--- a/atom/browser/mac/atom_application_delegate.h
+++ b/atom/browser/mac/atom_application_delegate.h
@@ -4,7 +4,16 @@

 #import <Cocoa/Cocoa.h>

+#import "atom/browser/ui/cocoa/atom_menu_controller.h"
+
@interface AtomApplicationDelegate : NSObject<NSApplicationDelegate> {
+ @private
+  base::scoped_nsobject<AtomMenuController> menu_controller_;
 }

+- (id)init;
+
+// Sets the menu that will be returned in "applicationDockMenu:".
+- (void)setApplicationDockMenu:(ui::MenuModel*)model;
+
@end
--- a/atom/browser/mac/atom_application_delegate.mm
+++ b/atom/browser/mac/atom_application_delegate.mm
@@ -10,6 +10,16 @@

@implementation AtomApplicationDelegate

+- (id)init {
+  self = [super init];
+  menu_controller_.reset([[AtomMenuController alloc] init]);
+  return self;
+}
+
+- (void)setApplicationDockMenu:(ui::MenuModel*)model {
+  [menu_controller_ populateWithModel:model];
+}
+
 - (void)applicationWillFinishLaunching:(NSNotification*)notify {
  atom::Browser::Get()->WillFinishLaunching();
 }
@@ -18,6 +28,10 @@
  atom::Browser::Get()->DidFinishLaunching();
 }

+- (NSMenu*)applicationDockMenu:(NSApplication*)sender {
+  return [menu_controller_ menu];
+}
+
 - (BOOL)application:(NSApplication*)sender
           openFile:(NSString*)filename {
  std::string filename_str(base::SysNSStringToUTF8(filename));
--- a/atom/browser/native_window.cc
+++ b/atom/browser/native_window.cc
@@ -21,7 +21,7 @@
 #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/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/prefs/pref_service.h"
 #include "base/message_loop/message_loop.h"
@@ -32,6 +32,7 @@
 #include "brightray/browser/inspectable_web_contents_view.h"
 #include "chrome/browser/printing/print_view_manager_basic.h"
 #include "chrome/browser/ui/browser_dialogs.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_entry.h"
@@ -50,11 +51,23 @@
 #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 "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/geometry/point.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/screen.h"
+#include "ui/gfx/geometry/size.h"
+
+#if defined(OS_WIN)
+#include "ui/gfx/switches.h"
+#endif

 using content::NavigationEntry;
+using content::RenderWidgetHostView;
+using content::RenderWidgetHost;
+
+namespace content {
+CONTENT_EXPORT extern bool g_use_transparent_window;
+}

 namespace atom {

@@ -64,7 +77,6 @@ namespace {
 const char* kWebRuntimeFeatures[] = {
  switches::kExperimentalFeatures,
  switches::kExperimentalCanvasFeatures,
-  switches::kSubpixelFontScaling,
  switches::kOverlayScrollbars,
  switches::kOverlayFullscreenVideo,
  switches::kSharedWorker,
@@ -84,6 +96,7 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
                           const mate::Dictionary& options)
    : content::WebContentsObserver(web_contents),
      has_frame_(true),
+      transparent_(false),
      enable_larger_than_screen_(false),
      is_closed_(false),
      node_integration_(true),
@@ -95,12 +108,24 @@ NativeWindow::NativeWindow(content::WebContents* web_contents,
  printing::PrintViewManagerBasic::CreateForWebContents(web_contents);

  options.Get(switches::kFrame, &has_frame_);
+  options.Get(switches::kTransparent, &transparent_);
  options.Get(switches::kEnableLargerThanScreen, &enable_larger_than_screen_);
  options.Get(switches::kNodeIntegration, &node_integration_);

+  // Tell the content module to initialize renderer widget with transparent
+  // mode.
+  content::g_use_transparent_window = transparent_;
+
  // Read icon before window is created.
  options.Get(switches::kIcon, &icon_);

+  // The "preload" option must be absolute path.
+  if (options.Get(switches::kPreloadScript, &preload_script_) &&
+      !preload_script_.IsAbsolute()) {
+    LOG(ERROR) << "Path of \"preload\" script must be absolute.";
+    preload_script_.clear();
+  }
+
  // Be compatible with old API of "node-integration" option.
  std::string old_string_token;
  if (options.Get(switches::kNodeIntegration, &old_string_token) &&
@@ -158,7 +183,7 @@ NativeWindow* NativeWindow::FromRenderView(int process_id, int routing_id) {
      return window;
  }

-  return NULL;
+  return nullptr;
 }

 void NativeWindow::InitFromOptions(const mate::Dictionary& options) {
@@ -193,7 +218,7 @@ void NativeWindow::InitFromOptions(const mate::Dictionary& options) {
  }
  bool fullscreen;
  if (options.Get(switches::kFullscreen, &fullscreen) && fullscreen) {
-    SetFullscreen(true);
+    SetFullScreen(true);
  }
  bool skip;
  if (options.Get(switches::kSkipTaskbar, &skip) && skip) {
@@ -236,6 +261,24 @@ void NativeWindow::Print(bool silent, bool print_background) {
      PrintNow(silent, print_background);
 }

+void NativeWindow::ShowDefinitionForSelection() {
+  NOTIMPLEMENTED();
+}
+
+void NativeWindow::SetAutoHideMenuBar(bool auto_hide) {
+}
+
+bool NativeWindow::IsMenuBarAutoHide() {
+  return false;
+}
+
+void NativeWindow::SetMenuBarVisibility(bool visible) {
+}
+
+bool NativeWindow::IsMenuBarVisible() {
+  return true;
+}
+
 bool NativeWindow::HasModalDialog() {
  return has_dialog_attached_;
 }
@@ -268,31 +311,43 @@ void NativeWindow::BlurWebView() {
 }

 bool NativeWindow::IsWebViewFocused() {
-  content::RenderWidgetHostView* host_view =
+  RenderWidgetHostView* host_view =
      GetWebContents()->GetRenderViewHost()->GetView();
  return host_view && host_view->HasFocus();
 }

 void NativeWindow::CapturePage(const gfx::Rect& rect,
                               const CapturePageCallback& callback) {
-  content::RenderViewHost* render_view_host =
-      GetWebContents()->GetRenderViewHost();
-  content::RenderWidgetHostView* render_widget_host_view =
-      render_view_host->GetView();
-
-  if (!render_widget_host_view) {
+  content::WebContents* contents = GetWebContents();
+  RenderWidgetHostView* const view = contents->GetRenderWidgetHostView();
+  RenderWidgetHost* const host = view ? view->GetRenderWidgetHost() : nullptr;
+  if (!view || !host) {
    callback.Run(std::vector<unsigned char>());
    return;
  }

-  GetWebContents()->GetRenderViewHost()->CopyFromBackingStore(
-      rect,
-      rect.IsEmpty() ? render_widget_host_view->GetViewBounds().size() :
-                       rect.size(),
+  // Capture full page if user doesn't specify a |rect|.
+  const gfx::Size view_size = rect.IsEmpty() ? view->GetViewBounds().size() :
+                                               rect.size();
+
+  // By default, the requested bitmap size is the view size in screen
+  // coordinates.  However, if there's more pixel detail available on the
+  // current system, increase the requested bitmap size to capture it all.
+  gfx::Size bitmap_size = view_size;
+  const gfx::NativeView native_view = view->GetNativeView();
+  gfx::Screen* const screen = gfx::Screen::GetScreenFor(native_view);
+  const float scale =
+      screen->GetDisplayNearestWindow(native_view).device_scale_factor();
+  if (scale > 1.0f)
+    bitmap_size = gfx::ToCeiledSize(gfx::ScaleSize(view_size, scale));
+
+  host->CopyFromBackingStore(
+      rect.IsEmpty() ? gfx::Rect(view_size) : rect,
+      bitmap_size,
      base::Bind(&NativeWindow::OnCapturePageDone,
                 weak_factory_.GetWeakPtr(),
                 callback),
-      kAlpha_8_SkColorType);
+      kBGRA_8888_SkColorType);
 }

 void NativeWindow::DestroyWebContents() {
@@ -333,13 +388,13 @@ void NativeWindow::CloseWebContents() {

 content::WebContents* NativeWindow::GetWebContents() const {
  if (!inspectable_web_contents_)
-    return NULL;
+    return nullptr;
  return inspectable_web_contents()->GetWebContents();
 }

 content::WebContents* NativeWindow::GetDevToolsWebContents() const {
  if (!inspectable_web_contents_)
-    return NULL;
+    return nullptr;
  return inspectable_web_contents()->devtools_web_contents();
 }

@@ -349,6 +404,10 @@ void NativeWindow::AppendExtraCommandLineSwitches(
  command_line->AppendSwitchASCII(switches::kNodeIntegration,
                                  node_integration_ ? "true" : "false");

+  // Append --preload.
+  if (!preload_script_.empty())
+    command_line->AppendSwitchPath(switches::kPreloadScript, preload_script_);
+
  // Append --zoom-factor.
  if (zoom_factor_ != 1.0)
    command_line->AppendSwitchASCII(switches::kZoomFactor,
@@ -398,9 +457,10 @@ void NativeWindow::OverrideWebkitPrefs(const GURL& url,
    prefs->experimental_webgl_enabled = b;
  if (web_preferences_.Get("webaudio", &b))
    prefs->webaudio_enabled = b;
-  if (web_preferences_.Get("extra-plugin-dirs", &list))
+  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() {
@@ -425,9 +485,36 @@ void NativeWindow::NotifyWindowFocus() {
  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowFocus());
 }

+void NativeWindow::NotifyWindowMaximize() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowMaximize());
+}
+
+void NativeWindow::NotifyWindowUnmaximize() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowUnmaximize());
+}
+
+void NativeWindow::NotifyWindowMinimize() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowMinimize());
+}
+
+void NativeWindow::NotifyWindowRestore() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnWindowRestore());
+}
+
+void NativeWindow::NotifyWindowEnterFullScreen() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
+                    OnWindowEnterFullScreen());
+}
+
+void NativeWindow::NotifyWindowLeaveFullScreen() {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
+                    OnWindowLeaveFullScreen());
+}
+
 bool NativeWindow::ShouldCreateWebContents(
    content::WebContents* web_contents,
    int route_id,
+    int main_frame_route_id,
    WindowContainerType window_container_type,
    const base::string16& frame_name,
    const GURL& target_url,
@@ -456,9 +543,17 @@ content::WebContents* NativeWindow::OpenURLFromTab(
                                            params.url,
                                            "",
                                            params.disposition));
-    return NULL;
+    return nullptr;
  }

+  // Give user a chance to prevent navigation.
+  bool prevent_default = false;
+  FOR_EACH_OBSERVER(NativeWindowObserver,
+                    observers_,
+                    WillNavigate(&prevent_default, params.url));
+  if (prevent_default)
+    return nullptr;
+
  content::NavigationController::LoadURLParams load_url_params(params.url);
  load_url_params.referrer = params.referrer;
  load_url_params.transition_type = params.transition;
@@ -473,13 +568,26 @@ content::WebContents* NativeWindow::OpenURLFromTab(
  return source;
 }

-content::JavaScriptDialogManager* NativeWindow::GetJavaScriptDialogManager() {
+content::JavaScriptDialogManager* NativeWindow::GetJavaScriptDialogManager(
+    content::WebContents* source) {
  if (!dialog_manager_)
    dialog_manager_.reset(new AtomJavaScriptDialogManager);

  return dialog_manager_.get();
 }

+void NativeWindow::RenderViewCreated(
+    content::RenderViewHost* render_view_host) {
+  if (!transparent_)
+    return;
+
+  content::RenderWidgetHostImpl* impl = content::RenderWidgetHostImpl::FromID(
+      render_view_host->GetProcess()->GetID(),
+      render_view_host->GetRoutingID());
+  if (impl)
+    impl->SetBackgroundOpaque(false);
+}
+
 void NativeWindow::BeforeUnloadFired(content::WebContents* tab,
                                     bool proceed,
                                     bool* proceed_to_fire_unload) {
@@ -623,7 +731,7 @@ void NativeWindow::DevToolsSaveToFile(const std::string& url,
    base::FilePath default_path(base::FilePath::FromUTF8Unsafe(url));
    if (!file_dialog::ShowSaveDialog(this, url, default_path, filters, &path)) {
      base::StringValue url_value(url);
-      CallDevToolsFunction("InspectorFrontendAPI.canceledSaveURL", &url_value);
+      CallDevToolsFunction("DevToolsAPI.canceledSaveURL", &url_value);
      return;
    }
  }
@@ -633,7 +741,7 @@ void NativeWindow::DevToolsSaveToFile(const std::string& url,

  // Notify devtools.
  base::StringValue url_value(url);
-  CallDevToolsFunction("InspectorFrontendAPI.savedURL", &url_value);
+  CallDevToolsFunction("DevToolsAPI.savedURL", &url_value);
 }

 void NativeWindow::DevToolsAppendToFile(const std::string& url,
@@ -645,7 +753,7 @@ void NativeWindow::DevToolsAppendToFile(const std::string& url,

  // Notify devtools.
  base::StringValue url_value(url);
-  CallDevToolsFunction("InspectorFrontendAPI.appendedToURL", &url_value);
+  CallDevToolsFunction("DevToolsAPI.appendedToURL", &url_value);
 }

 void NativeWindow::ScheduleUnresponsiveEvent(int ms) {
@@ -671,10 +779,11 @@ void NativeWindow::NotifyWindowUnresponsive() {
 }

 void NativeWindow::OnCapturePageDone(const CapturePageCallback& callback,
-                                     bool succeed,
-                                     const SkBitmap& bitmap) {
+                                     const SkBitmap& bitmap,
+                                     content::ReadbackResponse response) {
+  SkAutoLockPixels screen_capture_lock(bitmap);
  std::vector<unsigned char> data;
-  if (succeed)
+  if (response == content::READBACK_SUCCESS)
    gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, true, &data);
  callback.Run(data);
 }
--- a/atom/browser/native_window.h
+++ b/atom/browser/native_window.h
@@ -20,8 +20,9 @@
 #include "brightray/browser/inspectable_web_contents_impl.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_observer.h"
+#include "content/public/browser/readback_types.h"
 #include "native_mate/persistent_dictionary.h"
-#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image.h"

 namespace base {
 class CommandLine;
@@ -111,7 +112,7 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  virtual void Minimize() = 0;
  virtual void Restore() = 0;
  virtual bool IsMinimized() = 0;
-  virtual void SetFullscreen(bool fullscreen) = 0;
+  virtual void SetFullScreen(bool fullscreen) = 0;
  virtual bool IsFullscreen() = 0;
  virtual void SetSize(const gfx::Size& size) = 0;
  virtual gfx::Size GetSize() = 0;
@@ -142,6 +143,8 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  virtual bool HasModalDialog();
  virtual gfx::NativeWindow GetNativeWindow() = 0;
  virtual void SetProgressBar(double progress) = 0;
+  virtual void SetOverlayIcon(const gfx::Image& overlay,
+                              const std::string& description) = 0;

  virtual bool IsClosed() const { return is_closed_; }
  virtual void OpenDevTools();
@@ -161,6 +164,15 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  // Print current page.
  virtual void Print(bool silent, bool print_background);

+  // Show popup dictionary.
+  virtual void ShowDefinitionForSelection();
+
+  // Toggle the menu bar.
+  virtual void SetAutoHideMenuBar(bool auto_hide);
+  virtual bool IsMenuBarAutoHide();
+  virtual void SetMenuBarVisibility(bool visible);
+  virtual bool IsMenuBarVisible();
+
  // The same with closing a tab in a real browser.
  //
  // Should be called by platform code when user want to close the window.
@@ -186,6 +198,12 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  void NotifyWindowClosed();
  void NotifyWindowBlur();
  void NotifyWindowFocus();
+  void NotifyWindowMaximize();
+  void NotifyWindowUnmaximize();
+  void NotifyWindowMinimize();
+  void NotifyWindowRestore();
+  void NotifyWindowEnterFullScreen();
+  void NotifyWindowLeaveFullScreen();

  void AddObserver(NativeWindowObserver* obs) {
    observers_.AddObserver(obs);
@@ -218,6 +236,7 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  bool ShouldCreateWebContents(
      content::WebContents* web_contents,
      int route_id,
+      int main_frame_route_id,
      WindowContainerType window_container_type,
      const base::string16& frame_name,
      const GURL& target_url,
@@ -226,7 +245,8 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  content::WebContents* OpenURLFromTab(
      content::WebContents* source,
      const content::OpenURLParams& params) override;
-  content::JavaScriptDialogManager* GetJavaScriptDialogManager() override;
+  content::JavaScriptDialogManager* GetJavaScriptDialogManager(
+      content::WebContents* source) override;
  void BeforeUnloadFired(content::WebContents* tab,
                         bool proceed,
                         bool* proceed_to_fire_unload) override;
@@ -254,6 +274,7 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  void RendererResponsive(content::WebContents* source) override;

  // Implementations of content::WebContentsObserver.
+  void RenderViewCreated(content::RenderViewHost* render_view_host) override;
  void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
  bool OnMessageReceived(const IPC::Message& message) override;

@@ -272,6 +293,9 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  // Whether window has standard frame.
  bool has_frame_;

+  // Whether window is transparent.
+  bool transparent_;
+
  // Whether window can be resized larger than screen.
  bool enable_larger_than_screen_;

@@ -293,8 +317,8 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,

  // Called when CapturePage has done.
  void OnCapturePageDone(const CapturePageCallback& callback,
-                         bool succeed,
-                         const SkBitmap& bitmap);
+                         const SkBitmap& bitmap,
+                         content::ReadbackResponse response);

  // Notification manager.
  content::NotificationRegistrar registrar_;
@@ -318,6 +342,9 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
  // Web preferences.
  mate::PersistentDictionary web_preferences_;

+  // The script to load before page's JavaScript starts to run.
+  base::FilePath preload_script_;
+
  // Page's default zoom factor.
  double zoom_factor_;

--- a/atom/browser/native_window_mac.h
+++ b/atom/browser/native_window_mac.h
@@ -7,10 +7,14 @@

 #import <Cocoa/Cocoa.h>

+#include <string>
+#include <vector>
+
 #include "base/mac/scoped_nsobject.h"
 #include "base/memory/scoped_ptr.h"
 #include "atom/browser/native_window.h"

+@class FullSizeContentView;
 class SkRegion;

 namespace atom {
@@ -22,51 +26,54 @@ class NativeWindowMac : public NativeWindow {
  virtual ~NativeWindowMac();

  // 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 ShowInactive() OVERRIDE;
-  virtual void Hide() OVERRIDE;
-  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;
-  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 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;
+  void Close() override;
+  void CloseImmediately() override;
+  void Move(const gfx::Rect& pos) override;
+  void Focus(bool focus) override;
+  bool IsFocused() override;
+  void Show() override;
+  void ShowInactive() override;
+  void Hide() override;
+  bool IsVisible() override;
+  void Maximize() override;
+  void Unmaximize() override;
+  bool IsMaximized() override;
+  void Minimize() override;
+  void Restore() override;
+  bool IsMinimized() override;
+  void SetFullScreen(bool fullscreen) override;
+  bool IsFullscreen() override;
+  void SetSize(const gfx::Size& size) override;
+  gfx::Size GetSize() override;
+  void SetContentSize(const gfx::Size& size) override;
+  gfx::Size GetContentSize() override;
+  void SetMinimumSize(const gfx::Size& size) override;
+  gfx::Size GetMinimumSize() override;
+  void SetMaximumSize(const gfx::Size& size) override;
+  gfx::Size GetMaximumSize() override;
+  void SetResizable(bool resizable) override;
+  bool IsResizable() override;
+  void SetAlwaysOnTop(bool top) override;
+  bool IsAlwaysOnTop() override;
+  void Center() override;
+  void SetPosition(const gfx::Point& position) override;
+  gfx::Point GetPosition() override;
+  void SetTitle(const std::string& title) override;
+  std::string GetTitle() override;
+  void FlashFrame(bool flash) override;
+  void SetSkipTaskbar(bool skip) override;
+  void SetKiosk(bool kiosk) override;
+  bool IsKiosk() override;
+  void SetRepresentedFilename(const std::string& filename) override;
+  std::string GetRepresentedFilename() override;
+  void SetDocumentEdited(bool edited) override;
+  bool IsDocumentEdited() override;
+  bool HasModalDialog() override;
+  gfx::NativeWindow GetNativeWindow() override;
+  void SetProgressBar(double progress) override;
+  void SetOverlayIcon(const gfx::Image& overlay,
+                      const std::string& description) override;
+  void ShowDefinitionForSelection() override;

  // Returns true if |point| in local Cocoa coordinate system falls within
  // the draggable region.
@@ -78,26 +85,28 @@ class NativeWindowMac : public NativeWindow {
  // Clip web view to rounded corner.
  void ClipWebView();

-  SkRegion* draggable_region() const { return draggable_region_.get(); }
-
 protected:
-  virtual void UpdateDraggableRegions(
-      const std::vector<DraggableRegion>& regions) OVERRIDE;
+  void UpdateDraggableRegions(
+      const std::vector<DraggableRegion>& regions) override;

  // Implementations of content::WebContentsDelegate.
-  virtual void HandleKeyboardEvent(
+  void HandleKeyboardEvent(
      content::WebContents*,
-      const content::NativeWebKeyboardEvent&) OVERRIDE;
+      const content::NativeWebKeyboardEvent&) override;

 private:
  void InstallView();
  void UninstallView();
-  void InstallDraggableRegionViews();
-  void UpdateDraggableRegionsForCustomDrag(
-      const std::vector<DraggableRegion>& regions);
+
+  // Install the drag view, which will cover the whole window and decides
+  // whehter we can drag.
+  void InstallDraggableRegionView();

  base::scoped_nsobject<NSWindow> window_;

+  // The view that will fill the whole frameless window.
+  base::scoped_nsobject<FullSizeContentView> content_view_;
+
  bool is_kiosk_;

  NSInteger attention_request_id_;  // identifier from requestUserAttention
@@ -105,10 +114,6 @@ class NativeWindowMac : public NativeWindow {
  // 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_;
-
  // For custom drag, the whole window is non-draggable and the draggable region
  // has to been explicitly provided.
  scoped_ptr<SkRegion> draggable_region_;  // used in custom drag.
--- a/atom/browser/native_window_mac.mm
+++ b/atom/browser/native_window_mac.mm
@@ -25,6 +25,31 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
 - (CGFloat)roundedCornerRadius;
@end

+// This view always takes the size of its superview. It is intended to be used
+// as a NSWindow's contentView.  It is needed because NSWindow's implementation
+// explicitly resizes the contentView at inopportune times.
+@interface FullSizeContentView : NSView
+@end
+
+@implementation FullSizeContentView
+
+// This method is directly called by NSWindow during a window resize on OSX
+// 10.10.0, beta 2. We must override it to prevent the content view from
+// shrinking.
+- (void)setFrameSize:(NSSize)size {
+  if ([self superview])
+    size = [[self superview] bounds].size;
+  [super setFrameSize:size];
+}
+
+// The contentView gets moved around during certain full-screen operations.
+// This is less than ideal, and should eventually be removed.
+- (void)viewDidMoveToSuperview {
+  [self setFrame:[[self superview] bounds]];
+}
+
+@end
+
@interface AtomNSWindowDelegate : NSObject<NSWindowDelegate> {
 @private
  atom::NativeWindowMac* shell_;
@@ -76,16 +101,41 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;
  shell_->NotifyWindowBlur();
 }

- (void)windowDidResize:(NSNotification*)otification {
+- (void)windowDidResize:(NSNotification*)notification {
  if (!shell_->has_frame())
    shell_->ClipWebView();
 }

+- (void)windowDidMiniaturize:(NSNotification*)notification {
+  shell_->NotifyWindowMinimize();
+}
+
+- (void)windowDidDeminiaturize:(NSNotification*)notification {
+  shell_->NotifyWindowRestore();
+}
+
+- (BOOL)windowShouldZoom:(NSWindow*)window toFrame:(NSRect)newFrame {
+  // Cocoa doen't have concept of maximize/unmaximize, so wee need to emulate
+  // them by calculating size change when zooming.
+  if (newFrame.size.width < [window frame].size.width ||
+      newFrame.size.height < [window frame].size.height)
+    shell_->NotifyWindowUnmaximize();
+  else
+    shell_->NotifyWindowMaximize();
+  return YES;
+}
+
+- (void)windowDidEnterFullScreen:(NSNotification*)notification {
+  shell_->NotifyWindowEnterFullScreen();
+}
+
 - (void)windowDidExitFullScreen:(NSNotification*)notification {
  if (!shell_->has_frame()) {
    NSWindow* window = shell_->GetNativeWindow();
    [[window standardWindowButton:NSWindowFullScreenButton] setHidden:YES];
  }
+
+  shell_->NotifyWindowLeaveFullScreen();
 }

 - (void)windowWillClose:(NSNotification*)notification {
@@ -230,6 +280,29 @@ static const CGFloat kAtomWindowCornerRadius = 4.0;

 namespace atom {

+namespace {
+
+// Convert draggable regions in raw format to SkRegion format. Caller is
+// responsible for deleting the returned SkRegion instance.
+SkRegion* DraggableRegionsToSkRegion(
+    const std::vector<DraggableRegion>& regions) {
+  SkRegion* sk_region = new SkRegion;
+  for (std::vector<DraggableRegion>::const_iterator iter = regions.begin();
+       iter != regions.end();
+       ++iter) {
+    const DraggableRegion& region = *iter;
+    sk_region->op(
+        region.bounds.x(),
+        region.bounds.y(),
+        region.bounds.right(),
+        region.bounds.bottom(),
+        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
+  }
+  return sk_region;
+}
+
+}  // namespace
+
 NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
                                 const mate::Dictionary& options)
    : NativeWindow(web_contents, options),
@@ -246,9 +319,7 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
      width,
      height);

-  AtomNSWindow* atomWindow;
-
-  atomWindow = [[AtomNSWindow alloc]
+  AtomNSWindow* atomWindow = [[AtomNSWindow alloc]
      initWithContentRect:cocoa_bounds
                styleMask:NSTitledWindowMask | NSClosableWindowMask |
                          NSMiniaturizableWindowMask | NSResizableWindowMask |
@@ -264,6 +335,13 @@ NativeWindowMac::NativeWindowMac(content::WebContents* web_contents,
      [[AtomNSWindowDelegate alloc] initWithShell:this];
  [window_ setDelegate:delegate];

+  if (transparent_) {
+    // Make window has transparent background.
+    [window_ setOpaque:NO];
+    [window_ setHasShadow:NO];
+    [window_ setBackgroundColor:[NSColor clearColor]];
+  }
+
  // We will manage window's lifetime ourselves.
  [window_ setReleasedWhenClosed:NO];

@@ -336,6 +414,10 @@ bool NativeWindowMac::IsFocused() {
 }

 void NativeWindowMac::Show() {
+  // This method is supposed to put focus on window, however if the app does not
+  // have focus then "makeKeyAndOrderFront" will only show the window.
+  [NSApp activateIgnoringOtherApps:YES];
+
  [window_ makeKeyAndOrderFront:nil];
 }

@@ -375,7 +457,7 @@ bool NativeWindowMac::IsMinimized() {
  return [window_ isMiniaturized];
 }

-void NativeWindowMac::SetFullscreen(bool fullscreen) {
+void NativeWindowMac::SetFullScreen(bool fullscreen) {
  if (fullscreen == IsFullscreen())
    return;

@@ -488,6 +570,10 @@ gfx::Point NativeWindowMac::GetPosition() {
 }

 void NativeWindowMac::SetTitle(const std::string& title) {
+  // We don't want the title to show in transparent window.
+  if (transparent_)
+    return;
+
  [window_ setTitle:base::SysUTF8ToNSString(title)];
 }

@@ -520,10 +606,10 @@ void NativeWindowMac::SetKiosk(bool kiosk) {
        NSApplicationPresentationDisableHideApplication;
    [NSApp setPresentationOptions:options];
    is_kiosk_ = true;
-    SetFullscreen(true);
+    SetFullScreen(true);
  } else if (!kiosk && is_kiosk_) {
    is_kiosk_ = false;
-    SetFullscreen(false);
+    SetFullScreen(false);
    [NSApp setPresentationOptions:kiosk_options_];
  }
 }
@@ -592,10 +678,27 @@ void NativeWindowMac::SetProgressBar(double progress) {
  [dock_tile display];
 }

+void NativeWindowMac::SetOverlayIcon(const gfx::Image& overlay,
+                                     const std::string& description) {
+}
+
+void NativeWindowMac::ShowDefinitionForSelection() {
+  content::WebContents* web_contents = GetWebContents();
+  if (!web_contents)
+    return;
+  content::RenderWidgetHostView* rwhv = web_contents->GetRenderWidgetHostView();
+  if (!rwhv)
+    return;
+  rwhv->ShowDefinitionForSelection();
+}
+
 bool NativeWindowMac::IsWithinDraggableRegion(NSPoint point) const {
  if (!draggable_region_)
    return false;
-  NSView* webView = GetWebContents()->GetNativeView();
+  content::WebContents* web_contents = GetWebContents();
+  if (!web_contents)
+    return false;
+  NSView* webView = web_contents->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
@@ -608,7 +711,6 @@ void NativeWindowMac::HandleMouseEvent(NSEvent* event) {
  NSRect mouseRect = [window_ convertRectToScreen:NSMakeRect(eventLoc.x, eventLoc.y, 0, 0)];
  NSPoint current_mouse_location = mouseRect.origin;

-
  if ([event type] == NSLeftMouseDown) {
    NSPoint frame_origin = [window_ frame].origin;
    last_mouse_offset_ = NSMakePoint(
@@ -627,8 +729,7 @@ void NativeWindowMac::UpdateDraggableRegions(
  if (has_frame_)
    return;

-  UpdateDraggableRegionsForCustomDrag(regions);
-  InstallDraggableRegionViews();
+  draggable_region_.reset(DraggableRegionsToSkRegion(regions));
 }

 void NativeWindowMac::HandleKeyboardEvent(
@@ -665,16 +766,36 @@ void NativeWindowMac::InstallView() {
    [view setFrame:[[window_ contentView] bounds]];
    [[window_ contentView] addSubview:view];
  } else {
-    NSView* frameView = [[window_ contentView] superview];
-    [view setFrame:[frameView bounds]];
-    [frameView addSubview:view];
+    if (base::mac::IsOSYosemiteOrLater()) {
+      // In OSX 10.10, adding subviews to the root view for the NSView hierarchy
+      // produces warnings. To eliminate the warnings, we resize the contentView
+      // to fill the window, and add subviews to that.
+      // http://crbug.com/380412
+      content_view_.reset([[FullSizeContentView alloc] init]);
+      [content_view_
+          setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
+      [content_view_ setFrame:[[[window_ contentView] superview] bounds]];
+      [window_ setContentView:content_view_];
+
+      [view setFrame:[content_view_ bounds]];
+      [content_view_ addSubview:view];
+    } else {
+      NSView* frameView = [[window_ contentView] superview];
+      [view setFrame:[frameView bounds]];
+      [frameView addSubview:view];
+    }

    ClipWebView();
+    InstallDraggableRegionView();

    [[window_ standardWindowButton:NSWindowZoomButton] setHidden:YES];
    [[window_ standardWindowButton:NSWindowMiniaturizeButton] setHidden:YES];
    [[window_ standardWindowButton:NSWindowCloseButton] setHidden:YES];
-    [[window_ standardWindowButton:NSWindowFullScreenButton] setHidden:YES];
+
+    // Some third-party OS X utilities check the zoom button's enabled state to
+    // determine whether to show custom UI on hover, so we disable it here to
+    // prevent them from doing so in a frameless app window.
+    [[window_ standardWindowButton:NSWindowZoomButton] setEnabled:NO];
  }
 }

@@ -684,70 +805,19 @@ void NativeWindowMac::UninstallView() {
 }

 void NativeWindowMac::ClipWebView() {
-  NSView* view = GetWebContents()->GetNativeView();
-  view.layer.masksToBounds = YES;
-  view.layer.cornerRadius = kAtomWindowCornerRadius;
-}
-
-void NativeWindowMac::InstallDraggableRegionViews() {
-  DCHECK(!has_frame_);
-
-  // All ControlRegionViews should be added as children of the WebContentsView,
-  // because WebContentsView will be removed and re-added when entering and
-  // leaving fullscreen mode.
  NSView* webView = GetWebContents()->GetNativeView();
-  NSInteger webViewHeight = NSHeight([webView bounds]);
-
-  // Remove all ControlRegionViews that are added last time.
-  // Note that [webView subviews] returns the view's mutable internal array and
-  // it should be copied to avoid mutating the original array while enumerating
-  // it.
-  base::scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
-  for (NSView* subview in subviews.get())
-    if ([subview isKindOfClass:[ControlRegionView class]])
-      [subview removeFromSuperview];
-
-  // Create and add ControlRegionView for each region that needs to be excluded
-  // from the dragging.
-  for (std::vector<gfx::Rect>::const_iterator iter =
-           system_drag_exclude_areas_.begin();
-       iter != system_drag_exclude_areas_.end();
-       ++iter) {
-    base::scoped_nsobject<NSView> controlRegion(
-        [[ControlRegionView alloc] initWithShellWindow:this]);
-    [controlRegion setFrame:NSMakeRect(iter->x(),
-                                       webViewHeight - iter->bottom(),
-                                       iter->width(),
-                                       iter->height())];
-    [webView addSubview:controlRegion];
-  }
+  webView.layer.masksToBounds = YES;
+  webView.layer.cornerRadius = kAtomWindowCornerRadius;
 }

-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()->GetNativeView();
-  gfx::Rect window_bounds(
-      0, 0, NSWidth([web_view bounds]), NSHeight([web_view bounds]));
-  system_drag_exclude_areas_.clear();
-  system_drag_exclude_areas_.push_back(window_bounds);
-
-  // Aggregate the draggable areas and non-draggable areas such that hit test
-  // could be performed easily.
-  SkRegion* draggable_region = new SkRegion;
-  for (std::vector<DraggableRegion>::const_iterator iter = regions.begin();
-       iter != regions.end();
-       ++iter) {
-    const DraggableRegion& region = *iter;
-    draggable_region->op(
-        region.bounds.x(),
-        region.bounds.y(),
-        region.bounds.right(),
-        region.bounds.bottom(),
-        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
-  }
-  draggable_region_.reset(draggable_region);
+void NativeWindowMac::InstallDraggableRegionView() {
+  NSView* webView = GetWebContents()->GetNativeView();
+  base::scoped_nsobject<NSView> controlRegion(
+      [[ControlRegionView alloc] initWithShellWindow:this]);
+  [controlRegion setFrame:NSMakeRect(0, 0,
+                                     NSWidth([webView bounds]),
+                                     NSHeight([webView bounds]))];
+  [webView addSubview:controlRegion];
 }

 // static
--- a/atom/browser/native_window_observer.h
+++ b/atom/browser/native_window_observer.h
@@ -27,6 +27,9 @@ class NativeWindowObserver {
                                     const std::string& partition_id,
                                     WindowOpenDisposition disposition) {}

+  // Called when user is starting an navigation in web page.
+  virtual void WillNavigate(bool* prevent_default, const GURL& url) {}
+
  // Called when the window is gonna closed.
  virtual void WillCloseWindow(bool* prevent_default) {}

@@ -39,6 +42,14 @@ class NativeWindowObserver {
  // Called when window gains focus.
  virtual void OnWindowFocus() {}

+  // Called when window state changed.
+  virtual void OnWindowMaximize() {}
+  virtual void OnWindowUnmaximize() {}
+  virtual void OnWindowMinimize() {}
+  virtual void OnWindowRestore() {}
+  virtual void OnWindowEnterFullScreen() {}
+  virtual void OnWindowLeaveFullScreen() {}
+
  // Called when renderer is hung.
  virtual void OnRendererUnresponsive() {}

--- a/atom/browser/native_window_views.cc
+++ b/atom/browser/native_window_views.cc
@@ -22,20 +22,24 @@
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/hit_test.h"
+#include "ui/gfx/image/image.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/native_widget_private.h"
 #include "ui/views/widget/widget.h"
+#include "ui/wm/core/shadow_types.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/window_state_watcher.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 "base/strings/string_util.h"
 #include "chrome/browser/ui/libgtk2ui/unity_service.h"
 #include "dbus/bus.h"
 #include "dbus/object_proxy.h"
@@ -48,6 +52,8 @@
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "ui/base/win/shell.h"
+#include "ui/gfx/icon_util.h"
+#include "ui/gfx/win/dpi.h"
 #include "ui/views/win/hwnd_util.h"
 #endif

@@ -63,10 +69,6 @@ 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;
-
 // Returns true if the bus name "com.canonical.AppMenu.Registrar" is available.
 bool ShouldUseGlobalMenuBar() {
  dbus::Bus::Options options;
@@ -113,9 +115,12 @@ bool IsAltKey(const content::NativeWebKeyboardEvent& event) {

 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));
+  int modifiers = event.modifiers;
+  modifiers &= ~Modifiers::NumLockOn;
+  modifiers &= ~Modifiers::CapsLockOn;
+  return (modifiers == Modifiers::AltKey) ||
+         (modifiers == (Modifiers::AltKey | Modifiers::IsLeft)) ||
+         (modifiers == (Modifiers::AltKey | Modifiers::IsRight));
 }

 class NativeWindowClientView : public views::ClientView {
@@ -126,7 +131,7 @@ class NativeWindowClientView : public views::ClientView {
  }
  virtual ~NativeWindowClientView() {}

-  virtual bool CanClose() OVERRIDE {
+  bool CanClose() override {
    static_cast<NativeWindowViews*>(contents_view())->CloseWebContents();
    return false;
  }
@@ -145,6 +150,9 @@ NativeWindowViews::NativeWindowViews(content::WebContents* web_contents,
      menu_bar_autohide_(false),
      menu_bar_visible_(false),
      menu_bar_alt_pressed_(false),
+#if defined(OS_WIN)
+      is_minimized_(false),
+#endif
      keyboard_event_handler_(new views::UnhandledKeyboardEventHandler),
      use_content_size_(false),
      resizable_(true) {
@@ -178,19 +186,24 @@ NativeWindowViews::NativeWindowViews(content::WebContents* web_contents,
  params.type = views::Widget::InitParams::TYPE_WINDOW;
  params.remove_standard_frame = !has_frame_;

+  if (transparent_)
+    params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
+
 #if defined(USE_X11)
+  std::string name = Browser::Get()->GetName();
  // Set WM_WINDOW_ROLE.
-  params.wm_role_name = base::StringPrintf(
-      "%s/%s/%d", "Atom Shell", Browser::Get()->GetName().c_str(),
-      ++kWindowsCreated);
+  params.wm_role_name = "browser-window";
  // Set WM_CLASS.
-  params.wm_class_name = "atom";
-  params.wm_class_class = "Atom";
+  params.wm_class_name = base::StringToLowerASCII(name);
+  params.wm_class_class = name;
 #endif

  window_->Init(params);

 #if defined(USE_X11)
+  // Start monitoring window states.
+  window_state_watcher_.reset(new WindowStateWatcher(this));
+
  // 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) {
@@ -212,10 +225,15 @@ NativeWindowViews::NativeWindowViews(content::WebContents* web_contents,
    ui::SetAtomArrayProperty(GetAcceleratedWidget(), "_NET_WM_STATE", "ATOM",
                             state_atom_list);
  }
+
+  // Set the _NET_WM_WINDOW_TYPE.
+  std::string window_type;
+  if (options.Get(switches::kType, &window_type))
+    SetWindowType(GetAcceleratedWidget(), window_type);
 #endif

  // Add web view.
-  SetLayoutManager(new MenuLayout(kMenuBarHeight));
+  SetLayoutManager(new MenuLayout(this, kMenuBarHeight));
  set_background(views::Background::CreateStandardPanelBackground());
  AddChildView(web_view_);

@@ -224,6 +242,38 @@ NativeWindowViews::NativeWindowViews(content::WebContents* web_contents,
      use_content_size_)
    bounds = ContentBoundsToWindowBounds(bounds);

+#if defined(OS_WIN)
+  if (!has_frame_) {
+    // Set Window style so that we get a minimize and maximize animation when
+    // frameless.
+    DWORD frame_style = WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX |
+                        WS_CAPTION;
+    // We should not show a frame for transparent window.
+    if (transparent_)
+      frame_style &= ~(WS_THICKFRAME | WS_CAPTION);
+    ::SetWindowLong(GetAcceleratedWidget(), GWL_STYLE, frame_style);
+  }
+
+  if (transparent_) {
+    // Transparent window on Windows has to have WS_EX_COMPOSITED style.
+    LONG ex_style = ::GetWindowLong(GetAcceleratedWidget(), GWL_EXSTYLE);
+    ex_style |= WS_EX_COMPOSITED;
+    ::SetWindowLong(GetAcceleratedWidget(), GWL_EXSTYLE, ex_style);
+  }
+#endif
+
+  // TODO(zcbenz): This was used to force using native frame on Windows 2003, we
+  // should check whether setting it in InitParams can work.
+  if (has_frame_) {
+    window_->set_frame_type(views::Widget::FrameType::FRAME_TYPE_FORCE_NATIVE);
+    window_->FrameTypeChanged();
+  }
+
+  // The given window is most likely not rectangular since it uses
+  // transparency and has no standard frame, don't show a shadow for it.
+  if (transparent_ && !has_frame_)
+    wm::SetShadowType(GetNativeWindow(), wm::SHADOW_TYPE_NONE);
+
  window_->UpdateWindowIcon();
  window_->CenterWindow(bounds.size());
  Layout();
@@ -273,7 +323,11 @@ bool NativeWindowViews::IsVisible() {
 }

 void NativeWindowViews::Maximize() {
-  window_->Maximize();
+  if (IsVisible())
+    window_->Maximize();
+  else
+    window_->native_widget_private()->ShowWithWindowState(
+        ui::SHOW_STATE_MAXIMIZED);
 }

 void NativeWindowViews::Unmaximize() {
@@ -285,7 +339,11 @@ bool NativeWindowViews::IsMaximized() {
 }

 void NativeWindowViews::Minimize() {
-  window_->Minimize();
+  if (IsVisible())
+    window_->Minimize();
+  else
+    window_->native_widget_private()->ShowWithWindowState(
+        ui::SHOW_STATE_MINIMIZED);
 }

 void NativeWindowViews::Restore() {
@@ -296,8 +354,19 @@ bool NativeWindowViews::IsMinimized() {
  return window_->IsMinimized();
 }

-void NativeWindowViews::SetFullscreen(bool fullscreen) {
-  window_->SetFullscreen(fullscreen);
+void NativeWindowViews::SetFullScreen(bool fullscreen) {
+  if (IsVisible())
+    window_->SetFullscreen(fullscreen);
+  else
+    window_->native_widget_private()->ShowWithWindowState(
+        ui::SHOW_STATE_FULLSCREEN);
+#if defined(OS_WIN)
+  // There is no native fullscreen state on Windows.
+  if (fullscreen)
+    NotifyWindowEnterFullScreen();
+  else
+    NotifyWindowLeaveFullScreen();
+#endif
 }

 bool NativeWindowViews::IsFullscreen() {
@@ -381,17 +450,15 @@ gfx::Size NativeWindowViews::GetMaximumSize() {

 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);
-  }
+  // 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
@@ -448,6 +515,18 @@ std::string NativeWindowViews::GetTitle() {
 }

 void NativeWindowViews::FlashFrame(bool flash) {
+#if defined(OS_WIN)
+  // The Chromium's implementation has a bug stopping flash.
+  if (!flash) {
+    FLASHWINFO fwi;
+    fwi.cbSize = sizeof(fwi);
+    fwi.hwnd = GetAcceleratedWidget();
+    fwi.dwFlags = FLASHW_STOP;
+    fwi.uCount = 0;
+    FlashWindowEx(&fwi);
+    return;
+  }
+#endif
  window_->FlashFrame(flash);
 }

@@ -469,7 +548,7 @@ void NativeWindowViews::SetSkipTaskbar(bool skip) {
 }

 void NativeWindowViews::SetKiosk(bool kiosk) {
-  SetFullscreen(kiosk);
+  SetFullScreen(kiosk);
 }

 bool NativeWindowViews::IsKiosk() {
@@ -541,6 +620,60 @@ void NativeWindowViews::SetProgressBar(double progress) {
 #endif
 }

+void NativeWindowViews::SetOverlayIcon(const gfx::Image& overlay,
+                                       const std::string& description) {
+#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());
+
+  std::wstring wstr = std::wstring(description.begin(), description.end());
+  taskbar->SetOverlayIcon(frame,
+      IconUtil::CreateHICONFromSkBitmap(overlay.AsBitmap()),
+      wstr.c_str());
+#endif
+}
+
+void NativeWindowViews::SetAutoHideMenuBar(bool auto_hide) {
+  menu_bar_autohide_ = auto_hide;
+}
+
+bool NativeWindowViews::IsMenuBarAutoHide() {
+  return menu_bar_autohide_;
+}
+
+void NativeWindowViews::SetMenuBarVisibility(bool visible) {
+  if (!menu_bar_ || menu_bar_visible_ == visible)
+    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());
+  }
+
+  Layout();
+}
+
+bool NativeWindowViews::IsMenuBarVisible() {
+  return menu_bar_visible_;
+}
+
 gfx::AcceleratedWidget NativeWindowViews::GetAcceleratedWidget() {
  return GetNativeWindow()->GetHost()->GetAcceleratedWidget();
 }
@@ -582,10 +715,8 @@ void NativeWindowViews::OnWidgetActivationChanged(
    GetWebContents()->Focus();

  // Hide menu bar when window is blured.
-  if (!active && menu_bar_autohide_ && menu_bar_visible_) {
+  if (!active && menu_bar_autohide_ && menu_bar_visible_)
    SetMenuBarVisibility(false);
-    Layout();
-  }
 }

 void NativeWindowViews::DeleteDelegate() {
@@ -604,6 +735,10 @@ bool NativeWindowViews::CanMaximize() const {
  return resizable_;
 }

+bool NativeWindowViews::CanMinimize() const {
+  return true;
+}
+
 base::string16 NativeWindowViews::GetWindowTitle() const {
  return base::UTF8ToUTF16(title_);
 }
@@ -657,34 +792,57 @@ views::ClientView* NativeWindowViews::CreateClientView(views::Widget* widget) {
 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)
+  WinFrameView* frame_view = new WinFrameView;
+  frame_view->Init(this, widget);
+  return frame_view;
+#else
  if (has_frame_) {
    return new views::NativeFrameView(widget);
  } else {
-    FramelessView* frame_view =  new FramelessView;
+    FramelessView* frame_view = new FramelessView;
    frame_view->Init(this, widget);
    return frame_view;
  }
 #endif
-
-  return NULL;
 }

+#if defined(OS_WIN)
+bool NativeWindowViews::ExecuteWindowsCommand(int command_id) {
+  // Windows uses the 4 lower order bits of |command_id| for type-specific
+  // information so we must exclude this when comparing.
+  static const int sc_mask = 0xFFF0;
+  if ((command_id & sc_mask) == SC_MINIMIZE) {
+    NotifyWindowMinimize();
+    is_minimized_ = true;
+  } else if ((command_id & sc_mask) == SC_RESTORE) {
+    if (is_minimized_)
+      NotifyWindowRestore();
+    else
+      NotifyWindowUnmaximize();
+    is_minimized_ = false;
+  } else if ((command_id & sc_mask) == SC_MAXIMIZE) {
+    NotifyWindowMaximize();
+  }
+  return false;
+}
+#endif
+
 gfx::ImageSkia NativeWindowViews::GetDevToolsWindowIcon() {
  return GetWindowAppIcon();
 }

+#if defined(USE_X11)
+void NativeWindowViews::GetDevToolsWindowWMClass(
+    std::string* name, std::string* class_name) {
+  *class_name = Browser::Get()->GetName();
+  *name = base::StringToLowerASCII(*class_name);
+}
+#endif
+
 void NativeWindowViews::HandleMouseDown() {
  // Hide menu bar when web view is clicked.
-  if (menu_bar_autohide_ && menu_bar_visible_) {
+  if (menu_bar_autohide_ && menu_bar_visible_)
    SetMenuBarVisibility(false);
-    Layout();
-  }
 }

 void NativeWindowViews::HandleKeyboardEvent(
@@ -704,10 +862,8 @@ void NativeWindowViews::HandleKeyboardEvent(
  if (event.type == blink::WebInputEvent::RawKeyDown && !IsAltKey(event) &&
      IsAltModifier(event)) {
    if (!menu_bar_visible_ &&
-        (menu_bar_->GetAcceleratorIndex(event.windowsKeyCode) != -1)) {
+        (menu_bar_->GetAcceleratorIndex(event.windowsKeyCode) != -1))
      SetMenuBarVisibility(true);
-      Layout();
-    }
    menu_bar_->ActivateAccelerator(event.windowsKeyCode);
    return;
  }
@@ -716,8 +872,7 @@ void NativeWindowViews::HandleKeyboardEvent(
    return;

  // Toggle the menu bar only when a single Alt is released.
-  if (event.type == blink::WebInputEvent::RawKeyDown && IsAltKey(event) &&
-      IsAltModifier(event)) {
+  if (event.type == blink::WebInputEvent::RawKeyDown && IsAltKey(event)) {
    // When a single Alt is pressed:
    menu_bar_alt_pressed_ = true;
  } else if (event.type == blink::WebInputEvent::KeyUp && IsAltKey(event) &&
@@ -728,7 +883,6 @@ void NativeWindowViews::HandleKeyboardEvent(
    // 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;
@@ -759,31 +913,20 @@ void NativeWindowViews::RegisterAccelerators(ui::MenuModel* menu_model) {

 gfx::Rect NativeWindowViews::ContentBoundsToWindowBounds(
    const gfx::Rect& bounds) {
+#if defined(OS_WIN)
+  gfx::Rect dpi_bounds = gfx::win::DIPToScreenRect(bounds);
+  gfx::Rect window_bounds = gfx::win::ScreenToDIPRect(
+      window_->non_client_view()->GetWindowBoundsForClientBounds(dpi_bounds));
+#else
  gfx::Rect window_bounds =
      window_->non_client_view()->GetWindowBoundsForClientBounds(bounds);
+#endif
+
  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) {
--- a/atom/browser/native_window_views.h
+++ b/atom/browser/native_window_views.h
@@ -22,6 +22,7 @@ namespace atom {

 class GlobalMenuBarX11;
 class MenuBar;
+class WindowStateWatcher;

 class NativeWindowViews : public NativeWindow,
                          public views::WidgetDelegateView,
@@ -32,47 +33,53 @@ class NativeWindowViews : public NativeWindow,
  virtual ~NativeWindowViews();

  // NativeWindow:
-  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 ShowInactive() OVERRIDE;
-  virtual void Hide() OVERRIDE;
-  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;
-  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 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 Close() override;
+  void CloseImmediately() override;
+  void Move(const gfx::Rect& pos) override;
+  void Focus(bool focus) override;
+  bool IsFocused() override;
+  void Show() override;
+  void ShowInactive() override;
+  void Hide() override;
+  bool IsVisible() override;
+  void Maximize() override;
+  void Unmaximize() override;
+  bool IsMaximized() override;
+  void Minimize() override;
+  void Restore() override;
+  bool IsMinimized() override;
+  void SetFullScreen(bool fullscreen) override;
+  bool IsFullscreen() override;
+  void SetSize(const gfx::Size& size) override;
+  gfx::Size GetSize() override;
+  void SetContentSize(const gfx::Size& size) override;
+  gfx::Size GetContentSize() override;
+  void SetMinimumSize(const gfx::Size& size) override;
+  gfx::Size GetMinimumSize() override;
+  void SetMaximumSize(const gfx::Size& size) override;
+  gfx::Size GetMaximumSize() override;
+  void SetResizable(bool resizable) override;
+  bool IsResizable() override;
+  void SetAlwaysOnTop(bool top) override;
+  bool IsAlwaysOnTop() override;
+  void Center() override;
+  void SetPosition(const gfx::Point& position) override;
+  gfx::Point GetPosition() override;
+  void SetTitle(const std::string& title) override;
+  std::string GetTitle() override;
+  void FlashFrame(bool flash) override;
+  void SetSkipTaskbar(bool skip) override;
+  void SetKiosk(bool kiosk) override;
+  bool IsKiosk() override;
+  void SetMenu(ui::MenuModel* menu_model) override;
+  gfx::NativeWindow GetNativeWindow() override;
+  void SetOverlayIcon(const gfx::Image& overlay,
+                      const std::string& description) override;
+  void SetProgressBar(double value) override;
+  void SetAutoHideMenuBar(bool auto_hide) override;
+  bool IsMenuBarAutoHide() override;
+  void SetMenuBarVisibility(bool visible) override;
+  bool IsMenuBarVisible() override;

  gfx::AcceleratedWidget GetAcceleratedWidget();

@@ -81,43 +88,51 @@ class NativeWindowViews : public NativeWindow,

 private:
  // NativeWindow:
-  virtual void UpdateDraggableRegions(
-      const std::vector<DraggableRegion>& regions) OVERRIDE;
+  void UpdateDraggableRegions(
+      const std::vector<DraggableRegion>& regions) override;

  // views::WidgetObserver:
-  virtual void OnWidgetActivationChanged(
-      views::Widget* widget, bool active) OVERRIDE;
+  void OnWidgetActivationChanged(
+      views::Widget* widget, bool active) override;

  // views::WidgetDelegate:
-  virtual void DeleteDelegate() OVERRIDE;
-  virtual views::View* GetInitiallyFocusedView() OVERRIDE;
-  virtual bool CanResize() const OVERRIDE;
-  virtual bool CanMaximize() 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(
+  void DeleteDelegate() override;
+  views::View* GetInitiallyFocusedView() override;
+  bool CanResize() const override;
+  bool CanMaximize() const override;
+  bool CanMinimize() const override;
+  base::string16 GetWindowTitle() const override;
+  bool ShouldHandleSystemCommands() const override;
+  gfx::ImageSkia GetWindowAppIcon() override;
+  gfx::ImageSkia GetWindowIcon() override;
+  views::Widget* GetWidget() override;
+  const views::Widget* GetWidget() const override;
+  views::View* GetContentsView() override;
+  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;
+     const gfx::Point& location) override;
+  views::ClientView* CreateClientView(views::Widget* widget) override;
+  views::NonClientFrameView* CreateNonClientFrameView(
+      views::Widget* widget) override;
+#if defined(OS_WIN)
+  bool ExecuteWindowsCommand(int command_id) override;
+#endif

  // brightray::InspectableWebContentsDelegate:
-  virtual gfx::ImageSkia GetDevToolsWindowIcon() OVERRIDE;
+  gfx::ImageSkia GetDevToolsWindowIcon() override;
+#if defined(USE_X11)
+  void GetDevToolsWindowWMClass(
+      std::string* name, std::string* class_name) override;
+#endif

  // content::WebContentsDelegate:
-  virtual void HandleMouseDown() OVERRIDE;
-  virtual void HandleKeyboardEvent(
+  void HandleMouseDown() override;
+  void HandleKeyboardEvent(
      content::WebContents*,
-      const content::NativeWebKeyboardEvent& event) OVERRIDE;
+      const content::NativeWebKeyboardEvent& event) override;

  // views::View:
-  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override;

  // Register accelerators supported by the menu model.
  void RegisterAccelerators(ui::MenuModel* menu_model);
@@ -126,9 +141,6 @@ class NativeWindowViews : public NativeWindow,
  // 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::View* web_view_;  // Managed by inspectable_web_contents_.

@@ -139,6 +151,13 @@ class NativeWindowViews : public NativeWindow,

 #if defined(USE_X11)
  scoped_ptr<GlobalMenuBarX11> global_menu_bar_;
+
+  // Handles window state events.
+  scoped_ptr<WindowStateWatcher> window_state_watcher_;
+#elif defined(OS_WIN)
+  // Records window was whether restored from minimized state or maximized
+  // state.
+  bool is_minimized_;
 #endif

  // Handles unhandled keyboard messages coming back from the renderer process.
--- a/atom/browser/net/adapter_request_job.cc
+++ b/atom/browser/net/adapter_request_job.cc
@@ -6,6 +6,8 @@

 #include "base/threading/sequenced_worker_pool.h"
 #include "atom/browser/net/url_request_string_job.h"
+#include "atom/browser/net/asar/url_request_asar_job.h"
+#include "atom/common/asar/asar_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_error_job.h"
@@ -22,7 +24,7 @@ AdapterRequestJob::AdapterRequestJob(ProtocolHandler* protocol_handler,
 }

 void AdapterRequestJob::Start() {
-  DCHECK(!real_job_);
+  DCHECK(!real_job_.get());
  content::BrowserThread::PostTask(
      content::BrowserThread::UI,
      FROM_HERE,
@@ -31,35 +33,35 @@ void AdapterRequestJob::Start() {
 }

 void AdapterRequestJob::Kill() {
-  if (real_job_)  // Kill could happen when real_job_ is created.
+  if (real_job_.get())  // Kill could happen when real_job_ is created.
    real_job_->Kill();
 }

 bool AdapterRequestJob::ReadRawData(net::IOBuffer* buf,
                                    int buf_size,
                                    int *bytes_read) {
-  DCHECK(real_job_);
+  DCHECK(!real_job_.get());
  return real_job_->ReadRawData(buf, buf_size, bytes_read);
 }

 bool AdapterRequestJob::IsRedirectResponse(GURL* location,
                                           int* http_status_code) {
-  DCHECK(real_job_);
+  DCHECK(!real_job_.get());
  return real_job_->IsRedirectResponse(location, http_status_code);
 }

 net::Filter* AdapterRequestJob::SetupFilter() const {
-  DCHECK(real_job_);
+  DCHECK(!real_job_.get());
  return real_job_->SetupFilter();
 }

 bool AdapterRequestJob::GetMimeType(std::string* mime_type) const {
-  DCHECK(real_job_);
+  DCHECK(!real_job_.get());
  return real_job_->GetMimeType(mime_type);
 }

 bool AdapterRequestJob::GetCharset(std::string* charset) {
-  DCHECK(real_job_);
+  DCHECK(!real_job_.get());
  return real_job_->GetCharset(charset);
 }

@@ -88,13 +90,31 @@ void AdapterRequestJob::CreateStringJobAndStart(const std::string& mime_type,
 void AdapterRequestJob::CreateFileJobAndStart(const base::FilePath& path) {
  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));

-  real_job_ = new net::URLRequestFileJob(
-      request(),
-      network_delegate(),
-      path,
-      content::BrowserThread::GetBlockingPool()->
-          GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
+  base::FilePath asar_path, relative_path;
+  if (!asar::GetAsarArchivePath(path, &asar_path, &relative_path)) {
+    real_job_ = new net::URLRequestFileJob(
+        request(),
+        network_delegate(),
+        path,
+        content::BrowserThread::GetBlockingPool()->
+            GetTaskRunnerWithShutdownBehavior(
+                base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
+  } else {
+    auto archive = asar::GetOrCreateAsarArchive(asar_path);
+    if (archive)
+      real_job_ = new asar::URLRequestAsarJob(
+          request(),
+          network_delegate(),
+          archive,
+          relative_path,
+          content::BrowserThread::GetBlockingPool()->
+              GetTaskRunnerWithShutdownBehavior(
+                  base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
+    else
+      real_job_ = new net::URLRequestErrorJob(
+          request(), network_delegate(), net::ERR_FILE_NOT_FOUND);
+  }
+
  real_job_->Start();
 }

--- a/atom/browser/net/adapter_request_job.h
+++ b/atom/browser/net/adapter_request_job.h
@@ -28,16 +28,16 @@ class AdapterRequestJob : public net::URLRequestJob {

 public:
  // 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 IsRedirectResponse(GURL* location,
-                                  int* http_status_code) OVERRIDE;
-  virtual net::Filter* SetupFilter() const OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual bool GetCharset(std::string* charset) OVERRIDE;
+  void Start() override;
+  void Kill() override;
+  bool ReadRawData(net::IOBuffer* buf,
+                   int buf_size,
+                   int *bytes_read) override;
+  bool IsRedirectResponse(GURL* location,
+                          int* http_status_code) override;
+  net::Filter* SetupFilter() const override;
+  bool GetMimeType(std::string* mime_type) const override;
+  bool GetCharset(std::string* charset) override;

  base::WeakPtr<AdapterRequestJob> GetWeakPtr();

--- a/atom/browser/net/asar/asar_protocol_handler.cc
+++ b/atom/browser/net/asar/asar_protocol_handler.cc
@@ -6,6 +6,7 @@

 #include "atom/browser/net/asar/url_request_asar_job.h"
 #include "atom/common/asar/archive.h"
+#include "atom/common/asar/asar_util.h"
 #include "net/base/filename_util.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_error_job.h"
@@ -13,35 +14,6 @@

 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) {}
@@ -49,19 +21,6 @@ AsarProtocolHandler::AsarProtocolHandler(
 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 {
@@ -71,11 +30,11 @@ net::URLRequestJob* AsarProtocolHandler::MaybeCreateJob(
  // 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))
+  if (!GetAsarArchivePath(full_path, &asar_path, &relative_path))
    return new net::URLRequestFileJob(request, network_delegate, full_path,
                                      file_task_runner_);

-  Archive* archive = GetOrCreateAsarArchive(asar_path);
+  std::shared_ptr<Archive> archive = GetOrCreateAsarArchive(asar_path);
  if (!archive)
    return new net::URLRequestErrorJob(request, network_delegate,
                                       net::ERR_FILE_NOT_FOUND);
--- a/atom/browser/net/asar/asar_protocol_handler.h
+++ b/atom/browser/net/asar/asar_protocol_handler.h
@@ -5,8 +5,6 @@
 #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"

@@ -16,27 +14,21 @@ 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::URLRequestJob* MaybeCreateJob(
      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+      net::NetworkDelegate* network_delegate) const override;
+  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);
 };

--- a/atom/browser/net/asar/url_request_asar_job.cc
+++ b/atom/browser/net/asar/url_request_asar_job.cc
@@ -17,7 +17,7 @@ namespace asar {
 URLRequestAsarJob::URLRequestAsarJob(
    net::URLRequest* request,
    net::NetworkDelegate* network_delegate,
-    Archive* archive,
+    std::shared_ptr<Archive> archive,
    const base::FilePath& file_path,
    const scoped_refptr<base::TaskRunner>& file_task_runner)
    : net::URLRequestJob(request, network_delegate),
--- a/atom/browser/net/asar/url_request_asar_job.h
+++ b/atom/browser/net/asar/url_request_asar_job.h
@@ -5,6 +5,7 @@
 #ifndef ATOM_BROWSER_NET_ASAR_URL_REQUEST_ASAR_JOB_H_
 #define ATOM_BROWSER_NET_ASAR_URL_REQUEST_ASAR_JOB_H_

+#include <memory>
 #include <string>

 #include "atom/common/asar/archive.h"
@@ -27,17 +28,17 @@ class URLRequestAsarJob : public net::URLRequestJob {
 public:
  URLRequestAsarJob(net::URLRequest* request,
                    net::NetworkDelegate* network_delegate,
-                    Archive* archive,
+                    std::shared_ptr<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;
+  void Start() override;
+  void Kill() override;
+  bool ReadRawData(net::IOBuffer* buf,
+                   int buf_size,
+                   int* bytes_read) override;
+  bool GetMimeType(std::string* mime_type) const override;

 protected:
  virtual ~URLRequestAsarJob();
@@ -53,7 +54,7 @@ class URLRequestAsarJob : public net::URLRequestJob {
  // Callback after data is asynchronously read from the file into |buf|.
  void DidRead(scoped_refptr<net::IOBuffer> buf, int result);

-  Archive* archive_;
+  std::shared_ptr<Archive> archive_;
  Archive::FileInfo file_info_;
  base::FilePath file_path_;

--- a/atom/browser/net/atom_url_request_job_factory.cc
+++ b/atom/browser/net/atom_url_request_job_factory.cc
@@ -50,7 +50,7 @@ ProtocolHandler* AtomURLRequestJobFactory::ReplaceProtocol(

  base::AutoLock locked(lock_);
  if (!ContainsKey(protocol_handler_map_, scheme))
-    return NULL;
+    return nullptr;
  ProtocolHandler* original_protocol_handler = protocol_handler_map_[scheme];
  protocol_handler_map_[scheme] = protocol_handler;
  return original_protocol_handler;
@@ -63,7 +63,7 @@ ProtocolHandler* AtomURLRequestJobFactory::GetProtocolHandler(
  base::AutoLock locked(lock_);
  ProtocolHandlerMap::const_iterator it = protocol_handler_map_.find(scheme);
  if (it == protocol_handler_map_.end())
-    return NULL;
+    return nullptr;
  return it->second;
 }

@@ -82,10 +82,23 @@ net::URLRequestJob* AtomURLRequestJobFactory::MaybeCreateJobWithProtocolHandler(
  base::AutoLock locked(lock_);
  ProtocolHandlerMap::const_iterator it = protocol_handler_map_.find(scheme);
  if (it == protocol_handler_map_.end())
-    return NULL;
+    return nullptr;
  return it->second->MaybeCreateJob(request, network_delegate);
 }

+net::URLRequestJob* AtomURLRequestJobFactory::MaybeInterceptRedirect(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    const GURL& location) const {
+  return nullptr;
+}
+
+net::URLRequestJob* AtomURLRequestJobFactory::MaybeInterceptResponse(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  return nullptr;
+}
+
 bool AtomURLRequestJobFactory::IsHandledProtocol(
    const std::string& scheme) const {
  DCHECK(CalledOnValidThread());
--- a/atom/browser/net/atom_url_request_job_factory.h
+++ b/atom/browser/net/atom_url_request_job_factory.h
@@ -40,13 +40,20 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
  bool HasProtocolHandler(const std::string& scheme) const;

  // URLRequestJobFactory implementation
-  virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+  net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
      const std::string& scheme,
      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE;
-  virtual bool IsHandledURL(const GURL& url) const OVERRIDE;
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+      net::NetworkDelegate* network_delegate) const override;
+  net::URLRequestJob* MaybeInterceptRedirect(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      const GURL& location) const override;
+  net::URLRequestJob* MaybeInterceptResponse(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override;
+  bool IsHandledProtocol(const std::string& scheme) const override;
+  bool IsHandledURL(const GURL& url) const override;
+  bool IsSafeRedirectTarget(const GURL& location) const override;

 private:
  typedef std::map<std::string, ProtocolHandler*> ProtocolHandlerMap;
--- a/atom/browser/net/url_request_string_job.h
+++ b/atom/browser/net/url_request_string_job.h
@@ -20,10 +20,10 @@ class URLRequestStringJob : public net::URLRequestSimpleJob {
                      const std::string& data);

  // URLRequestSimpleJob:
-  virtual int GetData(std::string* mime_type,
-                      std::string* charset,
-                      std::string* data,
-                      const net::CompletionCallback& callback) const OVERRIDE;
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* data,
+              const net::CompletionCallback& callback) const override;

 private:
  std::string mime_type_;
--- a/atom/browser/node_debugger.h
+++ b/atom/browser/node_debugger.h
@@ -33,12 +33,12 @@ class NodeDebugger : public net::StreamListenSocket::Delegate {
  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;
+  void DidAccept(net::StreamListenSocket* server,
+                 scoped_ptr<net::StreamListenSocket> socket) override;
+  void DidRead(net::StreamListenSocket* socket,
+               const char* data,
+               int len) override;
+  void DidClose(net::StreamListenSocket* socket) override;

  v8::Isolate* isolate_;

--- a/atom/browser/resources/mac/Info.plist
+++ b/atom/browser/resources/mac/Info.plist
@@ -7,7 +7,7 @@
  <key>CFBundleExecutable</key>
  <string>${PRODUCT_NAME}</string>
  <key>CFBundleIdentifier</key>
-  <string>com.github.atom</string>
+  <string>com.github.atom-shell</string>
  <key>CFBundleInfoDictionaryVersion</key>
  <string>6.0</string>
  <key>CFBundleName</key>
@@ -17,7 +17,7 @@
  <key>CFBundleIconFile</key>
  <string>atom.icns</string>
  <key>CFBundleVersion</key>
-  <string>0.19.1</string>
+  <string>0.22.0</string>
  <key>LSMinimumSystemVersion</key>
  <string>10.8.0</string>
  <key>NSMainNibFile</key>
--- a/atom/browser/resources/win/atom.rc
+++ b/atom/browser/resources/win/atom.rc
@@ -7,7 +7,7 @@
 //
 // Generated from the TEXTINCLUDE 2 resource.
 //
-#include "afxres.h"
+#include "windows.h"

 /////////////////////////////////////////////////////////////////////////////
 #undef APSTUDIO_READONLY_SYMBOLS
@@ -31,7 +31,7 @@ END

 2 TEXTINCLUDE
 BEGIN
-    "#include ""afxres.h""\r\n"
+    "#include ""windows.h""\r\n"
    "\0"
 END

@@ -50,8 +50,8 @@ END
 //

 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 0,19,1,0
- PRODUCTVERSION 0,19,1,0
+ FILEVERSION 0,22,0,0
+ PRODUCTVERSION 0,22,0,0
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@@ -68,12 +68,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "GitHub, Inc."
            VALUE "FileDescription", "Atom-Shell"
-            VALUE "FileVersion", "0.19.1"
+            VALUE "FileVersion", "0.22.0"
            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.19.1"
+            VALUE "ProductVersion", "0.22.0"
            VALUE "SquirrelAwareVersion", "1"
        END
    END
--- a/atom/browser/ui/accelerator_util.cc
+++ b/atom/browser/ui/accelerator_util.cc
@@ -121,6 +121,9 @@ bool StringToAccelerator(const std::string& description,
      modifiers |= ui::EF_ALT_DOWN;
    } else if (tokens[i] == "shift") {
      modifiers |= ui::EF_SHIFT_DOWN;
+    } else if (tokens[i] == "plus") {
+      modifiers |= ui::EF_SHIFT_DOWN;
+      key = ui::VKEY_OEM_PLUS;
    } else if (tokens[i] == "tab") {
      key = ui::VKEY_TAB;
    } else if (tokens[i] == "space") {
--- a/atom/browser/ui/cocoa/atom_menu_controller.h
+++ b/atom/browser/ui/cocoa/atom_menu_controller.h
@@ -39,6 +39,9 @@ class MenuModel;
 // to the contents of the model after calling this will not be noticed.
 - (id)initWithModel:(ui::MenuModel*)model;

+// Populate current NSMenu with |model|.
+- (void)populateWithModel:(ui::MenuModel*)model;
+
 // Programmatically close the constructed menu.
 - (void)cancel;

--- a/atom/browser/ui/cocoa/atom_menu_controller.mm
+++ b/atom/browser/ui/cocoa/atom_menu_controller.mm
@@ -70,7 +70,8 @@ int EventFlagsFromNSEvent(NSEvent* event) {
@synthesize model = model_;

 - (id)init {
-  self = [super init];
+  if ((self = [super init]))
+    [self menu];
  return self;
 }

@@ -93,6 +94,22 @@ int EventFlagsFromNSEvent(NSEvent* event) {
  [super dealloc];
 }

+- (void)populateWithModel:(ui::MenuModel*)model {
+  if (!menu_)
+    return;
+
+  model_ = model;
+  [menu_ removeAllItems];
+
+  const int count = model->GetItemCount();
+  for (int index = 0; index < count; index++) {
+    if (model->GetTypeAt(index) == ui::MenuModel::TYPE_SEPARATOR)
+      [self addSeparatorToMenu:menu_ atIndex:index];
+    else
+      [self addItemToMenu:menu_ atIndex:index fromModel:model];
+  }
+}
+
 - (void)cancel {
  if (isMenuOpen_) {
    [menu_ cancelTracking];
@@ -235,10 +252,13 @@ int EventFlagsFromNSEvent(NSEvent* event) {
 }

 - (NSMenu*)menu {
-  if (!menu_ && model_) {
-    menu_.reset([[self menuFromModel:model_] retain]);
-    [menu_ setDelegate:self];
-  }
+  if (menu_)
+    return menu_.get();
+
+  menu_.reset([[NSMenu alloc] initWithTitle:@""]);
+  [menu_ setDelegate:self];
+  if (model_)
+    [self populateWithModel:model_];
  return menu_.get();
 }

--- a/atom/browser/ui/file_dialog_gtk.cc
+++ b/atom/browser/ui/file_dialog_gtk.cc
@@ -16,7 +16,7 @@

 #include "atom/browser/native_window.h"
 #include "base/callback.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/ui/libgtk2ui/gtk2_signal.h"
 #include "ui/aura/window.h"
--- a/atom/browser/ui/file_dialog_mac.mm
+++ b/atom/browser/ui/file_dialog_mac.mm
@@ -8,7 +8,8 @@
 #import <CoreServices/CoreServices.h>

 #include "atom/browser/native_window.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
+#include "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/strings/sys_string_conversions.h"
--- a/atom/browser/ui/file_dialog_win.cc
+++ b/atom/browser/ui/file_dialog_win.cc
@@ -10,11 +10,12 @@
 #include <shlobj.h>

 #include "atom/browser/native_window_views.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/strings/string_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread.h"
 #include "base/win/registry.h"
 #include "third_party/wtl/include/atlapp.h"
 #include "third_party/wtl/include/atldlgs.h"
@@ -105,7 +106,7 @@ class FileDialog {
                                             NULL,
                                             IID_PPV_ARGS(&folder_item));
    if (SUCCEEDED(hr))
-      GetPtr()->SetDefaultFolder(folder_item);
+      GetPtr()->SetFolder(folder_item);
  }

  scoped_ptr<T> dialog_;
@@ -113,6 +114,50 @@ class FileDialog {
  DISALLOW_COPY_AND_ASSIGN(FileDialog);
 };

+struct RunState {
+  base::Thread* dialog_thread;
+  base::MessageLoop* ui_message_loop;
+};
+
+bool CreateDialogThread(RunState* run_state) {
+  base::Thread* thread = new base::Thread("AtomShell_FileDialogThread");
+  thread->init_com_with_mta(false);
+  if (!thread->Start())
+    return false;
+
+  run_state->dialog_thread = thread;
+  run_state->ui_message_loop = base::MessageLoop::current();
+  return true;
+}
+
+void RunOpenDialogInNewThread(const RunState& run_state,
+                              atom::NativeWindow* parent,
+                              const std::string& title,
+                              const base::FilePath& default_path,
+                              const Filters& filters,
+                              int properties,
+                              const OpenDialogCallback& callback) {
+  std::vector<base::FilePath> paths;
+  bool result = ShowOpenDialog(parent, title, default_path, filters, properties,
+                               &paths);
+  run_state.ui_message_loop->PostTask(FROM_HERE,
+                                      base::Bind(callback, result, paths));
+  run_state.ui_message_loop->DeleteSoon(FROM_HERE, run_state.dialog_thread);
+}
+
+void RunSaveDialogInNewThread(const RunState& run_state,
+                              atom::NativeWindow* parent,
+                              const std::string& title,
+                              const base::FilePath& default_path,
+                              const Filters& filters,
+                              const SaveDialogCallback& callback) {
+  base::FilePath path;
+  bool result = ShowSaveDialog(parent, title, default_path, filters, &path);
+  run_state.ui_message_loop->PostTask(FROM_HERE,
+                                      base::Bind(callback, result, path));
+  run_state.ui_message_loop->DeleteSoon(FROM_HERE, run_state.dialog_thread);
+}
+
 }  // namespace

 bool ShowOpenDialog(atom::NativeWindow* parent_window,
@@ -162,20 +207,22 @@ bool ShowOpenDialog(atom::NativeWindow* parent_window,
  return true;
 }

-void ShowOpenDialog(atom::NativeWindow* parent_window,
+void ShowOpenDialog(atom::NativeWindow* parent,
                    const std::string& title,
                    const base::FilePath& default_path,
                    const Filters& filters,
                    int properties,
                    const OpenDialogCallback& callback) {
-  std::vector<base::FilePath> paths;
-  bool result = ShowOpenDialog(parent_window,
-                               title,
-                               default_path,
-                               filters,
-                               properties,
-                               &paths);
-  callback.Run(result, paths);
+  RunState run_state;
+  if (!CreateDialogThread(&run_state)) {
+    callback.Run(false, std::vector<base::FilePath>());
+    return;
+  }
+
+  run_state.dialog_thread->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&RunOpenDialogInNewThread, run_state, parent, title,
+                 default_path, filters, properties, callback));
 }

 bool ShowSaveDialog(atom::NativeWindow* parent_window,
@@ -218,15 +265,21 @@ bool ShowSaveDialog(atom::NativeWindow* parent_window,
  return true;
 }

-void ShowSaveDialog(atom::NativeWindow* parent_window,
+void ShowSaveDialog(atom::NativeWindow* parent,
                    const std::string& title,
                    const base::FilePath& default_path,
                    const Filters& filters,
                    const SaveDialogCallback& callback) {
-  base::FilePath path;
-  bool result = ShowSaveDialog(parent_window, title, default_path, filters,
-                               &path);
-  callback.Run(result, path);
+  RunState run_state;
+  if (!CreateDialogThread(&run_state)) {
+    callback.Run(false, base::FilePath());
+    return;
+  }
+
+  run_state.dialog_thread->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&RunSaveDialogInNewThread, run_state, parent, title,
+                 default_path, filters, callback));
 }

 }  // namespace file_dialog
--- a/atom/browser/ui/message_box.h
+++ b/atom/browser/ui/message_box.h
@@ -9,6 +9,11 @@
 #include <vector>

 #include "base/callback_forward.h"
+#include "base/strings/string16.h"
+
+namespace gfx {
+class ImageSkia;
+}

 namespace atom {

@@ -27,7 +32,8 @@ int ShowMessageBox(NativeWindow* parent_window,
                   const std::vector<std::string>& buttons,
                   const std::string& title,
                   const std::string& message,
-                   const std::string& detail);
+                   const std::string& detail,
+                   const gfx::ImageSkia& icon);

 void ShowMessageBox(NativeWindow* parent_window,
                    MessageBoxType type,
@@ -35,8 +41,13 @@ void ShowMessageBox(NativeWindow* parent_window,
                    const std::string& title,
                    const std::string& message,
                    const std::string& detail,
+                    const gfx::ImageSkia& icon,
                    const MessageBoxCallback& callback);

+// Like ShowMessageBox with simplest settings, but safe to call at very early
+// stage of application.
+void ShowErrorBox(const base::string16& title, const base::string16& content);
+
 }  // namespace atom

 #endif  // ATOM_BROWSER_UI_MESSAGE_BOX_H_
--- a/Show More
+++ b/Show More