Bump v0.32.1

Fix session not getting persisted on exit

.gitignore

@@ -4,9 +4,16 @@
 /external_binaries/
 /out/
 /vendor/brightray/vendor/download/
+/vendor/debian_wheezy_arm-sysroot/
+/vendor/debian_wheezy_i386-sysroot/
 /vendor/python_26/
 /vendor/npm/
+/vendor/llvm/
+/vendor/llvm-build/
+/vendor/.gclient
 node_modules/
 *.xcodeproj
 *.swp
 *.pyc
+debug.log
+npm-debug.log

.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
@@ -13,3 +13,12 @@
 [submodule "vendor/native_mate"]
 	path = vendor/native_mate
 	url = https://github.com/zcbenz/native-mate.git
+[submodule "vendor/crashpad"]
+	path = vendor/crashpad
+	url = https://github.com/atom/crashpad.git
+[submodule "vendor/requests"]
+	path = vendor/requests
+	url = https://github.com/kennethreitz/requests
+[submodule "vendor/boto"]
+	path = vendor/boto
+	url = https://github.com/boto/boto.git

.travis.yml

@@ -1,15 +1,28 @@
+git:
+  depth: 10
+notifications:
+  email: false
+
 language: cpp
 compiler: clang
 os:
   - linux
   - osx
+env:
+  - TARGET_ARCH=x64
 
-notifications:
-  email:
-    on_success: never
-    on_failure: change
+matrix:
+  include:
+    - os: linux
+      env: TARGET_ARCH=arm
+    - os: linux
+      env: TARGET_ARCH=ia32
+  allow_failures:
+    - env: TARGET_ARCH=arm
+    - env: TARGET_ARCH=ia32
 
 script: './script/cibuild'
 
-git:
-  depth: 10
+branches:
+  only:
+    - master

CONTRIBUTING.md

@@ -0,0 +1,74 @@
+# Contributing to Electron
+
+:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
+
+This project adheres to the [Contributor Covenant 1.2](http://contributor-covenant.org/version/1/2/0).
+By participating, you are expected to uphold this code. Please report unacceptable behavior to atom@github.com.
+
+The following is a set of guidelines for contributing to Electron.
+These are just guidelines, not rules, use your best judgment and feel free to
+propose changes to this document in a pull request.
+
+## Submitting Issues
+
+* You can create an issue [here](https://github.com/atom/electron/issues/new),
+but before doing that please read the notes below and include as many details as
+possible with your report. If you can, please include:
+  * The version of Electron you are using
+  * The operating system you are using
+  * If applicable, what you were doing when the issue arose and what you
+  expected to happen
+* Other things that will help resolve your issue:
+  * Screenshots and animated GIFs
+  * Error output that appears in your terminal, dev tools or as an alert
+  * Perform a [cursory search](https://github.com/atom/electron/issues?utf8=✓&q=is%3Aissue+)
+  to see if a similar issue has already been submitted
+
+## Submitting Pull Requests
+
+* Include screenshots and animated GIFs in your pull request whenever possible.
+* Follow the CoffeeScript, JavaScript, C++ and Python [coding style defined in docs](/docs/development/coding-style.md).
+* Write documentation in [Markdown](https://daringfireball.net/projects/markdown).
+* Use short, present tense commit messages. See [Commit Message Styleguide](#git-commit-messages-styleguide).
+
+## Styleguides
+
+### General Code
+
+* End files with a newline.
+* Place requires in the following order:
+  * Built in Node Modules (such as `path`)
+  * Built in Electron Modules (such as `ipc`, `app`)
+  * Local Modules (using relative paths)
+* Place class properties in the following order:
+  * Class methods and properties (methods starting with a `@`)
+  * Instance methods and properties
+* Avoid platform-dependent code:
+  * Use `path.join()` to concatenate filenames.
+  * Use `os.tmpdir()` rather than `/tmp` when you need to reference the
+    temporary directory.
+* Using a plain `return` when returning explicitly at the end of a function.
+  * Not `return null`, `return undefined`, `null`, or `undefined`
+
+### Git Commit Messages
+
+* Use the present tense ("Add feature" not "Added feature")
+* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+* Limit the first line to 72 characters or less
+* Reference issues and pull requests liberally
+* Consider starting the commit message with an applicable emoji:
+  * :art: `:art:` when improving the format/structure of the code
+  * :racehorse: `:racehorse:` when improving performance
+  * :non-potable_water: `:non-potable_water:` when plugging memory leaks
+  * :memo: `:memo:` when writing docs
+  * :penguin: `:penguin:` when fixing something on Linux
+  * :apple: `:apple:` when fixing something on Mac OS
+  * :checkered_flag: `:checkered_flag:` when fixing something on Windows
+  * :bug: `:bug:` when fixing a bug
+  * :fire: `:fire:` when removing code or files
+  * :green_heart: `:green_heart:` when fixing the CI build
+  * :white_check_mark: `:white_check_mark:` when adding tests
+  * :lock: `:lock:` when dealing with security
+  * :arrow_up: `:arrow_up:` when upgrading dependencies
+  * :arrow_down: `:arrow_down:` when downgrading dependencies
+  * :shirt: `:shirt:` when removing linter warnings

README-ko.md

@@ -0,0 +1,54 @@
+[![Electron Logo](http://electron.atom.io/images/electron-logo.svg)](http://electron.atom.io/)
+
+[![Build Status](https://travis-ci.org/atom/electron.svg?branch=master)](https://travis-ci.org/atom/electron)
+[![devDependency Status](https://david-dm.org/atom/electron/dev-status.svg)](https://david-dm.org/atom/electron#info=devDependencies)
+[![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
+
+### [Electron](https://github.com/atom/electron/) 한국어 참조문서
+
+:zap: *프레임워크 이름이 Atom Shell에서 Electron으로 변경되었습니다* :zap:
+
+Electron 프레임워크는 JavaScript, HTML 그리고 CSS를 사용하여 Cross-Platform 데스크톱 어플리케이션을 개발할 수 있도록 해주는 프레임워크입니다. 이 프레임워크는 [io.js](http://iojs.org) 와
+[Chromium](http://www.chromium.org)을 기반으로 만들어 졌으며 [Atom Editor](https://github.com/atom/atom)에 사용되고 있습니다.
+
+Electron에 대한 중요한 알림을 받고 싶다면 Twitter에서 [@ElectronJS](https://twitter.com/electronjs)를 팔로우 하세요.
+
+이 프로젝트는 기여자 규약 1.2를 준수합니다. 이 프로젝트에 참여할 때 코드를 유지해야 합니다. 받아들일 수 없는 행동은 atom@github.com로 보고 하십시오.
+
+## 다운로드
+
+Linux, Windows, Mac용으로 미리 빌드된 Electron 바이너리와 디버그 심볼이 준비되어 있습니다. [releases](https://github.com/atom/electron/releases) 페이지에서 받아 볼 수 있습니다.
+
+또한 [`npm`](https://docs.npmjs.com/)을 통해 미리 빌드된 Electron 바이너리를 받을 수도 있습니다:
+
+```sh
+# $PATH에 `electron` 커맨드를 등록하고 전역에 설치합니다.
+npm install electron-prebuilt -g
+
+# 개발 의존성 모듈 형태로 설치합니다.
+npm install electron-prebuilt --save-dev
+```
+
+### 미러
+
+- [China](https://npm.taobao.org/mirrors/electron)
+
+## 참조 문서
+
+[Docs](https://github.com/atom/electron/tree/master/docs/README.md)에 개발 가이드와 API 레퍼런스가 있습니다.
+Electron을 빌드 하는 방법과 프로젝트에 기여하는 방법도 문서에 포함되어 있으니 참고하시기 바랍니다.
+
+## 참조 문서 (번역)
+
+- [브라질 포르투칼어](https://github.com/atom/electron/tree/master/docs-translations/pt-BR)
+- [한국어](https://github.com/atom/electron/tree/master/docs-translations/ko)
+- [일본어](https://github.com/atom/electron/tree/master/docs-translations/jp)
+- [스페인어](https://github.com/atom/electron/tree/master/docs-translations/es)
+- [중국어 간체](https://github.com/atom/electron/tree/master/docs-translations/zh-CN)
+- [중국어 번체](https://github.com/atom/electron/tree/master/docs-translations/zh-TW)
+
+## 커뮤니티
+
+[Atom 포럼내의 `electron` 카테고리](http://discuss.atom.io/category/electron)와 Freenode `#atom-shell` 채팅 채널에서 활발하게 토론이 이어지고 있습니다.
+
+[awesome-electron](https://github.com/sindresorhus/awesome-electron) 프로젝트엔 커뮤니티가 운영중인 유용한 예제 어플리케이션과 도구, 리소스가 있으니 한번 참고해 보시기 바랍니다.

README.md

@@ -1,22 +1,60 @@
-# Atom Shell [![Build Status](https://travis-ci.org/atom/atom-shell.svg?branch=master)](https://travis-ci.org/atom/atom-shell)
+[![Electron Logo](http://electron.atom.io/images/electron-logo.svg)](http://electron.atom.io/)
 
-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
+[![Build Status](https://travis-ci.org/atom/electron.svg?branch=master)](https://travis-ci.org/atom/electron)
+[![devDependency Status](https://david-dm.org/atom/electron/dev-status.svg)](https://david-dm.org/atom/electron#info=devDependencies)
+[![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
+
+:zap: *formerly known as Atom Shell* :zap:
+
+The Electron framework lets you write cross-platform desktop applications
+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).
 
+Follow [@ElectronJS](https://twitter.com/electronjs) on Twitter for important
+announcements.
+
+This project adheres to the [Contributor Covenant 1.2](http://contributor-covenant.org/version/1/2/0).
+By participating, you are expected to uphold this code. Please report unacceptable behavior to atom@github.com.
+
 ## Downloads
 
-Prebuilt binaries of atom-shell for Linux, Windows and Mac can be found on the
-[releases](https://github.com/atom/atom-shell/releases) page.
+Prebuilt binaries and debug symbols of Electron for Linux, Windows and Mac can
+be found on the [releases](https://github.com/atom/electron/releases) page.
+
+You can also use [`npm`](https://docs.npmjs.com/) to install prebuilt electron
+binaries:
+
+```sh
+# Install the `electron` command globally in your $PATH
+npm install electron-prebuilt -g
+
+# Install as a development dependency
+npm install electron-prebuilt --save-dev
+```
+
+### Mirrors
+
+- [China](https://npm.taobao.org/mirrors/electron)
 
 ## Documentation
 
 Guides and the API reference are located in the
-[docs](https://github.com/atom/atom-shell/tree/master/docs) directory. It also
-contains documents describing how to build and contribute to atom-shell.
+[docs](https://github.com/atom/electron/tree/master/docs) directory. It also
+contains documents describing how to build and contribute to Electron.
+
+## Documentation Translations
+
+- [Brazilian Portuguese](https://github.com/atom/electron/tree/master/docs-translations/pt-BR)
+- [Korean](https://github.com/atom/electron/tree/master/docs-translations/ko)
+- [Japanese](https://github.com/atom/electron/tree/master/docs-translations/jp)
+- [Spanish](https://github.com/atom/electron/tree/master/docs-translations/es)
+- [Simplified Chinese](https://github.com/atom/electron/tree/master/docs-translations/zh-CN)
+- [Traditional Chinese](https://github.com/atom/electron/tree/master/docs-translations/zh-TW)
 
 ## Community
 
-There is an [`atom-shell` category on the Atom forums](http://discuss.atom.io/category/atom-shell)
+There is an [`electron` category on the Atom forums](http://discuss.atom.io/category/electron)
 as well as an `#atom-shell` channel on Freenode.
+
+Check out [awesome-electron](https://github.com/sindresorhus/awesome-electron) for a community maintained list of useful example apps, tools and resources.

appveyor.yml

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

atom.gyp

@@ -1,392 +1,34 @@
 {
   'variables': {
-    'includes': [
-      'vendor/native_mate/native_mate_files.gypi',
-    ],
-    'project_name%': 'atom',
-    'product_name%': 'Atom',
-    'app_sources': [
-      'atom/app/atom_main.cc',
-      'atom/app/atom_main.h',
-    ],
-    'bundle_sources': [
-      'atom/browser/resources/mac/atom.icns',
-    ],
-    'coffee_sources': [
-      'atom/browser/api/lib/app.coffee',
-      'atom/browser/api/lib/atom-delegate.coffee',
-      'atom/browser/api/lib/auto-updater.coffee',
-      'atom/browser/api/lib/browser-window.coffee',
-      'atom/browser/api/lib/content-tracing.coffee',
-      'atom/browser/api/lib/dialog.coffee',
-      'atom/browser/api/lib/global-shortcut.coffee',
-      'atom/browser/api/lib/ipc.coffee',
-      'atom/browser/api/lib/menu.coffee',
-      'atom/browser/api/lib/menu-item.coffee',
-      'atom/browser/api/lib/power-monitor.coffee',
-      'atom/browser/api/lib/protocol.coffee',
-      'atom/browser/api/lib/tray.coffee',
-      'atom/browser/api/lib/web-contents.coffee',
-      'atom/browser/lib/chrome-extension.coffee',
-      'atom/browser/lib/guest-view-manager.coffee',
-      'atom/browser/lib/guest-window-manager.coffee',
-      'atom/browser/lib/init.coffee',
-      'atom/browser/lib/objects-registry.coffee',
-      'atom/browser/lib/rpc-server.coffee',
-      'atom/common/api/lib/callbacks-registry.coffee',
-      'atom/common/api/lib/clipboard.coffee',
-      'atom/common/api/lib/crash-reporter.coffee',
-      'atom/common/api/lib/id-weak-map.coffee',
-      'atom/common/api/lib/original-fs.coffee',
-      'atom/common/api/lib/screen.coffee',
-      'atom/common/api/lib/shell.coffee',
-      'atom/common/lib/init.coffee',
-      'atom/common/lib/asar.coffee',
-      'atom/renderer/lib/chrome-api.coffee',
-      'atom/renderer/lib/init.coffee',
-      'atom/renderer/lib/inspector.coffee',
-      'atom/renderer/lib/override.coffee',
-      'atom/renderer/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/web-frame.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/browser/api/atom_api_app.cc',
-      'atom/browser/api/atom_api_app.h',
-      'atom/browser/api/atom_api_auto_updater.cc',
-      'atom/browser/api/atom_api_auto_updater.h',
-      'atom/browser/api/atom_api_content_tracing.cc',
-      'atom/browser/api/atom_api_dialog.cc',
-      'atom/browser/api/atom_api_global_shortcut.cc',
-      'atom/browser/api/atom_api_global_shortcut.h',
-      'atom/browser/api/atom_api_menu.cc',
-      'atom/browser/api/atom_api_menu.h',
-      'atom/browser/api/atom_api_menu_views.cc',
-      'atom/browser/api/atom_api_menu_views.h',
-      'atom/browser/api/atom_api_menu_mac.h',
-      'atom/browser/api/atom_api_menu_mac.mm',
-      'atom/browser/api/atom_api_power_monitor.cc',
-      'atom/browser/api/atom_api_power_monitor.h',
-      'atom/browser/api/atom_api_protocol.cc',
-      'atom/browser/api/atom_api_protocol.h',
-      'atom/browser/api/atom_api_tray.cc',
-      'atom/browser/api/atom_api_tray.h',
-      'atom/browser/api/atom_api_web_contents.cc',
-      'atom/browser/api/atom_api_web_contents.h',
-      'atom/browser/api/atom_api_window.cc',
-      'atom/browser/api/atom_api_window.h',
-      'atom/browser/api/event.cc',
-      'atom/browser/api/event.h',
-      'atom/browser/api/event_emitter.cc',
-      'atom/browser/api/event_emitter.h',
-      'atom/browser/auto_updater.cc',
-      'atom/browser/auto_updater.h',
-      'atom/browser/auto_updater_delegate.h',
-      'atom/browser/auto_updater_linux.cc',
-      'atom/browser/auto_updater_mac.mm',
-      'atom/browser/auto_updater_win.cc',
-      'atom/browser/atom_access_token_store.cc',
-      'atom/browser/atom_access_token_store.h',
-      'atom/browser/atom_browser_client.cc',
-      'atom/browser/atom_browser_client.h',
-      'atom/browser/atom_browser_context.cc',
-      'atom/browser/atom_browser_context.h',
-      'atom/browser/atom_browser_main_parts.cc',
-      'atom/browser/atom_browser_main_parts.h',
-      'atom/browser/atom_browser_main_parts_linux.cc',
-      '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_speech_recognition_manager_delegate.cc',
-      'atom/browser/atom_speech_recognition_manager_delegate.h',
-      'atom/browser/browser.cc',
-      'atom/browser/browser.h',
-      'atom/browser/browser_linux.cc',
-      'atom/browser/browser_mac.mm',
-      'atom/browser/browser_win.cc',
-      'atom/browser/browser_observer.h',
-      'atom/browser/javascript_environment.cc',
-      'atom/browser/javascript_environment.h',
-      'atom/browser/mac/atom_application.h',
-      'atom/browser/mac/atom_application.mm',
-      'atom/browser/mac/atom_application_delegate.h',
-      'atom/browser/mac/atom_application_delegate.mm',
-      'atom/browser/native_window.cc',
-      'atom/browser/native_window.h',
-      'atom/browser/native_window_views.cc',
-      'atom/browser/native_window_views.h',
-      'atom/browser/native_window_mac.h',
-      'atom/browser/native_window_mac.mm',
-      'atom/browser/native_window_observer.h',
-      'atom/browser/net/adapter_request_job.cc',
-      'atom/browser/net/adapter_request_job.h',
-      'atom/browser/net/asar/asar_protocol_handler.cc',
-      'atom/browser/net/asar/asar_protocol_handler.h',
-      'atom/browser/net/asar/url_request_asar_job.cc',
-      'atom/browser/net/asar/url_request_asar_job.h',
-      'atom/browser/net/atom_url_request_job_factory.cc',
-      'atom/browser/net/atom_url_request_job_factory.h',
-      'atom/browser/net/url_request_string_job.cc',
-      'atom/browser/net/url_request_string_job.h',
-      'atom/browser/node_debugger.cc',
-      'atom/browser/node_debugger.h',
-      'atom/browser/ui/accelerator_util.cc',
-      'atom/browser/ui/accelerator_util.h',
-      'atom/browser/ui/accelerator_util_mac.mm',
-      'atom/browser/ui/accelerator_util_views.cc',
-      'atom/browser/ui/cocoa/atom_menu_controller.h',
-      'atom/browser/ui/cocoa/atom_menu_controller.mm',
-      'atom/browser/ui/cocoa/event_processing_window.h',
-      'atom/browser/ui/cocoa/event_processing_window.mm',
-      'atom/browser/ui/file_dialog.h',
-      'atom/browser/ui/file_dialog_gtk.cc',
-      'atom/browser/ui/file_dialog_mac.mm',
-      'atom/browser/ui/file_dialog_win.cc',
-      'atom/browser/ui/message_box.h',
-      'atom/browser/ui/message_box_mac.mm',
-      'atom/browser/ui/message_box_views.cc',
-      'atom/browser/ui/tray_icon.cc',
-      'atom/browser/ui/tray_icon.h',
-      'atom/browser/ui/tray_icon_gtk.cc',
-      'atom/browser/ui/tray_icon_gtk.h',
-      'atom/browser/ui/tray_icon_cocoa.h',
-      'atom/browser/ui/tray_icon_cocoa.mm',
-      'atom/browser/ui/tray_icon_observer.h',
-      'atom/browser/ui/tray_icon_win.cc',
-      'atom/browser/ui/views/frameless_view.cc',
-      'atom/browser/ui/views/frameless_view.h',
-      'atom/browser/ui/views/global_menu_bar_x11.cc',
-      'atom/browser/ui/views/global_menu_bar_x11.h',
-      'atom/browser/ui/views/menu_bar.cc',
-      'atom/browser/ui/views/menu_bar.h',
-      'atom/browser/ui/views/menu_delegate.cc',
-      'atom/browser/ui/views/menu_delegate.h',
-      'atom/browser/ui/views/menu_layout.cc',
-      'atom/browser/ui/views/menu_layout.h',
-      'atom/browser/ui/views/submenu_button.cc',
-      'atom/browser/ui/views/submenu_button.h',
-      'atom/browser/ui/views/win_frame_view.cc',
-      'atom/browser/ui/views/win_frame_view.h',
-      'atom/browser/ui/win/notify_icon_host.cc',
-      'atom/browser/ui/win/notify_icon_host.h',
-      'atom/browser/ui/win/notify_icon.cc',
-      'atom/browser/ui/win/notify_icon.h',
-      'atom/browser/ui/x/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_dialog_helper.cc',
-      'atom/browser/web_dialog_helper.h',
-      'atom/browser/window_list.cc',
-      'atom/browser/window_list.h',
-      'atom/browser/window_list_observer.h',
-      'atom/common/api/api_messages.h',
-      'atom/common/api/atom_api_asar.cc',
-      'atom/common/api/atom_api_clipboard.cc',
-      'atom/common/api/atom_api_crash_reporter.cc',
-      'atom/common/api/atom_api_id_weak_map.cc',
-      'atom/common/api/atom_api_id_weak_map.h',
-      'atom/common/api/atom_api_screen.cc',
-      'atom/common/api/atom_api_screen.h',
-      'atom/common/api/atom_api_shell.cc',
-      'atom/common/api/atom_api_v8_util.cc',
-      'atom/common/api/atom_bindings.cc',
-      'atom/common/api/atom_bindings.h',
-      'atom/common/api/object_life_monitor.cc',
-      'atom/common/api/object_life_monitor.h',
-      'atom/common/asar/archive.cc',
-      'atom/common/asar/archive.h',
-      'atom/common/asar/scoped_temporary_file.cc',
-      'atom/common/asar/scoped_temporary_file.h',
-      'atom/common/common_message_generator.cc',
-      'atom/common/common_message_generator.h',
-      'atom/common/crash_reporter/crash_reporter.cc',
-      'atom/common/crash_reporter/crash_reporter.h',
-      'atom/common/crash_reporter/crash_reporter_linux.cc',
-      'atom/common/crash_reporter/crash_reporter_linux.h',
-      'atom/common/crash_reporter/crash_reporter_mac.h',
-      'atom/common/crash_reporter/crash_reporter_mac.mm',
-      'atom/common/crash_reporter/crash_reporter_win.cc',
-      'atom/common/crash_reporter/crash_reporter_win.h',
-      'atom/common/crash_reporter/linux/crash_dump_handler.cc',
-      'atom/common/crash_reporter/linux/crash_dump_handler.h',
-      'atom/common/crash_reporter/win/crash_service.cc',
-      'atom/common/crash_reporter/win/crash_service.h',
-      'atom/common/crash_reporter/win/crash_service_main.cc',
-      'atom/common/crash_reporter/win/crash_service_main.h',
-      'atom/common/draggable_region.cc',
-      'atom/common/draggable_region.h',
-      'atom/common/google_api_key.h',
-      'atom/common/linux/application_info.cc',
-      'atom/common/native_mate_converters/accelerator_converter.cc',
-      'atom/common/native_mate_converters/accelerator_converter.h',
-      'atom/common/native_mate_converters/file_path_converter.h',
-      'atom/common/native_mate_converters/gfx_converter.h',
-      'atom/common/native_mate_converters/gurl_converter.h',
-      'atom/common/native_mate_converters/image_converter.cc',
-      'atom/common/native_mate_converters/image_converter.h',
-      'atom/common/native_mate_converters/image_converter_mac.mm',
-      'atom/common/native_mate_converters/string16_converter.h',
-      'atom/common/native_mate_converters/v8_value_converter.cc',
-      'atom/common/native_mate_converters/v8_value_converter.h',
-      'atom/common/native_mate_converters/value_converter.cc',
-      'atom/common/native_mate_converters/value_converter.h',
-      'atom/common/node_bindings.cc',
-      'atom/common/node_bindings.h',
-      'atom/common/node_bindings_linux.cc',
-      'atom/common/node_bindings_linux.h',
-      'atom/common/node_bindings_mac.cc',
-      'atom/common/node_bindings_mac.h',
-      'atom/common/node_bindings_win.cc',
-      'atom/common/node_bindings_win.h',
-      'atom/common/node_includes.h',
-      'atom/common/options_switches.cc',
-      'atom/common/options_switches.h',
-      'atom/common/platform_util.h',
-      'atom/common/platform_util_linux.cc',
-      'atom/common/platform_util_mac.mm',
-      'atom/common/platform_util_win.cc',
-      'atom/renderer/api/atom_api_renderer_ipc.cc',
-      'atom/renderer/api/atom_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/api/atom_renderer_bindings.cc',
-      'atom/renderer/api/atom_renderer_bindings.h',
-      'atom/renderer/atom_render_view_observer.cc',
-      'atom/renderer/atom_render_view_observer.h',
-      'atom/renderer/atom_renderer_client.cc',
-      'atom/renderer/atom_renderer_client.h',
-      'chromium_src/chrome/browser/browser_process.cc',
-      'chromium_src/chrome/browser/browser_process.h',
-      'chromium_src/chrome/browser/chrome_notification_types.h',
-      'chromium_src/chrome/browser/extensions/global_shortcut_listener.cc',
-      'chromium_src/chrome/browser/extensions/global_shortcut_listener.h',
-      'chromium_src/chrome/browser/extensions/global_shortcut_listener_mac.mm',
-      'chromium_src/chrome/browser/extensions/global_shortcut_listener_mac.h',
-      'chromium_src/chrome/browser/extensions/global_shortcut_listener_x11.cc',
-      'chromium_src/chrome/browser/extensions/global_shortcut_listener_x11.h',
-      'chromium_src/chrome/browser/extensions/global_shortcut_listener_win.cc',
-      'chromium_src/chrome/browser/extensions/global_shortcut_listener_win.h',
-      'chromium_src/chrome/browser/printing/print_job.cc',
-      'chromium_src/chrome/browser/printing/print_job.h',
-      'chromium_src/chrome/browser/printing/print_job_manager.cc',
-      'chromium_src/chrome/browser/printing/print_job_manager.h',
-      'chromium_src/chrome/browser/printing/print_job_worker.cc',
-      'chromium_src/chrome/browser/printing/print_job_worker.h',
-      'chromium_src/chrome/browser/printing/print_job_worker_owner.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',
-      'chromium_src/chrome/browser/printing/print_view_manager_basic.cc',
-      'chromium_src/chrome/browser/printing/print_view_manager_basic.h',
-      'chromium_src/chrome/browser/printing/print_view_manager_observer.h',
-      'chromium_src/chrome/browser/printing/printer_query.cc',
-      'chromium_src/chrome/browser/printing/printer_query.h',
-      'chromium_src/chrome/browser/printing/printing_message_filter.cc',
-      'chromium_src/chrome/browser/printing/printing_message_filter.h',
-      'chromium_src/chrome/browser/speech/tts_controller.h',
-      'chromium_src/chrome/browser/speech/tts_controller_impl.cc',
-      'chromium_src/chrome/browser/speech/tts_controller_impl.h',
-      'chromium_src/chrome/browser/speech/tts_linux.cc',
-      'chromium_src/chrome/browser/speech/tts_mac.mm',
-      'chromium_src/chrome/browser/speech/tts_message_filter.cc',
-      'chromium_src/chrome/browser/speech/tts_message_filter.h',
-      'chromium_src/chrome/browser/speech/tts_platform.cc',
-      'chromium_src/chrome/browser/speech/tts_platform.h',
-      'chromium_src/chrome/browser/speech/tts_win.cc',
-      'chromium_src/chrome/browser/ui/browser_dialogs.h',
-      '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/views/frame/global_menu_bar_registrar_x11.cc',
-      'chromium_src/chrome/browser/ui/views/frame/global_menu_bar_registrar_x11.h',
-      'chromium_src/chrome/common/print_messages.cc',
-      'chromium_src/chrome/common/print_messages.h',
-      'chromium_src/chrome/common/tts_messages.h',
-      'chromium_src/chrome/common/tts_utterance_request.cc',
-      'chromium_src/chrome/common/tts_utterance_request.h',
-      'chromium_src/chrome/renderer/printing/print_web_view_helper.cc',
-      'chromium_src/chrome/renderer/printing/print_web_view_helper_linux.cc',
-      'chromium_src/chrome/renderer/printing/print_web_view_helper_mac.mm',
-      'chromium_src/chrome/renderer/printing/print_web_view_helper_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',
-      'chromium_src/library_loaders/libgio.h',
-      'chromium_src/library_loaders/libspeechd_loader.cc',
-      'chromium_src/library_loaders/libspeechd.h',
-      '<@(native_mate_files)',
-    ],
-    'lib_sources_win': [
-      'chromium_src/chrome/browser/ui/views/color_chooser_dialog.cc',
-      'chromium_src/chrome/browser/ui/views/color_chooser_dialog.h',
-      'chromium_src/chrome/browser/ui/views/color_chooser_win.cc',
-    ],
-    'framework_sources': [
-      'atom/app/atom_library_main.cc',
-      'atom/app/atom_library_main.h',
-    ],
-    'locales': [
-      'am', 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en-GB',
-      'en-US', 'es-419', 'es', 'et', 'fa', 'fi', 'fil', 'fr', 'gu', 'he',
-      'hi', 'hr', 'hu', 'id', 'it', 'ja', 'kn', 'ko', 'lt', 'lv',
-      'ml', 'mr', 'ms', 'nb', 'nl', 'pl', 'pt-BR', 'pt-PT', 'ro', 'ru',
-      'sk', 'sl', 'sr', 'sv', 'sw', 'ta', 'te', 'th', 'tr', 'uk',
-      'vi', 'zh-CN', 'zh-TW',
-    ],
-    'atom_source_root': '<!(["python", "tools/atom_source_root.py"])',
-    'conditions': [
-      ['OS=="win"', {
-        'app_sources': [
-          'atom/browser/resources/win/resource.h',
-          'atom/browser/resources/win/atom.ico',
-          'atom/browser/resources/win/atom.rc',
-          '<(libchromiumcontent_src_dir)/content/app/startup_helper_win.cc',
-        ],
-      }],  # OS=="win"
-      ['OS=="mac"', {
-        'apply_locales_cmd': ['python', 'tools/mac/apply_locales.py'],
-      }],  # OS=="mac"
-    ],
+    'project_name%': 'electron',
+    'product_name%': 'Electron',
+    'company_name%': 'GitHub, Inc',
+    'company_abbr%': 'github',
+    'version%': '0.32.1',
   },
+  'includes': [
+    'filenames.gypi',
+    'vendor/native_mate/native_mate_files.gypi',
+  ],
   'target_defaults': {
-    'mac_framework_dirs': [
-      '<(atom_source_root)/external_binaries',
+    'defines': [
+      'ATOM_PRODUCT_NAME="<(product_name)"',
+      'ATOM_PROJECT_NAME="<(project_name)"',
     ],
-    'includes': [
-       # Rules for excluding e.g. foo_win.cc from the build on non-Windows.
-      'filename_rules.gypi',
+    'conditions': [
+      ['OS=="mac"', {
+        'mac_framework_dirs': [
+          '<(source_root)/external_binaries',
+        ],
+      }],
     ],
-    'configurations': {
-      'Debug': {
-        'defines': [ 'DEBUG' ],
-        'cflags': [ '-g', '-O0' ],
-      },
-    },
   },
   'targets': [
     {
       'target_name': '<(project_name)',
       'type': 'executable',
       'dependencies': [
-        'generated_sources',
+        'compile_coffee',
         '<(project_name)_lib',
       ],
       'sources': [
@@ -407,6 +49,7 @@
             '<(project_name)_helper',
           ],
           'xcode_settings': {
+            'ATOM_BUNDLE_ID': 'com.<(company_abbr).<(project_name)',
             'INFOPLIST_FILE': 'atom/browser/resources/mac/Info.plist',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@executable_path/../Frameworks',
@@ -456,6 +99,7 @@
             {
               'postbuild_name': 'Make Empty Localizations',
               'variables': {
+                'apply_locales_cmd': ['python', 'tools/mac/apply_locales.py'],
                 'locale_dirs': [
                   '>!@(<(apply_locales_cmd) -d ZZLOCALE.lproj <(locales))',
                 ],
@@ -472,23 +116,47 @@
           ],
         }],  # OS!="mac"
         ['OS=="win"', {
+          'include_dirs': [
+            '<(libchromiumcontent_dir)/gen/ui/resources',
+          ],
+          'msvs_settings': {
+            'VCManifestTool': {
+              'EmbedManifest': 'true',
+              'AdditionalManifestFiles': 'atom/browser/resources/win/atom.manifest',
+            }
+          },
           'copies': [
             {
+              'variables': {
+                'conditions': [
+                  ['libchromiumcontent_component', {
+                    'copied_libraries': [
+                      '<@(libchromiumcontent_shared_libraries)',
+                      '<@(libchromiumcontent_shared_v8_libraries)',
+                    ],
+                  }, {
+                    'copied_libraries': [
+                      '<(libchromiumcontent_dir)/pdf.dll',
+                    ],
+                  }],
+                ],
+              },
               'destination': '<(PRODUCT_DIR)',
               'files': [
-                '<(libchromiumcontent_library_dir)/chromiumcontent.dll',
-                '<(libchromiumcontent_library_dir)/ffmpegsumo.dll',
-                '<(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',
-                'external_binaries/d3dcompiler_46.dll',
+                '<@(copied_libraries)',
+                '<(libchromiumcontent_dir)/libEGL.dll',
+                '<(libchromiumcontent_dir)/libGLESv2.dll',
+                '<(libchromiumcontent_dir)/icudtl.dat',
+                '<(libchromiumcontent_dir)/content_resources_200_percent.pak',
+                '<(libchromiumcontent_dir)/content_shell.pak',
+                '<(libchromiumcontent_dir)/ui_resources_200_percent.pak',
+                '<(libchromiumcontent_dir)/natives_blob.bin',
+                '<(libchromiumcontent_dir)/snapshot_blob.bin',
+                'external_binaries/d3dcompiler_47.dll',
+                'external_binaries/xinput1_3.dll',
                 'external_binaries/msvcp120.dll',
                 'external_binaries/msvcr120.dll',
                 'external_binaries/vccorlib120.dll',
-                'external_binaries/xinput1_3.dll',
               ],
             },
             {
@@ -498,16 +166,36 @@
               ]
             },
           ],
+        }, {
+          'dependencies': [
+            'vendor/breakpad/breakpad.gyp:dump_syms#host',
+          ],
         }],  # OS=="win"
         ['OS=="linux"', {
           'copies': [
             {
+              'variables': {
+                'conditions': [
+                  ['libchromiumcontent_component', {
+                    'copied_libraries': [
+                      '<(PRODUCT_DIR)/lib/libnode.so',
+                      '<@(libchromiumcontent_shared_libraries)',
+                      '<@(libchromiumcontent_shared_v8_libraries)',
+                    ],
+                  }, {
+                    'copied_libraries': [
+                      '<(PRODUCT_DIR)/lib/libnode.so',
+                    ],
+                  }],
+                ],
+              },
               'destination': '<(PRODUCT_DIR)',
               'files': [
-                '<(libchromiumcontent_library_dir)/libchromiumcontent.so',
-                '<(libchromiumcontent_library_dir)/libffmpegsumo.so',
-                '<(libchromiumcontent_resources_dir)/icudtl.dat',
-                '<(libchromiumcontent_resources_dir)/content_shell.pak',
+                '<@(copied_libraries)',
+                '<(libchromiumcontent_dir)/icudtl.dat',
+                '<(libchromiumcontent_dir)/content_shell.pak',
+                '<(libchromiumcontent_dir)/natives_blob.bin',
+                '<(libchromiumcontent_dir)/snapshot_blob.bin',
               ],
             },
             {
@@ -524,15 +212,18 @@
       'target_name': '<(project_name)_lib',
       'type': 'static_library',
       'dependencies': [
+        'atom_coffee2c',
         'vendor/brightray/brightray.gyp:brightray',
-        'vendor/node/node.gyp:node_lib',
+        'vendor/node/node.gyp:node',
       ],
       '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)',
@@ -542,14 +233,18 @@
         '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',
         'vendor/node/deps/uv/include',
         # The `node.h` is using `#include"v8.h"`.
-        'vendor/brightray/vendor/download/libchromiumcontent/src/v8/include',
+        '<(libchromiumcontent_src_dir)/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`.
+        '<(libchromiumcontent_src_dir)/third_party/WebKit/Source',
       ],
       'direct_dependent_settings': {
         'include_dirs': [
@@ -560,6 +255,11 @@
         'vendor/brightray/brightray.gyp:brightray',
       ],
       'conditions': [
+        ['libchromiumcontent_component', {
+          'link_settings': {
+            'libraries': [ '<@(libchromiumcontent_v8_libraries)' ],
+          },
+        }],
         ['OS=="win"', {
           'sources': [
             '<@(lib_sources_win)',
@@ -568,18 +268,27 @@
             'libraries': [
               '-limm32.lib',
               '-loleacc.lib',
-              '-lComdlg32.lib',
-              '-lWininet.lib',
+              '-lcomctl32.lib',
+              '-lcomdlg32.lib',
+              '-lwininet.lib',
             ],
           },
           'dependencies': [
+            # Node is built as static_library on Windows, so we also need to
+            # include its dependencies here.
+            'vendor/node/deps/cares/cares.gyp:cares',
+            'vendor/node/deps/http_parser/http_parser.gyp:http_parser',
+            'vendor/node/deps/uv/uv.gyp:libuv',
+            'vendor/node/deps/zlib/zlib.gyp:zlib',
+            # Build with breakpad support.
             'vendor/breakpad/breakpad.gyp:breakpad_handler',
             'vendor/breakpad/breakpad.gyp:breakpad_sender',
           ],
         }],  # OS=="win"
         ['OS=="mac"', {
           'dependencies': [
-            'vendor/breakpad/breakpad.gyp:breakpad',
+            'vendor/crashpad/client/client.gyp:crashpad_client',
+            'vendor/crashpad/handler/handler.gyp:crashpad_handler',
           ],
         }],  # OS=="mac"
         ['OS=="linux"', {
@@ -594,15 +303,13 @@
             ],
           },
           # Required settings of using breakpad.
-          'include_dirs': [
-            'vendor/breakpad/src',
-          ],
-          'cflags': [
-            '<!@(pkg-config --cflags dbus-1)',
-            '-Wno-deprecated-register',
+          'cflags_cc': [
             '-Wno-empty-body',
             '-Wno-reserved-user-defined-literal',
           ],
+          'include_dirs': [
+            'vendor/breakpad/src',
+          ],
           'dependencies': [
             'vendor/breakpad/breakpad.gyp:breakpad_client',
           ],
@@ -610,176 +317,56 @@
       ],
     },  # target <(product_name)_lib
     {
-      'target_name': 'generated_sources',
-      'type': 'none',
-      'sources': [
-        '<@(coffee_sources)',
-      ],
-      'rules': [
-        {
-          'rule_name': 'coffee',
-          'extension': 'coffee',
-          'inputs': [
-            'script/compile-coffee.py',
-          ],
-          '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"
-          ],
-        },
-      ],
-    },  # target generated_sources
-    {
-      'target_name': '<(project_name)_dump_symbols',
-      'type': 'none',
-      'dependencies': [
-        '<(project_name)',
-      ],
-      'conditions': [
-        ['OS=="mac"', {
-          'dependencies': [
-            'vendor/breakpad/breakpad.gyp:dump_syms',
-          ],
-          'actions': [
-            {
-              'action_name': 'Dump Symbols',
-              'inputs': [
-                '<(PRODUCT_DIR)/<(product_name).app/Contents/MacOS/<(product_name)',
-              ],
-              'outputs': [
-                '<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
-              ],
-              'action': [
-                'python',
-                'tools/posix/generate_breakpad_symbols.py',
-                '--build-dir=<(PRODUCT_DIR)',
-                '--binary=<(PRODUCT_DIR)/<(product_name).app/Contents/MacOS/<(product_name)',
-                '--symbols-dir=<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
-                '--libchromiumcontent-dir=<(libchromiumcontent_library_dir)',
-                '--clear',
-                '--jobs=16',
-              ],
-            },
-          ],
-        }],  # OS=="mac"
-        ['OS=="win"', {
-          'actions': [
-            {
-              'action_name': 'Dump Symbols',
-              'inputs': [
-                '<(PRODUCT_DIR)/<(project_name).exe',
-              ],
-              'outputs': [
-                '<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
-              ],
-              'action': [
-                'python',
-                'tools/win/generate_breakpad_symbols.py',
-                '--symbols-dir=<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
-                '--jobs=16',
-                '<(PRODUCT_DIR)',
-                '<(libchromiumcontent_library_dir)',
-              ],
-            },
-          ],
-        }],  # OS=="win"
-        ['OS=="linux"', {
-          'dependencies': [
-            'vendor/breakpad/breakpad.gyp:dump_syms',
-          ],
-          'actions': [
-            {
-              'action_name': 'Dump Symbols',
-              'inputs': [
-                '<(PRODUCT_DIR)/<(project_name)',
-              ],
-              'outputs': [
-                '<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
-              ],
-              'action': [
-                'python',
-                'tools/posix/generate_breakpad_symbols.py',
-                '--build-dir=<(PRODUCT_DIR)',
-                '--binary=<(PRODUCT_DIR)/<(project_name)',
-                '--symbols-dir=<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
-                '--libchromiumcontent-dir=<(libchromiumcontent_library_dir)',
-                '--clear',
-                '--jobs=16',
-              ],
-            },
-            {
-              'action_name': 'Strip Binary',
-              'inputs': [
-                '<(PRODUCT_DIR)/libchromiumcontent.so',
-                '<(PRODUCT_DIR)/libffmpegsumo.so',
-                '<(PRODUCT_DIR)/<(project_name)',
-                # Add the syms folder as input would force this action to run
-                # after the 'Dump Symbols' action. And since it is a folder,
-                # it would be ignored by the 'strip' command.
-                '<(PRODUCT_DIR)/Atom-Shell.breakpad.syms',
-              ],
-              'outputs': [
-                # Gyp action requires a output file, add a fake one here.
-                '<(PRODUCT_DIR)/dummy_file',
-              ],
-              'action': [
-                'tools/posix/strip.sh',
-                '<@(_inputs)',
-              ],
-            },
-          ],
-        }],  # OS=="linux"
-      ],
-    },  # target <(project_name>_dump_symbols
-    {
-      'target_name': 'copy_chromedriver',
+      'target_name': 'compile_coffee',
       'type': 'none',
       'actions': [
         {
-          'action_name': 'Copy ChromeDriver Binary',
+          'action_name': 'compile_coffee',
           'variables': {
             'conditions': [
-              ['OS=="win"', {
-                'chromedriver_binary': 'chromedriver.exe',
+              ['OS=="mac"', {
+                'resources_path': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources',
               },{
-                'chromedriver_binary': 'chromedriver',
+                'resources_path': '<(PRODUCT_DIR)/resources',
               }],
             ],
           },
           'inputs': [
-            '<(libchromiumcontent_library_dir)/<(chromedriver_binary)',
+            '<@(coffee_sources)',
           ],
           'outputs': [
-            '<(PRODUCT_DIR)/<(chromedriver_binary)',
+            '<(resources_path)/atom.asar',
           ],
           'action': [
             'python',
-            'tools/copy_binary.py',
-            '<@(_inputs)',
+            'tools/coffee2asar.py',
             '<@(_outputs)',
+            '<@(_inputs)',
           ],
         }
       ],
-    },  # copy_chromedriver
+    },  # 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
   ],
   'conditions': [
     ['OS=="mac"', {
@@ -797,7 +384,7 @@
           'include_dirs': [
             '.',
             'vendor',
-            '<(libchromiumcontent_include_dir)',
+            '<(libchromiumcontent_src_dir)',
           ],
           'export_dependent_settings': [
             '<(project_name)_lib',
@@ -814,14 +401,14 @@
           'mac_bundle': 1,
           'mac_bundle_resources': [
             'atom/common/resources/mac/MainMenu.xib',
-            '<(libchromiumcontent_resources_dir)/content_shell.pak',
-            '<(libchromiumcontent_resources_dir)/icudtl.dat',
+            '<(libchromiumcontent_dir)/content_shell.pak',
+            '<(libchromiumcontent_dir)/icudtl.dat',
+            '<(libchromiumcontent_dir)/natives_blob.bin',
+            '<(libchromiumcontent_dir)/snapshot_blob.bin',
           ],
           'xcode_settings': {
+            'ATOM_BUNDLE_ID': 'com.<(company_abbr).<(project_name).framework',
             'INFOPLIST_FILE': 'atom/common/resources/mac/Info.plist',
-            'LIBRARY_SEARCH_PATHS': [
-              '<(libchromiumcontent_library_dir)',
-            ],
             'LD_DYLIB_INSTALL_NAME': '@rpath/<(product_name) Framework.framework/<(product_name) Framework',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@loader_path/Libraries',
@@ -832,28 +419,60 @@
           },
           'copies': [
             {
+              'variables': {
+                'conditions': [
+                  ['libchromiumcontent_component', {
+                    'copied_libraries': [
+                      '<(PRODUCT_DIR)/libnode.dylib',
+                      '<@(libchromiumcontent_shared_libraries)',
+                      '<@(libchromiumcontent_shared_v8_libraries)',
+                    ],
+                  }, {
+                    'copied_libraries': [
+                      '<(PRODUCT_DIR)/libnode.dylib',
+                    ],
+                  }],
+                ],
+              },
               'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Libraries',
               'files': [
-                '<(libchromiumcontent_library_dir)/ffmpegsumo.so',
-                '<(libchromiumcontent_library_dir)/libchromiumcontent.dylib',
+                '<@(copied_libraries)',
               ],
             },
             {
               'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Resources',
               'files': [
-                '<(PRODUCT_DIR)/Inspector',
-                '<(PRODUCT_DIR)/crash_report_sender.app',
+                '<(PRODUCT_DIR)/crashpad_handler',
               ],
             },
           ],
           'postbuilds': [
+            {
+              'postbuild_name': 'Fix path of libnode',
+              'action': [
+                'install_name_tool',
+                '-change',
+                '/usr/local/lib/libnode.dylib',
+                '@rpath/libnode.dylib',
+                '${BUILT_PRODUCTS_DIR}/<(product_name) Framework.framework/Versions/A/<(product_name) Framework',
+              ],
+            },
+            {
+              'postbuild_name': 'Fix path of ffmpeg',
+              'action': [
+                'install_name_tool',
+                '-change',
+                '@loader_path/libffmpeg.dylib',
+                '@rpath/libffmpeg.dylib',
+                '${BUILT_PRODUCTS_DIR}/<(product_name) Framework.framework/Versions/A/<(product_name) Framework',
+              ],
+            },
             {
               'postbuild_name': 'Add symlinks for framework subdirectories',
               'action': [
                 'tools/mac/create-framework-subdir-symlinks.sh',
                 '<(product_name) Framework',
                 'Libraries',
-                'Frameworks',
               ],
             },
           ],
@@ -873,6 +492,7 @@
           ],
           'mac_bundle': 1,
           'xcode_settings': {
+            'ATOM_BUNDLE_ID': 'com.<(company_abbr).<(project_name).helper',
             'INFOPLIST_FILE': 'atom/renderer/resources/mac/Info.plist',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@executable_path/../../..',
@@ -906,37 +526,5 @@
         },
       ],
     }],  # OS!="mac"
-    ['OS=="win"', {
-      'targets': [
-        {
-          'target_name': 'generate_node_lib',
-          'type': 'none',
-          'dependencies': [
-            '<(project_name)',
-          ],
-          'actions': [
-            {
-              'action_name': 'Create node.lib',
-              'inputs': [
-                '<(PRODUCT_DIR)/<(project_name).lib',
-                '<(libchromiumcontent_library_dir)/chromiumcontent.dll.lib',
-              ],
-              'outputs': [
-                '<(PRODUCT_DIR)/node.lib',
-              ],
-              'action': [
-                'lib.exe',
-                '/nologo',
-                # We can't use <(_outputs) here because that escapes the
-                # backslash in the path, which confuses lib.exe.
-                '/OUT:<(PRODUCT_DIR)\\node.lib',
-                '<@(_inputs)',
-              ],
-              'msvs_cygwin_shell': 0,
-            },
-          ],
-        },  # target generate_node_lib
-      ],
-    }],  # OS==win
   ],
 }

atom/app/atom_content_client.cc

@@ -8,9 +8,60 @@
 #include <vector>
 
 #include "atom/common/chrome_version.h"
+#include "atom/common/options_switches.h"
+#include "base/command_line.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "content/public/common/content_constants.h"
+#include "content/public/common/pepper_plugin_info.h"
+#include "ppapi/shared_impl/ppapi_permissions.h"
 
 namespace atom {
 
+namespace {
+
+content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
+                                                const std::string& version) {
+  content::PepperPluginInfo plugin;
+
+  plugin.is_out_of_process = true;
+  plugin.name = content::kFlashPluginName;
+  plugin.path = path;
+  plugin.permissions = ppapi::PERMISSION_ALL_BITS;
+
+  std::vector<std::string> flash_version_numbers;
+  base::SplitString(version, '.', &flash_version_numbers);
+  if (flash_version_numbers.size() < 1)
+    flash_version_numbers.push_back("11");
+  // |SplitString()| puts in an empty string given an empty string. :(
+  else if (flash_version_numbers[0].empty())
+    flash_version_numbers[0] = "11";
+  if (flash_version_numbers.size() < 2)
+    flash_version_numbers.push_back("2");
+  if (flash_version_numbers.size() < 3)
+    flash_version_numbers.push_back("999");
+  if (flash_version_numbers.size() < 4)
+    flash_version_numbers.push_back("999");
+  // E.g., "Shockwave Flash 10.2 r154":
+  plugin.description = plugin.name + " " + flash_version_numbers[0] + "." +
+      flash_version_numbers[1] + " r" + flash_version_numbers[2];
+  plugin.version = JoinString(flash_version_numbers, '.');
+  content::WebPluginMimeType swf_mime_type(
+      content::kFlashPluginSwfMimeType,
+      content::kFlashPluginSwfExtension,
+      content::kFlashPluginSwfDescription);
+  plugin.mime_types.push_back(swf_mime_type);
+  content::WebPluginMimeType spl_mime_type(
+      content::kFlashPluginSplMimeType,
+      content::kFlashPluginSplExtension,
+      content::kFlashPluginSplDescription);
+  plugin.mime_types.push_back(spl_mime_type);
+
+  return plugin;
+}
+
+}  // namespace
+
 AtomContentClient::AtomContentClient() {
 }
 
@@ -24,7 +75,32 @@ std::string AtomContentClient::GetProduct() const {
 void AtomContentClient::AddAdditionalSchemes(
     std::vector<std::string>* standard_schemes,
     std::vector<std::string>* savable_schemes) {
+  auto command_line = base::CommandLine::ForCurrentProcess();
+  auto custom_schemes = command_line->GetSwitchValueASCII(
+      switches::kRegisterStandardSchemes);
+  if (!custom_schemes.empty()) {
+    std::vector<std::string> schemes;
+    base::SplitString(custom_schemes, ',', &schemes);
+    standard_schemes->insert(standard_schemes->end(),
+                             schemes.begin(),
+                             schemes.end());
+  }
   standard_schemes->push_back("chrome-extension");
 }
 
+void AtomContentClient::AddPepperPlugins(
+    std::vector<content::PepperPluginInfo>* plugins) {
+  auto command_line = base::CommandLine::ForCurrentProcess();
+  auto flash_path = command_line->GetSwitchValueNative(
+      switches::kPpapiFlashPath);
+  if (flash_path.empty())
+    return;
+
+  auto flash_version = command_line->GetSwitchValueASCII(
+      switches::kPpapiFlashVersion);
+
+  plugins->push_back(
+      CreatePepperFlashInfo(base::FilePath(flash_path), flash_version));
+}
+
 }  // namespace atom

atom/app/atom_content_client.h

@@ -19,10 +19,12 @@ 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;
+  void AddPepperPlugins(
+      std::vector<content::PepperPluginInfo>* plugins) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AtomContentClient);

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

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
 

atom/app/atom_library_main.mm

@@ -0,0 +1,36 @@
+// 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 "atom/common/atom_command_line.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;
+  atom::AtomCommandLine::Init(argc, 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(ATOM_PRODUCT_NAME " Framework.framework"));
+  base::i18n::InitializeICU();
+  return atom::NodeMain(argc, argv);
+}
+#endif  // OS_MACOSX

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,55 @@
 #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 "atom/common/atom_command_line.h"
+#include "base/at_exit.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);
@@ -52,44 +97,47 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
     freopen_s(&dontcare, "CON", "r", stdin);
   }
 
-  std::string node_indicator, crash_service_indicator;
-  if (env->GetVar("ATOM_SHELL_INTERNAL_RUN_AS_NODE", &node_indicator) &&
-      node_indicator == "1") {
-    // Convert argv to to UTF8
-    char** argv = new char*[argc];
-    for (int i = 0; i < argc; i++) {
-      // Compute the size of the required buffer
-      DWORD size = WideCharToMultiByte(CP_UTF8,
+  // Convert argv to to UTF8
+  char** argv = new char*[argc];
+  for (int i = 0; i < argc; i++) {
+    // Compute the size of the required buffer
+    DWORD size = WideCharToMultiByte(CP_UTF8,
+                                     0,
+                                     wargv[i],
+                                     -1,
+                                     NULL,
+                                     0,
+                                     NULL,
+                                     NULL);
+    if (size == 0) {
+      // This should never happen.
+      fprintf(stderr, "Could not convert arguments to utf8.");
+      exit(1);
+    }
+    // Do the actual conversion
+    argv[i] = new char[size];
+    DWORD result = WideCharToMultiByte(CP_UTF8,
                                        0,
                                        wargv[i],
                                        -1,
-                                       NULL,
-                                       0,
+                                       argv[i],
+                                       size,
                                        NULL,
                                        NULL);
-      if (size == 0) {
-        // This should never happen.
-        fprintf(stderr, "Could not convert arguments to utf8.");
-        exit(1);
-      }
-      // Do the actual conversion
-      argv[i] = new char[size];
-      DWORD result = WideCharToMultiByte(CP_UTF8,
-                                         0,
-                                         wargv[i],
-                                         -1,
-                                         argv[i],
-                                         size,
-                                         NULL,
-                                         NULL);
-      if (result == 0) {
-        // This should never happen.
-        fprintf(stderr, "Could not convert arguments to utf8.");
-        exit(1);
-      }
+    if (result == 0) {
+      // This should never happen.
+      fprintf(stderr, "Could not convert arguments to utf8.");
+      exit(1);
     }
-    // Now that conversion is done, we can finally start.
-    return node::Start(argc, argv);
+  }
+
+  std::string node_indicator, crash_service_indicator;
+  if (env->GetVar("ATOM_SHELL_INTERNAL_RUN_AS_NODE", &node_indicator) &&
+      node_indicator == "1") {
+    // Now that argv conversion is done, we can finally start.
+    base::AtExitManager atexit_manager;
+    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,12 +148,16 @@ 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;
   params.sandbox_info = &sandbox_info;
+  atom::AtomCommandLine::Init(argc, argv);
   return content::ContentMain(params);
 }
 
@@ -113,13 +165,17 @@ 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();
+    base::AtExitManager atexit_manager;
+    return atom::NodeMain(argc, const_cast<char**>(argv));
+  }
 
   atom::AtomMainDelegate delegate;
   content::ContentMainParams params(&delegate);
   params.argc = argc;
   params.argv = argv;
+  atom::AtomCommandLine::Init(argc, argv);
   return content::ContentMain(params);
 }
 
@@ -127,8 +183,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);
 }

atom/app/atom_main_delegate.cc

@@ -10,6 +10,7 @@
 #include "atom/browser/atom_browser_client.h"
 #include "atom/common/google_api_key.h"
 #include "atom/renderer/atom_renderer_client.h"
+#include "atom/utility/atom_content_utility_client.h"
 #include "base/command_line.h"
 #include "base/debug/stack_trace.h"
 #include "base/environment.h"
@@ -27,8 +28,8 @@ AtomMainDelegate::~AtomMainDelegate() {
 
 bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
   // Disable logging out to debug.log on Windows
-#if defined(OS_WIN)
   logging::LoggingSettings settings;
+#if defined(OS_WIN)
 #if defined(DEBUG)
   settings.logging_dest = logging::LOG_TO_ALL;
   settings.log_file = L"debug.log";
@@ -36,15 +37,17 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
   settings.delete_old = logging::DELETE_OLD_LOG_FILE;
 #else
   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
-#endif
+#endif  // defined(DEBUG)
+#else  // defined(OS_WIN)
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+#endif  // !defined(OS_WIN)
   logging::InitLogging(settings);
-#endif  // defined(OS_WIN)
 
   // Logging with pid and timestamp.
   logging::SetLogItems(true, false, true, false);
 
-  // Enable convient stack printing.
 #if defined(DEBUG) && defined(OS_LINUX)
+  // Enable convient stack printing.
   base::debug::EnableInProcessStackDumping();
 #endif
 
@@ -59,17 +62,18 @@ 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);
 
+  if (process_type == switches::kUtilityProcess) {
+    AtomContentUtilityClient::PreSandboxStartup();
+  }
+
   // Only append arguments for browser process.
   if (!process_type.empty())
     return;
 
-  // Add a flag to mark the start of switches added by atom-shell.
-  command_line->AppendSwitch("atom-shell-switches-start");
-
 #if defined(OS_WIN)
   // Disable the LegacyRenderWidgetHostHWND, it made frameless windows unable
   // to move and resize. We may consider enabling it again after upgraded to
@@ -80,13 +84,13 @@ void AtomMainDelegate::PreSandboxStartup() {
   // Disable renderer sandbox for most of node's functions.
   command_line->AppendSwitch(switches::kNoSandbox);
 
+  // Allow file:// URIs to read other file:// URIs by default.
+  command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
+
 #if defined(OS_MACOSX)
   // Enable AVFoundation.
   command_line->AppendSwitch("enable-avfoundation");
 #endif
-
-  // Add a flag to mark the end of switches added by atom-shell.
-  command_line->AppendSwitch("atom-shell-switches-end");
 }
 
 content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
@@ -100,6 +104,11 @@ content::ContentRendererClient*
   return renderer_client_.get();
 }
 
+content::ContentUtilityClient* AtomMainDelegate::CreateContentUtilityClient() {
+  utility_client_.reset(new AtomContentUtilityClient);
+  return utility_client_.get();
+}
+
 scoped_ptr<brightray::ContentClient> AtomMainDelegate::CreateContentClient() {
   return scoped_ptr<brightray::ContentClient>(new AtomContentClient).Pass();
 }

atom/app/atom_main_delegate.h

@@ -21,6 +21,7 @@ class AtomMainDelegate : public brightray::MainDelegate {
   void PreSandboxStartup() override;
   content::ContentBrowserClient* CreateContentBrowserClient() override;
   content::ContentRendererClient* CreateContentRendererClient() override;
+  content::ContentUtilityClient* CreateContentUtilityClient() override;
 
   // brightray::MainDelegate:
   scoped_ptr<brightray::ContentClient> CreateContentClient() override;
@@ -35,6 +36,7 @@ class AtomMainDelegate : public brightray::MainDelegate {
   brightray::ContentClient content_client_;
   scoped_ptr<content::ContentBrowserClient> browser_client_;
   scoped_ptr<content::ContentRendererClient> renderer_client_;
+  scoped_ptr<content::ContentUtilityClient> utility_client_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomMainDelegate);
 };

atom/app/atom_main_delegate_mac.mm

@@ -6,7 +6,9 @@
 
 #include "base/mac/bundle_locations.h"
 #include "base/files/file_path.h"
+#include "base/files/file_util.h"
 #include "base/path_service.h"
+#include "brightray/common/application_info.h"
 #include "brightray/common/mac/main_application_bundle.h"
 #include "content/public/common/content_paths.h"
 
@@ -19,19 +21,30 @@ base::FilePath GetFrameworksPath() {
                                                .Append("Frameworks");
 }
 
+base::FilePath GetHelperAppPath(const base::FilePath& frameworks_path,
+                                const std::string& name) {
+  return frameworks_path.Append(name + " Helper.app")
+                        .Append("Contents")
+                        .Append("MacOS")
+                        .Append(name + " Helper");
+}
+
 }  // namespace
 
 void AtomMainDelegate::OverrideFrameworkBundlePath() {
   base::mac::SetOverrideFrameworkBundlePath(
-      GetFrameworksPath().Append(PRODUCT_NAME " Framework.framework"));
+      GetFrameworksPath().Append(ATOM_PRODUCT_NAME " Framework.framework"));
 }
 
 void AtomMainDelegate::OverrideChildProcessPath() {
-  base::FilePath helper_path =
-      GetFrameworksPath().Append(PRODUCT_NAME " Helper.app")
-                         .Append("Contents")
-                         .Append("MacOS")
-                         .Append(PRODUCT_NAME " Helper");
+  base::FilePath frameworks_path = GetFrameworksPath();
+  base::FilePath helper_path = GetHelperAppPath(frameworks_path,
+                                                ATOM_PRODUCT_NAME);
+  if (!base::PathExists(helper_path))
+    helper_path = GetHelperAppPath(frameworks_path,
+                                   brightray::GetApplicationName());
+  if (!base::PathExists(helper_path))
+    LOG(FATAL) << "Unable to find helper app";
   PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
 }
 

atom/app/node_main.cc

@@ -0,0 +1,77 @@
+// 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/app/uv_task_runner.h"
+#include "atom/browser/javascript_environment.h"
+#include "atom/browser/node_debugger.h"
+#include "atom/common/node_includes.h"
+#include "base/command_line.h"
+#include "base/thread_task_runner_handle.h"
+#include "gin/array_buffer.h"
+#include "gin/public/isolate_holder.h"
+#include "gin/v8_initializer.h"
+
+namespace atom {
+
+int NodeMain(int argc, char *argv[]) {
+  base::CommandLine::Init(argc, 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;
+  {
+    // Feed gin::PerIsolateData with a task runner.
+    uv_loop_t* loop = uv_default_loop();
+    scoped_refptr<UvTaskRunner> uv_task_runner(new UvTaskRunner(loop));
+    base::ThreadTaskRunnerHandle handle(uv_task_runner);
+
+    gin::V8Initializer::LoadV8Snapshot();
+    gin::V8Initializer::LoadV8Natives();
+    gin::IsolateHolder::Initialize(
+        gin::IsolateHolder::kNonStrictMode,
+        gin::ArrayBufferAllocator::SharedInstance());
+
+    JavascriptEnvironment gin_env;
+    node::Environment* env = node::CreateEnvironment(
+        gin_env.isolate(), loop, gin_env.context(), argc, argv,
+        exec_argc, exec_argv);
+
+    // Start our custom debugger implementation.
+    NodeDebugger node_debugger(gin_env.isolate());
+    if (node_debugger.IsRunning())
+      env->AssignToContext(v8::Debug::GetDebugContext());
+
+    node::LoadEnvironment(env);
+
+    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

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_

atom/app/uv_task_runner.cc

@@ -0,0 +1,55 @@
+// 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/uv_task_runner.h"
+
+#include "base/stl_util.h"
+
+namespace atom {
+
+UvTaskRunner::UvTaskRunner(uv_loop_t* loop) : loop_(loop) {
+}
+
+UvTaskRunner::~UvTaskRunner() {
+  for (auto& iter : tasks_) {
+    uv_unref(reinterpret_cast<uv_handle_t*>(iter.first));
+    delete iter.first;
+  }
+}
+
+bool UvTaskRunner::PostDelayedTask(const tracked_objects::Location& from_here,
+                                   const base::Closure& task,
+                                   base::TimeDelta delay) {
+  uv_timer_t* timer = new uv_timer_t;
+  timer->data = this;
+  uv_timer_init(loop_, timer);
+  uv_timer_start(timer, UvTaskRunner::OnTimeout, delay.InMilliseconds(), 0);
+  tasks_[timer] = task;
+  return true;
+}
+
+bool UvTaskRunner::RunsTasksOnCurrentThread() const {
+  return true;
+}
+
+bool UvTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  return PostDelayedTask(from_here, task, delay);;
+}
+
+// static
+void UvTaskRunner::OnTimeout(uv_timer_t* timer) {
+  UvTaskRunner* self = static_cast<UvTaskRunner*>(timer->data);
+  if (!ContainsKey(self->tasks_, timer))
+    return;
+
+  self->tasks_[timer].Run();
+  self->tasks_.erase(timer);
+  uv_unref(reinterpret_cast<uv_handle_t*>(timer));
+  delete timer;
+}
+
+}  // namespace atom

atom/app/uv_task_runner.h

@@ -0,0 +1,44 @@
+// 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_UV_TASK_RUNNER_H_
+#define ATOM_APP_UV_TASK_RUNNER_H_
+
+#include <map>
+
+#include "base/callback.h"
+#include "base/single_thread_task_runner.h"
+#include "vendor/node/deps/uv/include/uv.h"
+
+namespace atom {
+
+// TaskRunner implementation that posts tasks into libuv's default loop.
+class UvTaskRunner : public base::SingleThreadTaskRunner {
+ public:
+  explicit UvTaskRunner(uv_loop_t* loop);
+  ~UvTaskRunner() override;
+
+  // base::SingleThreadTaskRunner:
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override;
+  bool RunsTasksOnCurrentThread() const override;
+  bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      base::TimeDelta delay) override;
+
+ private:
+  static void OnTimeout(uv_timer_t* timer);
+
+  uv_loop_t* loop_;
+
+  std::map<uv_timer_t*, base::Closure> tasks_;
+
+  DISALLOW_COPY_AND_ASSIGN(UvTaskRunner);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_APP_UV_TASK_RUNNER_H_

atom/browser/api/atom_api_app.cc

@@ -7,28 +7,32 @@
 #include <string>
 #include <vector>
 
+#if defined(OS_WIN)
+#include <shlobj.h>
+#endif
+
 #include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/api/atom_api_session.h"
 #include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/browser.h"
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/common/native_mate_converters/callback.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 "atom/common/node_includes.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
-#include "native_mate/callback.h"
+#include "brightray/browser/brightray_paths.h"
+#include "content/public/browser/client_certificate_delegate.h"
+#include "content/public/browser/gpu_data_manager.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
-#include "net/base/load_flags.h"
-#include "net/proxy/proxy_service.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_getter.h"
+#include "net/ssl/ssl_cert_request_info.h"
 
-#include "atom/common/node_includes.h"
-
-#if defined(OS_LINUX)
-#include "base/nix/xdg_util.h"
+#if defined(OS_WIN)
+#include "base/strings/utf_string_conversions.h"
 #endif
 
 using atom::Browser;
@@ -38,7 +42,7 @@ namespace mate {
 #if defined(OS_WIN)
 template<>
 struct Converter<Browser::UserTask> {
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      Browser::UserTask* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
@@ -56,6 +60,21 @@ struct Converter<Browser::UserTask> {
 };
 #endif
 
+template<>
+struct Converter<scoped_refptr<net::X509Certificate>> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const scoped_refptr<net::X509Certificate>& val) {
+    mate::Dictionary dict(isolate, v8::Object::New(isolate));
+    std::string encoded_data;
+    net::X509Certificate::GetPEMEncoded(
+        val->os_cert_handle(), &encoded_data);
+    dict.Set("data", encoded_data);
+    dict.Set("issuerName", val->issuer().GetDisplayName());
+    return dict.GetHandle();
+  }
+};
+
 }  // namespace mate
 
 
@@ -65,50 +84,67 @@ namespace api {
 
 namespace {
 
-class ResolveProxyHelper {
- public:
-  ResolveProxyHelper(const GURL& url, App::ResolveProxyCallback callback)
-      : callback_(callback) {
-    net::ProxyService* proxy_service = AtomBrowserContext::Get()->
-        url_request_context_getter()->GetURLRequestContext()->proxy_service();
+// 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;
+}
 
-    // Start the request.
-    int result = proxy_service->ResolveProxy(
-        url, net::LOAD_NORMAL, &proxy_info_,
-        base::Bind(&ResolveProxyHelper::OnResolveProxyCompleted,
-                   base::Unretained(this)),
-        &pac_req_, nullptr, net::BoundNetLog());
-
-    // Completed synchronously.
-    if (result != net::ERR_IO_PENDING)
-      OnResolveProxyCompleted(result);
+void OnClientCertificateSelected(
+    v8::Isolate* isolate,
+    std::shared_ptr<content::ClientCertificateDelegate> delegate,
+    mate::Arguments* args) {
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  mate::Dictionary cert_data;
+  if (!(args->Length() == 1 && args->GetNext(&cert_data))) {
+    args->ThrowError();
+    return;
   }
 
-  void OnResolveProxyCompleted(int result) {
-    std::string proxy;
-    if (result == net::OK)
-      proxy = proxy_info_.ToPacString();
-    callback_.Run(proxy);
+  std::string encoded_data;
+  cert_data.Get("data", &encoded_data);
 
-    delete this;
-  }
+  auto certs =
+      net::X509Certificate::CreateCertificateListFromBytes(
+          encoded_data.data(), encoded_data.size(),
+          net::X509Certificate::FORMAT_AUTO);
 
- private:
-  App::ResolveProxyCallback callback_;
-  net::ProxyInfo proxy_info_;
-  net::ProxyService::PacRequest* pac_req_;
-
-  DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
-};
+  delegate->ContinueWithCertificate(certs[0].get());
+}
 
 }  // namespace
 
 App::App() {
   Browser::Get()->AddObserver(this);
+  content::GpuDataManager::GetInstance()->AddObserver(this);
 }
 
 App::~App() {
   Browser::Get()->RemoveObserver(this);
+  content::GpuDataManager::GetInstance()->RemoveObserver(this);
+}
+
+void App::OnBeforeQuit(bool* prevent_default) {
+  *prevent_default = Emit("before-quit");
 }
 
 void App::OnWillQuit(bool* prevent_default) {
@@ -124,15 +160,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() {
@@ -144,26 +176,62 @@ void App::OnWillFinishLaunching() {
 }
 
 void App::OnFinishLaunching() {
+  // Create the defaultSession.
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  auto browser_context = static_cast<AtomBrowserContext*>(
+      AtomBrowserMainParts::Get()->browser_context());
+  auto handle = Session::CreateFrom(isolate(), browser_context);
+  default_session_.Reset(isolate(), handle.ToV8());
+
   Emit("ready");
 }
 
-base::FilePath App::GetDataPath() {
-  base::FilePath path;
-#if defined(OS_LINUX)
-  scoped_ptr<base::Environment> env(base::Environment::Create());
-  path = base::nix::GetXDGDirectory(env.get(),
-                                    base::nix::kXdgConfigHomeEnvVar,
-                                    base::nix::kDotConfigDir);
-#else
-  PathService::Get(base::DIR_APP_DATA, &path);
-#endif
+void App::OnSelectCertificate(
+    content::WebContents* web_contents,
+    net::SSLCertRequestInfo* cert_request_info,
+    scoped_ptr<content::ClientCertificateDelegate> delegate) {
+  std::shared_ptr<content::ClientCertificateDelegate>
+      shared_delegate(delegate.release());
+  bool prevent_default =
+      Emit("select-certificate",
+           api::WebContents::CreateFrom(isolate(), web_contents),
+           cert_request_info->host_and_port.ToString(),
+           cert_request_info->client_certs,
+           base::Bind(&OnClientCertificateSelected,
+                      isolate(),
+                      shared_delegate));
 
-  return path.Append(base::FilePath::FromUTF8Unsafe(
-      Browser::Get()->GetName()));
+  // Default to first certificate from the platform store.
+  if (!prevent_default)
+    shared_delegate->ContinueWithCertificate(
+        cert_request_info->client_certs[0].get());
 }
 
-void App::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
-  new ResolveProxyHelper(url, callback);
+void App::OnGpuProcessCrashed(base::TerminationStatus exit_code) {
+  Emit("gpu-process-crashed");
+}
+
+base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
+  bool succeed = false;
+  base::FilePath path;
+  int key = GetPathConstant(name);
+  if (key >= 0)
+    succeed = PathService::Get(key, &path);
+  if (!succeed)
+    args->ThrowError("Failed to get path");
+  return path;
+}
+
+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::SetDesktopName(const std::string& desktop_name) {
@@ -173,6 +241,20 @@ void App::SetDesktopName(const std::string& desktop_name) {
 #endif
 }
 
+void App::SetAppUserModelId(const std::string& app_id) {
+#if defined(OS_WIN)
+  base::string16 app_id_utf16 = base::UTF8ToUTF16(app_id);
+  SetCurrentProcessExplicitAppUserModelID(app_id_utf16.c_str());
+#endif
+}
+
+v8::Local<v8::Value> App::DefaultSession(v8::Isolate* isolate) {
+  if (default_session_.IsEmpty())
+    return v8::Null(isolate);
+  else
+    return v8::Local<v8::Value>::New(isolate, default_session_);
+}
+
 mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   auto browser = base::Unretained(Browser::Get());
@@ -192,9 +274,11 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
       .SetMethod("setUserTasks",
                  base::Bind(&Browser::SetUserTasks, browser))
 #endif
-      .SetMethod("getDataPath", &App::GetDataPath)
-      .SetMethod("resolveProxy", &App::ResolveProxy)
-      .SetMethod("setDesktopName", &App::SetDesktopName);
+      .SetMethod("setPath", &App::SetPath)
+      .SetMethod("getPath", &App::GetPath)
+      .SetMethod("setDesktopName", &App::SetDesktopName)
+      .SetMethod("setAppUserModelId", &App::SetAppUserModelId)
+      .SetProperty("defaultSession", &App::DefaultSession);
 }
 
 // static
@@ -210,11 +294,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)
@@ -232,16 +317,16 @@ void DockSetMenu(atom::api::Menu* menu) {
 }
 #endif
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
-  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());

atom/browser/api/atom_api_app.h

@@ -9,24 +9,25 @@
 
 #include "atom/browser/api/event_emitter.h"
 #include "atom/browser/browser_observer.h"
-#include "base/callback.h"
+#include "content/public/browser/gpu_data_manager_observer.h"
 #include "native_mate/handle.h"
 
-class GURL;
-
 namespace base {
 class FilePath;
 }
 
+namespace mate {
+class Arguments;
+}
+
 namespace atom {
 
 namespace api {
 
 class App : public mate::EventEmitter,
-            public BrowserObserver {
+            public BrowserObserver,
+            public content::GpuDataManagerObserver {
  public:
-  typedef base::Callback<void(std::string)> ResolveProxyCallback;
-
   static mate::Handle<App> Create(v8::Isolate* isolate);
 
  protected:
@@ -34,6 +35,7 @@ class App : public mate::EventEmitter,
   virtual ~App();
 
   // BrowserObserver:
+  void OnBeforeQuit(bool* prevent_default) override;
   void OnWillQuit(bool* prevent_default) override;
   void OnWindowAllClosed() override;
   void OnQuit() override;
@@ -42,15 +44,30 @@ class App : public mate::EventEmitter,
   void OnActivateWithNoOpenWindows() override;
   void OnWillFinishLaunching() override;
   void OnFinishLaunching() override;
+  void OnSelectCertificate(
+      content::WebContents* web_contents,
+      net::SSLCertRequestInfo* cert_request_info,
+      scoped_ptr<content::ClientCertificateDelegate> delegate) override;
+
+  // content::GpuDataManagerObserver:
+  void OnGpuProcessCrashed(base::TerminationStatus exit_code) override;
 
   // mate::Wrappable:
   mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override;
 
  private:
-  base::FilePath GetDataPath();
-  void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
+  // 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 SetDesktopName(const std::string& desktop_name);
+  void SetAppUserModelId(const std::string& app_id);
+  v8::Local<v8::Value> DefaultSession(v8::Isolate* isolate);
+
+  v8::Global<v8::Value> default_session_;
 
   DISALLOW_COPY_AND_ASSIGN(App);
 };

atom/browser/api/atom_api_auto_updater.cc

@@ -5,14 +5,12 @@
 #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 "atom/common/node_includes.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 
-#include "atom/common/node_includes.h"
-
 namespace atom {
 
 namespace api {
@@ -26,9 +24,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 +45,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(
@@ -85,8 +76,8 @@ mate::Handle<AutoUpdater> AutoUpdater::Create(v8::Isolate* isolate) {
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("autoUpdater", atom::api::AutoUpdater::Create(isolate));

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();

atom/browser/api/atom_api_content_tracing.cc

@@ -5,54 +5,32 @@
 #include <set>
 #include <string>
 
+#include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
-#include "base/bind.h"
-#include "content/public/browser/tracing_controller.h"
-#include "native_mate/callback.h"
-#include "native_mate/dictionary.h"
-
 #include "atom/common/node_includes.h"
+#include "base/bind.h"
+#include "base/files/file_util.h"
+#include "content/public/browser/tracing_controller.h"
+#include "native_mate/dictionary.h"
 
 using content::TracingController;
 
 namespace mate {
 
-template<typename T>
-struct Converter<std::set<T> > {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    const std::set<T>& val) {
-    v8::Handle<v8::Array> result = v8::Array::New(
-        isolate, static_cast<int>(val.size()));
-    typename std::set<T>::const_iterator it;
-    int i;
-    for (i = 0, it = val.begin(); it != val.end(); ++it, ++i)
-      result->Set(i, Converter<T>::ToV8(isolate, *it));
-    return result;
-  }
-};
-
 template<>
-struct Converter<base::debug::CategoryFilter> {
+struct Converter<base::trace_event::TraceConfig> {
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     base::debug::CategoryFilter* out) {
-    std::string filter;
-    if (!ConvertFromV8(isolate, val, &filter))
-      return false;
-    *out = base::debug::CategoryFilter(filter);
-    return true;
-  }
-};
-
-template<>
-struct Converter<base::debug::TraceOptions> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
-                     base::debug::TraceOptions* out) {
-    std::string options;
+                     v8::Local<v8::Value> val,
+                     base::trace_event::TraceConfig* out) {
+    Dictionary options;
     if (!ConvertFromV8(isolate, val, &options))
       return false;
-    return out->SetFromString(options);
+    std::string category_filter, trace_options;
+    if (!options.Get("categoryFilter", &category_filter) ||
+        !options.Get("traceOptions", &trace_options))
+      return false;
+    *out = base::trace_event::TraceConfig(category_filter, trace_options);
+    return true;
   }
 };
 
@@ -60,33 +38,51 @@ struct Converter<base::debug::TraceOptions> {
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
-  TracingController* controller = TracingController::GetInstance();
+using CompletionCallback = base::Callback<void(const base::FilePath&)>;
+
+scoped_refptr<TracingController::TraceDataSink> GetTraceDataSink(
+    const base::FilePath& path, const CompletionCallback& callback) {
+  base::FilePath result_file_path = path;
+  if (result_file_path.empty() && !base::CreateTemporaryFile(&result_file_path))
+    LOG(ERROR) << "Creating temporary file failed";
+
+  return TracingController::CreateFileSink(result_file_path,
+                                           base::Bind(callback,
+                                                      result_file_path));
+}
+
+void StopRecording(const base::FilePath& path,
+                   const CompletionCallback& callback) {
+  TracingController::GetInstance()->DisableRecording(
+      GetTraceDataSink(path, callback));
+}
+
+void CaptureMonitoringSnapshot(const base::FilePath& path,
+                               const CompletionCallback& callback) {
+  TracingController::GetInstance()->CaptureMonitoringSnapshot(
+      GetTraceDataSink(path, callback));
+}
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
+  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)));
-  dict.SetMethod("stopRecording", base::Bind(
-      &TracingController::DisableRecording,
-      base::Unretained(controller),
-      nullptr));
+      &TracingController::EnableRecording, controller));
+  dict.SetMethod("stopRecording", &StopRecording);
   dict.SetMethod("startMonitoring", base::Bind(
-      &TracingController::EnableMonitoring, base::Unretained(controller)));
+      &TracingController::EnableMonitoring, controller));
   dict.SetMethod("stopMonitoring", base::Bind(
-      &TracingController::DisableMonitoring, base::Unretained(controller)));
-  dict.SetMethod("captureMonitoringSnapshot", base::Bind(
-      &TracingController::CaptureMonitoringSnapshot,
-      base::Unretained(controller),
-      nullptr));
-  dict.SetMethod("getTraceBufferPercentFull", base::Bind(
-      &TracingController::GetTraceBufferPercentFull,
-      base::Unretained(controller)));
+      &TracingController::DisableMonitoring, controller));
+  dict.SetMethod("captureMonitoringSnapshot", &CaptureMonitoringSnapshot);
+  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

atom/browser/api/atom_api_cookies.cc

@@ -0,0 +1,346 @@
+// 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_cookies.h"
+
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "base/bind.h"
+#include "base/time/time.h"
+#include "base/values.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/cookies/cookie_store.h"
+#include "net/cookies/cookie_util.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+using atom::api::Cookies;
+using content::BrowserThread;
+
+namespace {
+
+bool GetCookieListFromStore(
+    net::CookieStore* cookie_store,
+    const std::string& url,
+    const net::CookieMonster::GetCookieListCallback& callback) {
+  DCHECK(cookie_store);
+  GURL gurl(url);
+  net::CookieMonster* monster = cookie_store->GetCookieMonster();
+  // Empty url will match all url cookies.
+  if (url.empty()) {
+    monster->GetAllCookiesAsync(callback);
+    return true;
+  }
+
+  if (!gurl.is_valid())
+    return false;
+
+  monster->GetAllCookiesForURLAsync(gurl, callback);
+  return true;
+}
+
+void RunGetCookiesCallbackOnUIThread(v8::Isolate* isolate,
+                                     const std::string& error_message,
+                                     const net::CookieList& cookie_list,
+                                     const Cookies::CookiesCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+
+  if (!error_message.empty()) {
+    v8::Local<v8::Value> error = mate::ConvertToV8(isolate, error_message);
+    callback.Run(error, v8::Null(isolate));
+    return;
+  }
+  callback.Run(v8::Null(isolate), mate::ConvertToV8(isolate, cookie_list));
+}
+
+void RunRemoveCookiesCallbackOnUIThread(
+    v8::Isolate* isolate,
+    const std::string& error_message,
+    const Cookies::CookiesCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+
+  if (!error_message.empty()) {
+    v8::Local<v8::Value> error = mate::ConvertToV8(isolate, error_message);
+    callback.Run(error, v8::Null(isolate));
+    return;
+  }
+
+  callback.Run(v8::Null(isolate), v8::Null(isolate));
+}
+
+void RunSetCookiesCallbackOnUIThread(v8::Isolate* isolate,
+                                     const std::string& error_message,
+                                     bool set_success,
+                                     const Cookies::CookiesCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+
+  if (!error_message.empty()) {
+    v8::Local<v8::Value> error = mate::ConvertToV8(isolate, error_message);
+    callback.Run(error, v8::Null(isolate));
+    return;
+  }
+  if (!set_success) {
+    v8::Local<v8::Value> error = mate::ConvertToV8(
+        isolate, "Failed to set cookies");
+    callback.Run(error, v8::Null(isolate));
+  }
+
+  callback.Run(v8::Null(isolate), v8::Null(isolate));
+}
+
+bool MatchesDomain(const base::DictionaryValue* filter,
+                   const std::string& cookie_domain) {
+  std::string filter_domain;
+  if (!filter->GetString("domain", &filter_domain))
+    return true;
+
+  // Add a leading '.' character to the filter domain if it doesn't exist.
+  if (net::cookie_util::DomainIsHostOnly(filter_domain))
+    filter_domain.insert(0, ".");
+
+  std::string sub_domain(cookie_domain);
+  // Strip any leading '.' character from the input cookie domain.
+  if (!net::cookie_util::DomainIsHostOnly(sub_domain))
+    sub_domain = sub_domain.substr(1);
+
+  // Now check whether the domain argument is a subdomain of the filter domain.
+  for (sub_domain.insert(0, ".");
+       sub_domain.length() >= filter_domain.length();) {
+    if (sub_domain == filter_domain) {
+      return true;
+    }
+    const size_t next_dot = sub_domain.find('.', 1);  // Skip over leading dot.
+    sub_domain.erase(0, next_dot);
+  }
+  return false;
+}
+
+bool MatchesCookie(const base::DictionaryValue* filter,
+                   const net::CanonicalCookie& cookie) {
+  std::string name, domain, path;
+  bool is_secure, session;
+  if (filter->GetString("name", &name) && name != cookie.Name())
+    return false;
+  if (filter->GetString("path", &path) && path != cookie.Path())
+    return false;
+  if (!MatchesDomain(filter, cookie.Domain()))
+    return false;
+  if (filter->GetBoolean("secure", &is_secure) &&
+      is_secure != cookie.IsSecure())
+    return false;
+  if (filter->GetBoolean("session", &session) &&
+      session != cookie.IsPersistent())
+    return false;
+  return true;
+}
+
+}  // namespace
+
+namespace mate {
+
+template<>
+struct Converter<net::CanonicalCookie> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const net::CanonicalCookie& val) {
+    mate::Dictionary dict(isolate, v8::Object::New(isolate));
+    dict.Set("name", val.Name());
+    dict.Set("value", val.Value());
+    dict.Set("domain", val.Domain());
+    dict.Set("host_only", net::cookie_util::DomainIsHostOnly(val.Domain()));
+    dict.Set("path", val.Path());
+    dict.Set("secure", val.IsSecure());
+    dict.Set("http_only", val.IsHttpOnly());
+    dict.Set("session", val.IsPersistent());
+    if (!val.IsPersistent())
+      dict.Set("expirationDate", val.ExpiryDate().ToDoubleT());
+    return dict.GetHandle();
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+
+namespace api {
+
+Cookies::Cookies(content::BrowserContext* browser_context)
+    : request_context_getter_(browser_context->GetRequestContext()) {
+}
+
+Cookies::~Cookies() {
+}
+
+void Cookies::Get(const base::DictionaryValue& options,
+                  const CookiesCallback& callback) {
+  scoped_ptr<base::DictionaryValue> filter(
+      options.DeepCopyWithoutEmptyChildren());
+
+  content::BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&Cookies::GetCookiesOnIOThread, base::Unretained(this),
+          Passed(&filter), callback));
+}
+
+void Cookies::GetCookiesOnIOThread(scoped_ptr<base::DictionaryValue> filter,
+                                   const CookiesCallback& callback) {
+  std::string url;
+  filter->GetString("url", &url);
+  if (!GetCookieListFromStore(GetCookieStore(), url,
+          base::Bind(&Cookies::OnGetCookies, base::Unretained(this),
+              Passed(&filter), callback))) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+        base::Bind(&RunGetCookiesCallbackOnUIThread, isolate(),
+                   "Url is not valid", net::CookieList(), callback));
+  }
+}
+
+void Cookies::OnGetCookies(scoped_ptr<base::DictionaryValue> filter,
+                           const CookiesCallback& callback,
+                           const net::CookieList& cookie_list) {
+  net::CookieList result;
+  for (const auto& cookie : cookie_list) {
+    if (MatchesCookie(filter.get(), cookie))
+      result.push_back(cookie);
+  }
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
+      &RunGetCookiesCallbackOnUIThread, isolate(), "", result, callback));
+}
+
+void Cookies::Remove(const mate::Dictionary& details,
+                     const CookiesCallback& callback) {
+  GURL url;
+  std::string name;
+  std::string error_message;
+  if (!details.Get("url", &url) || !details.Get("name", &name)) {
+    error_message = "Details(url, name) of removing cookie are required.";
+  }
+  if (error_message.empty() && !url.is_valid()) {
+    error_message = "Url is not valid.";
+  }
+  if (!error_message.empty()) {
+     RunRemoveCookiesCallbackOnUIThread(isolate(), error_message, callback);
+     return;
+  }
+  content::BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&Cookies::RemoveCookiesOnIOThread, base::Unretained(this),
+          url, name, callback));
+}
+
+void Cookies::RemoveCookiesOnIOThread(const GURL& url, const std::string& name,
+                                      const CookiesCallback& callback) {
+  GetCookieStore()->DeleteCookieAsync(url, name,
+      base::Bind(&Cookies::OnRemoveCookies, base::Unretained(this), callback));
+}
+
+void Cookies::OnRemoveCookies(const CookiesCallback& callback) {
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      base::Bind(&RunRemoveCookiesCallbackOnUIThread, isolate(), "", callback));
+}
+
+void Cookies::Set(const base::DictionaryValue& options,
+                  const CookiesCallback& callback) {
+  std::string url;
+  std::string error_message;
+  if (!options.GetString("url", &url)) {
+    error_message = "The url field is required.";
+  }
+
+  GURL gurl(url);
+  if (error_message.empty() && !gurl.is_valid()) {
+    error_message = "Url is not valid.";
+  }
+
+  if (!error_message.empty()) {
+    RunSetCookiesCallbackOnUIThread(isolate(), error_message, false, callback);
+    return;
+  }
+
+  scoped_ptr<base::DictionaryValue> details(
+      options.DeepCopyWithoutEmptyChildren());
+
+  content::BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&Cookies::SetCookiesOnIOThread, base::Unretained(this),
+          Passed(&details), gurl, callback));
+}
+
+void Cookies::SetCookiesOnIOThread(scoped_ptr<base::DictionaryValue> details,
+                                   const GURL& url,
+                                   const CookiesCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  std::string name, value, domain, path;
+  bool secure = false;
+  bool http_only = false;
+  double expiration_date;
+
+  details->GetString("name", &name);
+  details->GetString("value", &value);
+  details->GetString("domain", &domain);
+  details->GetString("path", &path);
+  details->GetBoolean("secure", &secure);
+  details->GetBoolean("http_only", &http_only);
+
+  base::Time expiration_time;
+  if (details->GetDouble("expirationDate", &expiration_date)) {
+    expiration_time = (expiration_date == 0) ?
+        base::Time::UnixEpoch() :
+        base::Time::FromDoubleT(expiration_date);
+  }
+
+  GetCookieStore()->GetCookieMonster()->SetCookieWithDetailsAsync(
+      url,
+      name,
+      value,
+      domain,
+      path,
+      expiration_time,
+      secure,
+      http_only,
+      false,
+      net::COOKIE_PRIORITY_DEFAULT,
+      base::Bind(&Cookies::OnSetCookies, base::Unretained(this), callback));
+}
+
+void Cookies::OnSetCookies(const CookiesCallback& callback,
+                           bool set_success) {
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      base::Bind(&RunSetCookiesCallbackOnUIThread, isolate(), "", set_success,
+                 callback));
+}
+
+mate::ObjectTemplateBuilder Cookies::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("get", &Cookies::Get)
+      .SetMethod("remove", &Cookies::Remove)
+      .SetMethod("set", &Cookies::Set);
+}
+
+net::CookieStore* Cookies::GetCookieStore() {
+  return request_context_getter_->GetURLRequestContext()->cookie_store();
+}
+
+// static
+mate::Handle<Cookies> Cookies::Create(
+    v8::Isolate* isolate,
+    content::BrowserContext* browser_context) {
+  return mate::CreateHandle(isolate, new Cookies(browser_context));
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_cookies.h

@@ -0,0 +1,90 @@
+// 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_COOKIES_H_
+#define ATOM_BROWSER_API_ATOM_API_COOKIES_H_
+
+#include <string>
+
+#include "base/callback.h"
+#include "native_mate/wrappable.h"
+#include "native_mate/handle.h"
+#include "net/cookies/canonical_cookie.h"
+
+namespace base {
+class DictionaryValue;
+}
+
+namespace content {
+class BrowserContext;
+}
+
+namespace mate {
+class Dictionary;
+}
+
+namespace net {
+class CookieStore;
+class URLRequestContextGetter;
+}
+
+namespace atom {
+
+namespace api {
+
+class Cookies : public mate::Wrappable {
+ public:
+  // node.js style callback function(error, result)
+  typedef base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>
+      CookiesCallback;
+
+  static mate::Handle<Cookies> Create(v8::Isolate* isolate,
+                                      content::BrowserContext* browser_context);
+
+ protected:
+  explicit Cookies(content::BrowserContext* browser_context);
+  ~Cookies();
+
+  void Get(const base::DictionaryValue& options,
+           const CookiesCallback& callback);
+  void Remove(const mate::Dictionary& details,
+              const CookiesCallback& callback);
+  void Set(const base::DictionaryValue& details,
+           const CookiesCallback& callback);
+
+  void GetCookiesOnIOThread(scoped_ptr<base::DictionaryValue> filter,
+                            const CookiesCallback& callback);
+  void OnGetCookies(scoped_ptr<base::DictionaryValue> filter,
+                    const CookiesCallback& callback,
+                    const net::CookieList& cookie_list);
+
+  void RemoveCookiesOnIOThread(const GURL& url,
+                               const std::string& name,
+                               const CookiesCallback& callback);
+  void OnRemoveCookies(const CookiesCallback& callback);
+
+  void SetCookiesOnIOThread(scoped_ptr<base::DictionaryValue> details,
+                            const GURL& url,
+                            const CookiesCallback& callback);
+  void OnSetCookies(const CookiesCallback& callback,
+                    bool set_success);
+
+  // mate::Wrappable:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+
+ private:
+  // Must be called on IO thread.
+  net::CookieStore* GetCookieStore();
+
+  net::URLRequestContextGetter* request_context_getter_;
+
+  DISALLOW_COPY_AND_ASSIGN(Cookies);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_COOKIES_H_

atom/browser/api/atom_api_dialog.cc

@@ -10,9 +10,9 @@
 #include "atom/browser/native_window.h"
 #include "atom/browser/ui/file_dialog.h"
 #include "atom/browser/ui/message_box.h"
+#include "atom/common/native_mate_converters/callback.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"
 
 #include "atom/common/node_includes.h"
@@ -22,7 +22,7 @@ namespace mate {
 template<>
 struct Converter<file_dialog::Filter> {
   static bool FromV8(v8::Isolate* isolate,
-                     v8::Handle<v8::Value> val,
+                     v8::Local<v8::Value> val,
                      file_dialog::Filter* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
@@ -41,27 +41,25 @@ namespace {
 
 void ShowMessageBox(int type,
                     const std::vector<std::string>& buttons,
-                    const std::vector<std::string>& texts,
+                    int cancel_id,
+                    int options,
+                    const std::string& title,
+                    const std::string& message,
+                    const std::string& detail,
                     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();
+  v8::Local<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, icon, callback);
+    atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons, cancel_id,
+                         options, title, message, detail, icon, callback);
   } else {
     int chosen = atom::ShowMessageBox(window, (atom::MessageBoxType)type,
-                                      buttons, title, message, detail, icon);
+                                      buttons, cancel_id, options, title,
+                                      message, detail, icon);
     args->Return(chosen);
   }
 }
@@ -72,7 +70,7 @@ void ShowOpenDialog(const std::string& title,
                     int properties,
                     atom::NativeWindow* window,
                     mate::Arguments* args) {
-  v8::Handle<v8::Value> peek = args->PeekNext();
+  v8::Local<v8::Value> peek = args->PeekNext();
   file_dialog::OpenDialogCallback callback;
   if (mate::Converter<file_dialog::OpenDialogCallback>::FromV8(args->isolate(),
                                                                peek,
@@ -92,7 +90,7 @@ void ShowSaveDialog(const std::string& title,
                     const file_dialog::Filters& filters,
                     atom::NativeWindow* window,
                     mate::Arguments* args) {
-  v8::Handle<v8::Value> peek = args->PeekNext();
+  v8::Local<v8::Value> peek = args->PeekNext();
   file_dialog::SaveDialogCallback callback;
   if (mate::Converter<file_dialog::SaveDialogCallback>::FromV8(args->isolate(),
                                                                peek,
@@ -106,8 +104,8 @@ void ShowSaveDialog(const std::string& title,
   }
 }
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
   mate::Dictionary dict(context->GetIsolate(), exports);
   dict.SetMethod("showMessageBox", &ShowMessageBox);
   dict.SetMethod("showErrorBox", &atom::ShowErrorBox);

atom/browser/api/atom_api_global_shortcut.cc

@@ -7,8 +7,8 @@
 #include <string>
 
 #include "atom/common/native_mate_converters/accelerator_converter.h"
+#include "atom/common/native_mate_converters/callback.h"
 #include "base/stl_util.h"
-#include "native_mate/callback.h"
 #include "native_mate/dictionary.h"
 
 #include "atom/common/node_includes.h"
@@ -86,8 +86,8 @@ mate::Handle<GlobalShortcut> GlobalShortcut::Create(v8::Isolate* isolate) {
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
   dict.Set("globalShortcut", atom::api::GlobalShortcut::Create(isolate));

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_;
 

atom/browser/api/atom_api_menu.cc

@@ -6,6 +6,8 @@
 
 #include "atom/browser/native_window.h"
 #include "atom/common/native_mate_converters/accelerator_converter.h"
+#include "atom/common/native_mate_converters/callback.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"
@@ -17,143 +19,54 @@ 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)),
+    : model_(new AtomMenuModel(this)),
       parent_(NULL) {
 }
 
 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,
                                       ui::Accelerator* accelerator) {
-  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::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<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);
-}
-
-void Menu::AttachToWindow(Window* window) {
-  window->window()->SetMenu(model_.get());
+  menu_will_show_.Run();
 }
 
 void Menu::InsertItemAt(
@@ -186,10 +99,18 @@ 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);
 }
 
+void Menu::SetRole(int index, const base::string16& role) {
+  model_->SetRole(index, role);
+}
+
 void Menu::Clear() {
   model_->Clear();
 }
@@ -228,14 +149,16 @@ bool Menu::IsVisibleAt(int index) const {
 
 // static
 void Menu::BuildPrototype(v8::Isolate* isolate,
-                          v8::Handle<v8::ObjectTemplate> prototype) {
+                          v8::Local<v8::ObjectTemplate> prototype) {
   mate::ObjectTemplateBuilder(isolate, prototype)
       .SetMethod("insertItem", &Menu::InsertItemAt)
       .SetMethod("insertCheckItem", &Menu::InsertCheckItemAt)
       .SetMethod("insertRadioItem", &Menu::InsertRadioItemAt)
       .SetMethod("insertSeparator", &Menu::InsertSeparatorAt)
       .SetMethod("insertSubMenu", &Menu::InsertSubMenuAt)
+      .SetMethod("setIcon", &Menu::SetIcon)
       .SetMethod("setSublabel", &Menu::SetSublabel)
+      .SetMethod("setRole", &Menu::SetRole)
       .SetMethod("clear", &Menu::Clear)
       .SetMethod("getIndexOfCommandId", &Menu::GetIndexOfCommandId)
       .SetMethod("getItemCount", &Menu::GetItemCount)
@@ -245,7 +168,6 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("isItemCheckedAt", &Menu::IsItemCheckedAt)
       .SetMethod("isEnabledAt", &Menu::IsEnabledAt)
       .SetMethod("isVisibleAt", &Menu::IsVisibleAt)
-      .SetMethod("attachToWindow", &Menu::AttachToWindow)
       .SetMethod("_popup", &Menu::Popup)
       .SetMethod("_popupAt", &Menu::PopupAt);
 }
@@ -257,14 +179,14 @@ void Menu::BuildPrototype(v8::Isolate* isolate,
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
   using atom::api::Menu;
   v8::Isolate* isolate = context->GetIsolate();
   v8::Local<v8::Function> constructor = mate::CreateConstructor<Menu>(
       isolate, "Menu", base::Bind(&Menu::Create));
   mate::Dictionary dict(isolate, exports);
-  dict.Set("Menu", static_cast<v8::Handle<v8::Value>>(constructor));
+  dict.Set("Menu", static_cast<v8::Local<v8::Value>>(constructor));
 #if defined(OS_MACOSX)
   dict.SetMethod("setApplicationMenu", &Menu::SetApplicationMenu);
   dict.SetMethod("sendActionToFirstResponder",

atom/browser/api/atom_api_menu.h

@@ -8,23 +8,22 @@
 #include <string>
 
 #include "atom/browser/api/atom_api_window.h"
+#include "atom/browser/ui/atom_menu_model.h"
+#include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
-#include "ui/base/models/simple_menu_model.h"
 #include "native_mate/wrappable.h"
 
 namespace atom {
 
 namespace api {
 
-class MenuMac;
-
 class Menu : public mate::Wrappable,
-             public ui::SimpleMenuModel::Delegate {
+             public AtomMenuModel::Delegate {
  public:
   static mate::Wrappable* Create();
 
   static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Handle<v8::ObjectTemplate> prototype);
+                             v8::Local<v8::ObjectTemplate> prototype);
 
 #if defined(OS_MACOSX)
   // Set the global menubar.
@@ -34,30 +33,28 @@ class Menu : public mate::Wrappable,
   static void SendActionToFirstResponder(const std::string& action);
 #endif
 
-  ui::SimpleMenuModel* model() const { return model_.get(); }
+  AtomMenuModel* model() const { return model_.get(); }
 
  protected:
   Menu();
   virtual ~Menu();
 
-  // ui::SimpleMenuModel::Delegate implementations:
+  // mate::Wrappable:
+  void AfterInit(v8::Isolate* isolate) override;
+
+  // ui::SimpleMenuModel::Delegate:
   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;
-  bool IsItemForCommandIdDynamic(int command_id) const override;
-  base::string16 GetLabelForCommandId(int command_id) const override;
-  base::string16 GetSublabelForCommandId(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_;
+  scoped_ptr<AtomMenuModel> model_;
   Menu* parent_;
 
  private:
@@ -74,7 +71,9 @@ 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 SetRole(int index, const base::string16& role);
   void Clear();
   int GetIndexOfCommandId(int command_id);
   int GetItemCount() const;
@@ -85,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::Local<v8::Value>(int)> get_accelerator_;
+  base::Callback<void(int)> execute_command_;
+  base::Callback<void()> menu_will_show_;
+
   DISALLOW_COPY_AND_ASSIGN(Menu);
 };
 
@@ -92,4 +99,27 @@ class Menu : public mate::Wrappable,
 
 }  // namespace atom
 
+
+namespace mate {
+
+template<>
+struct Converter<atom::AtomMenuModel*> {
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
+                     atom::AtomMenuModel** out) {
+    // null would be tranfered to NULL.
+    if (val->IsNull()) {
+      *out = nullptr;
+      return true;
+    }
+
+    atom::api::Menu* menu;
+    if (!Converter<atom::api::Menu*>::FromV8(isolate, val, &menu))
+      return false;
+    *out = menu->model();
+    return true;
+  }
+};
+
+}  // namespace mate
+
 #endif  // ATOM_BROWSER_API_ATOM_API_MENU_H_

atom/browser/api/atom_api_menu_mac.h

@@ -19,8 +19,8 @@ class MenuMac : public Menu {
  protected:
   MenuMac();
 
-  virtual void Popup(Window* window) OVERRIDE;
-  virtual void PopupAt(Window* window, int x, int y) OVERRIDE;
+  void Popup(Window* window) override;
+  void PopupAt(Window* window, int x, int y) override;
 
   base::scoped_nsobject<AtomMenuController> menu_controller_;
 

atom/browser/api/atom_api_menu_mac.mm

@@ -22,7 +22,7 @@ void MenuMac::Popup(Window* window) {
   NativeWindow* native_window = window->window();
   if (!native_window)
     return;
-  content::WebContents* web_contents = native_window->GetWebContents();
+  content::WebContents* web_contents = native_window->web_contents();
   if (!web_contents)
     return;
 
@@ -54,7 +54,7 @@ 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();
+  content::WebContents* web_contents = native_window->web_contents();
   if (!web_contents)
     return;
 

atom/browser/api/atom_api_menu_views.cc

@@ -24,7 +24,7 @@ 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();
+  content::WebContents* web_contents = native_window->web_contents();
   if (!web_contents)
     return;
   content::RenderWidgetHostView* view = web_contents->GetRenderWidgetHostView();

atom/browser/api/atom_api_menu_views.h

@@ -17,8 +17,8 @@ class MenuViews : public Menu {
   MenuViews();
 
  protected:
-  virtual void Popup(Window* window) OVERRIDE;
-  virtual void PopupAt(Window* window, int x, int y) OVERRIDE;
+  void Popup(Window* window) override;
+  void PopupAt(Window* window, int x, int y) override;
 
  private:
   void PopupAtPoint(Window* window, const gfx::Point& point);

atom/browser/api/atom_api_power_monitor.cc

@@ -4,12 +4,12 @@
 
 #include "atom/browser/api/atom_api_power_monitor.h"
 
+#include "atom/browser/browser.h"
+#include "atom/common/node_includes.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "native_mate/dictionary.h"
 
-#include "atom/common/node_includes.h"
-
 namespace atom {
 
 namespace api {
@@ -38,8 +38,15 @@ void PowerMonitor::OnResume() {
 }
 
 // static
-mate::Handle<PowerMonitor> PowerMonitor::Create(v8::Isolate* isolate) {
-  return CreateHandle(isolate, new PowerMonitor);
+v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
+  if (!Browser::Get()->is_ready()) {
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate,
+        "Cannot initialize \"power-monitor\" module before app is ready")));
+    return v8::Null(isolate);
+  }
+
+  return CreateHandle(isolate, new PowerMonitor).ToV8();
 }
 
 }  // namespace api
@@ -49,17 +56,16 @@ mate::Handle<PowerMonitor> PowerMonitor::Create(v8::Isolate* isolate) {
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
 #if defined(OS_MACOSX)
   base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
 #endif
 
   using atom::api::PowerMonitor;
   v8::Isolate* isolate = context->GetIsolate();
-  mate::Handle<PowerMonitor> power_monitor = PowerMonitor::Create(isolate);
   mate::Dictionary dict(isolate, exports);
-  dict.Set("powerMonitor", power_monitor);
+  dict.Set("powerMonitor", PowerMonitor::Create(isolate));
 }
 
 }  // namespace

atom/browser/api/atom_api_power_monitor.h

@@ -17,16 +17,16 @@ namespace api {
 class PowerMonitor : public mate::EventEmitter,
                      public base::PowerObserver {
  public:
-  static mate::Handle<PowerMonitor> Create(v8::Isolate* isolate);
+  static v8::Local<v8::Value> Create(v8::Isolate* isolate);
 
  protected:
   PowerMonitor();
   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);

atom/browser/api/atom_api_power_save_blocker.cc

@@ -0,0 +1,128 @@
+// 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_power_save_blocker.h"
+
+#include <string>
+
+#include "atom/common/node_includes.h"
+#include "content/public/browser/power_save_blocker.h"
+#include "native_mate/dictionary.h"
+
+namespace mate {
+
+template<>
+struct Converter<content::PowerSaveBlocker::PowerSaveBlockerType> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     content::PowerSaveBlocker::PowerSaveBlockerType* out) {
+    using content::PowerSaveBlocker;
+    std::string type;
+    if (!ConvertFromV8(isolate, val, &type))
+      return false;
+    if (type == "prevent-app-suspension")
+      *out = PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension;
+    else if (type == "prevent-display-sleep")
+      *out = PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep;
+    else
+      return false;
+    return true;
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+
+namespace api {
+
+PowerSaveBlocker::PowerSaveBlocker()
+    : current_blocker_type_(
+        content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension) {
+}
+
+PowerSaveBlocker::~PowerSaveBlocker() {
+}
+
+void PowerSaveBlocker::UpdatePowerSaveBlocker() {
+  if (power_save_blocker_types_.empty()) {
+    power_save_blocker_.reset();
+    return;
+  }
+
+  // |kPowerSaveBlockPreventAppSuspension| keeps system active, but allows
+  // screen to be turned off.
+  // |kPowerSaveBlockPreventDisplaySleep| keeps system and screen active, has a
+  // higher precedence level than |kPowerSaveBlockPreventAppSuspension|.
+  //
+  // Only the highest-precedence blocker type takes effect.
+  content::PowerSaveBlocker::PowerSaveBlockerType new_blocker_type =
+      content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension;
+  for (const auto& element : power_save_blocker_types_) {
+    if (element.second ==
+        content::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep) {
+      new_blocker_type =
+          content::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep;
+      break;
+    }
+  }
+
+  if (!power_save_blocker_ || new_blocker_type != current_blocker_type_) {
+    scoped_ptr<content::PowerSaveBlocker> new_blocker =
+        content::PowerSaveBlocker::Create(
+            new_blocker_type,
+            content::PowerSaveBlocker::kReasonOther,
+            ATOM_PRODUCT_NAME);
+    power_save_blocker_.swap(new_blocker);
+    current_blocker_type_ = new_blocker_type;
+  }
+}
+
+int PowerSaveBlocker::Start(
+    content::PowerSaveBlocker::PowerSaveBlockerType type) {
+  static int count = 0;
+  power_save_blocker_types_[count] = type;
+  UpdatePowerSaveBlocker();
+  return count++;
+}
+
+bool PowerSaveBlocker::Stop(int id) {
+  bool success = power_save_blocker_types_.erase(id) > 0;
+  UpdatePowerSaveBlocker();
+  return success;
+}
+
+bool PowerSaveBlocker::IsStarted(int id) {
+  return power_save_blocker_types_.find(id) != power_save_blocker_types_.end();
+}
+
+mate::ObjectTemplateBuilder PowerSaveBlocker::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("start", &PowerSaveBlocker::Start)
+      .SetMethod("stop", &PowerSaveBlocker::Stop)
+      .SetMethod("isStarted", &PowerSaveBlocker::IsStarted);
+}
+
+// static
+mate::Handle<PowerSaveBlocker> PowerSaveBlocker::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new PowerSaveBlocker);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("powerSaveBlocker", atom::api::PowerSaveBlocker::Create(isolate));
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_power_save_blocker, Initialize);

atom/browser/api/atom_api_power_save_blocker.h

@@ -0,0 +1,59 @@
+// 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_POWER_SAVE_BLOCKER_H_
+#define ATOM_BROWSER_API_ATOM_API_POWER_SAVE_BLOCKER_H_
+
+#include <map>
+
+#include "base/memory/scoped_ptr.h"
+#include "content/public/browser/power_save_blocker.h"
+#include "native_mate/handle.h"
+#include "native_mate/wrappable.h"
+
+namespace mate {
+class Dictionary;
+}
+
+namespace atom {
+
+namespace api {
+
+class PowerSaveBlocker : public mate::Wrappable {
+ public:
+  static mate::Handle<PowerSaveBlocker> Create(v8::Isolate* isolate);
+
+ protected:
+  PowerSaveBlocker();
+  virtual ~PowerSaveBlocker();
+
+  // mate::Wrappable implementations:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+
+ private:
+  void UpdatePowerSaveBlocker();
+  int Start(content::PowerSaveBlocker::PowerSaveBlockerType type);
+  bool Stop(int id);
+  bool IsStarted(int id);
+
+  scoped_ptr<content::PowerSaveBlocker> power_save_blocker_;
+
+  // Currnet blocker type used by |power_save_blocker_|
+  content::PowerSaveBlocker::PowerSaveBlockerType current_blocker_type_;
+
+  // Map from id to the corresponding blocker type for each request.
+  using PowerSaveBlockerTypeMap =
+      std::map<int, content::PowerSaveBlocker::PowerSaveBlockerType>;
+  PowerSaveBlockerTypeMap power_save_blocker_types_;
+
+
+  DISALLOW_COPY_AND_ASSIGN(PowerSaveBlocker);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_POWER_SAVE_BLOCKER_H_

atom/browser/api/atom_api_protocol.cc

@@ -4,16 +4,16 @@
 
 #include "atom/browser/api/atom_api_protocol.h"
 
+#include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_context.h"
-#include "atom/browser/net/adapter_request_job.h"
-#include "atom/browser/net/atom_url_request_job_factory.h"
-#include "atom/common/native_mate_converters/file_path_converter.h"
-#include "content/public/browser/browser_thread.h"
-#include "native_mate/callback.h"
-#include "native_mate/dictionary.h"
-#include "net/url_request/url_request_context.h"
-
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/net/url_request_async_asar_job.h"
+#include "atom/browser/net/url_request_buffer_job.h"
+#include "atom/browser/net/url_request_fetch_job.h"
+#include "atom/browser/net/url_request_string_job.h"
+#include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/node_includes.h"
+#include "native_mate/dictionary.h"
 
 using content::BrowserThread;
 
@@ -21,8 +21,8 @@ namespace mate {
 
 template<>
 struct Converter<const net::URLRequest*> {
-  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    const net::URLRequest* val) {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   const net::URLRequest* val) {
     return mate::ObjectTemplateBuilder(isolate)
         .SetValue("method", val->method())
         .SetValue("url", val->url().spec())
@@ -33,286 +33,132 @@ struct Converter<const net::URLRequest*> {
 
 }  // namespace mate
 
-
 namespace atom {
 
 namespace api {
 
-namespace {
-
-typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
-
-class CustomProtocolRequestJob : public AdapterRequestJob {
- public:
-  CustomProtocolRequestJob(Protocol* registry,
-                           ProtocolHandler* protocol_handler,
-                           net::URLRequest* request,
-                           net::NetworkDelegate* network_delegate)
-      : AdapterRequestJob(protocol_handler, request, network_delegate),
-        registry_(registry) {
-  }
-
-  // AdapterRequestJob:
-  virtual void GetJobTypeInUI() OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    v8::Locker locker(isolate);
-    v8::HandleScope handle_scope(isolate);
-
-    // Call the JS handler.
-    Protocol::JsProtocolHandler callback =
-        registry_->GetProtocolHandler(request()->url().scheme());
-    v8::Handle<v8::Value> result = callback.Run(request());
-
-    // Determine the type of the job we are going to create.
-    if (result->IsString()) {
-      std::string data = mate::V8ToString(result);
-      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-          base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
-                     GetWeakPtr(), "text/plain", "UTF-8", data));
-      return;
-    } else if (result->IsObject()) {
-      v8::Handle<v8::Object> obj = result->ToObject();
-      mate::Dictionary dict(isolate, obj);
-      std::string name = mate::V8ToString(obj->GetConstructorName());
-      if (name == "RequestStringJob") {
-        std::string mime_type, charset, data;
-        dict.Get("mimeType", &mime_type);
-        dict.Get("charset", &charset);
-        dict.Get("data", &data);
-
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-            base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
-                       GetWeakPtr(), mime_type, charset, data));
-        return;
-      } else if (name == "RequestFileJob") {
-        base::FilePath path;
-        dict.Get("path", &path);
-
-        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-            base::Bind(&AdapterRequestJob::CreateFileJobAndStart,
-                       GetWeakPtr(), path));
-        return;
-      }
-    }
-
-    // Try the default protocol handler if we have.
-    if (default_protocol_handler()) {
-      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-          base::Bind(&AdapterRequestJob::CreateJobFromProtocolHandlerAndStart,
-                     GetWeakPtr()));
-      return;
-    }
-
-    // Fallback to the not implemented error.
-    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-        base::Bind(&AdapterRequestJob::CreateErrorJobAndStart,
-                   GetWeakPtr(), net::ERR_NOT_IMPLEMENTED));
-  }
-
- private:
-  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
-};
-
-// Always return the same CustomProtocolRequestJob for all requests, because
-// the content API needs the ProtocolHandler to return a job immediately, and
-// getting the real job from the JS requires asynchronous calls, so we have
-// to create an adapter job first.
-// Users can also pass an extra ProtocolHandler as the fallback one when
-// registered handler doesn't want to deal with the request.
-class CustomProtocolHandler : public ProtocolHandler {
- public:
-  CustomProtocolHandler(api::Protocol* registry,
-                        ProtocolHandler* protocol_handler = NULL)
-      : registry_(registry), protocol_handler_(protocol_handler) {
-  }
-
-  virtual net::URLRequestJob* MaybeCreateJob(
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
-    return new CustomProtocolRequestJob(registry_, protocol_handler_.get(),
-                                        request, network_delegate);
-  }
-
-  ProtocolHandler* ReleaseDefaultProtocolHandler() {
-    return protocol_handler_.release();
-  }
-
-  ProtocolHandler* original_handler() { return protocol_handler_.get(); }
-
- private:
-  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
-  scoped_ptr<ProtocolHandler> protocol_handler_;
-
-  DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
-};
-
-}  // namespace
-
-Protocol::Protocol()
-    : job_factory_(AtomBrowserContext::Get()->job_factory()) {
+Protocol::Protocol(AtomBrowserContext* browser_context)
+    : request_context_getter_(browser_context->GetRequestContext()),
+      job_factory_(browser_context->job_factory()) {
   CHECK(job_factory_);
 }
 
-Protocol::JsProtocolHandler Protocol::GetProtocolHandler(
-    const std::string& scheme) {
-  return protocol_handlers_[scheme];
-}
-
 mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return mate::ObjectTemplateBuilder(isolate)
-      .SetMethod("registerProtocol",
-                 base::Bind(&Protocol::RegisterProtocol,
-                            base::Unretained(this)))
-      .SetMethod("unregisterProtocol",
-                 base::Bind(&Protocol::UnregisterProtocol,
-                            base::Unretained(this)))
-      .SetMethod("isHandledProtocol",
-                 base::Bind(&Protocol::IsHandledProtocol,
-                            base::Unretained(this)))
-      .SetMethod("interceptProtocol",
-                 base::Bind(&Protocol::InterceptProtocol,
-                            base::Unretained(this)))
-      .SetMethod("uninterceptProtocol",
-                 base::Bind(&Protocol::UninterceptProtocol,
-                            base::Unretained(this)));
+      .SetMethod("registerStandardSchemes", &Protocol::RegisterStandardSchemes)
+      .SetMethod("registerStringProtocol",
+                 &Protocol::RegisterProtocol<URLRequestStringJob>)
+      .SetMethod("registerBufferProtocol",
+                 &Protocol::RegisterProtocol<URLRequestBufferJob>)
+      .SetMethod("registerFileProtocol",
+                 &Protocol::RegisterProtocol<UrlRequestAsyncAsarJob>)
+      .SetMethod("registerHttpProtocol",
+                 &Protocol::RegisterProtocol<URLRequestFetchJob>)
+      .SetMethod("unregisterProtocol", &Protocol::UnregisterProtocol)
+      .SetMethod("isProtocolHandled", &Protocol::IsProtocolHandled)
+      .SetMethod("interceptStringProtocol",
+                 &Protocol::InterceptProtocol<URLRequestStringJob>)
+      .SetMethod("interceptBufferProtocol",
+                 &Protocol::InterceptProtocol<URLRequestBufferJob>)
+      .SetMethod("interceptFileProtocol",
+                 &Protocol::InterceptProtocol<UrlRequestAsyncAsarJob>)
+      .SetMethod("interceptHttpProtocol",
+                 &Protocol::InterceptProtocol<URLRequestFetchJob>)
+      .SetMethod("uninterceptProtocol", &Protocol::UninterceptProtocol);
 }
 
-void Protocol::RegisterProtocol(const std::string& scheme,
-                                const JsProtocolHandler& callback) {
-  if (ContainsKey(protocol_handlers_, scheme) ||
-      job_factory_->IsHandledProtocol(scheme))
-    return node::ThrowError("The scheme is already registered");
-
-  protocol_handlers_[scheme] = callback;
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&Protocol::RegisterProtocolInIO,
-                                     base::Unretained(this), scheme));
+void Protocol::RegisterStandardSchemes(
+    const std::vector<std::string>& schemes) {
+  atom::AtomBrowserClient::SetCustomSchemes(schemes);
 }
 
-void Protocol::UnregisterProtocol(const std::string& scheme) {
-  ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
-  if (it == protocol_handlers_.end())
-    return node::ThrowError("The scheme has not been registered");
-
-  protocol_handlers_.erase(it);
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&Protocol::UnregisterProtocolInIO,
-                                     base::Unretained(this), scheme));
+void Protocol::UnregisterProtocol(
+    const std::string& scheme, mate::Arguments* args) {
+  CompletionCallback callback;
+  args->GetNext(&callback);
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&Protocol::UnregisterProtocolInIO,
+                 base::Unretained(this), scheme),
+      base::Bind(&Protocol::OnIOCompleted,
+                 base::Unretained(this), callback));
 }
 
-bool Protocol::IsHandledProtocol(const std::string& scheme) {
+Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
+    const std::string& scheme) {
+  if (!job_factory_->HasProtocolHandler(scheme))
+    return PROTOCOL_NOT_REGISTERED;
+  job_factory_->SetProtocolHandler(scheme, nullptr);
+  return PROTOCOL_OK;
+}
+
+void Protocol::IsProtocolHandled(const std::string& scheme,
+                                    const BooleanCallback& callback) {
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&Protocol::IsProtocolHandledInIO,
+                 base::Unretained(this), scheme),
+      callback);
+}
+
+bool Protocol::IsProtocolHandledInIO(const std::string& scheme) {
   return job_factory_->IsHandledProtocol(scheme);
 }
 
-void Protocol::InterceptProtocol(const std::string& scheme,
-                                 const JsProtocolHandler& callback) {
-  if (!job_factory_->HasProtocolHandler(scheme))
-    return node::ThrowError("Scheme does not exist.");
-
-  if (ContainsKey(protocol_handlers_, scheme))
-    return node::ThrowError("Cannot intercept custom procotols");
-
-  protocol_handlers_[scheme] = callback;
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&Protocol::InterceptProtocolInIO,
-                                     base::Unretained(this), scheme));
+void Protocol::UninterceptProtocol(
+    const std::string& scheme, mate::Arguments* args) {
+  CompletionCallback callback;
+  args->GetNext(&callback);
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(&Protocol::UninterceptProtocolInIO,
+                 base::Unretained(this), scheme),
+      base::Bind(&Protocol::OnIOCompleted,
+                 base::Unretained(this), callback));
 }
 
-void Protocol::UninterceptProtocol(const std::string& scheme) {
-  ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
-  if (it == protocol_handlers_.end())
-    return node::ThrowError("The scheme has not been registered");
-
-  protocol_handlers_.erase(it);
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&Protocol::UninterceptProtocolInIO,
-                                     base::Unretained(this), scheme));
+Protocol::ProtocolError Protocol::UninterceptProtocolInIO(
+    const std::string& scheme) {
+  if (!original_protocols_.contains(scheme))
+    return PROTOCOL_NOT_INTERCEPTED;
+  job_factory_->ReplaceProtocol(scheme,
+                                original_protocols_.take_and_erase(scheme));
+  return PROTOCOL_OK;
 }
 
-void Protocol::RegisterProtocolInIO(const std::string& scheme) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  job_factory_->SetProtocolHandler(scheme, new CustomProtocolHandler(this));
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&Protocol::EmitEventInUI,
-                                     base::Unretained(this),
-                                     "registered", scheme));
-}
-
-void Protocol::UnregisterProtocolInIO(const std::string& scheme) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  job_factory_->SetProtocolHandler(scheme, NULL);
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&Protocol::EmitEventInUI,
-                                     base::Unretained(this),
-                                     "unregistered", scheme));
-}
-
-void Protocol::InterceptProtocolInIO(const std::string& scheme) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  ProtocolHandler* original_handler = job_factory_->GetProtocolHandler(scheme);
-  if (original_handler == NULL) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-        &Protocol::EmitEventInUI,
-        base::Unretained(this),
-        "error", "There is no protocol handler to intercpet"));
+void Protocol::OnIOCompleted(
+    const CompletionCallback& callback, ProtocolError error) {
+  // The completion callback is optional.
+  if (callback.is_null())
     return;
-  }
 
-  job_factory_->ReplaceProtocol(
-      scheme, new CustomProtocolHandler(this, original_handler));
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&Protocol::EmitEventInUI,
-                                     base::Unretained(this),
-                                     "intercepted", scheme));
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+
+  if (error == PROTOCOL_OK) {
+    callback.Run(v8::Null(isolate()));
+  } else {
+    std::string str = ErrorCodeToString(error);
+    callback.Run(v8::Exception::Error(mate::StringToV8(isolate(), str)));
+  }
 }
 
-void Protocol::UninterceptProtocolInIO(const std::string& scheme) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  CustomProtocolHandler* handler = static_cast<CustomProtocolHandler*>(
-      job_factory_->GetProtocolHandler(scheme));
-  if (handler->original_handler() == NULL) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-        &Protocol::EmitEventInUI,
-        base::Unretained(this),
-        "error", "The protocol is not intercpeted"));
-    return;
+std::string Protocol::ErrorCodeToString(ProtocolError error) {
+  switch (error) {
+    case PROTOCOL_FAIL: return "Failed to manipulate protocol factory";
+    case PROTOCOL_REGISTERED: return "The scheme has been registred";
+    case PROTOCOL_NOT_REGISTERED: return "The scheme has not been registred";
+    case PROTOCOL_INTERCEPTED: return "The scheme has been intercepted";
+    case PROTOCOL_NOT_INTERCEPTED: return "The scheme has not been intercepted";
+    default: return "Unexpected error";
   }
-
-  // Reset the protocol handler to the orignal one and delete current protocol
-  // handler.
-  ProtocolHandler* original_handler = handler->ReleaseDefaultProtocolHandler();
-  delete job_factory_->ReplaceProtocol(scheme, original_handler);
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&Protocol::EmitEventInUI,
-                                     base::Unretained(this),
-                                     "unintercepted", scheme));
-}
-
-void Protocol::EmitEventInUI(const std::string& event,
-                             const std::string& parameter) {
-  base::ListValue args;
-  args.AppendString(parameter);
-  Emit(event, args);
 }
 
 // static
-mate::Handle<Protocol> Protocol::Create(v8::Isolate* isolate) {
-  return CreateHandle(isolate, new Protocol);
+mate::Handle<Protocol> Protocol::Create(
+    v8::Isolate* isolate, AtomBrowserContext* browser_context) {
+  return mate::CreateHandle(isolate, new Protocol(browser_context));
 }
 
 }  // namespace api
@@ -321,11 +167,13 @@ mate::Handle<Protocol> Protocol::Create(v8::Isolate* isolate) {
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   mate::Dictionary dict(isolate, exports);
-  dict.Set("protocol", atom::api::Protocol::Create(isolate));
+  auto browser_context = static_cast<atom::AtomBrowserContext*>(
+      atom::AtomBrowserMainParts::Get()->browser_context());
+  dict.Set("protocol", atom::api::Protocol::Create(isolate, browser_context));
 }
 
 }  // namespace

atom/browser/api/atom_api_protocol.h

@@ -7,67 +7,180 @@
 
 #include <string>
 #include <map>
+#include <vector>
 
-#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/net/atom_url_request_job_factory.h"
 #include "base/callback.h"
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "content/public/browser/browser_thread.h"
+#include "native_mate/arguments.h"
+#include "native_mate/dictionary.h"
 #include "native_mate/handle.h"
+#include "native_mate/wrappable.h"
 
 namespace net {
 class URLRequest;
+class URLRequestContextGetter;
 }
 
 namespace atom {
 
+class AtomBrowserContext;
 class AtomURLRequestJobFactory;
 
 namespace api {
 
-class Protocol : public mate::EventEmitter {
+class Protocol : public mate::Wrappable {
  public:
-  typedef base::Callback<v8::Handle<v8::Value>(const net::URLRequest*)>
-          JsProtocolHandler;
+  using Handler =
+      base::Callback<void(const net::URLRequest*, v8::Local<v8::Value>)>;
+  using CompletionCallback = base::Callback<void(v8::Local<v8::Value>)>;
+  using BooleanCallback = base::Callback<void(bool)>;
 
-  static mate::Handle<Protocol> Create(v8::Isolate* isolate);
-
-  JsProtocolHandler GetProtocolHandler(const std::string& scheme);
+  static mate::Handle<Protocol> Create(
+      v8::Isolate* isolate, AtomBrowserContext* browser_context);
 
  protected:
-  Protocol();
+  explicit Protocol(AtomBrowserContext* browser_context);
 
   // mate::Wrappable implementations:
   virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate);
 
  private:
-  typedef std::map<std::string, JsProtocolHandler> ProtocolHandlersMap;
+  // Possible errors.
+  enum ProtocolError {
+    PROTOCOL_OK,  // no error
+    PROTOCOL_FAIL,  // operation failed, should never occur
+    PROTOCOL_REGISTERED,
+    PROTOCOL_NOT_REGISTERED,
+    PROTOCOL_INTERCEPTED,
+    PROTOCOL_NOT_INTERCEPTED,
+  };
 
-  // Register/unregister an networking |scheme| which would be handled by
-  // |callback|.
+  // The protocol handler that will create a protocol handler for certain
+  // request job.
+  template<typename RequestJob>
+  class CustomProtocolHandler
+      : public net::URLRequestJobFactory::ProtocolHandler {
+   public:
+    CustomProtocolHandler(
+        v8::Isolate* isolate,
+        net::URLRequestContextGetter* request_context,
+        const Handler& handler)
+        : isolate_(isolate),
+          request_context_(request_context),
+          handler_(handler) {}
+    ~CustomProtocolHandler() override {}
+
+    net::URLRequestJob* MaybeCreateJob(
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const override {
+      RequestJob* request_job = new RequestJob(request, network_delegate);
+      request_job->SetHandlerInfo(isolate_, request_context_, handler_);
+      return request_job;
+    }
+
+   private:
+    v8::Isolate* isolate_;
+    net::URLRequestContextGetter* request_context_;
+    Protocol::Handler handler_;
+
+    DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
+  };
+
+  // Register schemes to standard scheme list.
+  void RegisterStandardSchemes(const std::vector<std::string>& schemes);
+
+  // Register the protocol with certain request job.
+  template<typename RequestJob>
   void RegisterProtocol(const std::string& scheme,
-                        const JsProtocolHandler& callback);
-  void UnregisterProtocol(const std::string& scheme);
+                        const Handler& handler,
+                        mate::Arguments* args) {
+    CompletionCallback callback;
+    args->GetNext(&callback);
+    content::BrowserThread::PostTaskAndReplyWithResult(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&Protocol::RegisterProtocolInIO<RequestJob>,
+                   base::Unretained(this), scheme, handler),
+        base::Bind(&Protocol::OnIOCompleted,
+                   base::Unretained(this), callback));
+  }
+  template<typename RequestJob>
+  ProtocolError RegisterProtocolInIO(const std::string& scheme,
+                                     const Handler& handler) {
+    if (job_factory_->IsHandledProtocol(scheme))
+      return PROTOCOL_REGISTERED;
+    scoped_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
+        new CustomProtocolHandler<RequestJob>(
+            isolate(), request_context_getter_, handler));
+    if (job_factory_->SetProtocolHandler(scheme, protocol_handler.Pass()))
+      return PROTOCOL_OK;
+    else
+      return PROTOCOL_FAIL;
+  }
 
-  // Returns whether a scheme has been registered.
-  // FIXME Should accept a callback and be asynchronous so we do not have to use
-  // locks.
-  bool IsHandledProtocol(const std::string& scheme);
+  // Unregister the protocol handler that handles |scheme|.
+  void UnregisterProtocol(const std::string& scheme, mate::Arguments* args);
+  ProtocolError UnregisterProtocolInIO(const std::string& scheme);
 
-  // Intercept/unintercept an existing protocol handler.
+  // Whether the protocol has handler registered.
+  void IsProtocolHandled(const std::string& scheme,
+                         const BooleanCallback& callback);
+  bool IsProtocolHandledInIO(const std::string& scheme);
+
+  // Replace the protocol handler with a new one.
+  template<typename RequestJob>
   void InterceptProtocol(const std::string& scheme,
-                         const JsProtocolHandler& callback);
-  void UninterceptProtocol(const std::string& scheme);
+                         const Handler& handler,
+                         mate::Arguments* args) {
+    CompletionCallback callback;
+    args->GetNext(&callback);
+    content::BrowserThread::PostTaskAndReplyWithResult(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&Protocol::InterceptProtocolInIO<RequestJob>,
+                   base::Unretained(this), scheme, handler),
+        base::Bind(&Protocol::OnIOCompleted,
+                   base::Unretained(this), callback));
+  }
+  template<typename RequestJob>
+  ProtocolError InterceptProtocolInIO(const std::string& scheme,
+                                      const Handler& handler) {
+    if (!job_factory_->IsHandledProtocol(scheme))
+      return PROTOCOL_NOT_REGISTERED;
+    // It is possible a protocol is handled but can not be intercepted.
+    if (!job_factory_->HasProtocolHandler(scheme))
+      return PROTOCOL_FAIL;
+    if (ContainsKey(original_protocols_, scheme))
+      return PROTOCOL_INTERCEPTED;
+    scoped_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
+        new CustomProtocolHandler<RequestJob>(
+            isolate(), request_context_getter_, handler));
+    original_protocols_.set(
+        scheme,
+        job_factory_->ReplaceProtocol(scheme, protocol_handler.Pass()));
+    return PROTOCOL_OK;
+  }
 
-  // The networking related operations have to be done in IO thread.
-  void RegisterProtocolInIO(const std::string& scheme);
-  void UnregisterProtocolInIO(const std::string& scheme);
-  void InterceptProtocolInIO(const std::string& scheme);
-  void UninterceptProtocolInIO(const std::string& scheme);
+  // Restore the |scheme| to its original protocol handler.
+  void UninterceptProtocol(const std::string& scheme, mate::Arguments* args);
+  ProtocolError UninterceptProtocolInIO(const std::string& scheme);
 
-  // Do protocol.emit(event, parameter) under UI thread.
-  void EmitEventInUI(const std::string& event, const std::string& parameter);
+  // Convert error code to JS exception and call the callback.
+  void OnIOCompleted(const CompletionCallback& callback, ProtocolError error);
 
-  AtomURLRequestJobFactory* job_factory_;
-  ProtocolHandlersMap protocol_handlers_;
+  // Convert error code to string.
+  std::string ErrorCodeToString(ProtocolError error);
+
+  net::URLRequestContextGetter* request_context_getter_;
+
+  // Map that stores the original protocols of schemes.
+  using OriginalProtocolsMap = base::ScopedPtrHashMap<
+      std::string,
+      scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>>;
+  OriginalProtocolsMap original_protocols_;
+
+  AtomURLRequestJobFactory* job_factory_;  // weak ref
 
   DISALLOW_COPY_AND_ASSIGN(Protocol);
 };

atom/browser/api/atom_api_screen.cc

@@ -0,0 +1,146 @@
+// 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) {
+  displays_ = screen_->GetAllDisplays();
+  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() {
+  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::Local<v8::Value> Screen::Create(v8::Isolate* isolate) {
+  if (!Browser::Get()->is_ready()) {
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate,
+        "Cannot initialize \"screen\" module before app is ready")));
+    return v8::Null(isolate);
+  }
+
+  gfx::Screen* screen = gfx::Screen::GetNativeScreen();
+  if (!screen) {
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Failed to get screen information")));
+    return v8::Null(isolate);
+  }
+
+  return mate::CreateHandle(isolate, new Screen(screen)).ToV8();
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<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)

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::Local<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_

atom/browser/api/atom_api_session.cc

@@ -0,0 +1,372 @@
+// 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_session.h"
+
+#include <string>
+#include <vector>
+
+#include "atom/browser/api/atom_api_cookies.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/node_includes.h"
+#include "base/files/file_path.h"
+#include "base/prefs/pref_service.h"
+#include "base/strings/string_util.h"
+#include "base/thread_task_runner_handle.h"
+#include "chrome/common/pref_names.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+#include "net/base/load_flags.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/proxy/proxy_service.h"
+#include "net/proxy/proxy_config_service_fixed.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+using content::BrowserThread;
+using content::StoragePartition;
+
+namespace {
+
+struct ClearStorageDataOptions {
+  GURL origin;
+  uint32 storage_types = StoragePartition::REMOVE_DATA_MASK_ALL;
+  uint32 quota_types = StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL;
+};
+
+uint32 GetStorageMask(const std::vector<std::string>& storage_types) {
+  uint32 storage_mask = 0;
+  for (const auto& it : storage_types) {
+    auto type = base::StringToLowerASCII(it);
+    if (type == "appcache")
+      storage_mask |= StoragePartition::REMOVE_DATA_MASK_APPCACHE;
+    else if (type == "cookies")
+      storage_mask |= StoragePartition::REMOVE_DATA_MASK_COOKIES;
+    else if (type == "filesystem")
+      storage_mask |= StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
+    else if (type == "indexdb")
+      storage_mask |= StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
+    else if (type == "localstorage")
+      storage_mask |= StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
+    else if (type == "shadercache")
+      storage_mask |= StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
+    else if (type == "websql")
+      storage_mask |= StoragePartition::REMOVE_DATA_MASK_WEBSQL;
+    else if (type == "serviceworkers")
+      storage_mask |= StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS;
+  }
+  return storage_mask;
+}
+
+uint32 GetQuotaMask(const std::vector<std::string>& quota_types) {
+  uint32 quota_mask = 0;
+  for (const auto& it : quota_types) {
+    auto type = base::StringToLowerASCII(it);
+    if (type == "temporary")
+      quota_mask |= StoragePartition::QUOTA_MANAGED_STORAGE_MASK_TEMPORARY;
+    else if (type == "persistent")
+      quota_mask |= StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
+    else if (type == "syncable")
+      quota_mask |= StoragePartition::QUOTA_MANAGED_STORAGE_MASK_SYNCABLE;
+  }
+  return quota_mask;
+}
+
+}  // namespace
+
+namespace mate {
+
+template<>
+struct Converter<ClearStorageDataOptions> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Local<v8::Value> val,
+                     ClearStorageDataOptions* out) {
+    mate::Dictionary options;
+    if (!ConvertFromV8(isolate, val, &options))
+      return false;
+    options.Get("origin", &out->origin);
+    std::vector<std::string> types;
+    if (options.Get("storages", &types))
+      out->storage_types = GetStorageMask(types);
+    if (options.Get("quotas", &types))
+      out->quota_types = GetQuotaMask(types);
+    return true;
+  }
+};
+
+template<>
+struct Converter<content::DownloadItem*> {
+  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
+                                   content::DownloadItem* val) {
+    mate::Dictionary dict(isolate, v8::Object::New(isolate));
+    dict.Set("url", val->GetURL());
+    dict.Set("filename", val->GetSuggestedFilename());
+    dict.Set("mimeType", val->GetMimeType());
+    dict.Set("hasUserGesture", val->HasUserGesture());
+    return dict.GetHandle();
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+// The wrapSession funtion which is implemented in JavaScript
+using WrapSessionCallback = base::Callback<void(v8::Local<v8::Value>)>;
+WrapSessionCallback g_wrap_session;
+
+class ResolveProxyHelper {
+ public:
+  ResolveProxyHelper(AtomBrowserContext* browser_context,
+                     const GURL& url,
+                     Session::ResolveProxyCallback callback)
+      : callback_(callback),
+        original_thread_(base::ThreadTaskRunnerHandle::Get()) {
+    scoped_refptr<net::URLRequestContextGetter> context_getter =
+        browser_context->GetRequestContext();
+    context_getter->GetNetworkTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ResolveProxyHelper::ResolveProxy,
+                   base::Unretained(this), context_getter, url));
+  }
+
+  void OnResolveProxyCompleted(int result) {
+    std::string proxy;
+    if (result == net::OK)
+      proxy = proxy_info_.ToPacString();
+    original_thread_->PostTask(FROM_HERE,
+                               base::Bind(callback_, proxy));
+    delete this;
+  }
+
+ private:
+  void ResolveProxy(scoped_refptr<net::URLRequestContextGetter> context_getter,
+                    const GURL& url) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
+    net::ProxyService* proxy_service =
+        context_getter->GetURLRequestContext()->proxy_service();
+    net::CompletionCallback completion_callback =
+        base::Bind(&ResolveProxyHelper::OnResolveProxyCompleted,
+                   base::Unretained(this));
+
+    // Start the request.
+    int result = proxy_service->ResolveProxy(
+        url, net::LOAD_NORMAL, &proxy_info_, completion_callback,
+        &pac_req_, nullptr, net::BoundNetLog());
+
+    // Completed synchronously.
+    if (result != net::ERR_IO_PENDING)
+      completion_callback.Run(result);
+  }
+
+  Session::ResolveProxyCallback callback_;
+  net::ProxyInfo proxy_info_;
+  net::ProxyService::PacRequest* pac_req_;
+  scoped_refptr<base::SingleThreadTaskRunner> original_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
+};
+
+// Runs the callback in UI thread.
+template <typename ...T>
+void RunCallbackInUI(const base::Callback<void(T...)>& callback, T... result) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE, base::Bind(callback, result...));
+}
+
+// Callback of HttpCache::GetBackend.
+void OnGetBackend(disk_cache::Backend** backend_ptr,
+                  const net::CompletionCallback& callback,
+                  int result) {
+  if (result != net::OK) {
+    RunCallbackInUI(callback, result);
+  } else if (backend_ptr && *backend_ptr) {
+    (*backend_ptr)->DoomAllEntries(base::Bind(&RunCallbackInUI<int>, callback));
+  } else {
+    RunCallbackInUI<int>(callback, net::ERR_FAILED);
+  }
+}
+
+void ClearHttpCacheInIO(
+    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
+    const net::CompletionCallback& callback) {
+  auto request_context = context_getter->GetURLRequestContext();
+  auto http_cache = request_context->http_transaction_factory()->GetCache();
+  if (!http_cache)
+    RunCallbackInUI<int>(callback, net::ERR_FAILED);
+
+  // Call GetBackend and make the backend's ptr accessable in OnGetBackend.
+  using BackendPtr = disk_cache::Backend*;
+  BackendPtr* backend_ptr = new BackendPtr(nullptr);
+  net::CompletionCallback on_get_backend =
+      base::Bind(&OnGetBackend, base::Owned(backend_ptr), callback);
+  int rv = http_cache->GetBackend(backend_ptr, on_get_backend);
+  if (rv != net::ERR_IO_PENDING)
+    on_get_backend.Run(net::OK);
+}
+
+void SetProxyInIO(net::URLRequestContextGetter* getter,
+                  const std::string& proxy,
+                  const base::Closure& callback) {
+  net::ProxyConfig config;
+  config.proxy_rules().ParseFromString(proxy);
+  auto proxy_service = getter->GetURLRequestContext()->proxy_service();
+  proxy_service->ResetConfigService(new net::ProxyConfigServiceFixed(config));
+  RunCallbackInUI(callback);
+}
+
+}  // namespace
+
+Session::Session(AtomBrowserContext* browser_context)
+    : browser_context_(browser_context) {
+  AttachAsUserData(browser_context);
+
+  // Observe DownloadManger to get download notifications.
+  content::BrowserContext::GetDownloadManager(browser_context)->
+      AddObserver(this);
+}
+
+Session::~Session() {
+  content::BrowserContext::GetDownloadManager(browser_context())->
+      RemoveObserver(this);
+  Destroy();
+}
+
+void Session::OnDownloadCreated(content::DownloadManager* manager,
+                                    content::DownloadItem* item) {
+  auto web_contents = item->GetWebContents();
+  bool prevent_default = Emit("will-download", item,
+                              api::WebContents::CreateFrom(isolate(),
+                                                           web_contents));
+  if (prevent_default) {
+    item->Cancel(true);
+    item->Remove();
+  }
+}
+
+bool Session::IsDestroyed() const {
+  return !browser_context_;
+}
+
+void Session::Destroy() {
+  browser_context_ = nullptr;
+}
+
+void Session::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
+  new ResolveProxyHelper(browser_context(), url, callback);
+}
+
+void Session::ClearCache(const net::CompletionCallback& callback) {
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&ClearHttpCacheInIO,
+                 make_scoped_refptr(browser_context_->GetRequestContext()),
+                 callback));
+}
+
+void Session::ClearStorageData(mate::Arguments* args) {
+  // clearStorageData([options, ]callback)
+  ClearStorageDataOptions options;
+  args->GetNext(&options);
+  base::Closure callback;
+  if (!args->GetNext(&callback)) {
+    args->ThrowError();
+    return;
+  }
+
+  auto storage_partition =
+      content::BrowserContext::GetStoragePartition(browser_context(), nullptr);
+  storage_partition->ClearData(
+      options.storage_types, options.quota_types, options.origin,
+      content::StoragePartition::OriginMatcherFunction(),
+      base::Time(), base::Time::Max(), callback);
+}
+
+void Session::SetProxy(const std::string& proxy,
+                       const base::Closure& callback) {
+  auto getter = browser_context_->GetRequestContext();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&SetProxyInIO, base::Unretained(getter), proxy, callback));
+}
+
+void Session::SetDownloadPath(const base::FilePath& path) {
+  browser_context_->prefs()->SetFilePath(
+      prefs::kDownloadDefaultDirectory, path);
+}
+
+v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
+  if (cookies_.IsEmpty()) {
+    auto handle = atom::api::Cookies::Create(isolate, browser_context());
+    cookies_.Reset(isolate, handle.ToV8());
+  }
+  return v8::Local<v8::Value>::New(isolate, cookies_);
+}
+
+mate::ObjectTemplateBuilder Session::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("resolveProxy", &Session::ResolveProxy)
+      .SetMethod("clearCache", &Session::ClearCache)
+      .SetMethod("clearStorageData", &Session::ClearStorageData)
+      .SetMethod("setProxy", &Session::SetProxy)
+      .SetMethod("setDownloadPath", &Session::SetDownloadPath)
+      .SetProperty("cookies", &Session::Cookies);
+}
+
+// static
+mate::Handle<Session> Session::CreateFrom(
+    v8::Isolate* isolate, AtomBrowserContext* browser_context) {
+  auto existing = TrackableObject::FromWrappedClass(isolate, browser_context);
+  if (existing)
+    return mate::CreateHandle(isolate, static_cast<Session*>(existing));
+
+  auto handle = mate::CreateHandle(isolate, new Session(browser_context));
+  g_wrap_session.Run(handle.ToV8());
+  return handle;
+}
+
+// static
+mate::Handle<Session> Session::FromPartition(
+    v8::Isolate* isolate, const std::string& partition, bool in_memory) {
+  auto browser_context = brightray::BrowserContext::From(partition, in_memory);
+  return CreateFrom(isolate,
+                    static_cast<AtomBrowserContext*>(browser_context.get()));
+}
+
+void SetWrapSession(const WrapSessionCallback& callback) {
+  g_wrap_session = callback;
+}
+
+void ClearWrapSession() {
+  g_wrap_session.Reset();
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.SetMethod("fromPartition", &atom::api::Session::FromPartition);
+  dict.SetMethod("_setWrapSession", &atom::api::SetWrapSession);
+  dict.SetMethod("_clearWrapSession", &atom::api::ClearWrapSession);
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_session, Initialize)

atom/browser/api/atom_api_session.h

@@ -0,0 +1,82 @@
+// 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_SESSION_H_
+#define ATOM_BROWSER_API_ATOM_API_SESSION_H_
+
+#include <string>
+
+#include "atom/browser/api/trackable_object.h"
+#include "content/public/browser/download_manager.h"
+#include "native_mate/handle.h"
+#include "net/base/completion_callback.h"
+
+class GURL;
+
+namespace base {
+class FilePath;
+}
+
+namespace mate {
+class Arguments;
+}
+
+namespace atom {
+
+class AtomBrowserContext;
+
+namespace api {
+
+class Session: public mate::TrackableObject<Session>,
+               public content::DownloadManager::Observer {
+ public:
+  using ResolveProxyCallback = base::Callback<void(std::string)>;
+
+  // Gets or creates Session from the |browser_context|.
+  static mate::Handle<Session> CreateFrom(
+      v8::Isolate* isolate, AtomBrowserContext* browser_context);
+
+  // Gets the Session of |partition| and |in_memory|.
+  static mate::Handle<Session> FromPartition(
+      v8::Isolate* isolate, const std::string& partition, bool in_memory);
+
+  AtomBrowserContext* browser_context() const { return browser_context_.get(); }
+
+ protected:
+  explicit Session(AtomBrowserContext* browser_context);
+  ~Session();
+
+  // content::DownloadManager::Observer:
+  void OnDownloadCreated(content::DownloadManager* manager,
+                         content::DownloadItem* item) override;
+
+  // mate::Wrappable:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+  bool IsDestroyed() const override;
+
+ private:
+  // mate::TrackableObject:
+  void Destroy() override;
+
+  void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
+  void ClearCache(const net::CompletionCallback& callback);
+  void ClearStorageData(mate::Arguments* args);
+  void SetProxy(const std::string& proxy, const base::Closure& callback);
+  void SetDownloadPath(const base::FilePath& path);
+  v8::Local<v8::Value> Cookies(v8::Isolate* isolate);
+
+  // Cached object for cookies API.
+  v8::Global<v8::Value> cookies_;
+
+  scoped_refptr<AtomBrowserContext> browser_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(Session);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_SESSION_H_

atom/browser/api/atom_api_tray.cc

@@ -7,15 +7,17 @@
 #include <string>
 
 #include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/browser.h"
 #include "atom/browser/ui/tray_icon.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
 #include "atom/common/native_mate_converters/image_converter.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_includes.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
+#include "ui/events/event_constants.h"
 #include "ui/gfx/image/image.h"
 
-#include "atom/common/node_includes.h"
-
 namespace atom {
 
 namespace api {
@@ -30,16 +32,34 @@ Tray::~Tray() {
 }
 
 // static
-mate::Wrappable* Tray::New(const gfx::Image& image) {
+mate::Wrappable* Tray::New(v8::Isolate* isolate, const gfx::Image& image) {
+  if (!Browser::Get()->is_ready()) {
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Cannot create Tray before app is ready")));
+    return nullptr;
+  }
   return new Tray(image);
 }
 
-void Tray::OnClicked() {
-  Emit("clicked");
+void Tray::OnClicked(const gfx::Rect& bounds, int modifiers) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  EmitCustomEvent("clicked",
+                  ModifiersToObject(isolate(), modifiers), bounds);
 }
 
-void Tray::OnDoubleClicked() {
-  Emit("double-clicked");
+void Tray::OnDoubleClicked(const gfx::Rect& bounds, int modifiers) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  EmitCustomEvent("double-clicked",
+                  ModifiersToObject(isolate(), modifiers), bounds);
+}
+
+void Tray::OnRightClicked(const gfx::Rect& bounds, int modifiers) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  EmitCustomEvent("right-clicked",
+                  ModifiersToObject(isolate(), modifiers), bounds);
 }
 
 void Tray::OnBalloonShow() {
@@ -54,45 +74,40 @@ void Tray::OnBalloonClosed() {
   Emit("balloon-closed");
 }
 
+void Tray::OnDropFiles(const std::vector<std::string>& files) {
+  Emit("drop-files", files);
+}
+
+bool Tray::IsDestroyed() const {
+  return !tray_icon_;
+}
+
 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(mate::Arguments* args, const gfx::Image& image) {
-  if (!CheckTrayLife(args))
-    return;
   tray_icon_->SetPressedImage(image);
 }
 
 void Tray::SetToolTip(mate::Arguments* args, const std::string& tool_tip) {
-  if (!CheckTrayLife(args))
-    return;
   tray_icon_->SetToolTip(tool_tip);
 }
 
 void Tray::SetTitle(mate::Arguments* args, const std::string& title) {
-  if (!CheckTrayLife(args))
-    return;
   tray_icon_->SetTitle(title);
 }
 
 void Tray::SetHighlightMode(mate::Arguments* args, bool highlight) {
-  if (!CheckTrayLife(args))
-    return;
   tray_icon_->SetHighlightMode(highlight);
 }
 
 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;
@@ -105,32 +120,38 @@ void Tray::DisplayBalloon(mate::Arguments* args,
   tray_icon_->DisplayBalloon(icon, title, content);
 }
 
+void Tray::PopUpContextMenu(mate::Arguments* args) {
+  gfx::Point pos;
+  args->GetNext(&pos);
+  tray_icon_->PopUpContextMenu(pos);
+}
+
 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;
-  }
+v8::Local<v8::Object> Tray::ModifiersToObject(v8::Isolate* isolate,
+                                              int modifiers) {
+  mate::Dictionary obj(isolate, v8::Object::New(isolate));
+  obj.Set("shiftKey", static_cast<bool>(modifiers & ui::EF_SHIFT_DOWN));
+  obj.Set("ctrlKey", static_cast<bool>(modifiers & ui::EF_CONTROL_DOWN));
+  obj.Set("altKey", static_cast<bool>(modifiers & ui::EF_ALT_DOWN));
+  obj.Set("metaKey", static_cast<bool>(modifiers & ui::EF_COMMAND_DOWN));
+  return obj.GetHandle();
 }
 
 // static
 void Tray::BuildPrototype(v8::Isolate* isolate,
-                          v8::Handle<v8::ObjectTemplate> prototype) {
+                          v8::Local<v8::ObjectTemplate> prototype) {
   mate::ObjectTemplateBuilder(isolate, prototype)
-      .SetMethod("destroy", &Tray::Destroy)
+      .SetMethod("destroy", &Tray::Destroy, true)
       .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("popUpContextMenu", &Tray::PopUpContextMenu)
       .SetMethod("_setContextMenu", &Tray::SetContextMenu);
 }
 
@@ -141,14 +162,14 @@ void Tray::BuildPrototype(v8::Isolate* isolate,
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
   using atom::api::Tray;
   v8::Isolate* isolate = context->GetIsolate();
-  v8::Handle<v8::Function> constructor = mate::CreateConstructor<Tray>(
+  v8::Local<v8::Function> constructor = mate::CreateConstructor<Tray>(
       isolate, "Tray", base::Bind(&Tray::New));
   mate::Dictionary dict(isolate, exports);
-  dict.Set("Tray", static_cast<v8::Handle<v8::Value>>(constructor));
+  dict.Set("Tray", static_cast<v8::Local<v8::Value>>(constructor));
 }
 
 }  // namespace

atom/browser/api/atom_api_tray.h

@@ -6,6 +6,7 @@
 #define ATOM_BROWSER_API_ATOM_API_TRAY_H_
 
 #include <string>
+#include <vector>
 
 #include "atom/browser/api/event_emitter.h"
 #include "atom/browser/ui/tray_icon_observer.h"
@@ -31,21 +32,26 @@ class Menu;
 class Tray : public mate::EventEmitter,
              public TrayIconObserver {
  public:
-  static mate::Wrappable* New(const gfx::Image& image);
+  static mate::Wrappable* New(v8::Isolate* isolate, const gfx::Image& image);
 
   static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Handle<v8::ObjectTemplate> prototype);
+                             v8::Local<v8::ObjectTemplate> prototype);
 
  protected:
   explicit Tray(const gfx::Image& image);
   virtual ~Tray();
 
   // TrayIconObserver:
-  void OnClicked() override;
-  void OnDoubleClicked() override;
+  void OnClicked(const gfx::Rect& bounds, int modifiers) override;
+  void OnDoubleClicked(const gfx::Rect& bounds, int modifiers) override;
+  void OnRightClicked(const gfx::Rect& bounds, int modifiers) override;
   void OnBalloonShow() override;
   void OnBalloonClicked() override;
   void OnBalloonClosed() override;
+  void OnDropFiles(const std::vector<std::string>& files) override;
+
+  // mate::Wrappable:
+  bool IsDestroyed() const override;
 
   void Destroy();
   void SetImage(mate::Arguments* args, const gfx::Image& image);
@@ -54,10 +60,11 @@ class Tray : public mate::EventEmitter,
   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 PopUpContextMenu(mate::Arguments* args);
   void SetContextMenu(mate::Arguments* args, Menu* menu);
 
  private:
-  bool CheckTrayLife(mate::Arguments* args);
+  v8::Local<v8::Object> ModifiersToObject(v8::Isolate* isolate, int modifiers);
 
   scoped_ptr<TrayIcon> tray_icon_;
 

atom/browser/api/atom_api_web_contents.h

@@ -6,33 +6,40 @@
 #define ATOM_BROWSER_API_ATOM_API_WEB_CONTENTS_H_
 
 #include <string>
+#include <vector>
 
-#include "atom/browser/api/event_emitter.h"
-#include "brightray/browser/default_web_contents_delegate.h"
-#include "content/public/browser/browser_plugin_guest_delegate.h"
-#include "content/public/browser/web_contents_delegate.h"
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/common_web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/common/favicon_url.h"
 #include "native_mate/handle.h"
+#include "ui/gfx/image/image.h"
 
 namespace brightray {
 class InspectableWebContents;
 }
 
 namespace mate {
+class Arguments;
 class Dictionary;
 }
 
 namespace atom {
 
-class WebDialogHelper;
+struct SetSizeParams;
+class AtomBrowserContext;
+class WebViewGuestDelegate;
 
 namespace api {
 
-class WebContents : public mate::EventEmitter,
-                    public content::BrowserPluginGuestDelegate,
-                    public content::WebContentsDelegate,
+class WebContents : public mate::TrackableObject<WebContents>,
+                    public CommonWebContentsDelegate,
                     public content::WebContentsObserver {
  public:
+  // For node.js callback function type: function(error, buffer)
+  using PrintToPDFCallback =
+      base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>;
+
   // Create from an existing WebContents.
   static mate::Handle<WebContents> CreateFrom(
       v8::Isolate* isolate, content::WebContents* web_contents);
@@ -41,61 +48,83 @@ class WebContents : public mate::EventEmitter,
   static mate::Handle<WebContents> Create(
       v8::Isolate* isolate, const mate::Dictionary& options);
 
-  void Destroy();
+  // mate::TrackableObject:
+  void Destroy() override;
+
   bool IsAlive() const;
+  int GetID() const;
+  bool Equal(const WebContents* web_contents) const;
   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(const mate::Dictionary& options);
-  void ReloadIgnoringCache(const mate::Dictionary& options);
-  bool CanGoBack() const;
-  bool CanGoForward() const;
-  bool CanGoToOffset(int offset) const;
+  void ReloadIgnoringCache();
   void GoBack();
   void GoForward();
-  void GoToIndex(int index);
   void GoToOffset(int offset);
-  int GetRoutingID() const;
-  int GetProcessID() const;
   bool IsCrashed() const;
   void SetUserAgent(const std::string& user_agent);
+  std::string GetUserAgent();
   void InsertCSS(const std::string& css);
-  void ExecuteJavaScript(const base::string16& code);
-  void OpenDevTools();
+  void ExecuteJavaScript(const base::string16& code,
+                         bool has_user_gesture);
+  void OpenDevTools(mate::Arguments* args);
   void CloseDevTools();
   bool IsDevToolsOpened();
+  void ToggleDevTools();
+  void InspectElement(int x, int y);
+  void InspectServiceWorker();
+  v8::Local<v8::Value> Session(v8::Isolate* isolate);
+  void HasServiceWorker(const base::Callback<void(bool)>&);
+  void UnregisterServiceWorker(const base::Callback<void(bool)>&);
+  void SetAudioMuted(bool muted);
+  bool IsAudioMuted();
+  void Print(mate::Arguments* args);
+
+  // Print current page as PDF.
+  void PrintToPDF(const base::DictionaryValue& setting,
+                  const PrintToPDFCallback& callback);
+
+  // DevTools workspace api.
+  void AddWorkSpace(mate::Arguments* args, const base::FilePath& path);
+  void RemoveWorkSpace(mate::Arguments* args, const base::FilePath& path);
+
+  // Editing commands.
+  void Undo();
+  void Redo();
+  void Cut();
+  void Copy();
+  void Paste();
+  void PasteAndMatchStyle();
+  void Delete();
+  void SelectAll();
+  void Unselect();
+  void Replace(const base::string16& word);
+  void ReplaceMisspelling(const base::string16& word);
+
+  // Focus.
+  void Focus();
+  void TabTraverse(bool reverse);
+
+  // Sending messages to browser.
   bool SendIPCMessage(const base::string16& channel,
                       const base::ListValue& args);
 
-  // Toggles autosize mode for corresponding <webview>.
-  void SetAutoSize(bool enabled,
-                   const gfx::Size& min_size,
-                   const gfx::Size& max_size);
-
-  // Sets the transparency of the guest.
+  // Methods for creating <webview>.
+  void SetSize(const SetSizeParams& params);
   void SetAllowTransparency(bool allow);
-
-  // Returns whether this is a guest view.
-  bool is_guest() const { return guest_instance_id_ != -1; }
-
-  // Returns whether this guest has an associated embedder.
-  bool attached() const { return !!embedder_web_contents_; }
-
-  content::WebContents* web_contents() const {
-    return content::WebContentsObserver::web_contents();
-  }
+  bool IsGuest() const;
 
  protected:
   explicit WebContents(content::WebContents* web_contents);
-  explicit WebContents(const mate::Dictionary& options);
+  WebContents(v8::Isolate* isolate, const mate::Dictionary& options);
   ~WebContents();
 
   // mate::Wrappable:
   mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
       v8::Isolate* isolate) override;
+  bool IsDestroyed() const override;
 
   // content::WebContentsDelegate:
   bool AddMessageToConsole(content::WebContents* source,
@@ -106,60 +135,79 @@ 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 std::string& frame_name,
       const GURL& target_url,
       const std::string& partition_id,
       content::SessionStorageNamespace* session_storage_namespace) override;
-  void CloseContents(content::WebContents* source) override;
   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;
-  void RequestMediaAccessPermission(
-      content::WebContents*,
-      const content::MediaStreamRequest&,
-      const content::MediaResponseCallback&) override;
+  void BeforeUnloadFired(content::WebContents* tab,
+                         bool proceed,
+                         bool* proceed_to_fire_unload) override;
+  void MoveContents(content::WebContents* source,
+                    const gfx::Rect& pos) override;
+  void CloseContents(content::WebContents* source) override;
+  void ActivateContents(content::WebContents* contents) override;
+  bool IsPopupOrPanel(const content::WebContents* source) const override;
   void HandleKeyboardEvent(
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event) override;
+  void EnterFullscreenModeForTab(content::WebContents* source,
+                                 const GURL& origin) override;
+  void ExitFullscreenModeForTab(content::WebContents* source) override;
+  void RendererUnresponsive(content::WebContents* source) override;
+  void RendererResponsive(content::WebContents* source) override;
 
   // content::WebContentsObserver:
+  void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
   void RenderViewDeleted(content::RenderViewHost*) override;
   void RenderProcessGone(base::TerminationStatus status) override;
+  void DocumentLoadedInFrame(
+      content::RenderFrameHost* render_frame_host) 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 DidStartLoading(content::RenderViewHost* render_view_host) override;
-  void DidStopLoading(content::RenderViewHost* render_view_host) override;
+                   const base::string16& error_description,
+                   bool was_ignored_by_handler) override;
+  void DidFailProvisionalLoad(content::RenderFrameHost* render_frame_host,
+                              const GURL& validated_url,
+                              int error_code,
+                              const base::string16& error_description,
+                              bool was_ignored_by_handler) override;
+  void DidStartLoading() override;
+  void DidStopLoading() override;
+  void DidGetResourceResponseStart(
+      const content::ResourceRequestDetails& details) override;
   void DidGetRedirectForResourceRequest(
-      content::RenderViewHost* render_view_host,
+      content::RenderFrameHost* render_frame_host,
       const content::ResourceRedirectDetails& details) 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;
-
-  // content::BrowserPluginGuestDelegate:
-  void DidAttach(int guest_proxy_routing_id) final;
-  void ElementSizeChanged(const gfx::Size& old_size,
-                          const gfx::Size& new_size) final;
-  void GuestSizeChanged(const gfx::Size& old_size,
-                        const gfx::Size& new_size) final;
-  void RegisterDestructionCallback(const DestructionCallback& callback) final;
-  void WillAttach(content::WebContents* embedder_web_contents,
-                  int browser_plugin_instance_id) final;
+  void NavigationEntryCommitted(
+      const content::LoadCommittedDetails& load_details) override;
+  void TitleWasSet(content::NavigationEntry* entry, bool explicit_set) override;
+  void DidUpdateFaviconURL(
+      const std::vector<content::FaviconURL>& urls) override;
+  void PluginCrashed(const base::FilePath& plugin_path,
+                     base::ProcessId plugin_pid) override;
 
  private:
+  enum Type {
+    BROWSER_WINDOW,  // Used by BrowserWindow.
+    WEB_VIEW,  // Used by <webview>.
+    REMOTE,  // Thin wrap around an existing WebContents.
+  };
+
+  AtomBrowserContext* GetBrowserContext() const;
+
   // Called when received a message from renderer.
   void OnRendererMessage(const base::string16& channel,
                          const base::ListValue& args);
@@ -169,44 +217,12 @@ class WebContents : public mate::EventEmitter,
                              const base::ListValue& args,
                              IPC::Message* message);
 
-  void GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
-                                     const gfx::Size& new_size);
+  v8::Global<v8::Value> session_;
 
-  scoped_ptr<WebDialogHelper> web_dialog_helper_;
+  scoped_ptr<WebViewGuestDelegate> guest_delegate_;
 
-  // 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_;
-
-  // Stores the WebContents that managed by this class.
-  scoped_ptr<brightray::InspectableWebContents> storage_;
-
-  // The WebContents that attaches this guest view.
-  content::WebContents* embedder_web_contents_;
-
-  // The size of the container element.
-  gfx::Size element_size_;
-
-  // The size of the guest content. Note: In autosize mode, the container
-  // element may not match the size of the guest.
-  gfx::Size guest_size_;
-
-  // Indicates whether autosize mode is enabled or not.
-  bool auto_size_enabled_;
-
-  // The maximum size constraints of the container element in autosize mode.
-  gfx::Size max_auto_size_;
-
-  // The minimum size constraints of the container element in autosize mode.
-  gfx::Size min_auto_size_;
+  // The type of current WebContents.
+  Type type_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContents);
 };

atom/browser/api/atom_api_web_view_manager.cc

@@ -0,0 +1,71 @@
+// 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_contents_preferences.h"
+#include "atom/browser/web_view_manager.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "atom/common/node_includes.h"
+#include "content/public/browser/browser_context.h"
+#include "native_mate/dictionary.h"
+
+using atom::WebContentsPreferences;
+
+namespace mate {
+
+template<>
+struct Converter<content::WebContents*> {
+  static bool FromV8(v8::Isolate* isolate, v8::Local<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;
+  }
+};
+
+}  // 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,
+              const base::DictionaryValue& options) {
+  auto manager = GetWebViewManager(embedder);
+  if (manager)
+    manager->AddGuest(guest_instance_id, element_instance_id, embedder,
+                      guest_web_contents);
+
+  WebContentsPreferences::FromWebContents(guest_web_contents)->Merge(options);
+}
+
+void RemoveGuest(content::WebContents* embedder, int guest_instance_id) {
+  auto manager = GetWebViewManager(embedder);
+  if (manager)
+    manager->RemoveGuest(guest_instance_id);
+}
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<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)

atom/browser/api/atom_api_window.cc

@@ -4,42 +4,47 @@
 
 #include "atom/browser/api/atom_api_window.h"
 
+#include "atom/browser/api/atom_api_menu.h"
 #include "atom/browser/api/atom_api_web_contents.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/native_window.h"
+#include "atom/common/native_mate_converters/callback.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 "atom/common/options_switches.h"
 #include "content/public/browser/render_process_host.h"
-#include "native_mate/callback.h"
 #include "native_mate/constructor.h"
 #include "native_mate/dictionary.h"
+#include "ui/gfx/geometry/rect.h"
+
+#if defined(OS_WIN)
+#include "atom/browser/native_window_views.h"
+#include "atom/browser/ui/win/taskbar_host.h"
+#endif
 
 #include "atom/common/node_includes.h"
 
-namespace {
-
-struct PrintSettings {
-  bool silent;
-  bool print_background;
-};
-
-}  // namespace
-
+#if defined(OS_WIN)
 namespace mate {
 
 template<>
-struct Converter<PrintSettings> {
+struct Converter<atom::TaskbarHost::ThumbarButton> {
   static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
-                     PrintSettings* out) {
+                     atom::TaskbarHost::ThumbarButton* out) {
     mate::Dictionary dict;
     if (!ConvertFromV8(isolate, val, &dict))
       return false;
-    dict.Get("silent", &(out->silent));
-    dict.Get("printBackground", &(out->print_background));
-    return true;
+    dict.Get("click", &(out->clicked_callback));
+    dict.Get("tooltip", &(out->tooltip));
+    dict.Get("flags", &out->flags);
+    return dict.Get("icon", &(out->icon));
   }
 };
 
 }  // namespace mate
+#endif
 
 namespace atom {
 
@@ -49,22 +54,39 @@ namespace {
 
 void OnCapturePageDone(
     v8::Isolate* isolate,
-    const base::Callback<void(v8::Handle<v8::Value>)>& callback,
-    const std::vector<unsigned char>& data) {
+    const base::Callback<void(const gfx::Image&)>& callback,
+    const SkBitmap& bitmap) {
   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::CreateFrom1xBitmap(bitmap));
 }
 
 }  // namespace
 
 
-Window::Window(const mate::Dictionary& options)
-    : window_(NativeWindow::Create(options)) {
+Window::Window(v8::Isolate* isolate, const mate::Dictionary& options) {
+  // Use options['web-preferences'] to create WebContents.
+  mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
+  options.Get(switches::kWebPreferences, &web_preferences);
+
+  // Be compatible with old options which are now in web_preferences.
+  v8::Local<v8::Value> value;
+  if (options.Get(switches::kNodeIntegration, &value))
+    web_preferences.Set(switches::kNodeIntegration, value);
+  if (options.Get(switches::kPreloadScript, &value))
+    web_preferences.Set(switches::kPreloadScript, value);
+  if (options.Get(switches::kZoomFactor, &value))
+    web_preferences.Set(switches::kZoomFactor, value);
+
+  // Creates the WebContents used by BrowserWindow.
+  auto web_contents = WebContents::Create(isolate, web_preferences);
+  web_contents_.Reset(isolate, web_contents.ToV8());
+  api_web_contents_ = web_contents.get();
+
+  // Creates BrowserWindow.
+  window_.reset(NativeWindow::Create(web_contents->managed_web_contents(),
+                                     options));
+  web_contents->SetOwnerWindow(window_.get());
   window_->InitFromOptions(options);
   window_->AddObserver(this);
 }
@@ -76,26 +98,7 @@ Window::~Window() {
 
 void Window::OnPageTitleUpdated(bool* prevent_default,
                                 const std::string& title) {
-  base::ListValue args;
-  args.AppendString(title);
-  *prevent_default = Emit("page-title-updated", args);
-}
-
-void Window::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);
-}
-
-void Window::WillNavigate(bool* prevent_default, const GURL& url) {
-  base::ListValue args;
-  args.AppendString(url.spec());
-  *prevent_default = Emit("-will-navigate", args);
+  *prevent_default = Emit("page-title-updated", title);
 }
 
 void Window::WillCloseWindow(bool* prevent_default) {
@@ -103,9 +106,16 @@ void Window::WillCloseWindow(bool* prevent_default) {
 }
 
 void Window::OnWindowClosed() {
-  Emit("closed");
+  if (api_web_contents_) {
+    api_web_contents_->DestroyWebContents();
+    api_web_contents_ = nullptr;
+    web_contents_.Reset();
+  }
 
+  RemoveFromWeakMap();
   window_->RemoveObserver(this);
+
+  Emit("closed");
 }
 
 void Window::OnWindowBlur() {
@@ -132,6 +142,18 @@ void Window::OnWindowRestore() {
   Emit("restore");
 }
 
+void Window::OnWindowResize() {
+  Emit("resize");
+}
+
+void Window::OnWindowMove() {
+  Emit("move");
+}
+
+void Window::OnWindowMoved() {
+  Emit("moved");
+}
+
 void Window::OnWindowEnterFullScreen() {
   Emit("enter-full-screen");
 }
@@ -140,6 +162,14 @@ void Window::OnWindowLeaveFullScreen() {
   Emit("leave-full-screen");
 }
 
+void Window::OnWindowEnterHtmlFullScreen() {
+  Emit("enter-html-full-screen");
+}
+
+void Window::OnWindowLeaveHtmlFullScreen() {
+  Emit("leave-html-full-screen");
+}
+
 void Window::OnRendererUnresponsive() {
   Emit("unresponsive");
 }
@@ -148,21 +178,52 @@ void Window::OnRendererResponsive() {
   Emit("responsive");
 }
 
+void Window::OnDevToolsFocus() {
+  Emit("devtools-focused");
+}
+
+void Window::OnDevToolsOpened() {
+  Emit("devtools-opened");
+
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  auto handle = WebContents::CreateFrom(
+      isolate(), api_web_contents_->GetDevToolsWebContents());
+  devtools_web_contents_.Reset(isolate(), handle.ToV8());
+}
+
+void Window::OnDevToolsClosed() {
+  Emit("devtools-closed");
+
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  devtools_web_contents_.Reset();
+}
+
+void Window::OnExecuteWindowsCommand(const std::string& command_name) {
+  Emit("app-command", command_name);
+}
+
 // static
 mate::Wrappable* Window::New(v8::Isolate* isolate,
                              const mate::Dictionary& options) {
-  if (Browser::Get()->is_ready()) {
-    return new Window(options);
-  } else {
-    isolate->ThrowException(v8::Exception::TypeError(mate::StringToV8(
-        isolate, "Can not create BrowserWindow before app is ready")));
+  if (!Browser::Get()->is_ready()) {
+    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
+        isolate, "Cannot create BrowserWindow before app is ready")));
     return nullptr;
   }
+  return new Window(isolate, options);
+}
+
+bool Window::IsDestroyed() const {
+  return !window_ || window_->IsClosed();
 }
 
 void Window::Destroy() {
-  window_->DestroyWebContents();
-  window_->CloseImmediately();
+  if (window_) {
+    window_->CloseContents(nullptr);
+    window_.reset();
+  }
 }
 
 void Window::Close() {
@@ -229,6 +290,14 @@ bool Window::IsFullscreen() {
   return window_->IsFullscreen();
 }
 
+void Window::SetBounds(const gfx::Rect& bounds) {
+  window_->SetBounds(bounds);
+}
+
+gfx::Rect Window::GetBounds() {
+  return window_->GetBounds();
+}
+
 void Window::SetSize(int width, int height) {
   window_->SetSize(gfx::Size(width, height));
 }
@@ -333,22 +402,6 @@ bool Window::IsKiosk() {
   return window_->IsKiosk();
 }
 
-void Window::OpenDevTools() {
-  window_->OpenDevTools();
-}
-
-void Window::CloseDevTools() {
-  window_->CloseDevTools();
-}
-
-bool Window::IsDevToolsOpened() {
-  return window_->IsDevToolsOpened();
-}
-
-void Window::InspectElement(int x, int y) {
-  window_->InspectElement(x, y);
-}
-
 void Window::FocusOnWebView() {
   window_->FocusOnWebView();
 }
@@ -379,7 +432,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)
@@ -392,20 +445,46 @@ void Window::CapturePage(mate::Arguments* args) {
       rect, base::Bind(&OnCapturePageDone, args->isolate(), callback));
 }
 
-void Window::Print(mate::Arguments* args) {
-  PrintSettings settings = { false, false };;
-  if (args->Length() == 1 && !args->GetNext(&settings)) {
-    args->ThrowError();
-    return;
-  }
-
-  window_->Print(settings.silent, settings.print_background);
-}
-
 void Window::SetProgressBar(double progress) {
   window_->SetProgressBar(progress);
 }
 
+void Window::SetOverlayIcon(const gfx::Image& overlay,
+                            const std::string& description) {
+  window_->SetOverlayIcon(overlay, description);
+}
+
+bool Window::SetThumbarButtons(mate::Arguments* args) {
+#if defined(OS_WIN)
+  std::vector<TaskbarHost::ThumbarButton> buttons;
+  if (!args->GetNext(&buttons)) {
+    args->ThrowError();
+    return false;
+  }
+  auto window = static_cast<NativeWindowViews*>(window_.get());
+  return window->taskbar_host().SetThumbarButtons(
+      window->GetAcceleratedWidget(), buttons);
+#else
+  return false;
+#endif
+}
+
+void Window::SetMenu(v8::Isolate* isolate, v8::Local<v8::Value> value) {
+  mate::Handle<Menu> menu;
+  if (value->IsObject() &&
+      mate::V8ToString(value->ToObject()->GetConstructorName()) == "Menu" &&
+      mate::ConvertFromV8(isolate, value, &menu)) {
+    menu_.Reset(isolate, menu.ToV8());
+    window_->SetMenu(menu->model());
+  } else if (value->IsNull()) {
+    menu_.Reset();
+    window_->SetMenu(nullptr);
+  } else {
+    isolate->ThrowException(v8::Exception::TypeError(
+        mate::StringToV8(isolate, "Invalid Menu")));
+  }
+}
+
 void Window::SetAutoHideMenuBar(bool auto_hide) {
   window_->SetAutoHideMenuBar(auto_hide);
 }
@@ -428,20 +507,43 @@ void Window::ShowDefinitionForSelection() {
 }
 #endif
 
-mate::Handle<WebContents> Window::GetWebContents(v8::Isolate* isolate) const {
-  return WebContents::CreateFrom(isolate, window_->GetWebContents());
+void Window::SetAspectRatio(double aspect_ratio, mate::Arguments* args) {
+  gfx::Size extra_size;
+  args->GetNext(&extra_size);
+  window_->SetAspectRatio(aspect_ratio, extra_size);
 }
 
-mate::Handle<WebContents> Window::GetDevToolsWebContents(
-    v8::Isolate* isolate) const {
-  return WebContents::CreateFrom(isolate, window_->GetDevToolsWebContents());
+void Window::SetVisibleOnAllWorkspaces(bool visible) {
+  return window_->SetVisibleOnAllWorkspaces(visible);
+}
+
+bool Window::IsVisibleOnAllWorkspaces() {
+  return window_->IsVisibleOnAllWorkspaces();
+}
+
+int32_t Window::ID() const {
+  return weak_map_id();
+}
+
+v8::Local<v8::Value> Window::WebContents(v8::Isolate* isolate) {
+  if (web_contents_.IsEmpty())
+    return v8::Null(isolate);
+  else
+    return v8::Local<v8::Value>::New(isolate, web_contents_);
+}
+
+v8::Local<v8::Value> Window::DevToolsWebContents(v8::Isolate* isolate) {
+  if (devtools_web_contents_.IsEmpty())
+    return v8::Null(isolate);
+  else
+    return v8::Local<v8::Value>::New(isolate, devtools_web_contents_);
 }
 
 // static
 void Window::BuildPrototype(v8::Isolate* isolate,
-                            v8::Handle<v8::ObjectTemplate> prototype) {
+                            v8::Local<v8::ObjectTemplate> prototype) {
   mate::ObjectTemplateBuilder(isolate, prototype)
-      .SetMethod("destroy", &Window::Destroy)
+      .SetMethod("destroy", &Window::Destroy, true)
       .SetMethod("close", &Window::Close)
       .SetMethod("isClosed", &Window::IsClosed)
       .SetMethod("focus", &Window::Focus)
@@ -458,6 +560,9 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("isMinimized", &Window::IsMinimized)
       .SetMethod("setFullScreen", &Window::SetFullScreen)
       .SetMethod("isFullScreen", &Window::IsFullscreen)
+      .SetMethod("setAspectRatio", &Window::SetAspectRatio)
+      .SetMethod("getBounds", &Window::GetBounds)
+      .SetMethod("setBounds", &Window::SetBounds)
       .SetMethod("getSize", &Window::GetSize)
       .SetMethod("setSize", &Window::SetSize)
       .SetMethod("getContentSize", &Window::GetContentSize)
@@ -483,26 +588,29 @@ void Window::BuildPrototype(v8::Isolate* isolate,
       .SetMethod("getRepresentedFilename", &Window::GetRepresentedFilename)
       .SetMethod("setDocumentEdited", &Window::SetDocumentEdited)
       .SetMethod("isDocumentEdited", &Window::IsDocumentEdited)
-      .SetMethod("_openDevTools", &Window::OpenDevTools)
-      .SetMethod("closeDevTools", &Window::CloseDevTools)
-      .SetMethod("isDevToolsOpened", &Window::IsDevToolsOpened)
-      .SetMethod("inspectElement", &Window::InspectElement)
       .SetMethod("focusOnWebView", &Window::FocusOnWebView)
       .SetMethod("blurWebView", &Window::BlurWebView)
       .SetMethod("isWebViewFocused", &Window::IsWebViewFocused)
       .SetMethod("capturePage", &Window::CapturePage)
-      .SetMethod("print", &Window::Print)
       .SetMethod("setProgressBar", &Window::SetProgressBar)
+      .SetMethod("setOverlayIcon", &Window::SetOverlayIcon)
+      .SetMethod("setThumbarButtons", &Window::SetThumbarButtons)
+      .SetMethod("setMenu", &Window::SetMenu)
       .SetMethod("setAutoHideMenuBar", &Window::SetAutoHideMenuBar)
       .SetMethod("isMenuBarAutoHide", &Window::IsMenuBarAutoHide)
       .SetMethod("setMenuBarVisibility", &Window::SetMenuBarVisibility)
       .SetMethod("isMenuBarVisible", &Window::IsMenuBarVisible)
+      .SetMethod("setVisibleOnAllWorkspaces",
+                 &Window::SetVisibleOnAllWorkspaces)
+      .SetMethod("isVisibleOnAllWorkspaces",
+                 &Window::IsVisibleOnAllWorkspaces)
 #if defined(OS_MACOSX)
       .SetMethod("showDefinitionForSelection",
                  &Window::ShowDefinitionForSelection)
 #endif
-      .SetMethod("_getWebContents", &Window::GetWebContents)
-      .SetMethod("_getDevToolsWebContents", &Window::GetDevToolsWebContents);
+      .SetProperty("id", &Window::ID, true)
+      .SetProperty("webContents", &Window::WebContents, true)
+      .SetProperty("devToolsWebContents", &Window::DevToolsWebContents, true);
 }
 
 }  // namespace api
@@ -512,14 +620,21 @@ void Window::BuildPrototype(v8::Isolate* isolate,
 
 namespace {
 
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
-  using atom::api::Window;
+using atom::api::Window;
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
   v8::Isolate* isolate = context->GetIsolate();
   v8::Local<v8::Function> constructor = mate::CreateConstructor<Window>(
       isolate, "BrowserWindow", base::Bind(&Window::New));
+  mate::Dictionary browser_window(isolate, constructor);
+  browser_window.SetMethod("fromId",
+                           &mate::TrackableObject<Window>::FromWeakMapID);
+  browser_window.SetMethod("getAllWindows",
+                           &mate::TrackableObject<Window>::GetAll);
+
   mate::Dictionary dict(isolate, exports);
-  dict.Set("BrowserWindow", static_cast<v8::Handle<v8::Value>>(constructor));
+  dict.Set("BrowserWindow", browser_window);
 }
 
 }  // namespace

atom/browser/api/atom_api_window.h

@@ -9,12 +9,18 @@
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
+#include "ui/gfx/image/image.h"
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/native_window.h"
 #include "atom/browser/native_window_observer.h"
-#include "atom/browser/api/event_emitter.h"
 #include "native_mate/handle.h"
 
 class GURL;
 
+namespace gfx {
+class Rect;
+}
+
 namespace mate {
 class Arguments;
 class Dictionary;
@@ -28,29 +34,24 @@ namespace api {
 
 class WebContents;
 
-class Window : public mate::EventEmitter,
+class Window : public mate::TrackableObject<Window>,
                public NativeWindowObserver {
  public:
   static mate::Wrappable* New(v8::Isolate* isolate,
                               const mate::Dictionary& options);
 
   static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Handle<v8::ObjectTemplate> prototype);
+                             v8::Local<v8::ObjectTemplate> prototype);
 
   NativeWindow* window() const { return window_.get(); }
 
  protected:
-  explicit Window(const mate::Dictionary& options);
+  Window(v8::Isolate* isolate, const mate::Dictionary& options);
   virtual ~Window();
 
   // 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;
@@ -59,14 +60,28 @@ class Window : public mate::EventEmitter,
   void OnWindowUnmaximize() override;
   void OnWindowMinimize() override;
   void OnWindowRestore() override;
+  void OnWindowResize() override;
+  void OnWindowMove() override;
+  void OnWindowMoved() override;
   void OnWindowEnterFullScreen() override;
   void OnWindowLeaveFullScreen() override;
+  void OnWindowEnterHtmlFullScreen() override;
+  void OnWindowLeaveHtmlFullScreen() override;
   void OnRendererUnresponsive() override;
   void OnRendererResponsive() override;
+  void OnDevToolsFocus() override;
+  void OnDevToolsOpened() override;
+  void OnDevToolsClosed() override;
+  void OnExecuteWindowsCommand(const std::string& command_name) override;
+
+  // mate::Wrappable:
+  bool IsDestroyed() const override;
 
  private:
+  // mate::TrackableObject:
+  void Destroy() override;
+
   // APIs for NativeWindow.
-  void Destroy();
   void Close();
   bool IsClosed();
   void Focus();
@@ -83,6 +98,8 @@ class Window : public mate::EventEmitter,
   bool IsMinimized();
   void SetFullScreen(bool fullscreen);
   bool IsFullscreen();
+  void SetBounds(const gfx::Rect& bounds);
+  gfx::Rect GetBounds();
   void SetSize(int width, int height);
   std::vector<int> GetSize();
   void SetContentSize(int width, int height);
@@ -104,10 +121,6 @@ class Window : public mate::EventEmitter,
   void SetSkipTaskbar(bool skip);
   void SetKiosk(bool kiosk);
   bool IsKiosk();
-  void OpenDevTools();
-  void CloseDevTools();
-  bool IsDevToolsOpened();
-  void InspectElement(int x, int y);
   void FocusOnWebView();
   void BlurWebView();
   bool IsWebViewFocused();
@@ -116,20 +129,33 @@ class Window : public mate::EventEmitter,
   void SetDocumentEdited(bool edited);
   bool IsDocumentEdited();
   void CapturePage(mate::Arguments* args);
-  void Print(mate::Arguments* args);
   void SetProgressBar(double progress);
+  void SetOverlayIcon(const gfx::Image& overlay,
+                      const std::string& description);
+  bool SetThumbarButtons(mate::Arguments* args);
+  void SetMenu(v8::Isolate* isolate, v8::Local<v8::Value> menu);
   void SetAutoHideMenuBar(bool auto_hide);
   bool IsMenuBarAutoHide();
   void SetMenuBarVisibility(bool visible);
   bool IsMenuBarVisible();
+  void SetAspectRatio(double aspect_ratio, mate::Arguments* args);
 
 #if defined(OS_MACOSX)
   void ShowDefinitionForSelection();
 #endif
 
-  // APIs for WebContents.
-  mate::Handle<WebContents> GetWebContents(v8::Isolate* isolate) const;
-  mate::Handle<WebContents> GetDevToolsWebContents(v8::Isolate* isolate) const;
+  void SetVisibleOnAllWorkspaces(bool visible);
+  bool IsVisibleOnAllWorkspaces();
+
+  int32_t ID() const;
+  v8::Local<v8::Value> WebContents(v8::Isolate* isolate);
+  v8::Local<v8::Value> DevToolsWebContents(v8::Isolate* isolate);
+
+  v8::Global<v8::Value> web_contents_;
+  v8::Global<v8::Value> devtools_web_contents_;
+  v8::Global<v8::Value> menu_;
+
+  api::WebContents* api_web_contents_;
 
   scoped_ptr<NativeWindow> window_;
 
@@ -145,7 +171,7 @@ namespace mate {
 
 template<>
 struct Converter<atom::NativeWindow*> {
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      atom::NativeWindow** out) {
     // null would be tranfered to NULL.
     if (val->IsNull()) {

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.

atom/browser/api/event_emitter.cc

@@ -5,14 +5,10 @@
 #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/dictionary.h"
 #include "native_mate/object_template_builder.h"
 
-#include "atom/common/node_includes.h"
-
 namespace mate {
 
 namespace {
@@ -20,8 +16,8 @@ namespace {
 v8::Persistent<v8::ObjectTemplate> event_template;
 
 void PreventDefault(mate::Arguments* args) {
-  args->GetThis()->Set(StringToV8(args->isolate(), "defaultPrevented"),
-                       v8::True(args->isolate()));
+  mate::Dictionary self(args->isolate(), args->GetThis());
+  self.Set("defaultPrevented", true);
 }
 
 // Create a pure JavaScript Event object.
@@ -41,63 +37,28 @@ 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) {
-  v8::Handle<v8::Object> event;
+v8::Local<v8::Object> EventEmitter::CreateJSEvent(
+    v8::Isolate* isolate, content::WebContents* sender, IPC::Message* message) {
+  v8::Local<v8::Object> event;
   bool use_native_event = sender && message;
 
   if (use_native_event) {
     mate::Handle<mate::Event> native_event = mate::Event::Create(isolate);
     native_event->SetSenderAndMessage(sender, message);
-    event = v8::Handle<v8::Object>::Cast(native_event.ToV8());
+    event = v8::Local<v8::Object>::Cast(native_event.ToV8());
   } else {
     event = CreateEventObject(isolate);
   }
+  mate::Dictionary(isolate, event).Set("sender", GetWrapper(isolate));
+  return event;
+}
 
-  // args = [name, event, args...];
-  args.insert(args.begin(), event);
-  args.insert(args.begin(), mate::StringToV8(isolate, name));
-
-  // this.emit.apply(this, args);
-  node::MakeCallback(isolate, GetWrapper(isolate), "emit", args.size(),
-                     &args[0]);
-
-  return event->Get(StringToV8(isolate, "defaultPrevented"))->BooleanValue();
+v8::Local<v8::Object> EventEmitter::CreateCustomEvent(
+    v8::Isolate* isolate, v8::Local<v8::Object> custom_event) {
+  v8::Local<v8::Object> event = CreateEventObject(isolate);
+  (void)event->SetPrototype(custom_event->CreationContext(), custom_event);
+  mate::Dictionary(isolate, event).Set("sender", GetWrapper(isolate));
+  return event;
 }
 
 }  // namespace mate

atom/browser/api/event_emitter.h

@@ -7,12 +7,9 @@
 
 #include <vector>
 
+#include "atom/common/api/event_emitter_caller.h"
 #include "native_mate/wrappable.h"
 
-namespace base {
-class ListValue;
-}
-
 namespace content {
 class WebContents;
 }
@@ -26,29 +23,56 @@ 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::Local<v8::Value>> ValueArray;
+
+  // this.emit(name, event, args...);
+  template<typename... Args>
+  bool EmitCustomEvent(const base::StringPiece& name,
+                       v8::Local<v8::Object> event,
+                       const Args&... args) {
+    return EmitWithEvent(name, CreateCustomEvent(isolate(), event), args...);
+  }
+
+  // this.emit(name, new Event(), 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...);
+  template<typename... Args>
+  bool EmitWithSender(const base::StringPiece& name,
+                      content::WebContents* sender,
+                      IPC::Message* message,
+                      const Args&... args) {
+    v8::Locker locker(isolate());
+    v8::HandleScope handle_scope(isolate());
+    v8::Local<v8::Object> event = CreateJSEvent(isolate(), sender, message);
+    return EmitWithEvent(name, event, args...);
+  }
 
  protected:
   EventEmitter();
 
-  // this.emit(name, new Event());
-  bool Emit(const base::StringPiece& name);
-
-  // this.emit(name, new Event(), args...);
-  bool Emit(const base::StringPiece& name, const base::ListValue& args);
-
-  // this.emit(name, new Event(sender, message), args...);
-  bool Emit(const base::StringPiece& name, const base::ListValue& args,
-            content::WebContents* sender, IPC::Message* message);
-
-  // Lower level implementations.
-  bool Emit(v8::Isolate* isolate,
-            const base::StringPiece& name,
-            Arguments args,
-            content::WebContents* sender = nullptr,
-            IPC::Message* message = nullptr);
-
  private:
+  // this.emit(name, event, args...);
+  template<typename... Args>
+  bool EmitWithEvent(const base::StringPiece& name,
+                     v8::Local<v8::Object> event,
+                     const Args&... args) {
+    v8::Locker locker(isolate());
+    v8::HandleScope handle_scope(isolate());
+    EmitEvent(isolate(), GetWrapper(isolate()), name, event, args...);
+    return event->Get(
+        StringToV8(isolate(), "defaultPrevented"))->BooleanValue();
+  }
+
+  v8::Local<v8::Object> CreateJSEvent(v8::Isolate* isolate,
+                                      content::WebContents* sender,
+                                      IPC::Message* message);
+  v8::Local<v8::Object> CreateCustomEvent(
+      v8::Isolate* isolate, v8::Local<v8::Object> event);
+
   DISALLOW_COPY_AND_ASSIGN(EventEmitter);
 };
 

atom/browser/api/lib/app.coffee

@@ -1,12 +1,14 @@
 EventEmitter = require('events').EventEmitter
 
 bindings = process.atomBinding 'app'
+sessionBindings = process.atomBinding 'session'
 
 app = bindings.app
 app.__proto__ = EventEmitter.prototype
 
-app.getHomeDir = ->
-  process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
+wrapSession = (session) ->
+  # session is an Event Emitter.
+  session.__proto__ = EventEmitter.prototype
 
 app.setApplicationMenu = (menu) ->
   require('menu').setApplicationMenu menu
@@ -28,10 +30,25 @@ if process.platform is 'darwin'
     show: bindings.dockShow
     setMenu: bindings.dockSetMenu
 
+appPath = null
+app.setAppPath = (path) ->
+  appPath = path
+
+app.getAppPath = ->
+  appPath
+
 # Be compatible with old API.
-app.once 'ready', -> app.emit 'finish-launching'
+app.once 'ready', -> @emit 'finish-launching'
 app.terminate = app.quit
 app.exit = process.exit
+app.getHomeDir = -> @getPath 'home'
+app.getDataPath = -> @getPath 'userData'
+app.setDataPath = (path) -> @setPath 'userData', path
+app.resolveProxy = -> @defaultSession.resolveProxy.apply @defaultSession, arguments
+
+# Session wrapper.
+sessionBindings._setWrapSession wrapSession
+process.once 'exit', sessionBindings._clearWrapSession
 
 # Only one App object pemitted.
 module.exports = app

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

@@ -1,76 +1,49 @@
 EventEmitter = require('events').EventEmitter
-IDWeakMap = require 'id-weak-map'
 app = require 'app'
 ipc = require 'ipc'
-wrapWebContents = require('web-contents').wrap
 
 BrowserWindow = process.atomBinding('window').BrowserWindow
 BrowserWindow::__proto__ = EventEmitter.prototype
 
-# Store all created windows in the weak map.
-BrowserWindow.windows = new IDWeakMap
-
 BrowserWindow::_init = ->
   # Simulate the application menu on platforms other than OS X.
   if process.platform isnt 'darwin'
     menu = app.getApplicationMenu()
     @setMenu menu if menu?
 
-  @webContents = @getWebContents()
-  @webContents.once 'destroyed', => @webContents = null
-
-  # Remember the window ID.
-  Object.defineProperty this, 'id',
-    value: BrowserWindow.windows.add(this)
-    enumerable: true
-
   # Make new windows requested by links behave like "window.open"
-  @on '-new-window', (event, url, frameName) =>
-    event.sender = @webContents
+  @webContents.on '-new-window', (event, url, frameName) ->
     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
+  # window.resizeTo(...)
+  # window.moveTo(...)
+  @webContents.on 'move', (event, size) =>
+    @setBounds size
 
-  # Remove the window from weak map immediately when it's destroyed, since we
-  # could be iterating windows before GC happened.
-  @once 'closed', =>
-    BrowserWindow.windows.remove @id if BrowserWindow.windows.has @id
+  # Hide the auto-hide menu when webContents is focused.
+  @webContents.on 'activate', =>
+    if process.platform isnt 'darwin' and @isMenuBarAutoHide() and @isMenuBarVisible()
+      @setMenuBarVisibility false
 
-BrowserWindow::openDevTools = ->
-  @_openDevTools()
+  # Forward the crashed event.
+  @webContents.on 'crashed', =>
+    @emit 'crashed'
 
-  # Force devToolsWebContents to be created.
-  @devToolsWebContents = @getDevToolsWebContents()
-  @devToolsWebContents.once 'destroyed', => @devToolsWebContents = null
+  # Sometimes the webContents doesn't get focus when window is shown, so we have
+  # to force focusing on webContents in this case. The safest way is to focus it
+  # when we first start to load URL, if we do it earlier it won't have effect,
+  # if we do it later we might move focus in the page.
+  # Though this hack is only needed on OS X when the app is launched from
+  # Finder, we still do it on all platforms in case of other bugs we don't know.
+  @webContents.once 'load-url', ->
+    @focus()
 
-  # Emit devtools events.
-  @devToolsWebContents.once 'did-finish-load', => @emit 'devtools-opened'
-  @devToolsWebContents.once 'destroyed', => @emit 'devtools-closed'
-
-BrowserWindow::toggleDevTools = ->
-  if @isDevToolsOpened() then @closeDevTools() else @openDevTools()
-
-BrowserWindow::getWebContents = ->
-  wrapWebContents @_getWebContents()
-
-BrowserWindow::getDevToolsWebContents = ->
-  wrapWebContents @_getDevToolsWebContents()
-
-BrowserWindow::setMenu = (menu) ->
-  if process.platform is 'darwin'
-    throw new Error('BrowserWindow.setMenu is not available on OS X')
-
-  throw new TypeError('Invalid menu') unless menu?.constructor?.name is 'Menu'
-
-  @menu = menu  # Keep a reference of menu in case of GC.
-  @menu.attachToWindow this
-
-BrowserWindow.getAllWindows = ->
-  windows = BrowserWindow.windows
-  windows.get key for key in windows.keys()
+  # Redirect focus/blur event to app instance too.
+  @on 'blur', (event) =>
+    app.emit 'browser-window-blur', event, this
+  @on 'focus', (event) =>
+    app.emit 'browser-window-focus', event, this
 
 BrowserWindow.getFocusedWindow = ->
   windows = BrowserWindow.getAllWindows()
@@ -78,20 +51,23 @@ BrowserWindow.getFocusedWindow = ->
 
 BrowserWindow.fromWebContents = (webContents) ->
   windows = BrowserWindow.getAllWindows()
-  return window for window in windows when webContents.equal window.webContents
+  return window for window in windows when window.webContents?.equal webContents
 
 BrowserWindow.fromDevToolsWebContents = (webContents) ->
   windows = BrowserWindow.getAllWindows()
-  return window for window in windows when webContents.equal window.devToolsWebContents
-
-BrowserWindow.fromId = (id) ->
-  BrowserWindow.windows.get id
+  return window for window in windows when window.devToolsWebContents?.equal webContents
 
 # Helpers.
 BrowserWindow::loadUrl = -> @webContents.loadUrl.apply @webContents, arguments
 BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
 
 # Be compatible with old API.
+BrowserWindow::undo = -> @webContents.undo()
+BrowserWindow::redo = -> @webContents.redo()
+BrowserWindow::cut = -> @webContents.cut()
+BrowserWindow::copy = -> @webContents.copy()
+BrowserWindow::paste = -> @webContents.paste()
+BrowserWindow::selectAll = -> @webContents.selectAll()
 BrowserWindow::restart = -> @webContents.reload()
 BrowserWindow::getUrl = -> @webContents.getUrl()
 BrowserWindow::reload = -> @webContents.reload.apply @webContents, arguments
@@ -100,10 +76,15 @@ BrowserWindow::getPageTitle = -> @webContents.getTitle()
 BrowserWindow::isLoading = -> @webContents.isLoading()
 BrowserWindow::isWaitingForResponse = -> @webContents.isWaitingForResponse()
 BrowserWindow::stop = -> @webContents.stop()
-BrowserWindow::getRoutingId = -> @webContents.getRoutingId()
-BrowserWindow::getProcessId = -> @webContents.getProcessId()
 BrowserWindow::isCrashed = -> @webContents.isCrashed()
-BrowserWindow::executeJavaScriptInDevTools = (code) ->
-  @devToolsWebContents.executeJavaScript code
+BrowserWindow::executeJavaScriptInDevTools = (code) -> @devToolsWebContents?.executeJavaScript code
+BrowserWindow::openDevTools = -> @webContents.openDevTools.apply @webContents, arguments
+BrowserWindow::closeDevTools = -> @webContents.closeDevTools()
+BrowserWindow::isDevToolsOpened = -> @webContents.isDevToolsOpened()
+BrowserWindow::toggleDevTools = -> @webContents.toggleDevTools()
+BrowserWindow::inspectElement = -> @webContents.inspectElement.apply @webContents, arguments
+BrowserWindow::inspectServiceWorker = -> @webContents.inspectServiceWorker()
+BrowserWindow::print = -> @webContents.print.apply @webContents, arguments
+BrowserWindow::printToPDF = -> @webContents.printToPDF.apply @webContents, arguments
 
 module.exports = BrowserWindow

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

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

atom/browser/api/lib/dialog.coffee

@@ -9,7 +9,10 @@ fileDialogProperties =
   multiSelections: 1 << 2
   createDirectory: 1 << 3
 
-messageBoxTypes = ['none', 'info', 'warning']
+messageBoxTypes = ['none', 'info', 'warning', 'error', 'question']
+
+messageBoxOptions =
+  noLink: 1 << 0
 
 parseArgs = (window, options, callback) ->
   unless window is null or window?.constructor is BrowserWindow
@@ -83,8 +86,8 @@ module.exports =
 
     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
 
@@ -93,9 +96,23 @@ module.exports =
     options.detail ?= ''
     options.icon ?= null
 
-    binding.showMessageBox options.type,
+    # Choose a default button to get selected when dialog is cancelled.
+    unless options.cancelId?
+      options.cancelId = 0
+      for text, i in options.buttons
+        if text.toLowerCase() in ['cancel', 'no']
+          options.cancelId = i
+          break
+
+    flags = if options.noLink then messageBoxOptions.noLink else 0
+
+    binding.showMessageBox messageBoxType,
                            options.buttons,
-                           [options.title, options.message, options.detail],
+                           options.cancelId,
+                           flags,
+                           options.title,
+                           options.message,
+                           options.detail,
                            options.icon,
                            window,
                            callback
@@ -104,4 +121,5 @@ module.exports =
     binding.showErrorBox args...
 
 # Mark standard asynchronous functions.
-v8Util.setHiddenValue f, 'asynchronous', true for k, f of module.exports
+for api in ['showMessageBox', 'showOpenDialog', 'showSaveDialog']
+  v8Util.setHiddenValue module.exports[api], 'asynchronous', true

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

@@ -3,19 +3,32 @@ v8Util = process.atomBinding 'v8_util'
 
 nextCommandId = 0
 
+# Maps role to methods of webContents
+rolesMap =
+  undo: 'undo'
+  redo: 'redo'
+  cut: 'cut'
+  copy: 'copy'
+  paste: 'paste'
+  selectall: 'selectAll'
+  minimize: 'minimize'
+  close: 'close'
+
 class MenuItem
   @types = ['normal', 'separator', 'submenu', 'checkbox', 'radio']
 
   constructor: (options) ->
     Menu = require 'menu'
 
-    {click, @selector, @type, @label, @sublabel, @accelerator, @enabled, @visible, @checked, @submenu} = options
+    {click, @selector, @type, @role, @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 'role'
     @overrideReadOnlyProperty 'accelerator'
+    @overrideReadOnlyProperty 'icon'
     @overrideReadOnlyProperty 'submenu'
     @overrideProperty 'label', ''
     @overrideProperty 'sublabel', ''
@@ -26,12 +39,14 @@ class MenuItem
     throw new Error("Unknown menu type #{@type}") if MenuItem.types.indexOf(@type) is -1
 
     @commandId = ++nextCommandId
-    @click = =>
+    @click = (focusedWindow) =>
       # Manually flip the checked flags when clicked.
       @checked = !@checked if @type in ['checkbox', 'radio']
 
-      if typeof click is 'function'
-        click this, BrowserWindow.getFocusedWindow()
+      if @role and rolesMap[@role] and process.platform isnt 'darwin'
+        focusedWindow?[rolesMap[@role]]()
+      else if typeof click is 'function'
+        click this, focusedWindow
       else if typeof @selector is 'string'
         Menu.sendActionToFirstResponder @selector
 

atom/browser/api/lib/menu.coffee

@@ -23,6 +23,37 @@ generateGroupId = (items, pos) ->
       break if item.type is 'separator'
   ++nextGroupId
 
+# Returns the index of item according to |id|.
+indexOfItemById = (items, id) ->
+  return i for item, i in items when item.id is id
+  -1
+
+# Returns the index of where to insert the item according to |position|.
+indexToInsertByPosition = (items, position) ->
+  return items.length unless position
+
+  [query, id] = position.split '='
+  insertIndex = indexOfItemById items, id
+  if insertIndex is -1 and query isnt 'endof'
+    console.warn "Item with id '#{id}' is not found"
+    return items.length
+
+  switch query
+    when 'after'
+      insertIndex++
+    when 'endof'
+      # If the |id| doesn't exist, then create a new group with the |id|.
+      if insertIndex is -1
+        items.push id: id, type: 'separator'
+        insertIndex = items.length - 1
+
+      # Find the end of the group.
+      insertIndex++
+      while insertIndex < items.length and items[insertIndex].type isnt 'separator'
+        insertIndex++
+
+  insertIndex
+
 Menu = bindings.Menu
 Menu::__proto__ = EventEmitter.prototype
 
@@ -35,7 +66,9 @@ Menu::_init = ->
     isCommandIdEnabled: (commandId) => @commandsMap[commandId]?.enabled
     isCommandIdVisible: (commandId) => @commandsMap[commandId]?.visible
     getAcceleratorForCommandId: (commandId) => @commandsMap[commandId]?.accelerator
-    executeCommand: (commandId) => @commandsMap[commandId]?.click()
+    getIconForCommandId: (commandId) => @commandsMap[commandId]?.icon
+    executeCommand: (commandId) =>
+      @commandsMap[commandId]?.click BrowserWindow.getFocusedWindow()
     menuWillShow: =>
       # Make sure radio groups have at least one menu item seleted.
       for id, group of @groupsMap
@@ -82,6 +115,8 @@ 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?
+  @setRole pos, item.role if item.role?
 
   # Make menu accessable to items.
   item.overrideReadOnlyProperty 'menu', this
@@ -97,10 +132,11 @@ Menu::_callMenuWillShow = ->
 
 applicationMenu = null
 Menu.setApplicationMenu = (menu) ->
-  throw new TypeError('Invalid menu') unless menu?.constructor is Menu
+  throw new TypeError('Invalid menu') unless menu is null or menu.constructor is Menu
   applicationMenu = menu  # Keep a reference.
 
   if process.platform is 'darwin'
+    return if menu is null
     menu._callMenuWillShow()
     bindings.setApplicationMenu menu
   else
@@ -114,14 +150,25 @@ Menu.sendActionToFirstResponder = bindings.sendActionToFirstResponder
 Menu.buildFromTemplate = (template) ->
   throw new TypeError('Invalid template for Menu') unless Array.isArray template
 
-  menu = new Menu
+  positionedTemplate = []
+  insertIndex = 0
+
   for item in template
+    if item.position
+      insertIndex = indexToInsertByPosition positionedTemplate, item.position
+    else
+      # If no |position| is specified, insert after last item.
+      insertIndex++
+    positionedTemplate.splice insertIndex, 0, item
+
+  menu = new Menu
+
+  for item in positionedTemplate
     throw new TypeError('Invalid template for MenuItem') unless typeof item is 'object'
 
     item.submenu = Menu.buildFromTemplate item.submenu if item.submenu?
     menuItem = new MenuItem(item)
     menuItem[key] = value for key, value of item when not menuItem[key]?
-
     menu.append menuItem
 
   menu

atom/browser/api/lib/navigation-controller.coffee

@@ -0,0 +1,117 @@
+ipc = require 'ipc'
+
+# The history operation in renderer is redirected to browser.
+ipc.on 'ATOM_SHELL_NAVIGATION_CONTROLLER', (event, method, args...) ->
+  event.sender[method] args...
+
+ipc.on 'ATOM_SHELL_SYNC_NAVIGATION_CONTROLLER', (event, method, args...) ->
+  event.returnValue = event.sender[method] args...
+
+# JavaScript implementation of Chromium's NavigationController.
+# Instead of relying on Chromium for history control, we compeletely do history
+# control on user land, and only rely on WebContents.loadUrl for navigation.
+# This helps us avoid Chromium's various optimizations so we can ensure renderer
+# process is restarted everytime.
+class NavigationController
+  constructor: (@webContents) ->
+    @clearHistory()
+
+    @webContents.on 'navigation-entry-commited', (event, url, inPage, replaceEntry) =>
+      if @inPageIndex > -1 and not inPage
+        # Navigated to a new page, clear in-page mark.
+        @inPageIndex = -1
+      else if @inPageIndex is -1 and inPage
+        # Started in-page navigations.
+        @inPageIndex = @currentIndex
+
+      if @pendingIndex >= 0 # Go to index.
+        @currentIndex = @pendingIndex
+        @pendingIndex = -1
+        @history[@currentIndex] = url
+      else if replaceEntry # Non-user initialized navigation.
+        @history[@currentIndex] = url
+      else  # Normal navigation.
+        @history = @history.slice 0, @currentIndex + 1  # Clear history.
+        currentEntry = @history[@currentIndex]
+        if currentEntry?.url isnt url
+          @currentIndex++
+          @history.push url
+
+  loadUrl: (url, options={}) ->
+    @pendingIndex = -1
+    @webContents._loadUrl url, options
+    @webContents.emit 'load-url', url, options
+
+  getUrl: ->
+    if @currentIndex is -1
+      ''
+    else
+      @history[@currentIndex]
+
+  stop: ->
+    @pendingIndex = -1
+    @webContents._stop()
+
+  reload: ->
+    @pendingIndex = @currentIndex
+    @webContents._loadUrl @getUrl(), {}
+
+  reloadIgnoringCache: ->
+    @webContents._reloadIgnoringCache()  # Rely on WebContents to clear cache.
+    @reload()
+
+  canGoBack: ->
+    @getActiveIndex() > 0
+
+  canGoForward: ->
+    @getActiveIndex() < @history.length - 1
+
+  canGoToIndex: (index) ->
+    index >=0 and index < @history.length
+
+  canGoToOffset: (offset) ->
+    @canGoToIndex @currentIndex + offset
+
+  clearHistory: ->
+    @history = []
+    @currentIndex = -1
+    @pendingIndex = -1
+    @inPageIndex = -1
+
+  goBack: ->
+    return unless @canGoBack()
+    @pendingIndex = @getActiveIndex() - 1
+    if @inPageIndex > -1 and @pendingIndex >= @inPageIndex
+      @webContents._goBack()
+    else
+      @webContents._loadUrl @history[@pendingIndex], {}
+
+  goForward: ->
+    return unless @canGoForward()
+    @pendingIndex = @getActiveIndex() + 1
+    if @inPageIndex > -1 and @pendingIndex >= @inPageIndex
+      @webContents._goForward()
+    else
+      @webContents._loadUrl @history[@pendingIndex], {}
+
+  goToIndex: (index) ->
+    return unless @canGoToIndex index
+    @pendingIndex = index
+    @webContents._loadUrl @history[@pendingIndex], {}
+
+  goToOffset: (offset) ->
+    return unless @canGoToOffset offset
+    pendingIndex = @currentIndex + offset
+    if @inPageIndex > -1 and pendingIndex >= @inPageIndex
+      @pendingIndex = pendingIndex
+      @webContents._goToOffset offset
+    else
+      @goToIndex pendingIndex
+
+  getActiveIndex: ->
+    if @pendingIndex is -1 then @currentIndex else @pendingIndex
+
+  length: ->
+    @history.length
+
+module.exports = NavigationController

atom/browser/api/lib/power-save-blocker.coffee

@@ -0,0 +1,3 @@
+bindings = process.atomBinding 'power_save_blocker'
+
+module.exports = bindings.powerSaveBlocker

atom/browser/api/lib/protocol.coffee

@@ -2,22 +2,23 @@ app = require 'app'
 throw new Error('Can not initialize protocol module before app is ready') unless app.isReady()
 
 protocol = process.atomBinding('protocol').protocol
-EventEmitter = require('events').EventEmitter
 
-protocol.__proto__ = EventEmitter.prototype
-
-protocol.RequestStringJob =
-class RequestStringJob
-  constructor: ({mimeType, charset, data}) ->
-    if typeof data isnt 'string' and not data instanceof Buffer
-      throw new TypeError('Data should be string or Buffer')
-
-    @mimeType = mimeType ? 'text/plain'
-    @charset = charset ? 'UTF-8'
-    @data = String data
-
-protocol.RequestFileJob =
-class RequestFileJob
-  constructor: (@path) ->
+# Warn about removed APIs.
+logAndThrow = (callback, message) ->
+  console.error message
+  if callback then callback(new Error(message)) else throw new Error(message)
+protocol.registerProtocol = (scheme, handler, callback) ->
+  logAndThrow callback,
+              'registerProtocol API has been replaced by the
+               register[File/Http/Buffer/String]Protocol API family, please
+               switch to the new APIs.'
+protocol.isHandledProtocol = (scheme, callback) ->
+  logAndThrow callback,
+              'isHandledProtocol API has been replaced by isProtocolHandled.'
+protocol.interceptProtocol = (scheme, handler, callback) ->
+  logAndThrow callback,
+              'interceptProtocol API has been replaced by the
+               intercept[File/Http/Buffer/String]Protocol API family, please
+               switch to the new APIs.'
 
 module.exports = protocol

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

atom/browser/api/lib/tray.coffee

@@ -3,8 +3,12 @@ bindings = process.atomBinding 'tray'
 
 Tray = bindings.Tray
 Tray::__proto__ = EventEmitter.prototype
+
 Tray::setContextMenu = (menu) ->
   @_setContextMenu menu
   @menu = menu  # Keep a strong reference of menu.
 
+# Keep compatibility with old APIs.
+Tray::popContextMenu = Tray::popUpContextMenu
+
 module.exports = Tray

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

@@ -1,62 +1,114 @@
 EventEmitter = require('events').EventEmitter
+NavigationController = require './navigation-controller'
 binding = process.atomBinding 'web_contents'
 ipc = require 'ipc'
 
-module.exports.wrap = (webContents) ->
-  return null unless webContents.isAlive()
+nextId = 0
+getNextId = -> ++nextId
 
+PDFPageSize =
+  A4:
+    custom_display_name: "A4"
+    height_microns: 297000
+    name: "ISO_A4"
+    is_default: "true"
+    width_microns: 210000
+  A3:
+    custom_display_name: "A3"
+    height_microns: 420000
+    name: "ISO_A3"
+    width_microns: 297000
+  Legal:
+    custom_display_name: "Legal"
+    height_microns: 355600
+    name: "NA_LEGAL"
+    width_microns: 215900
+  Letter:
+    custom_display_name: "Letter"
+    height_microns: 279400
+    name: "NA_LETTER"
+    width_microns: 215900
+  Tabloid:
+    height_microns: 431800
+    name: "NA_LEDGER"
+    width_microns: 279400
+    custom_display_name: "Tabloid"
+
+wrapWebContents = (webContents) ->
   # webContents is an EventEmitter.
   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.
   webContents.loaded = false
   webContents.once 'did-finish-load', -> @loaded = true
-  webContents.executeJavaScript = (code) ->
+  webContents.executeJavaScript = (code, hasUserGesture=false) ->
     if @loaded
-      @_executeJavaScript code
+      @_executeJavaScript code, hasUserGesture
     else
-      webContents.once 'did-finish-load', @_executeJavaScript.bind(this, code)
+      webContents.once 'did-finish-load', @_executeJavaScript.bind(this, code, hasUserGesture)
 
-  # The processId and routingId and identify a 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 =
-      switch disposition
-        when 2 then 'default'
-        when 4 then 'foreground-tab'
-        when 5 then 'background-tab'
-        when 6, 7 then 'new-window'
-        else 'other'
-    @emit 'new-window', args..., disposition
-
-  # Tell the rpc server that a render view has been deleted and we need to
-  # release all objects owned by it.
-  webContents.on 'render-view-deleted', (event, processId, routingId) ->
-    process.emit 'ATOM_BROWSER_RELEASE_RENDER_VIEW', "#{processId}-#{routingId}"
+  # The navigation controller.
+  controller = new NavigationController(webContents)
+  for name, method of NavigationController.prototype when method instanceof Function
+    do (name, method) ->
+      webContents[name] = -> method.apply controller, arguments
 
   # Dispatch IPC messages to the ipc module.
-  webContents.on 'ipc-message', (event, channel, args...) ->
-    Object.defineProperty event, 'sender', value: webContents
+  webContents.on 'ipc-message', (event, packed) ->
+    [channel, args...] = packed
     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...
 
-  webContents
+  webContents.printToPDF = (options, callback) ->
+    printingSetting =
+      pageRage: []
+      mediaSize: {}
+      landscape: false
+      color: 2
+      headerFooterEnabled: false
+      marginsType: 0
+      isFirstRequest: false
+      requestID: getNextId()
+      previewModifiable: true
+      printToPDF: true
+      printWithCloudPrint: false
+      printWithPrivet: false
+      printWithExtension: false
+      deviceName: "Save as PDF"
+      generateDraftData: true
+      fitToPageEnabled: false
+      duplex: 0
+      copies: 1
+      collate: true
+      shouldPrintBackgrounds: false
+      shouldPrintSelectionOnly: false
+
+    if options.landscape
+      printingSetting.landscape = options.landscape
+    if options.marginsType
+      printingSetting.marginsType = options.marginsType
+    if options.printSelectionOnly
+      printingSetting.shouldPrintSelectionOnly = options.printSelectionOnly
+    if options.printBackground
+      printingSetting.shouldPrintBackgrounds = options.printBackground
+
+    if options.pageSize and PDFPageSize[options.pageSize]
+      printingSetting.mediaSize = PDFPageSize[options.pageSize]
+    else
+      printingSetting.mediaSize = PDFPageSize['A4']
+
+    @_printToPDF printingSetting, callback
+
+binding._setWrapWebContents wrapWebContents
+process.once 'exit', binding._clearWrapWebContents
 
 module.exports.create = (options={}) ->
-  @wrap binding.create(options)
+  binding.create(options)

atom/browser/api/trackable_object.cc

@@ -0,0 +1,71 @@
+// 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/trackable_object.h"
+
+#include "atom/browser/atom_browser_main_parts.h"
+#include "base/bind.h"
+#include "base/supports_user_data.h"
+
+namespace mate {
+
+namespace {
+
+const char* kTrackedObjectKey = "TrackedObjectKey";
+
+class IDUserData : public base::SupportsUserData::Data {
+ public:
+  explicit IDUserData(int32_t id) : id_(id) {}
+
+  operator int32_t() const { return id_; }
+
+ private:
+  int32_t id_;
+
+  DISALLOW_COPY_AND_ASSIGN(IDUserData);
+};
+
+}  // namespace
+
+TrackableObjectBase::TrackableObjectBase()
+    : weak_map_id_(0), wrapped_(nullptr), weak_factory_(this) {
+  RegisterDestructionCallback(
+      base::Bind(&TrackableObjectBase::Destroy, weak_factory_.GetWeakPtr()));
+}
+
+TrackableObjectBase::~TrackableObjectBase() {
+}
+
+void TrackableObjectBase::AfterInit(v8::Isolate* isolate) {
+  if (wrapped_)
+    AttachAsUserData(wrapped_);
+}
+
+void TrackableObjectBase::AttachAsUserData(base::SupportsUserData* wrapped) {
+  if (weak_map_id_ != 0) {
+    wrapped->SetUserData(kTrackedObjectKey, new IDUserData(weak_map_id_));
+    wrapped_ = nullptr;
+  } else {
+    // If the TrackableObjectBase is not ready yet then delay SetUserData until
+    // AfterInit is called.
+    wrapped_ = wrapped;
+  }
+}
+
+// static
+int32_t TrackableObjectBase::GetIDFromWrappedClass(base::SupportsUserData* w) {
+  auto id = static_cast<IDUserData*>(w->GetUserData(kTrackedObjectKey));
+  if (id)
+    return *id;
+  else
+    return 0;
+}
+
+// static
+void TrackableObjectBase::RegisterDestructionCallback(
+    const base::Closure& closure) {
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(closure);
+}
+
+}  // namespace mate

atom/browser/api/trackable_object.h

@@ -0,0 +1,133 @@
+// 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_TRACKABLE_OBJECT_H_
+#define ATOM_BROWSER_API_TRACKABLE_OBJECT_H_
+
+#include <vector>
+
+#include "atom/browser/api/event_emitter.h"
+#include "atom/common/id_weak_map.h"
+#include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+
+namespace base {
+class SupportsUserData;
+}
+
+namespace mate {
+
+// Users should use TrackableObject instead.
+class TrackableObjectBase : public mate::EventEmitter {
+ public:
+  TrackableObjectBase();
+
+  // The ID in weak map.
+  int32_t weak_map_id() const { return weak_map_id_; }
+
+  // Wrap TrackableObject into a class that SupportsUserData.
+  void AttachAsUserData(base::SupportsUserData* wrapped);
+
+  // Subclasses should implement this to destroy their native types.
+  virtual void Destroy() = 0;
+
+ protected:
+  ~TrackableObjectBase() override;
+
+  // mate::Wrappable:
+  void AfterInit(v8::Isolate* isolate) override;
+
+  // Get the weak_map_id from SupportsUserData.
+  static int32_t GetIDFromWrappedClass(base::SupportsUserData* wrapped);
+
+  // Register a callback that should be destroyed before JavaScript environment
+  // gets destroyed.
+  static void RegisterDestructionCallback(const base::Closure& closure);
+
+  int32_t weak_map_id_;
+  base::SupportsUserData* wrapped_;
+
+ private:
+  base::WeakPtrFactory<TrackableObjectBase> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(TrackableObjectBase);
+};
+
+// All instances of TrackableObject will be kept in a weak map and can be got
+// from its ID.
+template<typename T>
+class TrackableObject : public TrackableObjectBase {
+ public:
+  // Finds out the TrackableObject from its ID in weak map.
+  static T* FromWeakMapID(v8::Isolate* isolate, int32_t id) {
+    if (!weak_map_)
+      return nullptr;
+
+    v8::MaybeLocal<v8::Object> object = weak_map_->Get(isolate, id);
+    if (object.IsEmpty())
+      return nullptr;
+
+    T* self = nullptr;
+    mate::ConvertFromV8(isolate, object.ToLocalChecked(), &self);
+    return self;
+  }
+
+  // Finds out the TrackableObject from the class it wraps.
+  static T* FromWrappedClass(v8::Isolate* isolate,
+                             base::SupportsUserData* wrapped) {
+    int32_t id = GetIDFromWrappedClass(wrapped);
+    if (!id)
+      return nullptr;
+    return FromWeakMapID(isolate, id);
+  }
+
+  // Returns all objects in this class's weak map.
+  static std::vector<v8::Local<v8::Object>> GetAll(v8::Isolate* isolate) {
+    if (weak_map_)
+      return weak_map_->Values(isolate);
+    else
+      return std::vector<v8::Local<v8::Object>>();
+  }
+
+  TrackableObject() {
+    RegisterDestructionCallback(
+        base::Bind(&TrackableObject<T>::ReleaseAllWeakReferences));
+  }
+
+  // Removes this instance from the weak map.
+  void RemoveFromWeakMap() {
+    if (weak_map_ && weak_map_->Has(weak_map_id()))
+      weak_map_->Remove(weak_map_id());
+  }
+
+ protected:
+  ~TrackableObject() override {
+    RemoveFromWeakMap();
+  }
+
+  void AfterInit(v8::Isolate* isolate) override {
+    if (!weak_map_)
+      weak_map_.reset(new atom::IDWeakMap);
+    weak_map_id_ = weak_map_->Add(isolate, GetWrapper(isolate));
+    TrackableObjectBase::AfterInit(isolate);
+  }
+
+ private:
+  // Releases all weak references in weak map, called when app is terminating.
+  static void ReleaseAllWeakReferences() {
+    weak_map_.reset();
+  }
+
+  static scoped_ptr<atom::IDWeakMap> weak_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(TrackableObject);
+};
+
+template<typename T>
+scoped_ptr<atom::IDWeakMap> TrackableObject<T>::weak_map_;
+
+}  // namespace mate
+
+#endif  // ATOM_BROWSER_API_TRACKABLE_OBJECT_H_

atom/browser/atom_access_token_store.cc

@@ -7,7 +7,9 @@
 #include <utility>
 
 #include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
 #include "atom/common/google_api_key.h"
+#include "content/public/browser/geolocation_provider.h"
 
 namespace atom {
 
@@ -23,6 +25,7 @@ const char* kGeolocationProviderUrl =
 }  // namespace
 
 AtomAccessTokenStore::AtomAccessTokenStore() {
+  content::GeolocationProvider::GetInstance()->UserDidOptIntoLocationServices();
 }
 
 AtomAccessTokenStore::~AtomAccessTokenStore() {
@@ -39,8 +42,8 @@ void AtomAccessTokenStore::LoadAccessTokens(
   token_pair.first = GURL(kGeolocationProviderUrl);
   access_token_set.insert(token_pair);
 
-  callback.Run(access_token_set,
-               AtomBrowserContext::Get()->url_request_context_getter());
+  auto browser_context = AtomBrowserMainParts::Get()->browser_context();
+  callback.Run(access_token_set, browser_context->url_request_context_getter());
 }
 
 void AtomAccessTokenStore::SaveAccessToken(const GURL& server_url,

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);

atom/browser/atom_browser_client.cc

@@ -4,50 +4,89 @@
 
 #include "atom/browser/atom_browser_client.h"
 
+#if defined(OS_WIN)
+#include <shlobj.h>
+#endif
+
 #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_quota_permission_context.h"
 #include "atom/browser/atom_speech_recognition_manager_delegate.h"
+#include "atom/browser/browser.h"
 #include "atom/browser/native_window.h"
-#include "atom/browser/web_view/web_view_renderer_state.h"
+#include "atom/browser/web_contents_preferences.h"
 #include "atom/browser/window_list.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
+#include "base/files/file_util.h"
+#include "base/stl_util.h"
+#include "base/strings/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/printing/printing_message_filter.h"
+#include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
 #include "chrome/browser/speech/tts_message_filter.h"
+#include "content/public/browser/browser_ppapi_host.h"
+#include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/web_preferences.h"
+#include "net/cert/x509_certificate.h"
+#include "net/ssl/ssl_cert_request_info.h"
+#include "ppapi/host/ppapi_host.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "v8/include/v8.h"
 
 namespace atom {
 
 namespace {
 
-struct FindByProcessId {
-  explicit FindByProcessId(int child_process_id)
-      : child_process_id_(child_process_id) {
-  }
+// The default routing id of WebContents.
+// In Electron each RenderProcessHost only has one WebContents, so this ID is
+// same for every WebContents.
+int kDefaultRoutingID = 2;
 
-  bool operator() (NativeWindow* const window) {
-    content::WebContents* web_contents = window->GetWebContents();
-    if (!web_contents)
-      return false;
+// Next navigation should not restart renderer process.
+bool g_suppress_renderer_process_restart = false;
 
-    int id = window->GetWebContents()->GetRenderProcessHost()->GetID();
-    return id == child_process_id_;
-  }
+// Custom schemes to be registered to standard.
+std::string g_custom_schemes = "";
 
-  int child_process_id_;
-};
+scoped_refptr<net::X509Certificate> ImportCertFromFile(
+    const base::FilePath& path) {
+  if (path.empty())
+    return nullptr;
+
+  std::string cert_data;
+  if (!base::ReadFileToString(path, &cert_data))
+    return nullptr;
+
+  net::CertificateList certs =
+      net::X509Certificate::CreateCertificateListFromBytes(
+          cert_data.data(), cert_data.size(),
+          net::X509Certificate::FORMAT_AUTO);
+
+  if (certs.empty())
+    return nullptr;
+
+  return certs[0];
+}
 
 }  // namespace
 
-AtomBrowserClient::AtomBrowserClient()
-    : dying_render_process_(NULL) {
+// static
+void AtomBrowserClient::SuppressRendererProcessRestartForOnce() {
+  g_suppress_renderer_process_restart = true;
+}
+
+void AtomBrowserClient::SetCustomSchemes(
+    const std::vector<std::string>& schemes) {
+  g_custom_schemes = JoinString(schemes, ',');
+}
+
+AtomBrowserClient::AtomBrowserClient() {
 }
 
 AtomBrowserClient::~AtomBrowserClient() {
@@ -55,13 +94,13 @@ AtomBrowserClient::~AtomBrowserClient() {
 
 void AtomBrowserClient::RenderProcessWillLaunch(
     content::RenderProcessHost* host) {
-  int id = host->GetID();
-  host->AddFilter(new printing::PrintingMessageFilter(host->GetID()));
-  host->AddFilter(new TtsMessageFilter(id, host->GetBrowserContext()));
+  int process_id = host->GetID();
+  host->AddFilter(new printing::PrintingMessageFilter(process_id));
+  host->AddFilter(new TtsMessageFilter(process_id, host->GetBrowserContext()));
 }
 
 content::SpeechRecognitionManagerDelegate*
-    AtomBrowserClient::GetSpeechRecognitionManagerDelegate() {
+    AtomBrowserClient::CreateSpeechRecognitionManagerDelegate() {
   return new AtomSpeechRecognitionManagerDelegate;
 }
 
@@ -70,9 +109,7 @@ content::AccessTokenStore* AtomBrowserClient::CreateAccessTokenStore() {
 }
 
 void AtomBrowserClient::OverrideWebkitPrefs(
-    content::RenderViewHost* render_view_host,
-    const GURL& url,
-    content::WebPreferences* prefs) {
+    content::RenderViewHost* host, content::WebPreferences* prefs) {
   prefs->javascript_enabled = true;
   prefs->web_security_enabled = true;
   prefs->javascript_can_open_windows_automatically = true;
@@ -87,91 +124,106 @@ 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;
-
-  // Turn off web security for devtools.
-  if (url.SchemeIs("chrome-devtools")) {
-    prefs->web_security_enabled = false;
-    return;
-  }
+  prefs->allow_displaying_insecure_content = false;
+  prefs->allow_running_insecure_content = false;
 
   // Custom preferences of guest page.
-  int guest_process_id = render_view_host->GetProcess()->GetID();
-  WebViewRendererState::WebViewInfo info;
-  if (WebViewRendererState::GetInstance()->GetInfo(guest_process_id, &info)) {
-    prefs->web_security_enabled = !info.disable_web_security;
-    return;
-  }
-
-  NativeWindow* window = NativeWindow::FromRenderView(
-      render_view_host->GetProcess()->GetID(),
-      render_view_host->GetRoutingID());
-  if (window)
-    window->OverrideWebkitPrefs(url, prefs);
-}
-
-bool AtomBrowserClient::ShouldSwapBrowsingInstancesForNavigation(
-    content::SiteInstance* site_instance,
-    const GURL& current_url,
-    const GURL& new_url) {
-  if (site_instance->HasProcess())
-    dying_render_process_ = site_instance->GetProcess();
-
-  // Restart renderer process for all navigations, this relies on a patch to
-  // Chromium: http://git.io/_PaNyg.
-  return true;
+  auto web_contents = content::WebContents::FromRenderViewHost(host);
+  WebContentsPreferences::OverrideWebkitPrefs(web_contents, prefs);
 }
 
 std::string AtomBrowserClient::GetApplicationLocale() {
   return l10n_util::GetApplicationLocale("");
 }
 
+void AtomBrowserClient::OverrideSiteInstanceForNavigation(
+    content::BrowserContext* browser_context,
+    content::SiteInstance* current_instance,
+    const GURL& url,
+    content::SiteInstance** new_instance) {
+  if (g_suppress_renderer_process_restart) {
+    g_suppress_renderer_process_restart = false;
+    return;
+  }
+
+  // Restart renderer process for all navigations except "javacript:" scheme.
+  if (url.SchemeIs(url::kJavaScriptScheme))
+    return;
+
+  *new_instance = content::SiteInstance::CreateForURL(browser_context, url);
+
+  // Remember the original renderer process of the pending renderer process.
+  auto current_process = current_instance->GetProcess();
+  auto pending_process = (*new_instance)->GetProcess();
+  pending_processes_[pending_process->GetID()] = current_process->GetID();
+  // Clear the entry in map when process ends.
+  current_process->AddObserver(this);
+}
+
 void AtomBrowserClient::AppendExtraCommandLineSwitches(
     base::CommandLine* command_line,
-    int child_process_id) {
-  WindowList* list = WindowList::GetInstance();
-  NativeWindow* window = NULL;
+    int process_id) {
+  std::string process_type = command_line->GetSwitchValueASCII("type");
+  if (process_type != "renderer")
+    return;
 
-  // Find the owner of this child process.
-  WindowList::const_iterator iter = std::find_if(
-      list->begin(), list->end(), FindByProcessId(child_process_id));
-  if (iter != list->end())
-    window = *iter;
+  // The registered standard schemes.
+  if (!g_custom_schemes.empty())
+    command_line->AppendSwitchASCII(switches::kRegisterStandardSchemes,
+                                    g_custom_schemes);
 
-  // If the render process is a newly started one, which means the window still
-  // uses the old going-to-be-swapped render process, then we try to find the
-  // window from the swapped render process.
-  if (window == NULL && dying_render_process_ != NULL) {
-    child_process_id = dying_render_process_->GetID();
-    WindowList::const_iterator iter = std::find_if(
-        list->begin(), list->end(), FindByProcessId(child_process_id));
-    if (iter != list->end())
-      window = *iter;
+#if defined(OS_WIN)
+  // Append --app-user-model-id.
+  PWSTR current_app_id;
+  if (SUCCEEDED(GetCurrentProcessExplicitAppUserModelID(&current_app_id))) {
+    command_line->AppendSwitchNative(switches::kAppUserModelId, current_app_id);
+    CoTaskMemFree(current_app_id);
+  }
+#endif
+
+  // If the process is a pending process, we should use the old one.
+  if (ContainsKey(pending_processes_, process_id))
+    process_id = pending_processes_[process_id];
+
+  // Get the WebContents of the render process.
+  content::WebContents* web_contents = content::WebContents::FromRenderViewHost(
+      content::RenderViewHost::FromID(process_id, kDefaultRoutingID));
+  if (!web_contents)
+    return;
+
+  WebContentsPreferences::AppendExtraCommandLineSwitches(
+      web_contents, command_line);
+}
+
+void AtomBrowserClient::DidCreatePpapiPlugin(
+    content::BrowserPpapiHost* host) {
+  host->GetPpapiHost()->AddHostFactoryFilter(
+      make_scoped_ptr(new chrome::ChromeBrowserPepperHostFactory(host)));
+}
+
+content::QuotaPermissionContext*
+    AtomBrowserClient::CreateQuotaPermissionContext() {
+  return new AtomQuotaPermissionContext;
+}
+
+void AtomBrowserClient::SelectClientCertificate(
+    content::WebContents* web_contents,
+    net::SSLCertRequestInfo* cert_request_info,
+    scoped_ptr<content::ClientCertificateDelegate> delegate) {
+  // --client-certificate=`path`
+  auto cmd = base::CommandLine::ForCurrentProcess();
+  if (cmd->HasSwitch(switches::kClientCertificate)) {
+    auto cert_path = cmd->GetSwitchValuePath(switches::kClientCertificate);
+    auto certificate = ImportCertFromFile(cert_path);
+    if (certificate.get())
+      delegate->ContinueWithCertificate(certificate.get());
+    return;
   }
 
-  if (window != NULL) {
-    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)) {
-      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);
-    }
-  }
-
-  dying_render_process_ = NULL;
+  if (!cert_request_info->client_certs.empty())
+    Browser::Get()->ClientCertificateSelector(web_contents,
+                                              cert_request_info,
+                                              delegate.Pass());
 }
 
 brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
@@ -180,4 +232,15 @@ brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
   return new AtomBrowserMainParts;
 }
 
+void AtomBrowserClient::RenderProcessHostDestroyed(
+    content::RenderProcessHost* host) {
+  int process_id = host->GetID();
+  for (const auto& entry : pending_processes_) {
+    if (entry.first == process_id || entry.second == process_id) {
+      pending_processes_.erase(entry.first);
+      break;
+    }
+  }
+}
+
 }  // namespace atom

atom/browser/atom_browser_client.h

@@ -5,40 +5,68 @@
 #ifndef ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 #define ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
 
+#include <map>
 #include <string>
+#include <vector>
 
 #include "brightray/browser/browser_client.h"
+#include "content/public/browser/render_process_host_observer.h"
+
+namespace content {
+class QuotaPermissionContext;
+class ClientCertificateDelegate;
+}
+
+namespace net {
+class SSLCertRequestInfo;
+}
 
 namespace atom {
 
-class AtomBrowserClient : public brightray::BrowserClient {
+class AtomBrowserClient : public brightray::BrowserClient,
+                          public content::RenderProcessHostObserver {
  public:
   AtomBrowserClient();
   virtual ~AtomBrowserClient();
 
+  // Don't force renderer process to restart for once.
+  static void SuppressRendererProcessRestartForOnce();
+  // Custom schemes to be registered to standard.
+  static void SetCustomSchemes(const std::vector<std::string>& schemes);
+
  protected:
   // content::ContentBrowserClient:
   void RenderProcessWillLaunch(content::RenderProcessHost* host) override;
   content::SpeechRecognitionManagerDelegate*
-      GetSpeechRecognitionManagerDelegate() override;
+      CreateSpeechRecognitionManagerDelegate() override;
   content::AccessTokenStore* CreateAccessTokenStore() override;
   void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
-                           const GURL& url,
                            content::WebPreferences* prefs) override;
-  bool ShouldSwapBrowsingInstancesForNavigation(
-      content::SiteInstance* site_instance,
-      const GURL& current_url,
-      const GURL& new_url) override;
   std::string GetApplicationLocale() override;
+  void OverrideSiteInstanceForNavigation(
+      content::BrowserContext* browser_context,
+      content::SiteInstance* current_instance,
+      const GURL& dest_url,
+      content::SiteInstance** new_instance) override;
   void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
                                       int child_process_id) override;
+  void DidCreatePpapiPlugin(content::BrowserPpapiHost* browser_host) override;
+  content::QuotaPermissionContext* CreateQuotaPermissionContext() override;
+  void SelectClientCertificate(
+      content::WebContents* web_contents,
+      net::SSLCertRequestInfo* cert_request_info,
+      scoped_ptr<content::ClientCertificateDelegate> delegate) override;
 
- private:
+  // brightray::BrowserClient:
   brightray::BrowserMainParts* OverrideCreateBrowserMainParts(
       const content::MainFunctionParams&) override;
 
-  // The render process which would be swapped out soon.
-  content::RenderProcessHost* dying_render_process_;
+  // content::RenderProcessHostObserver:
+  void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
+
+ private:
+  // pending_render_process => current_render_process.
+  std::map<int, int> pending_processes_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
 };

atom/browser/atom_browser_context.cc

@@ -5,19 +5,31 @@
 #include "atom/browser/atom_browser_context.h"
 
 #include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/atom_download_manager_delegate.h"
+#include "atom/browser/browser.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/net/http_protocol_handler.h"
+#include "atom/browser/web_view_manager.h"
+#include "atom/common/atom_version.h"
+#include "atom/common/chrome_version.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
-#include "chrome/browser/browser_process.h"
+#include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/url_constants.h"
+#include "content/public/common/user_agent.h"
+#include "net/ftp/ftp_network_layer.h"
 #include "net/url_request/data_protocol_handler.h"
-#include "net/url_request/file_protocol_handler.h"
+#include "net/url_request/ftp_protocol_handler.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
+#include "net/url_request/url_request_context.h"
 #include "url/url_constants.h"
 
 using content::BrowserThread;
@@ -26,8 +38,6 @@ 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,
@@ -36,40 +46,81 @@ class NoCacheBackend : public net::HttpCache::BackendFactory {
   }
 };
 
+std::string RemoveWhitespace(const std::string& str) {
+  std::string trimmed;
+  if (base::RemoveChars(str, " ", &trimmed))
+    return trimmed;
+  else
+    return str;
+}
+
 }  // namespace
 
-AtomBrowserContext::AtomBrowserContext()
-    : fake_browser_process_(new BrowserProcess),
+AtomBrowserContext::AtomBrowserContext(const std::string& partition,
+                                       bool in_memory)
+    : brightray::BrowserContext(partition, in_memory),
       job_factory_(new AtomURLRequestJobFactory) {
 }
 
 AtomBrowserContext::~AtomBrowserContext() {
 }
 
+std::string AtomBrowserContext::GetUserAgent() {
+  Browser* browser = Browser::Get();
+  std::string name = RemoveWhitespace(browser->GetName());
+  std::string user_agent;
+  if (name == ATOM_PRODUCT_NAME) {
+    user_agent = "Chrome/" CHROME_VERSION_STRING " "
+                 ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING;
+  } else {
+    user_agent = base::StringPrintf(
+        "%s/%s Chrome/%s " ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING,
+        name.c_str(),
+        browser->GetVersion().c_str(),
+        CHROME_VERSION_STRING);
+  }
+  return content::BuildUserAgentFromProduct(user_agent);
+}
+
 net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
     content::ProtocolHandlerMap* handlers,
     content::URLRequestInterceptorScopedVector* interceptors) {
   scoped_ptr<AtomURLRequestJobFactory> job_factory(job_factory_);
 
-  for (content::ProtocolHandlerMap::iterator it = handlers->begin();
-       it != handlers->end(); ++it)
-    job_factory->SetProtocolHandler(it->first, it->second.release());
+  for (auto& it : *handlers) {
+    job_factory->SetProtocolHandler(it.first,
+                                    make_scoped_ptr(it.second.release()));
+  }
   handlers->clear();
 
   job_factory->SetProtocolHandler(
-      url::kDataScheme, new net::DataProtocolHandler);
+      url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler));
   job_factory->SetProtocolHandler(
-      url::kFileScheme, new net::FileProtocolHandler(
+      url::kFileScheme, make_scoped_ptr(new asar::AsarProtocolHandler(
           BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
   job_factory->SetProtocolHandler(
-      kAsarScheme, new asar::AsarProtocolHandler(
-          BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
+      url::kHttpScheme,
+      make_scoped_ptr(new HttpProtocolHandler(url::kHttpScheme)));
+  job_factory->SetProtocolHandler(
+      url::kHttpsScheme,
+      make_scoped_ptr(new HttpProtocolHandler(url::kHttpsScheme)));
+  job_factory->SetProtocolHandler(
+      url::kWsScheme,
+      make_scoped_ptr(new HttpProtocolHandler(url::kWsScheme)));
+  job_factory->SetProtocolHandler(
+      url::kWssScheme,
+      make_scoped_ptr(new HttpProtocolHandler(url::kWssScheme)));
+
+  auto host_resolver =
+      url_request_context_getter()->GetURLRequestContext()->host_resolver();
+  job_factory->SetProtocolHandler(
+      url::kFtpScheme,
+      make_scoped_ptr(new net::FtpProtocolHandler(
+          new net::FtpNetworkLayer(host_resolver))));
 
   // 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(
@@ -89,16 +140,37 @@ AtomBrowserContext::CreateHttpCacheBackendFactory(
     return brightray::BrowserContext::CreateHttpCacheBackendFactory(base_path);
 }
 
+content::DownloadManagerDelegate*
+AtomBrowserContext::GetDownloadManagerDelegate() {
+  if (!download_manager_delegate_.get()) {
+    auto download_manager = content::BrowserContext::GetDownloadManager(this);
+    download_manager_delegate_.reset(
+        new AtomDownloadManagerDelegate(download_manager));
+  }
+  return download_manager_delegate_.get();
+}
+
 content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
   if (!guest_manager_)
-    guest_manager_.reset(new WebViewManager(this));
+    guest_manager_.reset(new WebViewManager);
   return guest_manager_.get();
 }
 
-// static
-AtomBrowserContext* AtomBrowserContext::Get() {
-  return static_cast<AtomBrowserContext*>(
-      AtomBrowserMainParts::Get()->browser_context());
+void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
+  pref_registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory,
+                                      base::FilePath());
+  pref_registry->RegisterFilePathPref(prefs::kDownloadDefaultDirectory,
+                                      base::FilePath());
 }
 
 }  // namespace atom
+
+namespace brightray {
+
+// static
+scoped_refptr<BrowserContext> BrowserContext::Create(
+    const std::string& partition, bool in_memory) {
+  return make_scoped_refptr(new atom::AtomBrowserContext(partition, in_memory));
+}
+
+}  // namespace brightray

atom/browser/atom_browser_context.h

@@ -5,24 +5,23 @@
 #ifndef ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
 #define ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
 
-#include "brightray/browser/browser_context.h"
+#include <string>
 
-class BrowserProcess;
+#include "brightray/browser/browser_context.h"
 
 namespace atom {
 
+class AtomDownloadManagerDelegate;
 class AtomURLRequestJobFactory;
 class WebViewManager;
 
 class AtomBrowserContext : public brightray::BrowserContext {
  public:
-  AtomBrowserContext();
-  virtual ~AtomBrowserContext();
-
-  // Returns the browser context singleton.
-  static AtomBrowserContext* Get();
+  AtomBrowserContext(const std::string& partition, bool in_memory);
+  ~AtomBrowserContext() override;
 
   // brightray::URLRequestContextGetter::Delegate:
+  std::string GetUserAgent() override;
   net::URLRequestJobFactory* CreateURLRequestJobFactory(
       content::ProtocolHandlerMap* handlers,
       content::URLRequestInterceptorScopedVector* interceptors) override;
@@ -30,16 +29,20 @@ class AtomBrowserContext : public brightray::BrowserContext {
       const base::FilePath& base_path) override;
 
   // content::BrowserContext:
+  content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
   content::BrowserPluginGuestManager* GetGuestManager() override;
 
+  // brightray::BrowserContext:
+  void RegisterPrefs(PrefRegistrySimple* pref_registry) override;
+
   AtomURLRequestJobFactory* job_factory() const { return job_factory_; }
 
  private:
-  // A fake BrowserProcess object that used to feed the source code from chrome.
-  scoped_ptr<BrowserProcess> fake_browser_process_;
+  scoped_ptr<AtomDownloadManagerDelegate> download_manager_delegate_;
   scoped_ptr<WebViewManager> guest_manager_;
 
-  AtomURLRequestJobFactory* job_factory_;  // Weak reference.
+  // Managed by brightray::BrowserContext.
+  AtomURLRequestJobFactory* job_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
 };

atom/browser/atom_browser_main_parts.cc

@@ -4,29 +4,33 @@
 
 #include "atom/browser/atom_browser_main_parts.h"
 
+#include "atom/browser/api/trackable_object.h"
 #include "atom/browser/atom_browser_client.h"
 #include "atom/browser/atom_browser_context.h"
+#include "atom/browser/bridge_task_runner.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/javascript_environment.h"
 #include "atom/browser/node_debugger.h"
 #include "atom/common/api/atom_bindings.h"
 #include "atom/common/node_bindings.h"
+#include "atom/common/node_includes.h"
 #include "base/command_line.h"
+#include "base/thread_task_runner_handle.h"
+#include "chrome/browser/browser_process.h"
 #include "v8/include/v8-debug.h"
 
 #if defined(USE_X11)
 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
 #endif
 
-#include "atom/common/node_includes.h"
-
 namespace atom {
 
 // static
 AtomBrowserMainParts* AtomBrowserMainParts::self_ = NULL;
 
 AtomBrowserMainParts::AtomBrowserMainParts()
-    : browser_(new Browser),
+    : fake_browser_process_(new BrowserProcess),
+      browser_(new Browser),
       node_bindings_(NodeBindings::Create(true)),
       atom_bindings_(new AtomBindings),
       gc_timer_(true, true) {
@@ -43,8 +47,9 @@ AtomBrowserMainParts* AtomBrowserMainParts::Get() {
   return self_;
 }
 
-brightray::BrowserContext* AtomBrowserMainParts::CreateBrowserContext() {
-  return new AtomBrowserContext();
+void AtomBrowserMainParts::RegisterDestructionCallback(
+    const base::Closure& callback) {
+  destruction_callbacks_.push_back(callback);
 }
 
 void AtomBrowserMainParts::PostEarlyInitialization() {
@@ -54,9 +59,17 @@ void AtomBrowserMainParts::PostEarlyInitialization() {
   SetDPIFromGSettings();
 #endif
 
-  // The ProxyResolverV8 has setup a complete V8 environment, in order to avoid
-  // conflicts we only initialize our V8 environment after that.
-  js_env_.reset(new JavascriptEnvironment);
+  {
+    // Temporary set the bridge_task_runner_ as current thread's task runner,
+    // so we can fool gin::PerIsolateData to use it as its task runner, instead
+    // of getting current message loop's task runner, which is null for now.
+    bridge_task_runner_ = new BridgeTaskRunner;
+    base::ThreadTaskRunnerHandle handle(bridge_task_runner_);
+
+    // The ProxyResolverV8 has setup a complete V8 environment, in order to
+    // avoid conflicts we only initialize our V8 environment after that.
+    js_env_.reset(new JavascriptEnvironment);
+  }
 
   node_bindings_->Initialize();
 
@@ -72,6 +85,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 +106,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)
@@ -100,4 +116,14 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
 #endif
 }
 
+void AtomBrowserMainParts::PostMainMessageLoopRun() {
+  brightray::BrowserMainParts::PostMainMessageLoopRun();
+
+  // Make sure destruction callbacks are called before message loop is
+  // destroyed, otherwise some objects that need to be deleted on IO thread
+  // won't be freed.
+  for (const auto& callback : destruction_callbacks_)
+    callback.Run();
+}
+
 }  // namespace atom

atom/browser/atom_browser_main_parts.h

@@ -5,8 +5,15 @@
 #ifndef ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
 #define ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
 
+#include <list>
+#include <string>
+
+#include "base/callback.h"
 #include "base/timer/timer.h"
 #include "brightray/browser/browser_main_parts.h"
+#include "content/public/browser/browser_context.h"
+
+class BrowserProcess;
 
 namespace atom {
 
@@ -15,6 +22,7 @@ class Browser;
 class JavascriptEnvironment;
 class NodeBindings;
 class NodeDebugger;
+class BridgeTaskRunner;
 
 class AtomBrowserMainParts : public brightray::BrowserMainParts {
  public:
@@ -23,18 +31,20 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 
   static AtomBrowserMainParts* Get();
 
+  // Register a callback that should be destroyed before JavaScript environment
+  // gets destroyed.
+  void RegisterDestructionCallback(const base::Closure& callback);
+
   Browser* browser() { return browser_.get(); }
 
  protected:
-  // Implementations of brightray::BrowserMainParts.
-  virtual brightray::BrowserContext* CreateBrowserContext() OVERRIDE;
-
-  // Implementations of content::BrowserMainParts.
-  virtual void PostEarlyInitialization() OVERRIDE;
-  virtual void PreMainMessageLoopRun() OVERRIDE;
+  // content::BrowserMainParts:
+  void PostEarlyInitialization() override;
+  void PreMainMessageLoopRun() override;
+  void PostMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
-  virtual void PreMainMessageLoopStart() OVERRIDE;
-  virtual void PostDestroyThreads() OVERRIDE;
+  void PreMainMessageLoopStart() override;
+  void PostDestroyThreads() override;
 #endif
 
  private:
@@ -42,6 +52,13 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   void SetDPIFromGSettings();
 #endif
 
+  // A fake BrowserProcess object that used to feed the source code from chrome.
+  scoped_ptr<BrowserProcess> fake_browser_process_;
+
+  // The gin::PerIsolateData requires a task runner to create, so we feed it
+  // with a task runner that will post all work to main loop.
+  scoped_refptr<BridgeTaskRunner> bridge_task_runner_;
+
   scoped_ptr<Browser> browser_;
   scoped_ptr<JavascriptEnvironment> js_env_;
   scoped_ptr<NodeBindings> node_bindings_;
@@ -50,6 +67,9 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 
   base::Timer gc_timer_;
 
+  // List of callbacks should be executed before destroying JS env.
+  std::list<base::Closure> destruction_callbacks_;
+
   static AtomBrowserMainParts* self_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserMainParts);

atom/browser/atom_browser_main_parts_linux.cc

@@ -4,9 +4,10 @@
 
 #include "atom/browser/atom_browser_main_parts.h"
 
+#include <gio/gio.h>
+
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
-#include "library_loaders/libgio.h"
 #include "ui/gfx/switches.h"
 
 namespace atom {
@@ -16,8 +17,8 @@ namespace {
 const char* kInterfaceSchema = "org.gnome.desktop.interface";
 const char* kScaleFactor = "scaling-factor";
 
-bool SchemaExists(const LibGioLoader& libgio_loader, const char* schema_name) {
-  const gchar* const* schemas = libgio_loader.g_settings_list_schemas();
+bool SchemaExists(const char* schema_name) {
+  const gchar* const* schemas = g_settings_list_schemas();
   while (*schemas) {
     if (strcmp(schema_name, static_cast<const char*>(*schemas)) == 0)
       return true;
@@ -26,9 +27,8 @@ bool SchemaExists(const LibGioLoader& libgio_loader, const char* schema_name) {
   return false;
 }
 
-bool KeyExists(const LibGioLoader& libgio_loader, GSettings* client,
-               const char* key) {
-  gchar** keys = libgio_loader.g_settings_list_keys(client);
+bool KeyExists(GSettings* client, const char* key) {
+  gchar** keys = g_settings_list_keys(client);
   if (!keys)
     return false;
 
@@ -45,24 +45,15 @@ bool KeyExists(const LibGioLoader& libgio_loader, GSettings* client,
 }
 
 void GetDPIFromGSettings(guint* scale_factor) {
-  LibGioLoader libgio_loader;
-
-  // Try also without .0 at the end; on some systems this may be required.
-  if (!libgio_loader.Load("libgio-2.0.so.0") &&
-      !libgio_loader.Load("libgio-2.0.so")) {
-    VLOG(1) << "Cannot load gio library. Will fall back to gconf.";
-    return;
-  }
-
   GSettings* client = nullptr;
-  if (!SchemaExists(libgio_loader, kInterfaceSchema) ||
-      !(client = libgio_loader.g_settings_new(kInterfaceSchema))) {
+  if (!SchemaExists(kInterfaceSchema) ||
+      !(client = g_settings_new(kInterfaceSchema))) {
     VLOG(1) << "Cannot create gsettings client.";
     return;
   }
 
-  if (KeyExists(libgio_loader, client, kScaleFactor))
-    *scale_factor = libgio_loader.g_settings_get_uint(client, kScaleFactor);
+  if (KeyExists(client, kScaleFactor))
+    *scale_factor = g_settings_get_uint(client, kScaleFactor);
 
   g_object_unref(client);
 }

atom/browser/atom_browser_main_parts_mac.mm

@@ -4,12 +4,11 @@
 
 #include "atom/browser/atom_browser_main_parts.h"
 
-#import "atom/browser/mac/atom_application.h"
-#import "atom/browser/mac/atom_application_delegate.h"
-#include "base/files/file_path.h"
-#import "base/mac/foundation_util.h"
+#include "atom/browser/mac/atom_application.h"
+#include "atom/browser/mac/atom_application_delegate.h"
+#include "base/mac/bundle_locations.h"
+#include "base/mac/foundation_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
-#import "vendor/brightray/common/mac/main_application_bundle.h"
 
 namespace atom {
 
@@ -23,12 +22,7 @@ void AtomBrowserMainParts::PreMainMessageLoopStart() {
   AtomApplicationDelegate* delegate = [[AtomApplicationDelegate alloc] init];
   [NSApp setDelegate:(id<NSFileManagerDelegate>)delegate];
 
-  base::FilePath frameworkPath = brightray::MainApplicationBundlePath()
-      .Append("Contents")
-      .Append("Frameworks")
-      .Append(PRODUCT_NAME " Framework.framework");
-  NSBundle* frameworkBundle = [NSBundle
-       bundleWithPath:base::mac::FilePathToNSString(frameworkPath)];
+  NSBundle* frameworkBundle = base::mac::FrameworkBundle();
   NSNib* mainNib = [[NSNib alloc] initWithNibNamed:@"MainMenu"
                                             bundle:frameworkBundle];
   [mainNib instantiateWithOwner:application topLevelObjects:nil];

atom/browser/atom_download_manager_delegate.cc

@@ -0,0 +1,151 @@
+// 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/atom_download_manager_delegate.h"
+
+#include <string>
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/ui/file_dialog.h"
+#include "base/bind.h"
+#include "base/files/file_util.h"
+#include "base/prefs/pref_service.h"
+#include "chrome/common/pref_names.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/download_manager.h"
+#include "net/base/filename_util.h"
+
+namespace atom {
+
+AtomDownloadManagerDelegate::AtomDownloadManagerDelegate(
+    content::DownloadManager* manager)
+    : download_manager_(manager),
+      weak_ptr_factory_(this) {}
+
+AtomDownloadManagerDelegate::~AtomDownloadManagerDelegate() {
+  if (download_manager_) {
+    DCHECK_EQ(static_cast<content::DownloadManagerDelegate*>(this),
+              download_manager_->GetDelegate());
+    download_manager_->SetDelegate(nullptr);
+    download_manager_ = nullptr;
+  }
+}
+
+void AtomDownloadManagerDelegate::CreateDownloadPath(
+    const GURL& url,
+    const std::string& content_disposition,
+    const std::string& suggested_filename,
+    const std::string& mime_type,
+    const base::FilePath& default_download_path,
+    const CreateDownloadPathCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+
+  auto generated_name = net::GenerateFileName(url,
+                                              content_disposition,
+                                              std::string(),
+                                              suggested_filename,
+                                              mime_type,
+                                              std::string());
+
+  if (!base::PathExists(default_download_path))
+    base::CreateDirectory(default_download_path);
+
+  base::FilePath path(default_download_path.Append(generated_name));
+  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+                                   base::Bind(callback, path));
+}
+
+void AtomDownloadManagerDelegate::OnDownloadPathGenerated(
+    uint32 download_id,
+    const content::DownloadTargetCallback& callback,
+    const base::FilePath& default_path) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  auto item = download_manager_->GetDownload(download_id);
+  if (!item)
+    return;
+
+  NativeWindow* window = nullptr;
+  auto relay = NativeWindowRelay::FromWebContents(item->GetWebContents());
+  if (relay)
+    window = relay->window.get();
+
+  file_dialog::Filters filters;
+  base::FilePath path;
+  if (!file_dialog::ShowSaveDialog(window, item->GetURL().spec(), default_path,
+                                   filters, &path)) {
+    return;
+  }
+
+  // Remeber the last selected download directory.
+  AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
+      download_manager_->GetBrowserContext());
+  browser_context->prefs()->SetFilePath(prefs::kDownloadDefaultDirectory,
+                                        path.DirName());
+  callback.Run(path,
+               content::DownloadItem::TARGET_DISPOSITION_PROMPT,
+               content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, path);
+}
+
+void AtomDownloadManagerDelegate::Shutdown() {
+  weak_ptr_factory_.InvalidateWeakPtrs();
+  download_manager_ = nullptr;
+}
+
+bool AtomDownloadManagerDelegate::DetermineDownloadTarget(
+    content::DownloadItem* download,
+    const content::DownloadTargetCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  AtomBrowserContext* browser_context = static_cast<AtomBrowserContext*>(
+      download_manager_->GetBrowserContext());
+  base::FilePath default_download_path = browser_context->prefs()->GetFilePath(
+      prefs::kDownloadDefaultDirectory);
+  // If users didn't set download path, use 'Downloads' directory by default.
+  if (default_download_path.empty()) {
+    auto path = download_manager_->GetBrowserContext()->GetPath();
+    default_download_path = path.Append(FILE_PATH_LITERAL("Downloads"));
+  }
+
+  if (!download->GetForcedFilePath().empty()) {
+    callback.Run(download->GetForcedFilePath(),
+                 content::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+                 content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+                 download->GetForcedFilePath());
+    return true;
+  }
+
+  CreateDownloadPathCallback download_path_callback =
+      base::Bind(&AtomDownloadManagerDelegate::OnDownloadPathGenerated,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 download->GetId(), callback);
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(&AtomDownloadManagerDelegate::CreateDownloadPath,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 download->GetURL(),
+                 download->GetContentDisposition(),
+                 download->GetSuggestedFilename(),
+                 download->GetMimeType(),
+                 default_download_path,
+                 download_path_callback));
+  return true;
+}
+
+bool AtomDownloadManagerDelegate::ShouldOpenDownload(
+    content::DownloadItem* download,
+    const content::DownloadOpenDelayedCallback& callback) {
+  return true;
+}
+
+void AtomDownloadManagerDelegate::GetNextId(
+    const content::DownloadIdCallback& callback) {
+  static uint32 next_id = content::DownloadItem::kInvalidId + 1;
+  callback.Run(next_id++);
+}
+
+}  // namespace atom

atom/browser/atom_download_manager_delegate.h

@@ -0,0 +1,57 @@
+// 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_ATOM_DOWNLOAD_MANAGER_DELEGATE_H_
+#define ATOM_BROWSER_ATOM_DOWNLOAD_MANAGER_DELEGATE_H_
+
+#include <string>
+
+#include "base/memory/weak_ptr.h"
+#include "content/public/browser/download_manager_delegate.h"
+
+namespace content {
+class DownloadManager;
+}
+
+namespace atom {
+
+class AtomDownloadManagerDelegate : public content::DownloadManagerDelegate {
+ public:
+  using CreateDownloadPathCallback =
+      base::Callback<void(const base::FilePath&)>;
+
+  explicit AtomDownloadManagerDelegate(content::DownloadManager* manager);
+  virtual ~AtomDownloadManagerDelegate();
+
+  // Generate default file path to save the download.
+  void CreateDownloadPath(const GURL& url,
+                          const std::string& suggested_filename,
+                          const std::string& content_disposition,
+                          const std::string& mime_type,
+                          const base::FilePath& path,
+                          const CreateDownloadPathCallback& callback);
+  void OnDownloadPathGenerated(uint32 download_id,
+                               const content::DownloadTargetCallback& callback,
+                               const base::FilePath& default_path);
+
+  // content::DownloadManagerDelegate:
+  void Shutdown() override;
+  bool DetermineDownloadTarget(
+      content::DownloadItem* download,
+      const content::DownloadTargetCallback& callback) override;
+  bool ShouldOpenDownload(
+      content::DownloadItem* download,
+      const content::DownloadOpenDelayedCallback& callback) override;
+  void GetNextId(const content::DownloadIdCallback& callback) override;
+
+ private:
+  content::DownloadManager* download_manager_;
+  base::WeakPtrFactory<AtomDownloadManagerDelegate> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomDownloadManagerDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_DOWNLOAD_MANAGER_DELEGATE_H_

atom/browser/atom_javascript_dialog_manager.cc

@@ -27,7 +27,6 @@ void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(
     const base::string16& message_text,
     bool is_reload,
     const DialogClosedCallback& callback) {
-
   bool prevent_reload = message_text.empty() ||
                         message_text == base::ASCIIToUTF16("false");
   callback.Run(!prevent_reload, message_text);

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 ResetDialogState(content::WebContents* web_contents) override {};
 };
 
 }  // namespace atom

atom/browser/atom_quota_permission_context.cc

@@ -0,0 +1,24 @@
+// 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/atom_quota_permission_context.h"
+
+#include "storage/common/quota/quota_types.h"
+
+namespace atom {
+
+AtomQuotaPermissionContext::AtomQuotaPermissionContext() {
+}
+
+AtomQuotaPermissionContext::~AtomQuotaPermissionContext() {
+}
+
+void AtomQuotaPermissionContext::RequestQuotaPermission(
+    const content::StorageQuotaParams& params,
+    int render_process_id,
+    const PermissionCallback& callback) {
+  callback.Run(response::QUOTA_PERMISSION_RESPONSE_ALLOW);
+}
+
+}  // namespace atom

atom/browser/atom_quota_permission_context.h

@@ -0,0 +1,31 @@
+// 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_ATOM_QUOTA_PERMISSION_CONTEXT_H_
+#define ATOM_BROWSER_ATOM_QUOTA_PERMISSION_CONTEXT_H_
+
+#include "content/public/browser/quota_permission_context.h"
+
+namespace atom {
+
+class AtomQuotaPermissionContext : public content::QuotaPermissionContext {
+ public:
+  typedef content::QuotaPermissionContext::QuotaPermissionResponse response;
+
+  AtomQuotaPermissionContext();
+  virtual ~AtomQuotaPermissionContext();
+
+  // content::QuotaPermissionContext:
+  void RequestQuotaPermission(
+      const content::StorageQuotaParams& params,
+      int render_process_id,
+      const PermissionCallback& callback) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AtomQuotaPermissionContext);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_QUOTA_PERMISSION_CONTEXT_H_

atom/browser/auto_updater_mac.mm

@@ -36,15 +36,21 @@ void RelaunchToInstallUpdate() {
 // static
 void AutoUpdater::SetFeedURL(const std::string& feed) {
   if (g_updater == nil) {
-    // Initialize the SQRLUpdater.
-    NSURL* url = [NSURL URLWithString:base::SysUTF8ToNSString(feed)];
-    NSURLRequest* urlRequest = [NSURLRequest requestWithURL:url];
-    g_updater = [[SQRLUpdater alloc] initWithUpdateRequest:urlRequest];
-
     AutoUpdaterDelegate* delegate = GetDelegate();
     if (!delegate)
       return;
 
+    // Initialize the SQRLUpdater.
+    NSURL* url = [NSURL URLWithString:base::SysUTF8ToNSString(feed)];
+    NSURLRequest* urlRequest = [NSURLRequest requestWithURL:url];
+
+    @try {
+      g_updater = [[SQRLUpdater alloc] initWithUpdateRequest:urlRequest];
+    } @catch (NSException* error) {
+      delegate->OnError(base::SysNSStringToUTF8(error.reason));
+      return;
+    }
+
     [[g_updater rac_valuesForKeyPath:@"state" observer:g_updater]
       subscribeNext:^(NSNumber *stateNumber) {
         int state = [stateNumber integerValue];
@@ -88,7 +94,9 @@ void AutoUpdater::CheckForUpdates() {
           delegate->OnUpdateNotAvailable();
         }
       } error:^(NSError *error) {
-        delegate->OnError(base::SysNSStringToUTF8(error.localizedDescription));
+        delegate->OnError(base::SysNSStringToUTF8(
+            [NSString stringWithFormat:@"%@: %@",
+                error.localizedDescription, error.localizedFailureReason]));
       }];
 }
 

atom/browser/bridge_task_runner.cc

@@ -0,0 +1,42 @@
+// 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/bridge_task_runner.h"
+
+#include "base/message_loop/message_loop.h"
+
+namespace atom {
+
+bool BridgeTaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  auto message_loop = base::MessageLoop::current();
+  if (!message_loop)
+    return false;
+
+  return message_loop->task_runner()->PostDelayedTask(from_here, task, delay);
+}
+
+bool BridgeTaskRunner::RunsTasksOnCurrentThread() const {
+  auto message_loop = base::MessageLoop::current();
+  if (!message_loop)
+    return false;
+
+  return message_loop->task_runner()->RunsTasksOnCurrentThread();
+}
+
+bool BridgeTaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  auto message_loop = base::MessageLoop::current();
+  if (!message_loop)
+    return false;
+
+  return message_loop->task_runner()->PostNonNestableDelayedTask(
+      from_here, task, delay);
+}
+
+}  // namespace atom

atom/browser/bridge_task_runner.h

@@ -0,0 +1,35 @@
+// 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_BRIDGE_TASK_RUNNER_H_
+#define ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_
+
+#include "base/single_thread_task_runner.h"
+
+namespace atom {
+
+// Post all tasks to the current message loop's task runner if available,
+// otherwise fail silently.
+class BridgeTaskRunner : public base::SingleThreadTaskRunner {
+ public:
+  BridgeTaskRunner() {}
+  ~BridgeTaskRunner() override {}
+
+  // base::SingleThreadTaskRunner:
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const base::Closure& task,
+                       base::TimeDelta delay) override;
+  bool RunsTasksOnCurrentThread() const override;
+  bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      base::TimeDelta delay) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BridgeTaskRunner);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_BRIDGE_TASK_RUNNER_H_

atom/browser/browser.cc

@@ -9,6 +9,8 @@
 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/window_list.h"
 #include "base/message_loop/message_loop.h"
+#include "content/public/browser/client_certificate_delegate.h"
+#include "net/ssl/ssl_cert_request_info.h"
 
 namespace atom {
 
@@ -28,7 +30,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)
@@ -41,7 +45,8 @@ void Browser::Shutdown() {
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnQuit());
 
   is_quiting_ = true;
-  base::MessageLoop::current()->Quit();
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 std::string Browser::GetVersion() const {
@@ -102,6 +107,17 @@ void Browser::DidFinishLaunching() {
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnFinishLaunching());
 }
 
+void Browser::ClientCertificateSelector(
+    content::WebContents* web_contents,
+    net::SSLCertRequestInfo* cert_request_info,
+    scoped_ptr<content::ClientCertificateDelegate> delegate) {
+  FOR_EACH_OBSERVER(BrowserObserver,
+                    observers_,
+                    OnSelectCertificate(web_contents,
+                                        cert_request_info,
+                                        delegate.Pass()));
+}
+
 void Browser::NotifyAndShutdown() {
   bool prevent_default = false;
   FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWillQuit(&prevent_default));
@@ -114,6 +130,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

atom/browser/browser.h

@@ -115,6 +115,12 @@ class Browser : public WindowListObserver {
   void WillFinishLaunching();
   void DidFinishLaunching();
 
+  // Called when client certificate is required.
+  void ClientCertificateSelector(
+      content::WebContents* web_contents,
+      net::SSLCertRequestInfo* cert_request_info,
+      scoped_ptr<content::ClientCertificateDelegate> delegate);
+
   void AddObserver(BrowserObserver* obs) {
     observers_.AddObserver(obs);
   }
@@ -136,6 +142,9 @@ 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:
@@ -144,7 +153,7 @@ class Browser : public WindowListObserver {
   void OnWindowAllClosed() override;
 
   // Observers of the browser.
-  ObserverList<BrowserObserver> observers_;
+  base::ObserverList<BrowserObserver> observers_;
 
   // Whether "ready" event has been emitted.
   bool is_ready_;

atom/browser/browser_linux.cc

@@ -9,6 +9,7 @@
 #include "atom/browser/native_window.h"
 #include "atom/browser/window_list.h"
 #include "atom/common/atom_version.h"
+#include "brightray/common/application_info.h"
 
 namespace atom {
 
@@ -31,11 +32,11 @@ void Browser::ClearRecentDocuments() {
 }
 
 std::string Browser::GetExecutableFileVersion() const {
-  return ATOM_VERSION_STRING;
+  return brightray::GetApplicationVersion();
 }
 
 std::string Browser::GetExecutableFileProductName() const {
-  return "Atom-Shell";
+  return brightray::GetApplicationName();
 }
 
 }  // namespace atom

atom/browser/browser_mac.mm

@@ -4,13 +4,13 @@
 
 #include "atom/browser/browser.h"
 
-#import "atom/browser/mac/atom_application.h"
-#import "atom/browser/mac/atom_application_delegate.h"
+#include "atom/browser/mac/atom_application.h"
+#include "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/mac/foundation_util.h"
 #include "base/strings/sys_string_conversions.h"
+#include "brightray/common/application_info.h"
 
 namespace atom {
 
@@ -27,15 +27,11 @@ void Browser::ClearRecentDocuments() {
 }
 
 std::string Browser::GetExecutableFileVersion() const {
-  NSDictionary* infoDictionary = base::mac::OuterBundle().infoDictionary;
-  NSString *version = [infoDictionary objectForKey:@"CFBundleVersion"];
-  return base::SysNSStringToUTF8(version);
+  return brightray::GetApplicationVersion();
 }
 
 std::string Browser::GetExecutableFileProductName() const {
-  NSDictionary* infoDictionary = base::mac::OuterBundle().infoDictionary;
-  NSString *version = [infoDictionary objectForKey:@"CFBundleName"];
-  return base::SysNSStringToUTF8(version);
+  return brightray::GetApplicationName();
 }
 
 int Browser::DockBounce(BounceType type) {

atom/browser/browser_observer.h

@@ -7,10 +7,24 @@
 
 #include <string>
 
+#include "base/memory/scoped_ptr.h"
+#include "content/public/browser/client_certificate_delegate.h"
+
+namespace content {
+class WebContents;
+}
+
+namespace net {
+class SSLCertRequestInfo;
+}
+
 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) {}
 
@@ -37,6 +51,12 @@ class BrowserObserver {
   virtual void OnWillFinishLaunching() {}
   virtual void OnFinishLaunching() {}
 
+  // The browser requires client certificate.
+  virtual void OnSelectCertificate(
+      content::WebContents* web_contents,
+      net::SSLCertRequestInfo* cert_request_info,
+      scoped_ptr<content::ClientCertificateDelegate> delegate) {}
+
  protected:
   virtual ~BrowserObserver() {}
 };

atom/browser/browser_win.cc

@@ -118,7 +118,7 @@ void Browser::SetUserTasks(const std::vector<UserTask>& tasks) {
 }
 
 void Browser::SetAppUserModelID(const std::string& name) {
-  app_user_model_id_ = base::string16(L"atom-shell.app.");
+  app_user_model_id_ = base::string16(L"electron.app.");
   app_user_model_id_ += base::UTF8ToUTF16(name);
   SetCurrentProcessExplicitAppUserModelID(app_user_model_id_.c_str());
 }
@@ -142,7 +142,7 @@ std::string Browser::GetExecutableFileProductName() const {
     return base::UTF16ToUTF8(version_info->product_name());
   }
 
-  return "Atom-Shell";
+  return ATOM_PRODUCT_NAME;
 }
 
 }  // namespace atom

atom/browser/common_web_contents_delegate.cc

@@ -0,0 +1,377 @@
+// 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/common_web_contents_delegate.h"
+
+#include <string>
+#include <vector>
+
+#include "atom/browser/atom_javascript_dialog_manager.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/ui/file_dialog.h"
+#include "atom/browser/web_dialog_helper.h"
+#include "base/files/file_util.h"
+#include "chrome/browser/printing/print_preview_message_handler.h"
+#include "chrome/browser/printing/print_view_manager_basic.h"
+#include "chrome/browser/ui/browser_dialogs.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_security_policy.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "storage/browser/fileapi/isolated_context.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+struct FileSystem {
+  FileSystem() {
+  }
+  FileSystem(const std::string& file_system_name,
+             const std::string& root_url,
+             const std::string& file_system_path)
+    : file_system_name(file_system_name),
+      root_url(root_url),
+      file_system_path(file_system_path) {
+  }
+
+  std::string file_system_name;
+  std::string root_url;
+  std::string file_system_path;
+};
+
+std::string RegisterFileSystem(content::WebContents* web_contents,
+                               const base::FilePath& path,
+                               std::string* registered_name) {
+  auto isolated_context = storage::IsolatedContext::GetInstance();
+  std::string file_system_id = isolated_context->RegisterFileSystemForPath(
+      storage::kFileSystemTypeNativeLocal,
+      std::string(),
+      path,
+      registered_name);
+
+  content::ChildProcessSecurityPolicy* policy =
+      content::ChildProcessSecurityPolicy::GetInstance();
+  content::RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
+  int renderer_id = render_view_host->GetProcess()->GetID();
+  policy->GrantReadFileSystem(renderer_id, file_system_id);
+  policy->GrantWriteFileSystem(renderer_id, file_system_id);
+  policy->GrantCreateFileForFileSystem(renderer_id, file_system_id);
+  policy->GrantDeleteFromFileSystem(renderer_id, file_system_id);
+
+  if (!policy->CanReadFile(renderer_id, path))
+    policy->GrantReadFile(renderer_id, path);
+
+  return file_system_id;
+}
+
+FileSystem CreateFileSystemStruct(
+    content::WebContents* web_contents,
+    const std::string& file_system_id,
+    const std::string& registered_name,
+    const std::string& file_system_path) {
+  const GURL origin = web_contents->GetURL().GetOrigin();
+  std::string file_system_name =
+      storage::GetIsolatedFileSystemName(origin, file_system_id);
+  std::string root_url = storage::GetIsolatedFileSystemRootURIString(
+      origin, file_system_id, registered_name);
+  return FileSystem(file_system_name, root_url, file_system_path);
+}
+
+base::DictionaryValue* CreateFileSystemValue(const FileSystem& file_system) {
+  base::DictionaryValue* file_system_value = new base::DictionaryValue();
+  file_system_value->SetString("fileSystemName", file_system.file_system_name);
+  file_system_value->SetString("rootURL", file_system.root_url);
+  file_system_value->SetString("fileSystemPath", file_system.file_system_path);
+  return file_system_value;
+}
+
+void WriteToFile(const base::FilePath& path,
+                 const std::string& content) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(!path.empty());
+
+  base::WriteFile(path, content.data(), content.size());
+}
+
+void AppendToFile(const base::FilePath& path,
+                  const std::string& content) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(!path.empty());
+
+  base::AppendToFile(path, content.data(), content.size());
+}
+
+}  // namespace
+
+CommonWebContentsDelegate::CommonWebContentsDelegate()
+    : html_fullscreen_(false),
+      native_fullscreen_(false) {
+}
+
+CommonWebContentsDelegate::~CommonWebContentsDelegate() {
+}
+
+void CommonWebContentsDelegate::InitWithWebContents(
+    content::WebContents* web_contents) {
+  web_contents->SetDelegate(this);
+
+  printing::PrintViewManagerBasic::CreateForWebContents(web_contents);
+  printing::PrintPreviewMessageHandler::CreateForWebContents(web_contents);
+
+  // Create InspectableWebContents.
+  web_contents_.reset(brightray::InspectableWebContents::Create(web_contents));
+  web_contents_->SetDelegate(this);
+}
+
+void CommonWebContentsDelegate::SetOwnerWindow(NativeWindow* owner_window) {
+  content::WebContents* web_contents = GetWebContents();
+  owner_window_ = owner_window->GetWeakPtr();
+  NativeWindowRelay* relay = new NativeWindowRelay(owner_window_);
+  web_contents->SetUserData(relay->key, relay);
+}
+
+void CommonWebContentsDelegate::DestroyWebContents() {
+  web_contents_.reset();
+}
+
+content::WebContents* CommonWebContentsDelegate::GetWebContents() const {
+  if (!web_contents_)
+    return nullptr;
+  return web_contents_->GetWebContents();
+}
+
+content::WebContents*
+CommonWebContentsDelegate::GetDevToolsWebContents() const {
+  if (!web_contents_)
+    return nullptr;
+  return web_contents_->GetDevToolsWebContents();
+}
+
+content::WebContents* CommonWebContentsDelegate::OpenURLFromTab(
+    content::WebContents* source,
+    const content::OpenURLParams& params) {
+  content::NavigationController::LoadURLParams load_url_params(params.url);
+  load_url_params.referrer = params.referrer;
+  load_url_params.transition_type = params.transition;
+  load_url_params.extra_headers = params.extra_headers;
+  load_url_params.should_replace_current_entry =
+      params.should_replace_current_entry;
+  load_url_params.is_renderer_initiated = params.is_renderer_initiated;
+  load_url_params.transferred_global_request_id =
+      params.transferred_global_request_id;
+  load_url_params.should_clear_history_list = true;
+
+  source->GetController().LoadURLWithParams(load_url_params);
+  return source;
+}
+
+void CommonWebContentsDelegate::RequestToLockMouse(
+    content::WebContents* web_contents,
+    bool user_gesture,
+    bool last_unlocked_by_target) {
+  GetWebContents()->GotResponseToLockMouseRequest(true);
+}
+
+bool CommonWebContentsDelegate::CanOverscrollContent() const {
+  return false;
+}
+
+content::JavaScriptDialogManager*
+CommonWebContentsDelegate::GetJavaScriptDialogManager(
+    content::WebContents* source) {
+  if (!dialog_manager_)
+    dialog_manager_.reset(new AtomJavaScriptDialogManager);
+
+  return dialog_manager_.get();
+}
+
+content::ColorChooser* CommonWebContentsDelegate::OpenColorChooser(
+    content::WebContents* web_contents,
+    SkColor color,
+    const std::vector<content::ColorSuggestion>& suggestions) {
+  return chrome::ShowColorChooser(web_contents, color);
+}
+
+void CommonWebContentsDelegate::RunFileChooser(
+    content::WebContents* guest,
+    const content::FileChooserParams& params) {
+  if (!web_dialog_helper_)
+    web_dialog_helper_.reset(new WebDialogHelper(owner_window()));
+  web_dialog_helper_->RunFileChooser(guest, params);
+}
+
+void CommonWebContentsDelegate::EnumerateDirectory(content::WebContents* guest,
+                                                   int request_id,
+                                                   const base::FilePath& path) {
+  if (!web_dialog_helper_)
+    web_dialog_helper_.reset(new WebDialogHelper(owner_window()));
+  web_dialog_helper_->EnumerateDirectory(guest, request_id, path);
+}
+
+void CommonWebContentsDelegate::EnterFullscreenModeForTab(
+    content::WebContents* source, const GURL& origin) {
+  if (!owner_window_)
+    return;
+  SetHtmlApiFullscreen(true);
+  owner_window_->NotifyWindowEnterHtmlFullScreen();
+  source->GetRenderViewHost()->WasResized();
+}
+
+void CommonWebContentsDelegate::ExitFullscreenModeForTab(
+    content::WebContents* source) {
+  if (!owner_window_)
+    return;
+  SetHtmlApiFullscreen(false);
+  owner_window_->NotifyWindowLeaveHtmlFullScreen();
+  source->GetRenderViewHost()->WasResized();
+}
+
+bool CommonWebContentsDelegate::IsFullscreenForTabOrPending(
+    const content::WebContents* source) const {
+  return html_fullscreen_;
+}
+
+void CommonWebContentsDelegate::DevToolsSaveToFile(
+    const std::string& url, const std::string& content, bool save_as) {
+  base::FilePath path;
+  PathsMap::iterator it = saved_files_.find(url);
+  if (it != saved_files_.end() && !save_as) {
+    path = it->second;
+  } else {
+    file_dialog::Filters filters;
+    base::FilePath default_path(base::FilePath::FromUTF8Unsafe(url));
+    if (!file_dialog::ShowSaveDialog(owner_window(), url, default_path,
+                                     filters, &path)) {
+      base::StringValue url_value(url);
+      web_contents_->CallClientFunction(
+          "DevToolsAPI.canceledSaveURL", &url_value, nullptr, nullptr);
+      return;
+    }
+  }
+
+  saved_files_[url] = path;
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&WriteToFile, path, content),
+      base::Bind(&CommonWebContentsDelegate::OnDevToolsSaveToFile,
+                 base::Unretained(this), url));
+}
+
+void CommonWebContentsDelegate::DevToolsAppendToFile(
+    const std::string& url, const std::string& content) {
+  PathsMap::iterator it = saved_files_.find(url);
+  if (it == saved_files_.end())
+    return;
+
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&AppendToFile, it->second, content),
+      base::Bind(&CommonWebContentsDelegate::OnDevToolsAppendToFile,
+                 base::Unretained(this), url));
+}
+
+void CommonWebContentsDelegate::DevToolsAddFileSystem(
+    const base::FilePath& file_system_path) {
+  base::FilePath path = file_system_path;
+  if (path.empty()) {
+    file_dialog::Filters filters;
+    base::FilePath default_path;
+    std::vector<base::FilePath> paths;
+    int flag = file_dialog::FILE_DIALOG_OPEN_DIRECTORY;
+    if (!file_dialog::ShowOpenDialog(owner_window(), "", default_path,
+                                     filters, flag, &paths))
+      return;
+
+    path = paths[0];
+  }
+
+  std::string registered_name;
+  std::string file_system_id = RegisterFileSystem(GetDevToolsWebContents(),
+                                                  path,
+                                                  &registered_name);
+
+  WorkspaceMap::iterator it = saved_paths_.find(file_system_id);
+  if (it != saved_paths_.end())
+    return;
+
+  saved_paths_[file_system_id] = path;
+
+  FileSystem file_system = CreateFileSystemStruct(GetDevToolsWebContents(),
+                                                  file_system_id,
+                                                  registered_name,
+                                                  path.AsUTF8Unsafe());
+
+  scoped_ptr<base::StringValue> error_string_value(
+      new base::StringValue(std::string()));
+  scoped_ptr<base::DictionaryValue> file_system_value;
+  if (!file_system.file_system_path.empty())
+    file_system_value.reset(CreateFileSystemValue(file_system));
+  web_contents_->CallClientFunction(
+      "DevToolsAPI.fileSystemAdded",
+      error_string_value.get(),
+      file_system_value.get(),
+      nullptr);
+}
+
+void CommonWebContentsDelegate::DevToolsRemoveFileSystem(
+    const base::FilePath& file_system_path) {
+  if (!web_contents_)
+    return;
+
+  storage::IsolatedContext::GetInstance()->
+      RevokeFileSystemByPath(file_system_path);
+
+  for (auto it = saved_paths_.begin(); it != saved_paths_.end(); ++it)
+    if (it->second == file_system_path) {
+      saved_paths_.erase(it);
+      break;
+    }
+
+  base::StringValue file_system_path_value(file_system_path.AsUTF8Unsafe());
+  web_contents_->CallClientFunction(
+      "DevToolsAPI.fileSystemRemoved",
+       &file_system_path_value,
+       nullptr,
+       nullptr);
+}
+
+void CommonWebContentsDelegate::OnDevToolsSaveToFile(
+    const std::string& url) {
+  // Notify DevTools.
+  base::StringValue url_value(url);
+  web_contents_->CallClientFunction(
+      "DevToolsAPI.savedURL", &url_value, nullptr, nullptr);
+}
+
+void CommonWebContentsDelegate::OnDevToolsAppendToFile(
+    const std::string& url) {
+  // Notify DevTools.
+  base::StringValue url_value(url);
+  web_contents_->CallClientFunction(
+      "DevToolsAPI.appendedToURL", &url_value, nullptr, nullptr);
+}
+
+void CommonWebContentsDelegate::SetHtmlApiFullscreen(bool enter_fullscreen) {
+  // Window is already in fullscreen mode, save the state.
+  if (enter_fullscreen && owner_window_->IsFullscreen()) {
+    native_fullscreen_ = true;
+    html_fullscreen_ = true;
+    return;
+  }
+
+  // Exit html fullscreen state but not window's fullscreen mode.
+  if (!enter_fullscreen && native_fullscreen_) {
+    html_fullscreen_ = false;
+    return;
+  }
+
+  owner_window_->SetFullScreen(enter_fullscreen);
+  html_fullscreen_ = enter_fullscreen;
+  native_fullscreen_ = false;
+}
+
+}  // namespace atom

atom/browser/common_web_contents_delegate.h

@@ -0,0 +1,131 @@
+// 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_COMMON_WEB_CONTENTS_DELEGATE_H_
+#define ATOM_BROWSER_COMMON_WEB_CONTENTS_DELEGATE_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "brightray/browser/default_web_contents_delegate.h"
+#include "brightray/browser/inspectable_web_contents_impl.h"
+#include "brightray/browser/inspectable_web_contents_delegate.h"
+
+namespace atom {
+
+class AtomJavaScriptDialogManager;
+class NativeWindow;
+class WebDialogHelper;
+
+class CommonWebContentsDelegate
+    : public brightray::DefaultWebContentsDelegate,
+      public brightray::InspectableWebContentsDelegate {
+ public:
+  CommonWebContentsDelegate();
+  virtual ~CommonWebContentsDelegate();
+
+  // Creates a InspectableWebContents object and takes onwership of
+  // |web_contents|.
+  void InitWithWebContents(content::WebContents* web_contents);
+
+  // Set the window as owner window.
+  void SetOwnerWindow(NativeWindow* owner_window);
+
+  // Destroy the managed InspectableWebContents object.
+  void DestroyWebContents();
+
+  // Returns the WebContents managed by this delegate.
+  content::WebContents* GetWebContents() const;
+
+  // Returns the WebContents of devtools.
+  content::WebContents* GetDevToolsWebContents() const;
+
+  brightray::InspectableWebContents* managed_web_contents() const {
+    return web_contents_.get();
+  }
+
+  NativeWindow* owner_window() const { return owner_window_.get(); }
+
+  bool is_html_fullscreen() const { return html_fullscreen_; }
+
+ protected:
+  // content::WebContentsDelegate:
+  content::WebContents* OpenURLFromTab(
+      content::WebContents* source,
+      const content::OpenURLParams& params) override;
+  void RequestToLockMouse(content::WebContents* web_contents,
+                          bool user_gesture,
+                          bool last_unlocked_by_target) override;
+  bool CanOverscrollContent() const override;
+  content::JavaScriptDialogManager* GetJavaScriptDialogManager(
+      content::WebContents* source) override;
+  content::ColorChooser* OpenColorChooser(
+      content::WebContents* web_contents,
+      SkColor color,
+      const std::vector<content::ColorSuggestion>& suggestions) 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;
+  void EnterFullscreenModeForTab(content::WebContents* source,
+                                 const GURL& origin) override;
+  void ExitFullscreenModeForTab(content::WebContents* source) override;
+  bool IsFullscreenForTabOrPending(
+      const content::WebContents* source) const override;
+
+  // brightray::InspectableWebContentsDelegate:
+  void DevToolsSaveToFile(const std::string& url,
+                          const std::string& content,
+                          bool save_as) override;
+  void DevToolsAppendToFile(const std::string& url,
+                            const std::string& content) override;
+  void DevToolsAddFileSystem(const base::FilePath& path) override;
+  void DevToolsRemoveFileSystem(
+      const base::FilePath& file_system_path) override;
+
+ private:
+  // Callback for when DevToolsSaveToFile has completed.
+  void OnDevToolsSaveToFile(const std::string& url);
+
+  // Callback for when DevToolsAppendToFile has completed.
+  void OnDevToolsAppendToFile(const std::string& url);
+
+  // Set fullscreen mode triggered by html api.
+  void SetHtmlApiFullscreen(bool enter_fullscreen);
+
+  // The window that this WebContents belongs to.
+  base::WeakPtr<NativeWindow> owner_window_;
+
+  // Whether window is fullscreened by HTML5 api.
+  bool html_fullscreen_;
+
+  // Whether window is fullscreened by window api.
+  bool native_fullscreen_;
+
+  scoped_ptr<WebDialogHelper> web_dialog_helper_;
+  scoped_ptr<AtomJavaScriptDialogManager> dialog_manager_;
+
+  // The stored InspectableWebContents object.
+  // Notice that web_contents_ must be placed after dialog_manager_, so we can
+  // make sure web_contents_ is destroyed before dialog_manager_, otherwise a
+  // crash would happen.
+  scoped_ptr<brightray::InspectableWebContents> web_contents_;
+
+  // Maps url to file path, used by the file requests sent from devtools.
+  typedef std::map<std::string, base::FilePath> PathsMap;
+  PathsMap saved_files_;
+
+  // Maps file system id to file path, used by the file system requests
+  // sent from devtools.
+  typedef std::map<std::string, base::FilePath> WorkspaceMap;
+  WorkspaceMap saved_paths_;
+
+  DISALLOW_COPY_AND_ASSIGN(CommonWebContentsDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_COMMON_WEB_CONTENTS_DELEGATE_H_

atom/browser/default_app/default_app.js

@@ -1,10 +1,7 @@
 var app = require('app');
-var Menu = require('menu');
-var MenuItem = require('menu-item');
 var BrowserWindow = require('browser-window');
 
 var mainWindow = null;
-var menu = null;
 
 // Quit when all windows are closed.
 app.on('window-all-closed', function() {
@@ -15,177 +12,9 @@ app.on('ready', function() {
   mainWindow = new BrowserWindow({
     width: 800,
     height: 600,
-    resizable: false,
     'auto-hide-menu-bar': true,
     'use-content-size': true,
   });
   mainWindow.loadUrl('file://' + __dirname + '/index.html');
   mainWindow.focus();
-
-  if (process.platform == 'darwin') {
-    var template = [
-      {
-        label: 'Atom Shell',
-        submenu: [
-          {
-            label: 'About Atom Shell',
-            selector: 'orderFrontStandardAboutPanel:'
-          },
-          {
-            type: 'separator'
-          },
-          {
-            label: 'Services',
-            submenu: []
-          },
-          {
-            type: 'separator'
-          },
-          {
-            label: 'Hide Atom Shell',
-            accelerator: 'Command+H',
-            selector: 'hide:'
-          },
-          {
-            label: 'Hide Others',
-            accelerator: 'Command+Shift+H',
-            selector: 'hideOtherApplications:'
-          },
-          {
-            label: 'Show All',
-            selector: 'unhideAllApplications:'
-          },
-          {
-            type: 'separator'
-          },
-          {
-            label: 'Quit',
-            accelerator: 'Command+Q',
-            click: function() { app.quit(); }
-          },
-        ]
-      },
-      {
-        label: 'Edit',
-        submenu: [
-          {
-            label: 'Undo',
-            accelerator: 'Command+Z',
-            selector: 'undo:'
-          },
-          {
-            label: 'Redo',
-            accelerator: 'Shift+Command+Z',
-            selector: 'redo:'
-          },
-          {
-            type: 'separator'
-          },
-          {
-            label: 'Cut',
-            accelerator: 'Command+X',
-            selector: 'cut:'
-          },
-          {
-            label: 'Copy',
-            accelerator: 'Command+C',
-            selector: 'copy:'
-          },
-          {
-            label: 'Paste',
-            accelerator: 'Command+V',
-            selector: 'paste:'
-          },
-          {
-            label: 'Select All',
-            accelerator: 'Command+A',
-            selector: 'selectAll:'
-          },
-        ]
-      },
-      {
-        label: 'View',
-        submenu: [
-          {
-            label: 'Reload',
-            accelerator: 'Command+R',
-            click: function() { mainWindow.restart(); }
-          },
-          {
-            label: 'Enter Fullscreen',
-            click: function() { mainWindow.setFullScreen(true); }
-          },
-          {
-            label: 'Toggle DevTools',
-            accelerator: 'Alt+Command+I',
-            click: function() { mainWindow.toggleDevTools(); }
-          },
-        ]
-      },
-      {
-        label: 'Window',
-        submenu: [
-          {
-            label: 'Minimize',
-            accelerator: 'Command+M',
-            selector: 'performMiniaturize:'
-          },
-          {
-            label: 'Close',
-            accelerator: 'Command+W',
-            selector: 'performClose:'
-          },
-          {
-            type: 'separator'
-          },
-          {
-            label: 'Bring All to Front',
-            selector: 'arrangeInFront:'
-          },
-        ]
-      },
-    ];
-
-    menu = Menu.buildFromTemplate(template);
-    Menu.setApplicationMenu(menu);
-  } else {
-    var template = [
-      {
-        label: '&File',
-        submenu: [
-          {
-            label: '&Open',
-            accelerator: 'Ctrl+O',
-          },
-          {
-            label: '&Close',
-            accelerator: 'Ctrl+W',
-            click: function() { mainWindow.close(); }
-          },
-        ]
-      },
-      {
-        label: '&View',
-        submenu: [
-          {
-            label: '&Reload',
-            accelerator: 'Ctrl+R',
-            click: function() { mainWindow.restart(); }
-          },
-          {
-            label: '&Enter Fullscreen',
-            click: function() { mainWindow.setFullScreen(true); }
-          },
-          {
-            label: '&Toggle DevTools',
-            accelerator: 'Alt+Ctrl+I',
-            click: function() { mainWindow.toggleDevTools(); }
-          },
-        ]
-      },
-    ];
-
-    menu = Menu.buildFromTemplate(template);
-    mainWindow.setMenu(menu);
-  }
 });

atom/browser/default_app/index.html

@@ -1,6 +1,6 @@
 <html>
 <head>
-  <title>Atom Shell</title>
+  <title>Electron</title>
   <style>
     body {
       color: #555;
@@ -72,19 +72,19 @@
     };
   </script>
 
-  <h2 style="-webkit-app-region: drag">Welcome to Atom Shell</h2>
+  <h2 style="-webkit-app-region: drag">Welcome to Electron</h2>
 
   <p>
-  To run your app with atom-shell, execute the following command under your
+  To run your app with Electron, execute the following command under your
   Console (or Terminal):
   </p>
 
   <script>document.write('<pre>' + command + '</pre>')</script>
 
   <p>
-  The <code>path-to-your-app</code> should be the path to your own atom-shell
-  app, you can read the <a href='https://github.com/atom/atom-shell/blob/master/docs/tutorial/quick-start.md'>quick start</a>
-  guide in atom-shell's <a href='https://github.com/atom/atom-shell/blob/master/docs'>docs</a>
+  The <code>path-to-your-app</code> should be the path to your own Electron
+  app, you can read the <a href='https://github.com/atom/electron/blob/master/docs/tutorial/quick-start.md'>quick start</a>
+  guide in Electron's <a href='https://github.com/atom/electron/blob/master/docs'>docs</a>
   on how to write one.
   </p>