Merge remote-tracking branch 'refs/remotes/atom/master'

2015-11-20 19:25:23 +02:00 · 2015-11-20 19:25:23 +02:00 · f374508a61
commit f374508a61
parent 50083017bc 29052b0498
315 changed files with 9015 additions and 2713 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,4 +1,5 @@
 .DS_Store
+/.idea/
 /build/
 /dist/
 /external_binaries/
--- a/README-ko.md
+++ b/README-ko.md
@ -8,18 +8,26 @@

 :zap: *프레임워크 이름이 Atom Shell에서 Electron으로 변경되었습니다* :zap:

-Electron 프레임워크는 JavaScript, HTML 그리고 CSS를 사용하여 Cross-Platform 데스크톱 어플리케이션을 개발할 수 있도록 해주는 프레임워크입니다. 이 프레임워크는 [Node.js](https://nodejs.org) 와
-[Chromium](http://www.chromium.org)을 기반으로 만들어 졌으며 [Atom Editor](https://github.com/atom/atom)에 사용되고 있습니다.
+Electron 프레임워크는 JavaScript, HTML 그리고 CSS를 사용하여
+Cross-Platform 데스크톱 어플리케이션을 개발할 수 있도록 해주는 프레임워크입니다.
+[Node.js](https://nodejs.org/)와 [Chromium](http://www.chromium.org)을 기반으로
+만들어졌으며 [Atom Editor](https://github.com/atom/atom)에 사용되고 있습니다.

-Electron에 대한 중요한 알림을 받고 싶다면 Twitter에서 [@ElectronJS](https://twitter.com/electronjs)를 팔로우 하세요.
+Electron에 대한 중요한 알림을 받고 싶다면 Twitter에서
+[@ElectronJS](https://twitter.com/electronjs)를 팔로우 하세요.

-이 프로젝트는 기여자 규약 1.2를 준수합니다. 이 프로젝트에 참여할 때 코드를 유지해야 합니다. 받아들일 수 없는 행동은 atom@github.com로 보고 하십시오.
+이 프로젝트는 [기여자 규약 1.2](http://contributor-covenant.org/version/1/2/0/)을
+준수합니다. 따라서 이 프로젝트의 개발에 참여하려면 이 계약을 지켜야 합니다. 받아들일 수
+없는 행위를 발견했을 경우 atom@github.com로 보고 하십시오.

 ## 다운로드

-Linux, Windows, Mac용으로 미리 빌드된 Electron 바이너리와 디버그 심볼이 준비되어 있습니다. [releases](https://github.com/atom/electron/releases) 페이지에서 받아 볼 수 있습니다.
+Linux, Windows, OS X 용으로 미리 빌드된 Electron 바이너리와 디버그 심볼이 준비되어
+있습니다. [releases](https://github.com/atom/electron/releases) 페이지에서 받아 볼
+수 있습니다.

-또한 [`npm`](https://docs.npmjs.com/)을 통해 미리 빌드된 Electron 바이너리를 받을 수도 있습니다:
+또한 [`npm`](https://docs.npmjs.com/)을 통해 미리 빌드된 Electron 바이너리를 설치할
+수도 있습니다:

 ```sh
 # $PATH에 `electron` 커맨드를 등록하고 전역에 설치합니다.
@ -35,8 +43,9 @@ npm install electron-prebuilt --save-dev

 ## 참조 문서

-[Docs](https://github.com/atom/electron/tree/master/docs/README.md)에 개발 가이드와 API 레퍼런스가 있습니다.
-Electron을 빌드 하는 방법과 프로젝트에 기여하는 방법도 문서에 포함되어 있으니 참고하시기 바랍니다.
+[Docs](https://github.com/atom/electron/tree/master/docs/README.md)에 개발 지침과
+API 레퍼런스가 있습니다. Electron을 빌드 하는 방법과 프로젝트에 기여하는법 또한 문서에
+포함되어 있으니 참고하시기 바랍니다.

 ## 참조 문서 (번역)

@ -49,14 +58,17 @@ Electron을 빌드 하는 방법과 프로젝트에 기여하는 방법도 문

 ## 시작하기

-[`atom/electron-quick-start`](https://github.com/atom/electron-quick-start) 저장소를 클론하여 Electron을 간단히 접해볼 수 있습니다.
+[`atom/electron-quick-start`](https://github.com/atom/electron-quick-start)
+저장소를 클론하여 Electron을 간단히 접해볼 수 있습니다.

 ## 커뮤니티

 다음 링크를 통해 커뮤니티에 질문을 올리거나 토론을 나눌 수 있습니다:

- Atom 포럼의 [`electron`](http://discuss.atom.io/category/electron) 카테고리
- Freenode 채팅의 `#atom-shell` 채널 
+- Atom 포럼의 [`electron`](http://discuss.atom.io/c/electron) 카테고리
+- Freenode 채팅의 `#atom-shell` 채널
 - Slack의 [`Atom`](http://atom-slack.herokuapp.com/) 채널

-[awesome-electron](https://github.com/sindresorhus/awesome-electron) 프로젝트엔 커뮤니티가 운영중인 유용한 예제 어플리케이션과 도구, 리소스가 있으니 한번 참고해 보시기 바랍니다.
+[awesome-electron](https://github.com/sindresorhus/awesome-electron) 프로젝트에
+커뮤니티가 운영중인 유용한 예제 어플리케이션과 도구, 리소스가 있으니 한번 참고해 보시기
+바랍니다.
--- a/README.md
+++ b/README.md
@ -7,20 +7,20 @@
 :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 [Node.js](https://nodejs.org) and
+using JavaScript, HTML and CSS. It is based on [Node.js](https://nodejs.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).
+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 and debug symbols of Electron for Linux, Windows and Mac can
+Prebuilt binaries and debug symbols of Electron for Linux, Windows and OS X 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
@ -62,7 +62,7 @@ repository to see a minimal Electron app in action.

 You can ask questions and interact with the community in the following
 locations:
- [`electron`](http://discuss.atom.io/category/electron) category on the Atom
+- [`electron`](http://discuss.atom.io/c/electron) category on the Atom
 forums
 - `#atom-shell` channel on Freenode
 - [`Atom`](http://atom-slack.herokuapp.com/) channel on Slack
--- a/atom.gyp
+++ b/atom.gyp
@ -4,7 +4,7 @@
    'product_name%': 'Electron',
    'company_name%': 'GitHub, Inc',
    'company_abbr%': 'github',
-    'version%': '0.34.1',
+    'version%': '0.35.1',
  },
  'includes': [
    'filenames.gypi',
--- a/atom/app/atom_main_delegate.cc
+++ b/atom/app/atom_main_delegate.cc
@ -16,6 +16,7 @@
 #include "base/debug/stack_trace.h"
 #include "base/environment.h"
 #include "base/logging.h"
+#include "chrome/common/chrome_paths.h"
 #include "content/public/common/content_switches.h"
 #include "ui/base/resource/resource_bundle.h"

@ -79,6 +80,8 @@ bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
  if (enable_stack_dumping)
    base::debug::EnableInProcessStackDumping();

+  chrome::RegisterPathProvider();
+
  return brightray::MainDelegate::BasicStartupComplete(exit_code);
 }

@ -102,13 +105,6 @@ void AtomMainDelegate::PreSandboxStartup() {
  if (!IsBrowserProcess(command_line))
    return;

-#if defined(OS_WIN)
-  // Disable the LegacyRenderWidgetHostHWND, it made frameless windows unable
-  // to move and resize. We may consider enabling it again after upgraded to
-  // Chrome 38, which should have fixed the problem.
-  command_line->AppendSwitch(switches::kDisableLegacyIntermediateWindow);
-#endif
-
  // Disable renderer sandbox for most of node's functions.
  command_line->AppendSwitch(switches::kNoSandbox);

--- a/atom/browser/api/atom_api_app.cc
+++ b/atom/browser/api/atom_api_app.cc
@ -7,18 +7,17 @@
 #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/api/atom_api_web_contents.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/browser/login_handler.h"
 #include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
 #include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
@ -26,8 +25,10 @@
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "brightray/browser/brightray_paths.h"
+#include "chrome/common/chrome_paths.h"
 #include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/gpu_data_manager.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/common/content_switches.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
@ -63,21 +64,6 @@ 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


@ -101,12 +87,22 @@ int GetPathConstant(const std::string& name) {
    return base::DIR_HOME;
  else if (name == "temp")
    return base::DIR_TEMP;
-  else if (name == "userDesktop")
+  else if (name == "userDesktop" || name == "desktop")
    return base::DIR_USER_DESKTOP;
  else if (name == "exe")
    return base::FILE_EXE;
  else if (name == "module")
    return base::FILE_MODULE;
+  else if (name == "documents")
+    return chrome::DIR_USER_DOCUMENTS;
+  else if (name == "downloads")
+    return chrome::DIR_DEFAULT_DOWNLOADS;
+  else if (name == "music")
+    return chrome::DIR_USER_MUSIC;
+  else if (name == "pictures")
+    return chrome::DIR_USER_PICTURES;
+  else if (name == "videos")
+    return chrome::DIR_USER_VIDEOS;
  else
    return -1;
 }
@ -132,8 +128,6 @@ 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();
@ -147,18 +141,29 @@ void OnClientCertificateSelected(
      net::X509Certificate::CreateCertificateListFromBytes(
          encoded_data.data(), encoded_data.size(),
          net::X509Certificate::FORMAT_AUTO);
-
  delegate->ContinueWithCertificate(certs[0].get());
 }

+void PassLoginInformation(scoped_refptr<LoginHandler> login_handler,
+                          mate::Arguments* args) {
+  base::string16 username, password;
+  if (args->GetNext(&username) && args->GetNext(&password))
+    login_handler->Login(username, password);
+  else
+    login_handler->CancelAuth();
+}
+
 }  // namespace

 App::App() {
+  static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())->set_delegate(this);
  Browser::Get()->AddObserver(this);
  content::GpuDataManager::GetInstance()->AddObserver(this);
 }

 App::~App() {
+  static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())->set_delegate(
+      nullptr);
  Browser::Get()->RemoveObserver(this);
  content::GpuDataManager::GetInstance()->RemoveObserver(this);
 }
@ -201,26 +206,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");
 }

-void App::OnSelectCertificate(
+void App::OnLogin(LoginHandler* login_handler) {
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  bool prevent_default = Emit(
+      "login",
+      WebContents::CreateFrom(isolate(), login_handler->GetWebContents()),
+      login_handler->request(),
+      login_handler->auth_info(),
+      base::Bind(&PassLoginInformation, make_scoped_refptr(login_handler)));
+
+  // Default behavior is to always cancel the auth.
+  if (!prevent_default)
+    login_handler->CancelAuth();
+}
+
+void App::AllowCertificateError(
+    int pid,
+    int fid,
+    int cert_error,
+    const net::SSLInfo& ssl_info,
+    const GURL& request_url,
+    content::ResourceType resource_type,
+    bool overridable,
+    bool strict_enforcement,
+    bool expired_previous_decision,
+    const base::Callback<void(bool)>& callback,
+    content::CertificateRequestResultType* request) {
+  auto rfh = content::RenderFrameHost::FromID(pid, fid);
+  auto web_contents = content::WebContents::FromRenderFrameHost(rfh);
+
+  v8::Locker locker(isolate());
+  v8::HandleScope handle_scope(isolate());
+  bool prevent_default = Emit("certificate-error",
+                              WebContents::CreateFrom(isolate(), web_contents),
+                              request_url,
+                              net::ErrorToString(cert_error),
+                              ssl_info.cert,
+                              callback);
+
+  // Deny the certificate by default.
+  if (!prevent_default)
+    *request = content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY;
+}
+
+void App::SelectClientCertificate(
    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),
+      Emit("select-client-certificate",
+           WebContents::CreateFrom(isolate(), web_contents),
           cert_request_info->host_and_port.ToString(),
           cert_request_info->client_certs,
           base::Bind(&OnClientCertificateSelected,
@ -266,13 +307,6 @@ 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
-}
-
 void App::AllowNTLMCredentialsForAllDomains(bool should_allow) {
  auto browser_context = static_cast<AtomBrowserContext*>(
        AtomBrowserMainParts::Get()->browser_context());
@ -283,13 +317,6 @@ std::string App::GetLocale() {
  return l10n_util::GetApplicationLocale("");
 }

-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_);
-}
-
 bool App::MakeSingleInstance(
    const ProcessSingleton::NotificationCallback& callback) {
  if (process_singleton_.get())
@ -317,6 +344,7 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
  auto browser = base::Unretained(Browser::Get());
  return mate::ObjectTemplateBuilder(isolate)
      .SetMethod("quit", base::Bind(&Browser::Quit, browser))
+      .SetMethod("exit", base::Bind(&Browser::Exit, browser))
      .SetMethod("focus", base::Bind(&Browser::Focus, browser))
      .SetMethod("getVersion", base::Bind(&Browser::GetVersion, browser))
      .SetMethod("setVersion", base::Bind(&Browser::SetVersion, browser))
@ -327,6 +355,8 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
                 base::Bind(&Browser::AddRecentDocument, browser))
      .SetMethod("clearRecentDocuments",
                 base::Bind(&Browser::ClearRecentDocuments, browser))
+      .SetMethod("setAppUserModelId",
+                 base::Bind(&Browser::SetAppUserModelID, browser))
 #if defined(OS_WIN)
      .SetMethod("setUserTasks",
                 base::Bind(&Browser::SetUserTasks, browser))
@ -334,12 +364,10 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
      .SetMethod("setPath", &App::SetPath)
      .SetMethod("getPath", &App::GetPath)
      .SetMethod("setDesktopName", &App::SetDesktopName)
-      .SetMethod("setAppUserModelId", &App::SetAppUserModelId)
      .SetMethod("allowNTLMCredentialsForAllDomains",
                 &App::AllowNTLMCredentialsForAllDomains)
      .SetMethod("getLocale", &App::GetLocale)
-      .SetMethod("makeSingleInstance", &App::MakeSingleInstance)
-      .SetProperty("defaultSession", &App::DefaultSession);
+      .SetMethod("makeSingleInstance", &App::MakeSingleInstance);
 }

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

 #include "atom/browser/api/event_emitter.h"
+#include "atom/browser/atom_browser_client.h"
 #include "atom/browser/browser_observer.h"
 #include "atom/common/native_mate_converters/callback.h"
 #include "chrome/browser/process_singleton.h"
@ -26,7 +27,8 @@ namespace atom {

 namespace api {

-class App : public mate::EventEmitter,
+class App : public AtomBrowserClient::Delegate,
+            public mate::EventEmitter,
            public BrowserObserver,
            public content::GpuDataManagerObserver {
 public:
@ -46,7 +48,22 @@ class App : public mate::EventEmitter,
  void OnActivate(bool has_visible_windows) override;
  void OnWillFinishLaunching() override;
  void OnFinishLaunching() override;
-  void OnSelectCertificate(
+  void OnLogin(LoginHandler* login_handler) override;
+
+  // content::ContentBrowserClient:
+  void AllowCertificateError(
+      int render_process_id,
+      int render_frame_id,
+      int cert_error,
+      const net::SSLInfo& ssl_info,
+      const GURL& request_url,
+      content::ResourceType resource_type,
+      bool overridable,
+      bool strict_enforcement,
+      bool expired_previous_decision,
+      const base::Callback<void(bool)>& callback,
+      content::CertificateRequestResultType* request) override;
+  void SelectClientCertificate(
      content::WebContents* web_contents,
      net::SSLCertRequestInfo* cert_request_info,
      scoped_ptr<content::ClientCertificateDelegate> delegate) override;
@ -66,14 +83,10 @@ class App : public mate::EventEmitter,
               const base::FilePath& path);

  void SetDesktopName(const std::string& desktop_name);
-  void SetAppUserModelId(const std::string& app_id);
  void AllowNTLMCredentialsForAllDomains(bool should_allow);
  bool MakeSingleInstance(
      const ProcessSingleton::NotificationCallback& callback);
  std::string GetLocale();
-  v8::Local<v8::Value> DefaultSession(v8::Isolate* isolate);
-
-  v8::Global<v8::Value> default_session_;

  scoped_ptr<ProcessSingleton> process_singleton_;

--- a/atom/browser/api/atom_api_auto_updater.cc
+++ b/atom/browser/api/atom_api_auto_updater.cc
@ -81,7 +81,7 @@ void AutoUpdater::OnWindowAllClosed() {
 mate::ObjectTemplateBuilder AutoUpdater::GetObjectTemplateBuilder(
    v8::Isolate* isolate) {
  return mate::ObjectTemplateBuilder(isolate)
-      .SetMethod("setFeedUrl", &auto_updater::AutoUpdater::SetFeedURL)
+      .SetMethod("setFeedURL", &auto_updater::AutoUpdater::SetFeedURL)
      .SetMethod("checkForUpdates", &auto_updater::AutoUpdater::CheckForUpdates)
      .SetMethod("quitAndInstall", &AutoUpdater::QuitAndInstall);
 }
--- a/atom/browser/api/atom_api_cookies.cc
+++ b/atom/browser/api/atom_api_cookies.cc
@ -204,7 +204,7 @@ void Cookies::GetCookiesOnIOThread(scoped_ptr<base::DictionaryValue> filter,
              Passed(&filter), callback))) {
    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
        base::Bind(&RunGetCookiesCallbackOnUIThread, isolate(),
-                   "Url is not valid", net::CookieList(), callback));
+                   "URL is not valid", net::CookieList(), callback));
  }
 }

@ -229,7 +229,7 @@ void Cookies::Remove(const mate::Dictionary& details,
    error_message = "Details(url, name) of removing cookie are required.";
  }
  if (error_message.empty() && !url.is_valid()) {
-    error_message = "Url is not valid.";
+    error_message = "URL is not valid.";
  }
  if (!error_message.empty()) {
     RunRemoveCookiesCallbackOnUIThread(isolate(), error_message, callback);
@ -261,7 +261,7 @@ void Cookies::Set(const base::DictionaryValue& options,

  GURL gurl(url);
  if (error_message.empty() && !gurl.is_valid()) {
-    error_message = "Url is not valid.";
+    error_message = "URL is not valid.";
  }

  if (!error_message.empty()) {
--- a/atom/browser/api/atom_api_download_item.cc
+++ b/atom/browser/api/atom_api_download_item.cc
@ -6,6 +6,7 @@

 #include <map>

+#include "atom/browser/atom_browser_main_parts.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"
@ -102,7 +103,7 @@ int64 DownloadItem::GetTotalBytes() {
  return download_item_->GetTotalBytes();
 }

-const GURL& DownloadItem::GetUrl() {
+const GURL& DownloadItem::GetURL() {
  return download_item_->GetURL();
 }

@ -115,7 +116,7 @@ bool DownloadItem::HasUserGesture() {
 }

 std::string DownloadItem::GetFilename() {
-  return base::UTF16ToUTF8(net::GenerateFileName(GetUrl(),
+  return base::UTF16ToUTF8(net::GenerateFileName(GetURL(),
                           GetContentDisposition(),
                           std::string(),
                           download_item_->GetSuggestedFilename(),
@ -151,7 +152,7 @@ mate::ObjectTemplateBuilder DownloadItem::GetObjectTemplateBuilder(
      .SetMethod("cancel", &DownloadItem::Cancel)
      .SetMethod("getReceivedBytes", &DownloadItem::GetReceivedBytes)
      .SetMethod("getTotalBytes", &DownloadItem::GetTotalBytes)
-      .SetMethod("getUrl", &DownloadItem::GetUrl)
+      .SetMethod("getURL", &DownloadItem::GetURL)
      .SetMethod("getMimeType", &DownloadItem::GetMimeType)
      .SetMethod("hasUserGesture", &DownloadItem::HasUserGesture)
      .SetMethod("getFilename", &DownloadItem::GetFilename)
@ -159,14 +160,6 @@ mate::ObjectTemplateBuilder DownloadItem::GetObjectTemplateBuilder(
      .SetMethod("setSavePath", &DownloadItem::SetSavePath);
 }

-void SetWrapDownloadItem(const WrapDownloadItemCallback& callback) {
-  g_wrap_download_item = callback;
-}
-
-void ClearWrapDownloadItem() {
-  g_wrap_download_item.Reset();
-}
-
 // static
 mate::Handle<DownloadItem> DownloadItem::Create(
    v8::Isolate* isolate, content::DownloadItem* item) {
@ -182,6 +175,18 @@ void* DownloadItem::UserDataKey() {
  return &kDownloadItemSavePathKey;
 }

+void ClearWrapDownloadItem() {
+  g_wrap_download_item.Reset();
+}
+
+void SetWrapDownloadItem(const WrapDownloadItemCallback& callback) {
+  g_wrap_download_item = callback;
+
+  // Cleanup the wrapper on exit.
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(
+      base::Bind(ClearWrapDownloadItem));
+}
+
 }  // namespace api

 }  // namespace atom
@ -193,7 +198,6 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
  v8::Isolate* isolate = context->GetIsolate();
  mate::Dictionary dict(isolate, exports);
  dict.SetMethod("_setWrapDownloadItem", &atom::api::SetWrapDownloadItem);
-  dict.SetMethod("_clearWrapDownloadItem", &atom::api::ClearWrapDownloadItem);
 }

 }  // namespace
--- a/atom/browser/api/atom_api_download_item.h
+++ b/atom/browser/api/atom_api_download_item.h
@ -49,7 +49,7 @@ class DownloadItem : public mate::EventEmitter,
  bool HasUserGesture();
  std::string GetFilename();
  std::string GetContentDisposition();
-  const GURL& GetUrl();
+  const GURL& GetURL();
  void SetSavePath(const base::FilePath& path);

 private:
--- a/atom/browser/api/atom_api_global_shortcut.cc
+++ b/atom/browser/api/atom_api_global_shortcut.cc
@ -23,6 +23,9 @@ GlobalShortcut::GlobalShortcut() {
 }

 GlobalShortcut::~GlobalShortcut() {
+}
+
+void GlobalShortcut::Destroy() {
  UnregisterAll();
 }

--- a/atom/browser/api/atom_api_global_shortcut.h
+++ b/atom/browser/api/atom_api_global_shortcut.h
@ -8,9 +8,9 @@
 #include <map>
 #include <string>

+#include "atom/browser/api/trackable_object.h"
 #include "base/callback.h"
 #include "chrome/browser/extensions/global_shortcut_listener.h"
-#include "native_mate/wrappable.h"
 #include "native_mate/handle.h"
 #include "ui/base/accelerators/accelerator.h"

@ -19,13 +19,16 @@ namespace atom {
 namespace api {

 class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
-                       public mate::Wrappable {
+                       public mate::TrackableObject<GlobalShortcut> {
 public:
  static mate::Handle<GlobalShortcut> Create(v8::Isolate* isolate);

 protected:
  GlobalShortcut();
-  virtual ~GlobalShortcut();
+  ~GlobalShortcut() override;
+
+  // mate::TrackableObject:
+  void Destroy() override;

  // mate::Wrappable implementations:
  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
--- a/atom/browser/api/atom_api_menu.cc
+++ b/atom/browser/api/atom_api_menu.cc
@ -27,6 +27,14 @@ Menu::Menu()
 Menu::~Menu() {
 }

+void Menu::Destroy() {
+  model_.reset();
+}
+
+bool Menu::IsDestroyed() const {
+  return !model_;
+}
+
 void Menu::AfterInit(v8::Isolate* isolate) {
  mate::Dictionary wrappable(isolate, GetWrapper(isolate));
  mate::Dictionary delegate;
--- a/atom/browser/api/atom_api_menu.h
+++ b/atom/browser/api/atom_api_menu.h
@ -8,16 +8,16 @@
 #include <string>

 #include "atom/browser/api/atom_api_window.h"
+#include "atom/browser/api/trackable_object.h"
 #include "atom/browser/ui/atom_menu_model.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
-#include "native_mate/wrappable.h"

 namespace atom {

 namespace api {

-class Menu : public mate::Wrappable,
+class Menu : public mate::TrackableObject<Menu>,
             public AtomMenuModel::Delegate {
 public:
  static mate::Wrappable* Create();
@ -37,9 +37,13 @@ class Menu : public mate::Wrappable,

 protected:
  Menu();
-  virtual ~Menu();
+  ~Menu() override;
+
+  // mate::TrackableObject:
+  void Destroy() override;

  // mate::Wrappable:
+  bool IsDestroyed() const override;
  void AfterInit(v8::Isolate* isolate) override;

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

+  void Destroy() override;
  void Popup(Window* window) override;
  void PopupAt(Window* window, int x, int y) override;

--- a/atom/browser/api/atom_api_menu_mac.mm
+++ b/atom/browser/api/atom_api_menu_mac.mm
@ -18,6 +18,11 @@ namespace api {
 MenuMac::MenuMac() {
 }

+void MenuMac::Destroy() {
+  menu_controller_.reset();
+  Menu::Destroy();
+}
+
 void MenuMac::Popup(Window* window) {
  NativeWindow* native_window = window->window();
  if (!native_window)
--- a/atom/browser/api/atom_api_power_monitor.cc
+++ b/atom/browser/api/atom_api_power_monitor.cc
@ -19,6 +19,9 @@ PowerMonitor::PowerMonitor() {
 }

 PowerMonitor::~PowerMonitor() {
+}
+
+void PowerMonitor::Destroy() {
  base::PowerMonitor::Get()->RemoveObserver(this);
 }

--- a/atom/browser/api/atom_api_power_monitor.h
+++ b/atom/browser/api/atom_api_power_monitor.h
@ -5,7 +5,7 @@
 #ifndef ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
 #define ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_

-#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/api/trackable_object.h"
 #include "base/compiler_specific.h"
 #include "base/power_monitor/power_observer.h"
 #include "native_mate/handle.h"
@ -14,14 +14,17 @@ namespace atom {

 namespace api {

-class PowerMonitor : public mate::EventEmitter,
+class PowerMonitor : public mate::TrackableObject<PowerMonitor>,
                     public base::PowerObserver {
 public:
  static v8::Local<v8::Value> Create(v8::Isolate* isolate);

 protected:
  PowerMonitor();
-  virtual ~PowerMonitor();
+  ~PowerMonitor() override;
+
+  // mate::TrackableObject:
+  void Destroy() override;

  // base::PowerObserver implementations:
  void OnPowerStateChange(bool on_battery_power) override;
--- a/atom/browser/api/atom_api_power_save_blocker.cc
+++ b/atom/browser/api/atom_api_power_save_blocker.cc
@ -45,6 +45,11 @@ PowerSaveBlocker::PowerSaveBlocker()
 PowerSaveBlocker::~PowerSaveBlocker() {
 }

+void PowerSaveBlocker::Destroy() {
+  power_save_blocker_types_.clear();
+  power_save_blocker_.reset();
+}
+
 void PowerSaveBlocker::UpdatePowerSaveBlocker() {
  if (power_save_blocker_types_.empty()) {
    power_save_blocker_.reset();
--- a/atom/browser/api/atom_api_power_save_blocker.h
+++ b/atom/browser/api/atom_api_power_save_blocker.h
@ -7,10 +7,10 @@

 #include <map>

+#include "atom/browser/api/trackable_object.h"
 #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;
@ -20,13 +20,16 @@ namespace atom {

 namespace api {

-class PowerSaveBlocker : public mate::Wrappable {
+class PowerSaveBlocker : public mate::TrackableObject<PowerSaveBlocker> {
 public:
  static mate::Handle<PowerSaveBlocker> Create(v8::Isolate* isolate);

 protected:
  PowerSaveBlocker();
-  virtual ~PowerSaveBlocker();
+  ~PowerSaveBlocker() override;
+
+  // mate::TrackableObject:
+  void Destroy() override;

  // mate::Wrappable implementations:
  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
@ -48,7 +51,6 @@ class PowerSaveBlocker : public mate::Wrappable {
      std::map<int, content::PowerSaveBlocker::PowerSaveBlockerType>;
  PowerSaveBlockerTypeMap power_save_blocker_types_;

-
  DISALLOW_COPY_AND_ASSIGN(PowerSaveBlocker);
 };

--- a/atom/browser/api/atom_api_protocol.cc
+++ b/atom/browser/api/atom_api_protocol.cc
@ -12,27 +12,12 @@
 #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/native_mate_converters/net_converter.h"
 #include "atom/common/node_includes.h"
 #include "native_mate/dictionary.h"

 using content::BrowserThread;

-namespace mate {
-
-template<>
-struct Converter<const net::URLRequest*> {
-  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())
-        .SetValue("referrer", val->referrer())
-        .Build()->NewInstance();
-  }
-};
-
-}  // namespace mate
-
 namespace atom {

 namespace api {
@ -52,7 +37,7 @@ mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder(
      .SetMethod("registerBufferProtocol",
                 &Protocol::RegisterProtocol<URLRequestBufferJob>)
      .SetMethod("registerFileProtocol",
-                 &Protocol::RegisterProtocol<UrlRequestAsyncAsarJob>)
+                 &Protocol::RegisterProtocol<URLRequestAsyncAsarJob>)
      .SetMethod("registerHttpProtocol",
                 &Protocol::RegisterProtocol<URLRequestFetchJob>)
      .SetMethod("unregisterProtocol", &Protocol::UnregisterProtocol)
@ -62,7 +47,7 @@ mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder(
      .SetMethod("interceptBufferProtocol",
                 &Protocol::InterceptProtocol<URLRequestBufferJob>)
      .SetMethod("interceptFileProtocol",
-                 &Protocol::InterceptProtocol<UrlRequestAsyncAsarJob>)
+                 &Protocol::InterceptProtocol<URLRequestAsyncAsarJob>)
      .SetMethod("interceptHttpProtocol",
                 &Protocol::InterceptProtocol<URLRequestFetchJob>)
      .SetMethod("uninterceptProtocol", &Protocol::UninterceptProtocol);
--- a/atom/browser/api/atom_api_session.cc
+++ b/atom/browser/api/atom_api_session.cc
@ -9,12 +9,15 @@

 #include "atom/browser/api/atom_api_cookies.h"
 #include "atom/browser/api/atom_api_download_item.h"
-#include "atom/browser/atom_browser_context.h"
 #include "atom/browser/api/atom_api_web_contents.h"
 #include "atom/browser/api/save_page_handler.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/net/atom_cert_verifier.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/native_mate_converters/net_converter.h"
 #include "atom/common/node_includes.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
@ -354,6 +357,17 @@ void Session::DisableNetworkEmulation() {
                 base::Passed(&conditions)));
 }

+void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
+                                mate::Arguments* args) {
+  AtomCertVerifier::VerifyProc proc;
+  if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &proc))) {
+    args->ThrowError("Must pass null or function");
+    return;
+  }
+
+  browser_context_->cert_verifier()->SetVerifyProc(proc);
+}
+
 v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
  if (cookies_.IsEmpty()) {
    auto handle = atom::api::Cookies::Create(isolate, browser_context());
@ -372,6 +386,7 @@ mate::ObjectTemplateBuilder Session::GetObjectTemplateBuilder(
      .SetMethod("setDownloadPath", &Session::SetDownloadPath)
      .SetMethod("enableNetworkEmulation", &Session::EnableNetworkEmulation)
      .SetMethod("disableNetworkEmulation", &Session::DisableNetworkEmulation)
+      .SetMethod("setCertificateVerifyProc", &Session::SetCertVerifyProc)
      .SetProperty("cookies", &Session::Cookies);
 }

@ -395,14 +410,18 @@ mate::Handle<Session> Session::FromPartition(
                    static_cast<AtomBrowserContext*>(browser_context.get()));
 }

-void SetWrapSession(const WrapSessionCallback& callback) {
-  g_wrap_session = callback;
-}
-
 void ClearWrapSession() {
  g_wrap_session.Reset();
 }

+void SetWrapSession(const WrapSessionCallback& callback) {
+  g_wrap_session = callback;
+
+  // Cleanup the wrapper on exit.
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(
+      base::Bind(ClearWrapSession));
+}
+
 }  // namespace api

 }  // namespace atom
@ -415,7 +434,6 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
  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
--- a/atom/browser/api/atom_api_session.h
+++ b/atom/browser/api/atom_api_session.h
@ -72,6 +72,7 @@ class Session: public mate::TrackableObject<Session>,
  void SetDownloadPath(const base::FilePath& path);
  void EnableNetworkEmulation(const mate::Dictionary& options);
  void DisableNetworkEmulation();
+  void SetCertVerifyProc(v8::Local<v8::Value> proc, mate::Arguments* args);
  v8::Local<v8::Value> Cookies(v8::Isolate* isolate);

  // Cached object for cookies API.
--- a/atom/browser/api/atom_api_tray.cc
+++ b/atom/browser/api/atom_api_tray.cc
@ -44,21 +44,21 @@ mate::Wrappable* Tray::New(v8::Isolate* isolate, const gfx::Image& image) {
 void Tray::OnClicked(const gfx::Rect& bounds, int modifiers) {
  v8::Locker locker(isolate());
  v8::HandleScope handle_scope(isolate());
-  EmitCustomEvent("clicked",
+  EmitCustomEvent("click",
                  ModifiersToObject(isolate(), modifiers), bounds);
 }

 void Tray::OnDoubleClicked(const gfx::Rect& bounds, int modifiers) {
  v8::Locker locker(isolate());
  v8::HandleScope handle_scope(isolate());
-  EmitCustomEvent("double-clicked",
+  EmitCustomEvent("double-click",
                  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",
+  EmitCustomEvent("right-click",
                  ModifiersToObject(isolate(), modifiers), bounds);
 }

@ -67,17 +67,33 @@ void Tray::OnBalloonShow() {
 }

 void Tray::OnBalloonClicked() {
-  Emit("balloon-clicked");
+  Emit("balloon-click");
 }

 void Tray::OnBalloonClosed() {
  Emit("balloon-closed");
 }

+void Tray::OnDrop() {
+  Emit("drop");
+}
+
 void Tray::OnDropFiles(const std::vector<std::string>& files) {
  Emit("drop-files", files);
 }

+void Tray::OnDragEntered() {
+  Emit("drag-enter");
+}
+
+void Tray::OnDragExited() {
+  Emit("drag-leave");
+}
+
+void Tray::OnDragEnded() {
+  Emit("drag-end");
+}
+
 bool Tray::IsDestroyed() const {
  return !tray_icon_;
 }
@ -145,6 +161,7 @@ void Tray::BuildPrototype(v8::Isolate* isolate,
                          v8::Local<v8::ObjectTemplate> prototype) {
  mate::ObjectTemplateBuilder(isolate, prototype)
      .SetMethod("destroy", &Tray::Destroy, true)
+      .SetMethod("isDestroyed", &Tray::IsDestroyed, true)
      .SetMethod("setImage", &Tray::SetImage)
      .SetMethod("setPressedImage", &Tray::SetPressedImage)
      .SetMethod("setToolTip", &Tray::SetToolTip)
--- a/atom/browser/api/atom_api_tray.h
+++ b/atom/browser/api/atom_api_tray.h
@ -8,7 +8,7 @@
 #include <string>
 #include <vector>

-#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/api/trackable_object.h"
 #include "atom/browser/ui/tray_icon_observer.h"
 #include "base/memory/scoped_ptr.h"

@ -29,7 +29,7 @@ namespace api {

 class Menu;

-class Tray : public mate::EventEmitter,
+class Tray : public mate::TrackableObject<Tray>,
             public TrayIconObserver {
 public:
  static mate::Wrappable* New(v8::Isolate* isolate, const gfx::Image& image);
@ -39,7 +39,7 @@ class Tray : public mate::EventEmitter,

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

  // TrayIconObserver:
  void OnClicked(const gfx::Rect& bounds, int modifiers) override;
@ -48,12 +48,18 @@ class Tray : public mate::EventEmitter,
  void OnBalloonShow() override;
  void OnBalloonClicked() override;
  void OnBalloonClosed() override;
+  void OnDrop() override;
  void OnDropFiles(const std::vector<std::string>& files) override;
+  void OnDragEntered() override;
+  void OnDragExited() override;
+  void OnDragEnded() override;

  // mate::Wrappable:
  bool IsDestroyed() const override;

-  void Destroy();
+  // mate::TrackableObject:
+  void Destroy() override;
+
  void SetImage(mate::Arguments* args, const gfx::Image& image);
  void SetPressedImage(mate::Arguments* args, const gfx::Image& image);
  void SetToolTip(mate::Arguments* args, const std::string& tool_tip);
--- a/atom/browser/api/atom_api_web_contents.cc
+++ b/atom/browser/api/atom_api_web_contents.cc
@ -18,6 +18,7 @@
 #include "atom/common/api/event_emitter_caller.h"
 #include "atom/common/native_mate_converters/blink_converter.h"
 #include "atom/common/native_mate_converters/callback.h"
+#include "atom/common/native_mate_converters/content_converter.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/gfx_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
@ -46,6 +47,7 @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/context_menu_params.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
 #include "net/http/http_response_headers.h"
@ -169,11 +171,12 @@ struct Converter<content::SavePageType> {
    std::string save_type;
    if (!ConvertFromV8(isolate, val, &save_type))
      return false;
-    if (save_type == "HTMLOnly") {
+    save_type = base::StringToLowerASCII(save_type);
+    if (save_type == "htmlonly") {
      *out = content::SAVE_PAGE_TYPE_AS_ONLY_HTML;
-    } else if (save_type == "HTMLComplete") {
+    } else if (save_type == "htmlcomplete") {
      *out = content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML;
-    } else if (save_type == "MHTML") {
+    } else if (save_type == "mhtml") {
      *out = content::SAVE_PAGE_TYPE_AS_MHTML;
    } else {
      return false;
@ -266,9 +269,7 @@ WebContents::WebContents(v8::Isolate* isolate,
  managed_web_contents()->GetView()->SetDelegate(this);

  // Save the preferences in C++.
-  base::DictionaryValue web_preferences;
-  mate::ConvertFromV8(isolate, options.GetHandle(), &web_preferences);
-  new WebContentsPreferences(web_contents, &web_preferences);
+  new WebContentsPreferences(web_contents, options);

  web_contents->SetUserAgentOverride(GetBrowserContext()->GetUserAgent());

@ -404,6 +405,15 @@ void WebContents::RendererResponsive(content::WebContents* source) {
    owner_window()->RendererResponsive(source);
 }

+bool WebContents::HandleContextMenu(const content::ContextMenuParams& params) {
+  if (!params.custom_context.is_pepper_menu)
+    return false;
+
+  Emit("pepper-context-menu", std::make_pair(params, web_contents()));
+  web_contents()->NotifyContextMenuClosed(params.custom_context);
+  return true;
+}
+
 void WebContents::BeforeUnloadFired(const base::TimeTicks& proceed_time) {
  // Do nothing, we override this method just to avoid compilation error since
  // there are two virtual functions named BeforeUnloadFired.
@ -594,10 +604,6 @@ void WebContents::Destroy() {
  }
 }

-bool WebContents::IsAlive() const {
-  return web_contents() != NULL;
-}
-
 int WebContents::GetID() const {
  return web_contents()->GetRenderProcessHost()->GetID();
 }
@ -648,10 +654,6 @@ void WebContents::Stop() {
  web_contents()->Stop();
 }

-void WebContents::ReloadIgnoringCache() {
-  web_contents()->GetController().ReloadIgnoringCache(false);
-}
-
 void WebContents::GoBack() {
  atom::AtomBrowserClient::SuppressRendererProcessRestartForOnce();
  web_contents()->GetController().GoBack();
@ -990,16 +992,15 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
  if (template_.IsEmpty())
    template_.Reset(isolate, mate::ObjectTemplateBuilder(isolate)
        .SetMethod("destroy", &WebContents::Destroy, true)
-        .SetMethod("isAlive", &WebContents::IsAlive, true)
+        .SetMethod("isDestroyed", &WebContents::IsDestroyed, true)
        .SetMethod("getId", &WebContents::GetID)
        .SetMethod("equal", &WebContents::Equal)
-        .SetMethod("_loadUrl", &WebContents::LoadURL)
-        .SetMethod("_getUrl", &WebContents::GetURL)
+        .SetMethod("_loadURL", &WebContents::LoadURL)
+        .SetMethod("_getURL", &WebContents::GetURL)
        .SetMethod("getTitle", &WebContents::GetTitle)
        .SetMethod("isLoading", &WebContents::IsLoading)
        .SetMethod("isWaitingForResponse", &WebContents::IsWaitingForResponse)
        .SetMethod("_stop", &WebContents::Stop)
-        .SetMethod("_reloadIgnoringCache", &WebContents::ReloadIgnoringCache)
        .SetMethod("_goBack", &WebContents::GoBack)
        .SetMethod("_goForward", &WebContents::GoForward)
        .SetMethod("_goToOffset", &WebContents::GoToOffset)
@ -1061,7 +1062,7 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
 }

 bool WebContents::IsDestroyed() const {
-  return !IsAlive();
+  return !web_contents();
 }

 AtomBrowserContext* WebContents::GetBrowserContext() const {
@ -1112,14 +1113,18 @@ mate::Handle<WebContents> WebContents::Create(
  return handle;
 }

-void SetWrapWebContents(const WrapWebContentsCallback& callback) {
-  g_wrap_web_contents = callback;
-}
-
 void ClearWrapWebContents() {
  g_wrap_web_contents.Reset();
 }

+void SetWrapWebContents(const WrapWebContentsCallback& callback) {
+  g_wrap_web_contents = callback;
+
+  // Cleanup the wrapper on exit.
+  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(
+      base::Bind(ClearWrapWebContents));
+}
+
 }  // namespace api

 }  // namespace atom
@ -1133,7 +1138,6 @@ void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
  mate::Dictionary dict(isolate, exports);
  dict.SetMethod("create", &atom::api::WebContents::Create);
  dict.SetMethod("_setWrapWebContents", &atom::api::SetWrapWebContents);
-  dict.SetMethod("_clearWrapWebContents", &atom::api::ClearWrapWebContents);
 }

 }  // namespace
--- a/atom/browser/api/atom_api_web_contents.h
+++ b/atom/browser/api/atom_api_web_contents.h
@ -57,7 +57,6 @@ class WebContents : public mate::TrackableObject<WebContents>,
  // 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);
@ -189,6 +188,7 @@ class WebContents : public mate::TrackableObject<WebContents>,
  void ExitFullscreenModeForTab(content::WebContents* source) override;
  void RendererUnresponsive(content::WebContents* source) override;
  void RendererResponsive(content::WebContents* source) override;
+  bool HandleContextMenu(const content::ContextMenuParams& params) override;

  // content::WebContentsObserver:
  void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
--- a/atom/browser/api/atom_api_window.cc
+++ b/atom/browser/api/atom_api_window.cc
@ -3,6 +3,7 @@
 // found in the LICENSE file.

 #include "atom/browser/api/atom_api_window.h"
+#include "atom/common/native_mate_converters/value_converter.h"

 #include "atom/browser/api/atom_api_menu.h"
 #include "atom/browser/api/atom_api_web_contents.h"
@ -60,22 +61,82 @@ void OnCapturePageDone(
  callback.Run(gfx::Image::CreateFrom1xBitmap(bitmap));
 }

+// Converts min-width to minWidth, returns false if no conversion is needed.
+bool TranslateOldKey(const std::string& key, std::string* new_key) {
+  if (key.find('-') == std::string::npos)
+    return false;
+  new_key->reserve(key.size());
+  bool next_upper_case = false;
+  for (char c : key) {
+    if (c == '-') {
+      next_upper_case = true;
+    } else if (next_upper_case) {
+      new_key->push_back(base::ToUpperASCII(c));
+      next_upper_case = false;
+    } else {
+      new_key->push_back(c);
+    }
+  }
+  return true;
+}
+
+// Converts min-width to minWidth recursively in the dictionary.
+void TranslateOldOptions(v8::Isolate* isolate, v8::Local<v8::Object> options) {
+  auto context = isolate->GetCurrentContext();
+  auto maybe_keys = options->GetOwnPropertyNames(context);
+  if (maybe_keys.IsEmpty())
+    return;
+  std::vector<std::string> keys;
+  if (!mate::ConvertFromV8(isolate, maybe_keys.ToLocalChecked(), &keys))
+    return;
+  mate::Dictionary dict(isolate, options);
+  for (const auto& key : keys) {
+    v8::Local<v8::Value> value;
+    if (!dict.Get(key, &value))  // Shouldn't happen, but guard it anyway.
+      continue;
+    // Go recursively.
+    v8::Local<v8::Object> sub_options;
+    if (mate::ConvertFromV8(isolate, value, &sub_options))
+      TranslateOldOptions(isolate, sub_options);
+    // Translate key.
+    std::string new_key;
+    if (TranslateOldKey(key, &new_key)) {
+      dict.Set(new_key, value);
+      dict.Delete(key);
+    }
+  }
+}
+
+#if defined(OS_WIN)
+// Converts binary data to Buffer.
+v8::Local<v8::Value> ToBuffer(v8::Isolate* isolate, void* val, int size) {
+  auto buffer = node::Buffer::New(isolate, static_cast<char*>(val), size);
+  if (buffer.IsEmpty())
+    return v8::Null(isolate);
+  else
+    return buffer.ToLocalChecked();
+}
+#endif
+
 }  // namespace


 Window::Window(v8::Isolate* isolate, const mate::Dictionary& options) {
-  // Use options['web-preferences'] to create WebContents.
+  // Be compatible with old style field names like min-width.
+  TranslateOldOptions(isolate, options.GetHandle());
+
+  // Use options.webPreferences to create WebContents.
  mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
-  options.Get(switches::kWebPreferences, &web_preferences);
+  options.Get(options::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);
+  if (options.Get(options::kNodeIntegration, &value))
+    web_preferences.Set(options::kNodeIntegration, value);
+  if (options.Get(options::kPreloadScript, &value))
+    web_preferences.Set(options::kPreloadScript, value);
+  if (options.Get(options::kZoomFactor, &value))
+    web_preferences.Set(options::kZoomFactor, value);

  // Creates the WebContents used by BrowserWindow.
  auto web_contents = WebContents::Create(isolate, web_preferences);
@ -192,7 +253,9 @@ void Window::OnExecuteWindowsCommand(const std::string& command_name) {
 #if defined(OS_WIN)
 void Window::OnWindowMessage(UINT message, WPARAM w_param, LPARAM l_param) {
  if (IsWindowMessageHooked(message)) {
-    messages_callback_map_[message].Run(w_param, l_param);
+    messages_callback_map_[message].Run(
+        ToBuffer(isolate(), static_cast<void*>(&w_param), sizeof(WPARAM)),
+        ToBuffer(isolate(), static_cast<void*>(&l_param), sizeof(LPARAM)));
  }
 }
 #endif
@ -221,10 +284,6 @@ void Window::Close() {
  window_->Close();
 }

-bool Window::IsClosed() {
-  return window_->IsClosed();
-}
-
 void Window::Focus() {
  window_->Focus(true);
 }
@ -559,8 +618,8 @@ void Window::BuildPrototype(v8::Isolate* isolate,
                            v8::Local<v8::ObjectTemplate> prototype) {
  mate::ObjectTemplateBuilder(isolate, prototype)
      .SetMethod("destroy", &Window::Destroy, true)
+      .SetMethod("isDestroyed", &Window::IsDestroyed, true)
      .SetMethod("close", &Window::Close)
-      .SetMethod("isClosed", &Window::IsClosed)
      .SetMethod("focus", &Window::Focus)
      .SetMethod("isFocused", &Window::IsFocused)
      .SetMethod("show", &Window::Show)
--- a/atom/browser/api/atom_api_window.h
+++ b/atom/browser/api/atom_api_window.h
@ -77,8 +77,7 @@ class Window : public mate::TrackableObject<Window>,
  void OnExecuteWindowsCommand(const std::string& command_name) override;

  #if defined(OS_WIN)
-  void OnWindowMessage(UINT message, WPARAM w_param,
-                       LPARAM l_param) override;
+  void OnWindowMessage(UINT message, WPARAM w_param, LPARAM l_param) override;
  #endif

  // mate::Wrappable:
@ -90,7 +89,6 @@ class Window : public mate::TrackableObject<Window>,

  // APIs for NativeWindow.
  void Close();
-  bool IsClosed();
  void Focus();
  bool IsFocused();
  void Show();
@ -150,12 +148,10 @@ class Window : public mate::TrackableObject<Window>,
  void SetAspectRatio(double aspect_ratio, mate::Arguments* args);

 #if defined(OS_WIN)
-  typedef base::Callback<void(WPARAM, LPARAM)> MessageCallback;
-  typedef std::map<UINT, MessageCallback> MessageCallbackMap;
-  MessageCallbackMap messages_callback_map_;
+  typedef base::Callback<void(v8::Local<v8::Value>,
+                              v8::Local<v8::Value>)> MessageCallback;

-  bool HookWindowMessage(UINT message,
-                         const MessageCallback& callback);
+  bool HookWindowMessage(UINT message, const MessageCallback& callback);
  bool IsWindowMessageHooked(UINT message);
  void UnhookWindowMessage(UINT message);
  void UnhookAllWindowMessages();
@ -171,6 +167,11 @@ class Window : public mate::TrackableObject<Window>,
  int32_t ID() const;
  v8::Local<v8::Value> WebContents(v8::Isolate* isolate);

+#if defined(OS_WIN)
+  typedef std::map<UINT, MessageCallback> MessageCallbackMap;
+  MessageCallbackMap messages_callback_map_;
+#endif
+
  v8::Global<v8::Value> web_contents_;
  v8::Global<v8::Value> menu_;

--- a/atom/browser/api/frame_subscriber.cc
+++ b/atom/browser/api/frame_subscriber.cc
@ -38,6 +38,9 @@ void FrameSubscriber::OnFrameDelivered(
  if (!result)
    return;

+  v8::Locker locker(isolate_);
+  v8::HandleScope handle_scope(isolate_);
+
  gfx::Rect rect = frame->visible_rect();
  size_t rgb_arr_size = rect.width() * rect.height() * 4;
  v8::MaybeLocal<v8::Object> buffer = node::Buffer::New(isolate_, rgb_arr_size);
@ -56,8 +59,6 @@ void FrameSubscriber::OnFrameDelivered(
                           rect.width() * 4,
                           media::YV12);

-  v8::Locker locker(isolate_);
-  v8::HandleScope handle_scope(isolate_);
  callback_.Run(buffer.ToLocalChecked());
 }

--- a/atom/browser/api/lib/app.coffee
+++ b/atom/browser/api/lib/app.coffee
@ -1,30 +1,17 @@
-EventEmitter = require('events').EventEmitter
+{deprecate, session, Menu} = require 'electron'
+{EventEmitter} = require 'events'

 bindings = process.atomBinding 'app'
-sessionBindings = process.atomBinding 'session'
 downloadItemBindings = process.atomBinding 'download_item'

 app = bindings.app
 app.__proto__ = EventEmitter.prototype

-wrapSession = (session) ->
-  # session is an Event Emitter.
-  session.__proto__ = EventEmitter.prototype
-
-wrapDownloadItem = (download_item) ->
-  # download_item is an Event Emitter.
-  download_item.__proto__ = EventEmitter.prototype
-  # Be compatible with old APIs.
-  download_item.url = download_item.getUrl()
-  download_item.filename = download_item.getFilename()
-  download_item.mimeType = download_item.getMimeType()
-  download_item.hasUserGesture = download_item.hasUserGesture()
-
 app.setApplicationMenu = (menu) ->
-  require('menu').setApplicationMenu menu
+  Menu.setApplicationMenu menu

 app.getApplicationMenu = ->
-  require('menu').getApplicationMenu()
+  Menu.getApplicationMenu()

 app.commandLine =
  appendSwitch: bindings.appendSwitch,
@ -47,22 +34,40 @@ app.setAppPath = (path) ->
 app.getAppPath = ->
  appPath

-# Be compatible with old API.
-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
-app.on 'activate', (event, hasVisibleWindows) -> @emit 'activate-with-no-open-windows' if not hasVisibleWindows
+# Routes the events to webContents.
+for name in ['login', 'certificate-error', 'select-client-certificate']
+  do (name) ->
+    app.on name, (event, webContents, args...) ->
+      webContents.emit name, event, args...

-# Session wrapper.
-sessionBindings._setWrapSession wrapSession
-process.once 'exit', sessionBindings._clearWrapSession
+# Deprecated.
+app.getHomeDir = deprecate 'app.getHomeDir', 'app.getPath', ->
+  @getPath 'home'
+app.getDataPath = deprecate 'app.getDataPath', 'app.getPath', ->
+  @getPath 'userData'
+app.setDataPath = deprecate 'app.setDataPath', 'app.setPath', (path) ->
+  @setPath 'userData', path
+app.resolveProxy = deprecate 'app.resolveProxy', 'session.defaultSession.resolveProxy', (url, callback) ->
+  session.defaultSession.resolveProxy url, callback
+deprecate.rename app, 'terminate', 'quit'
+deprecate.event app, 'finish-launching', 'ready', ->
+  setImmediate => # give default app a chance to setup default menu.
+    @emit 'finish-launching'
+deprecate.event app, 'activate-with-no-open-windows', 'activate', (event, hasVisibleWindows) ->
+  @emit 'activate-with-no-open-windows' if not hasVisibleWindows
+deprecate.event app, 'select-certificate', 'select-client-certificate'

+# Wrappers for native classes.
+wrapDownloadItem = (downloadItem) ->
+  # downloadItem is an EventEmitter.
+  downloadItem.__proto__ = EventEmitter.prototype
+  # Deprecated.
+  deprecate.property downloadItem, 'url', 'getURL'
+  deprecate.property downloadItem, 'filename', 'getFilename'
+  deprecate.property downloadItem, 'mimeType', 'getMimeType'
+  deprecate.property downloadItem, 'hasUserGesture', 'hasUserGesture'
+  deprecate.rename downloadItem, 'getUrl', 'getURL'
 downloadItemBindings._setWrapDownloadItem wrapDownloadItem
-process.once 'exit', downloadItemBindings._clearWrapDownloadItem

 # Only one App object pemitted.
 module.exports = app
--- a/atom/browser/api/lib/atom-delegate.coffee
+++ b/atom/browser/api/lib/atom-delegate.coffee
@ -1,6 +0,0 @@
-module.exports =
-  browserMainParts:
-    preMainMessageLoopRun: ->
-
-setImmediate ->
-  module.exports.browserMainParts.preMainMessageLoopRun()
--- a/atom/browser/api/lib/auto-updater.coffee
+++ b/atom/browser/api/lib/auto-updater.coffee
@ -1,7 +1,12 @@
-switch process.platform
-  when 'win32'
-    module.exports = require './auto-updater/auto-updater-win'
-  when 'darwin'
-    module.exports = require './auto-updater/auto-updater-mac'
+{deprecate} = require 'electron'
+
+autoUpdater =
+  if process.platform is 'win32'
+    require './auto-updater/auto-updater-win'
  else
-    throw new Error('auto-updater is not implemented on this platform')
+    require './auto-updater/auto-updater-native'
+
+# Deprecated.
+deprecate.rename autoUpdater, 'setFeedUrl', 'setFeedURL'
+
+module.exports = autoUpdater
--- a/atom/browser/api/lib/auto-updater/auto-updater-native.coffee
+++ b/atom/browser/api/lib/auto-updater/auto-updater-native.coffee
--- a/atom/browser/api/lib/auto-updater/auto-updater-win.coffee
+++ b/atom/browser/api/lib/auto-updater/auto-updater-win.coffee
@ -1,6 +1,6 @@
-app = require 'app'
-url = require 'url'
+{app} = require 'electron'
 {EventEmitter} = require 'events'
+url = require 'url'

 squirrelUpdate = require './squirrel-update-win'

@ -9,28 +9,28 @@ class AutoUpdater extends EventEmitter
    squirrelUpdate.processStart()
    app.quit()

-  setFeedUrl: (updateUrl) ->
-    @updateUrl = updateUrl
+  setFeedURL: (updateURL) ->
+    @updateURL = updateURL

  checkForUpdates: ->
-    return @emitError 'Update URL is not set' unless @updateUrl
+    return @emitError 'Update URL is not set' unless @updateURL
    return @emitError 'Can not find Squirrel' unless squirrelUpdate.supported()

    @emit 'checking-for-update'

-    squirrelUpdate.download @updateUrl, (error, update) =>
+    squirrelUpdate.download @updateURL, (error, update) =>
      return @emitError error if error?
      return @emit 'update-not-available' unless update?

      @emit 'update-available'

-      squirrelUpdate.update @updateUrl, (error) =>
+      squirrelUpdate.update @updateURL, (error) =>
        return @emitError error if error?

        {releaseNotes, version} = update
        # Following information is not available on Windows, so fake them.
        date = new Date
-        url = @updateUrl
+        url = @updateURL

        @emit 'update-downloaded', {}, releaseNotes, version, date, url, => @quitAndInstall()

--- a/atom/browser/api/lib/auto-updater/squirrel-update-win.coffee
+++ b/atom/browser/api/lib/auto-updater/squirrel-update-win.coffee
@ -41,8 +41,8 @@ exports.processStart = (callback) ->
  spawnUpdate ['--processStart', exeName], true, ->

 # Download the releases specified by the URL and write new results to stdout.
-exports.download = (updateUrl, callback) ->
-  spawnUpdate ['--download', updateUrl], false, (error, stdout) ->
+exports.download = (updateURL, callback) ->
+  spawnUpdate ['--download', updateURL], false, (error, stdout) ->
    return callback(error) if error?

    try
@ -55,8 +55,8 @@ exports.download = (updateUrl, callback) ->
    callback null, update

 # Update the application to the latest remote version specified by URL.
-exports.update = (updateUrl, callback) ->
-  spawnUpdate ['--update', updateUrl], false, callback
+exports.update = (updateURL, callback) ->
+  spawnUpdate ['--update', updateURL], false, callback

 # Is the Update.exe installed with the current application?
 exports.supported = ->
--- a/atom/browser/api/lib/browser-window.coffee
+++ b/atom/browser/api/lib/browser-window.coffee
@ -1,11 +1,12 @@
-EventEmitter = require('events').EventEmitter
-app = require 'app'
-ipc = require 'ipc'
+{ipcMain, deprecate} = require 'electron'
+{EventEmitter} = require 'events'

-BrowserWindow = process.atomBinding('window').BrowserWindow
+{BrowserWindow} = process.atomBinding 'window'
 BrowserWindow::__proto__ = EventEmitter.prototype

 BrowserWindow::_init = ->
+  {app} = require 'electron'  # avoid recursive require.
+
  # Simulate the application menu on platforms other than OS X.
  if process.platform isnt 'darwin'
    menu = app.getApplicationMenu()
@ -14,7 +15,7 @@ BrowserWindow::_init = ->
  # Make new windows requested by links behave like "window.open"
  @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
+    ipcMain.emit 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', event, url, frameName, options

  # window.resizeTo(...)
  # window.moveTo(...)
@ -70,33 +71,35 @@ BrowserWindow.fromDevToolsWebContents = (webContents) ->
  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::loadURL = -> @webContents.loadURL.apply @webContents, arguments
+BrowserWindow::getURL = -> @webContents.getURL()
 BrowserWindow::reload = -> @webContents.reload.apply @webContents, arguments
-BrowserWindow::reloadIgnoringCache = -> @webContents.reloadIgnoringCache.apply @webContents, arguments
-BrowserWindow::getPageTitle = -> @webContents.getTitle()
-BrowserWindow::isLoading = -> @webContents.isLoading()
-BrowserWindow::isWaitingForResponse = -> @webContents.isWaitingForResponse()
-BrowserWindow::stop = -> @webContents.stop()
-BrowserWindow::isCrashed = -> @webContents.isCrashed()
-BrowserWindow::executeJavaScriptInDevTools = (code) -> @devToolsWebContents?.executeJavaScript code
+BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
 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
+
+# Deprecated.
+deprecate.member BrowserWindow, 'undo', 'webContents'
+deprecate.member BrowserWindow, 'redo', 'webContents'
+deprecate.member BrowserWindow, 'cut', 'webContents'
+deprecate.member BrowserWindow, 'copy', 'webContents'
+deprecate.member BrowserWindow, 'paste', 'webContents'
+deprecate.member BrowserWindow, 'selectAll', 'webContents'
+deprecate.member BrowserWindow, 'reloadIgnoringCache', 'webContents'
+deprecate.member BrowserWindow, 'getPageTitle', 'webContents'
+deprecate.member BrowserWindow, 'isLoading', 'webContents'
+deprecate.member BrowserWindow, 'isWaitingForResponse', 'webContents'
+deprecate.member BrowserWindow, 'stop', 'webContents'
+deprecate.member BrowserWindow, 'isCrashed', 'webContents'
+deprecate.member BrowserWindow, 'executeJavaScriptInDevTools', 'webContents'
+deprecate.member BrowserWindow, 'print', 'webContents'
+deprecate.member BrowserWindow, 'printToPDF', 'webContents'
+deprecate.rename BrowserWindow, 'restart', 'reload'
+deprecate.rename BrowserWindow, 'loadUrl', 'loadURL'
+deprecate.rename BrowserWindow, 'getUrl', 'getURL'

 module.exports = BrowserWindow
--- a/atom/browser/api/lib/dialog.coffee
+++ b/atom/browser/api/lib/dialog.coffee
@ -1,7 +1,7 @@
+{app, BrowserWindow} = require 'electron'
+
 binding = process.atomBinding 'dialog'
 v8Util = process.atomBinding 'v8_util'
-app = require 'app'
-BrowserWindow = require 'browser-window'

 fileDialogProperties =
  openFile:        1 << 0
--- a/atom/browser/api/lib/exports/electron.coffee
+++ b/atom/browser/api/lib/exports/electron.coffee
@ -0,0 +1,55 @@
+# Import common modules.
+module.exports = require '../../../../common/api/lib/exports/electron'
+
+Object.defineProperties module.exports,
+  # Browser side modules, please sort with alphabet order.
+  app:
+    enumerable: true
+    get: -> require '../app'
+  autoUpdater:
+    enumerable: true
+    get: -> require '../auto-updater'
+  BrowserWindow:
+    enumerable: true
+    get: -> require '../browser-window'
+  contentTracing:
+    enumerable: true
+    get: -> require '../content-tracing'
+  dialog:
+    enumerable: true
+    get: -> require '../dialog'
+  ipcMain:
+    enumerable: true
+    get: -> require '../ipc-main'
+  globalShortcut:
+    enumerable: true
+    get: -> require '../global-shortcut'
+  Menu:
+    enumerable: true
+    get: -> require '../menu'
+  MenuItem:
+    enumerable: true
+    get: -> require '../menu-item'
+  powerMonitor:
+    enumerable: true
+    get: -> require '../power-monitor'
+  powerSaveBlocker:
+    enumerable: true
+    get: -> require '../power-save-blocker'
+  protocol:
+    enumerable: true
+    get: -> require '../protocol'
+  screen:
+    enumerable: true
+    get: -> require '../screen'
+  session:
+    enumerable: true
+    get: -> require '../session'
+  Tray:
+    enumerable: true
+    get: -> require '../tray'
+  # The internal modules, invisible unless you know their names.
+  NavigationController:
+    get: -> require '../navigation-controller'
+  webContents:
+    get: -> require '../web-contents'
--- a/atom/browser/api/lib/global-shortcut.coffee
+++ b/atom/browser/api/lib/global-shortcut.coffee
@ -1,5 +1,3 @@
-bindings = process.atomBinding 'global_shortcut'
-
-globalShortcut = bindings.globalShortcut
+{globalShortcut} = process.atomBinding 'global_shortcut'

 module.exports = globalShortcut
--- a/atom/browser/api/lib/ipc-main.coffee
+++ b/atom/browser/api/lib/ipc-main.coffee
@ -0,0 +1,3 @@
+{EventEmitter} = require 'events'
+
+module.exports = new EventEmitter
--- a/atom/browser/api/lib/ipc.coffee
+++ b/atom/browser/api/lib/ipc.coffee
@ -1,3 +1,6 @@
-EventEmitter = require('events').EventEmitter
+{deprecate, ipcMain} = require 'electron'

-module.exports = new EventEmitter
+# This module is deprecated, we mirror everything from ipcMain.
+deprecate.warn 'ipc module', 'ipcMain module'
+
+module.exports = ipcMain
--- a/atom/browser/api/lib/menu-item.coffee
+++ b/atom/browser/api/lib/menu-item.coffee
@ -1,4 +1,3 @@
-BrowserWindow = require 'browser-window'
 v8Util = process.atomBinding 'v8_util'

 nextCommandId = 0
@ -18,7 +17,7 @@ class MenuItem
  @types = ['normal', 'separator', 'submenu', 'checkbox', 'radio']

  constructor: (options) ->
-    Menu = require 'menu'
+    {Menu} = require 'electron'

    {click, @selector, @type, @role, @label, @sublabel, @accelerator, @icon, @enabled, @visible, @checked, @submenu} = options

--- a/atom/browser/api/lib/menu.coffee
+++ b/atom/browser/api/lib/menu.coffee
@ -1,8 +1,7 @@
-BrowserWindow = require 'browser-window'
-EventEmitter = require('events').EventEmitter
-MenuItem = require 'menu-item'
-v8Util = process.atomBinding 'v8_util'
+{BrowserWindow, MenuItem} = require 'electron'
+{EventEmitter} = require 'events'

+v8Util = process.atomBinding 'v8_util'
 bindings = process.atomBinding 'menu'

 # Automatically generated radio menu item's group id.
--- a/atom/browser/api/lib/navigation-controller.coffee
+++ b/atom/browser/api/lib/navigation-controller.coffee
@ -1,15 +1,15 @@
-ipc = require 'ipc'
+{ipcMain} = require 'electron'

 # The history operation in renderer is redirected to browser.
-ipc.on 'ATOM_SHELL_NAVIGATION_CONTROLLER', (event, method, args...) ->
+ipcMain.on 'ATOM_SHELL_NAVIGATION_CONTROLLER', (event, method, args...) ->
  event.sender[method] args...

-ipc.on 'ATOM_SHELL_SYNC_NAVIGATION_CONTROLLER', (event, method, args...) ->
+ipcMain.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.
+# 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
@ -17,9 +17,9 @@ class NavigationController
    @clearHistory()

    # webContents may have already navigated to a page.
-    if @webContents._getUrl()
+    if @webContents._getURL()
      @currentIndex++
-      @history.push @webContents._getUrl()
+      @history.push @webContents._getURL()

    @webContents.on 'navigation-entry-commited', (event, url, inPage, replaceEntry) =>
      if @inPageIndex > -1 and not inPage
@ -42,12 +42,12 @@ class NavigationController
          @currentIndex++
          @history.push url

-  loadUrl: (url, options={}) ->
+  loadURL: (url, options={}) ->
    @pendingIndex = -1
-    @webContents._loadUrl url, options
+    @webContents._loadURL url, options
    @webContents.emit 'load-url', url, options

-  getUrl: ->
+  getURL: ->
    if @currentIndex is -1
      ''
    else
@ -59,11 +59,11 @@ class NavigationController

  reload: ->
    @pendingIndex = @currentIndex
-    @webContents._loadUrl @getUrl(), {}
+    @webContents._loadURL @getURL(), {}

  reloadIgnoringCache: ->
-    @webContents._reloadIgnoringCache()  # Rely on WebContents to clear cache.
-    @reload()
+    @pendingIndex = @currentIndex
+    @webContents._loadURL @getURL(), {extraHeaders: "pragma: no-cache\n"}

  canGoBack: ->
    @getActiveIndex() > 0
@ -89,7 +89,7 @@ class NavigationController
    if @inPageIndex > -1 and @pendingIndex >= @inPageIndex
      @webContents._goBack()
    else
-      @webContents._loadUrl @history[@pendingIndex], {}
+      @webContents._loadURL @history[@pendingIndex], {}

  goForward: ->
    return unless @canGoForward()
@ -97,12 +97,12 @@ class NavigationController
    if @inPageIndex > -1 and @pendingIndex >= @inPageIndex
      @webContents._goForward()
    else
-      @webContents._loadUrl @history[@pendingIndex], {}
+      @webContents._loadURL @history[@pendingIndex], {}

  goToIndex: (index) ->
    return unless @canGoToIndex index
    @pendingIndex = index
-    @webContents._loadUrl @history[@pendingIndex], {}
+    @webContents._loadURL @history[@pendingIndex], {}

  goToOffset: (offset) ->
    return unless @canGoToOffset offset
--- a/atom/browser/api/lib/power-monitor.coffee
+++ b/atom/browser/api/lib/power-monitor.coffee
@ -1,5 +1,6 @@
-powerMonitor = process.atomBinding('power_monitor').powerMonitor
-EventEmitter = require('events').EventEmitter
+{EventEmitter} = require 'events'
+
+{powerMonitor} = process.atomBinding 'power_monitor'

 powerMonitor.__proto__ = EventEmitter.prototype

--- a/atom/browser/api/lib/power-save-blocker.coffee
+++ b/atom/browser/api/lib/power-save-blocker.coffee
@ -1,3 +1,3 @@
-bindings = process.atomBinding 'power_save_blocker'
+{powerSaveBlocker} = process.atomBinding 'power_save_blocker'

-module.exports = bindings.powerSaveBlocker
+module.exports = powerSaveBlocker
--- a/atom/browser/api/lib/protocol.coffee
+++ b/atom/browser/api/lib/protocol.coffee
@ -1,7 +1,8 @@
-app = require 'app'
+{app} = require 'electron'
+
 throw new Error('Can not initialize protocol module before app is ready') unless app.isReady()

-protocol = process.atomBinding('protocol').protocol
+{protocol} = process.atomBinding 'protocol'

 # Warn about removed APIs.
 logAndThrow = (callback, message) ->
--- a/atom/browser/api/lib/screen.coffee
+++ b/atom/browser/api/lib/screen.coffee
@ -1,6 +1,6 @@
-EventEmitter = require('events').EventEmitter
+{EventEmitter} = require 'events'
+{screen} = process.atomBinding 'screen'

-screen = process.atomBinding('screen').screen
 screen.__proto__ = EventEmitter.prototype

 module.exports = screen
--- a/atom/browser/api/lib/session.coffee
+++ b/atom/browser/api/lib/session.coffee
@ -0,0 +1,23 @@
+{EventEmitter} = require 'events'
+
+bindings = process.atomBinding 'session'
+
+PERSIST_PERFIX = 'persist:'
+
+# Returns the Session from |partition| string.
+exports.fromPartition = (partition='') ->
+  if partition.startsWith PERSIST_PERFIX
+    bindings.fromPartition partition.substr(PERSIST_PERFIX.length), false
+  else
+    bindings.fromPartition partition, true
+
+# Returns the default session.
+Object.defineProperty exports, 'defaultSession',
+  enumerable: true
+  get: -> exports.fromPartition ''
+
+wrapSession = (session) ->
+  # session is an EventEmitter.
+  session.__proto__ = EventEmitter.prototype
+
+bindings._setWrapSession wrapSession
--- a/atom/browser/api/lib/tray.coffee
+++ b/atom/browser/api/lib/tray.coffee
@ -1,14 +1,19 @@
-EventEmitter = require('events').EventEmitter
-bindings = process.atomBinding 'tray'
+{deprecate} = require 'electron'
+{EventEmitter} = require 'events'

-Tray = bindings.Tray
+{Tray} = process.atomBinding 'tray'
 Tray::__proto__ = EventEmitter.prototype

+Tray::_init = ->
+  # Deprecated.
+  deprecate.rename this, 'popContextMenu', 'popUpContextMenu'
+  deprecate.event this, 'clicked', 'click'
+  deprecate.event this, 'double-clicked', 'double-click'
+  deprecate.event this, 'right-clicked', 'right-click'
+  deprecate.event this, 'balloon-clicked', 'balloon-click'
+
 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
--- a/atom/browser/api/lib/web-contents.coffee
+++ b/atom/browser/api/lib/web-contents.coffee
@ -1,7 +1,7 @@
-EventEmitter = require('events').EventEmitter
-NavigationController = require './navigation-controller'
+{EventEmitter} = require 'events'
+{deprecate, ipcMain, session, NavigationController, Menu} = require 'electron'
+
 binding = process.atomBinding 'web_contents'
-ipc = require 'ipc'

 nextId = 0
 getNextId = -> ++nextId
@ -45,7 +45,7 @@ wrapWebContents = (webContents) ->
  # Make sure webContents.executeJavaScript would run the code only when the
  # web contents has been loaded.
  webContents.executeJavaScript = (code, hasUserGesture=false) ->
-    if @getUrl() and not @isLoading()
+    if @getURL() and not @isLoading()
      @_executeJavaScript code, hasUserGesture
    else
      webContents.once 'did-finish-load', @_executeJavaScript.bind(this, code, hasUserGesture)
@ -59,11 +59,20 @@ wrapWebContents = (webContents) ->
  # Dispatch IPC messages to the ipc module.
  webContents.on 'ipc-message', (event, packed) ->
    [channel, args...] = packed
-    ipc.emit channel, event, args...
+    ipcMain.emit channel, event, args...
  webContents.on 'ipc-message-sync', (event, packed) ->
    [channel, args...] = packed
    Object.defineProperty event, 'returnValue', set: (value) -> event.sendReply JSON.stringify(value)
-    ipc.emit channel, event, args...
+    ipcMain.emit channel, event, args...
+
+  # Handle context menu action request from pepper plugin.
+  webContents.on 'pepper-context-menu', (event, params) ->
+    menu = Menu.buildFromTemplate params.menu
+    menu.popup params.x, params.y
+
+  # Deprecated.
+  deprecate.rename webContents, 'loadUrl', 'loadURL'
+  deprecate.rename webContents, 'getUrl', 'getURL'

  webContents.printToPDF = (options, callback) ->
    printingSetting =
@ -106,7 +115,6 @@ wrapWebContents = (webContents) ->
    @_printToPDF printingSetting, callback

 binding._setWrapWebContents wrapWebContents
-process.once 'exit', binding._clearWrapWebContents

 module.exports.create = (options={}) ->
  binding.create(options)
--- a/atom/browser/atom_access_token_store.cc
+++ b/atom/browser/atom_access_token_store.cc
@ -18,7 +18,7 @@ namespace {
 // Notice that we just combined the api key with the url together here, because
 // if we use the standard {url: key} format Chromium would override our key with
 // the predefined one in common.gypi of libchromiumcontent, which is empty.
-const char* kGeolocationProviderUrl =
+const char* kGeolocationProviderURL =
    "https://www.googleapis.com/geolocation/v1/geolocate?key="
    GOOGLEAPIS_API_KEY;

@ -35,11 +35,11 @@ void AtomAccessTokenStore::LoadAccessTokens(
    const LoadAccessTokensCallbackType& callback) {
  AccessTokenSet access_token_set;

-  // Equivelent to access_token_set[kGeolocationProviderUrl].
+  // Equivelent to access_token_set[kGeolocationProviderURL].
  // Somehow base::string16 is causing compilation errors when used in a pair
  // of std::map on Linux, this can work around it.
  std::pair<GURL, base::string16> token_pair;
-  token_pair.first = GURL(kGeolocationProviderUrl);
+  token_pair.first = GURL(kGeolocationProviderURL);
  access_token_set.insert(token_pair);

  auto browser_context = AtomBrowserMainParts::Get()->browser_context();
--- a/atom/browser/atom_browser_client.cc
+++ b/atom/browser/atom_browser_client.cc
@ -14,7 +14,6 @@
 #include "atom/browser/atom_quota_permission_context.h"
 #include "atom/browser/atom_resource_dispatcher_host_delegate.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_contents_preferences.h"
 #include "atom/browser/window_list.h"
@ -88,7 +87,7 @@ void AtomBrowserClient::SetCustomSchemes(
  g_custom_schemes = JoinString(schemes, ',');
 }

-AtomBrowserClient::AtomBrowserClient() {
+AtomBrowserClient::AtomBrowserClient() : delegate_(nullptr) {
 }

 AtomBrowserClient::~AtomBrowserClient() {
@ -208,6 +207,26 @@ content::QuotaPermissionContext*
  return new AtomQuotaPermissionContext;
 }

+void AtomBrowserClient::AllowCertificateError(
+    int render_process_id,
+    int render_frame_id,
+    int cert_error,
+    const net::SSLInfo& ssl_info,
+    const GURL& request_url,
+    content::ResourceType resource_type,
+    bool overridable,
+    bool strict_enforcement,
+    bool expired_previous_decision,
+    const base::Callback<void(bool)>& callback,
+    content::CertificateRequestResultType* request) {
+  if (delegate_) {
+    delegate_->AllowCertificateError(
+        render_process_id, render_frame_id, cert_error, ssl_info, request_url,
+        resource_type, overridable, strict_enforcement,
+        expired_previous_decision, callback, request);
+  }
+}
+
 void AtomBrowserClient::SelectClientCertificate(
    content::WebContents* web_contents,
    net::SSLCertRequestInfo* cert_request_info,
@ -222,10 +241,10 @@ void AtomBrowserClient::SelectClientCertificate(
    return;
  }

-  if (!cert_request_info->client_certs.empty())
-    Browser::Get()->ClientCertificateSelector(web_contents,
-                                              cert_request_info,
-                                              delegate.Pass());
+  if (!cert_request_info->client_certs.empty() && delegate_) {
+    delegate_->SelectClientCertificate(
+        web_contents, cert_request_info, delegate.Pass());
+  }
 }

 void AtomBrowserClient::ResourceDispatcherHostCreated() {
--- a/atom/browser/atom_browser_client.h
+++ b/atom/browser/atom_browser_client.h
@ -31,6 +31,9 @@ class AtomBrowserClient : public brightray::BrowserClient,
  AtomBrowserClient();
  virtual ~AtomBrowserClient();

+  using Delegate = content::ContentBrowserClient;
+  void set_delegate(Delegate* delegate) { delegate_ = delegate; }
+
  // Don't force renderer process to restart for once.
  static void SuppressRendererProcessRestartForOnce();
  // Custom schemes to be registered to standard.
@ -54,6 +57,18 @@ class AtomBrowserClient : public brightray::BrowserClient,
                                      int child_process_id) override;
  void DidCreatePpapiPlugin(content::BrowserPpapiHost* browser_host) override;
  content::QuotaPermissionContext* CreateQuotaPermissionContext() override;
+  void AllowCertificateError(
+      int render_process_id,
+      int render_frame_id,
+      int cert_error,
+      const net::SSLInfo& ssl_info,
+      const GURL& request_url,
+      content::ResourceType resource_type,
+      bool overridable,
+      bool strict_enforcement,
+      bool expired_previous_decision,
+      const base::Callback<void(bool)>& callback,
+      content::CertificateRequestResultType* request) override;
  void SelectClientCertificate(
      content::WebContents* web_contents,
      net::SSLCertRequestInfo* cert_request_info,
@ -74,6 +89,8 @@ class AtomBrowserClient : public brightray::BrowserClient,
  scoped_ptr<AtomResourceDispatcherHostDelegate>
      resource_dispatcher_host_delegate_;

+  Delegate* delegate_;
+
  DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
 };

--- a/atom/browser/atom_browser_context.cc
+++ b/atom/browser/atom_browser_context.cc
@ -6,8 +6,9 @@

 #include "atom/browser/atom_browser_main_parts.h"
 #include "atom/browser/atom_download_manager_delegate.h"
-#include "atom/browser/atom_ssl_config_service.h"
 #include "atom/browser/browser.h"
+#include "atom/browser/net/atom_cert_verifier.h"
+#include "atom/browser/net/atom_ssl_config_service.h"
 #include "atom/browser/net/atom_url_request_job_factory.h"
 #include "atom/browser/net/asar/asar_protocol_handler.h"
 #include "atom/browser/net/http_protocol_handler.h"
@ -60,6 +61,7 @@ std::string RemoveWhitespace(const std::string& str) {
 AtomBrowserContext::AtomBrowserContext(const std::string& partition,
                                       bool in_memory)
    : brightray::BrowserContext(partition, in_memory),
+      cert_verifier_(new AtomCertVerifier),
      job_factory_(new AtomURLRequestJobFactory),
      allow_ntlm_everywhere_(false) {
 }
@ -158,6 +160,10 @@ content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
  return guest_manager_.get();
 }

+net::CertVerifier* AtomBrowserContext::CreateCertVerifier() {
+  return cert_verifier_;
+}
+
 net::SSLConfigService* AtomBrowserContext::CreateSSLConfigService() {
  return new AtomSSLConfigService;
 }
--- a/atom/browser/atom_browser_context.h
+++ b/atom/browser/atom_browser_context.h
@ -12,6 +12,7 @@
 namespace atom {

 class AtomDownloadManagerDelegate;
+class AtomCertVerifier;
 class AtomURLRequestJobFactory;
 class WebViewManager;

@ -27,6 +28,7 @@ class AtomBrowserContext : public brightray::BrowserContext {
      content::URLRequestInterceptorScopedVector* interceptors) override;
  net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
      const base::FilePath& base_path) override;
+  net::CertVerifier* CreateCertVerifier() override;
  net::SSLConfigService* CreateSSLConfigService() override;
  bool AllowNTLMCredentialsForDomain(const GURL& auth_origin) override;

@ -39,6 +41,8 @@ class AtomBrowserContext : public brightray::BrowserContext {

  void AllowNTLMCredentialsForAllDomains(bool should_allow);

+  AtomCertVerifier* cert_verifier() const { return cert_verifier_; }
+
  AtomURLRequestJobFactory* job_factory() const { return job_factory_; }

 private:
@ -46,6 +50,7 @@ class AtomBrowserContext : public brightray::BrowserContext {
  scoped_ptr<WebViewManager> guest_manager_;

  // Managed by brightray::BrowserContext.
+  AtomCertVerifier* cert_verifier_;
  AtomURLRequestJobFactory* job_factory_;

  bool allow_ntlm_everywhere_;
--- a/atom/browser/atom_browser_main_parts.cc
+++ b/atom/browser/atom_browser_main_parts.cc
@ -30,6 +30,7 @@ AtomBrowserMainParts* AtomBrowserMainParts::self_ = NULL;

 AtomBrowserMainParts::AtomBrowserMainParts()
    : fake_browser_process_(new BrowserProcess),
+      exit_code_(nullptr),
      browser_(new Browser),
      node_bindings_(NodeBindings::Create(true)),
      atom_bindings_(new AtomBindings),
@ -47,6 +48,14 @@ AtomBrowserMainParts* AtomBrowserMainParts::Get() {
  return self_;
 }

+bool AtomBrowserMainParts::SetExitCode(int code) {
+  if (!exit_code_)
+    return false;
+
+  *exit_code_ = code;
+  return true;
+}
+
 void AtomBrowserMainParts::RegisterDestructionCallback(
    const base::Closure& callback) {
  destruction_callbacks_.push_back(callback);
@ -118,6 +127,11 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
 #endif
 }

+bool AtomBrowserMainParts::MainMessageLoopRun(int* result_code) {
+  exit_code_ = result_code;
+  return brightray::BrowserMainParts::MainMessageLoopRun(result_code);
+}
+
 void AtomBrowserMainParts::PostMainMessageLoopStart() {
  brightray::BrowserMainParts::PostMainMessageLoopStart();
 #if defined(OS_POSIX)
@ -128,11 +142,23 @@ void AtomBrowserMainParts::PostMainMessageLoopStart() {
 void AtomBrowserMainParts::PostMainMessageLoopRun() {
  brightray::BrowserMainParts::PostMainMessageLoopRun();

+#if defined(OS_MACOSX)
+  FreeAppDelegate();
+#endif
+
  // 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();
+
+  // Destroy JavaScript environment immediately after running destruction
+  // callbacks.
+  gc_timer_.Stop();
+  node_debugger_.reset();
+  atom_bindings_.reset();
+  node_bindings_.reset();
+  js_env_.reset();
 }

 }  // namespace atom
--- a/atom/browser/atom_browser_main_parts.h
+++ b/atom/browser/atom_browser_main_parts.h
@ -31,6 +31,9 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {

  static AtomBrowserMainParts* Get();

+  // Sets the exit code, will fail if the the message loop is not ready.
+  bool SetExitCode(int code);
+
  // Register a callback that should be destroyed before JavaScript environment
  // gets destroyed.
  void RegisterDestructionCallback(const base::Closure& callback);
@ -42,11 +45,11 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
  void PreEarlyInitialization() override;
  void PostEarlyInitialization() override;
  void PreMainMessageLoopRun() override;
+  bool MainMessageLoopRun(int* result_code) override;
  void PostMainMessageLoopStart() override;
  void PostMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
  void PreMainMessageLoopStart() override;
-  void PostDestroyThreads() override;
 #endif

 private:
@ -56,6 +59,10 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
  void HandleShutdownSignals();
 #endif

+#if defined(OS_MACOSX)
+  void FreeAppDelegate();
+#endif
+
  // A fake BrowserProcess object that used to feed the source code from chrome.
  scoped_ptr<BrowserProcess> fake_browser_process_;

@ -63,6 +70,9 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
  // with a task runner that will post all work to main loop.
  scoped_refptr<BridgeTaskRunner> bridge_task_runner_;

+  // Pointer to exit code.
+  int* exit_code_;
+
  scoped_ptr<Browser> browser_;
  scoped_ptr<JavascriptEnvironment> js_env_;
  scoped_ptr<NodeBindings> node_bindings_;
--- a/atom/browser/atom_browser_main_parts_mac.mm
+++ b/atom/browser/atom_browser_main_parts_mac.mm
@ -34,7 +34,7 @@ void AtomBrowserMainParts::PreMainMessageLoopStart() {
      setObject:@"NO" forKey:@"NSTreatUnknownArgumentsAsOpen"];
 }

-void AtomBrowserMainParts::PostDestroyThreads() {
+void AtomBrowserMainParts::FreeAppDelegate() {
  [[NSApp delegate] release];
  [NSApp setDelegate:nil];
 }
--- a/atom/browser/atom_resource_dispatcher_host_delegate.cc
+++ b/atom/browser/atom_resource_dispatcher_host_delegate.cc
@ -4,6 +4,7 @@

 #include "atom/browser/atom_resource_dispatcher_host_delegate.h"

+#include "atom/browser/login_handler.h"
 #include "atom/common/platform_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
@ -29,4 +30,11 @@ bool AtomResourceDispatcherHostDelegate::HandleExternalProtocol(
  return true;
 }

+content::ResourceDispatcherHostLoginDelegate*
+AtomResourceDispatcherHostDelegate::CreateLoginDelegate(
+    net::AuthChallengeInfo* auth_info,
+    net::URLRequest* request) {
+  return new LoginHandler(auth_info, request);
+}
+
 }  // namespace atom
--- a/atom/browser/atom_resource_dispatcher_host_delegate.h
+++ b/atom/browser/atom_resource_dispatcher_host_delegate.h
@ -21,6 +21,9 @@ class AtomResourceDispatcherHostDelegate
                              bool is_main_frame,
                              ui::PageTransition transition,
                              bool has_user_gesture) override;
+  content::ResourceDispatcherHostLoginDelegate* CreateLoginDelegate(
+      net::AuthChallengeInfo* auth_info,
+      net::URLRequest* request) override;
 };

 }  // namespace atom
--- a/atom/browser/browser.cc
+++ b/atom/browser/browser.cc
@ -7,10 +7,9 @@
 #include <string>

 #include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/native_window.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 {

@ -45,6 +44,27 @@ void Browser::Quit() {
  window_list->CloseAllWindows();
 }

+void Browser::Exit(int code) {
+  if (!AtomBrowserMainParts::Get()->SetExitCode(code)) {
+    // Message loop is not ready, quit directly.
+    exit(code);
+  } else {
+    // Prepare to quit when all windows have been closed..
+    is_quiting_ = true;
+
+    // Must destroy windows before quitting, otherwise bad things can happen.
+    atom::WindowList* window_list = atom::WindowList::GetInstance();
+    if (window_list->size() == 0) {
+      NotifyAndShutdown();
+    } else {
+      // Unlike Quit(), we do not ask to close window, but destroy the window
+      // without asking.
+      for (NativeWindow* window : *window_list)
+        window->CloseContents(nullptr);  // e.g. Destroy()
+    }
+  }
+}
+
 void Browser::Shutdown() {
  if (is_shutdown_)
    return;
@ -89,10 +109,6 @@ std::string Browser::GetName() const {

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

 bool Browser::OpenFile(const std::string& file_path) {
@ -123,15 +139,8 @@ 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::RequestLogin(LoginHandler* login_handler) {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnLogin(login_handler));
 }

 void Browser::NotifyAndShutdown() {
--- a/atom/browser/browser.h
+++ b/atom/browser/browser.h
@ -11,12 +11,12 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/observer_list.h"
+#include "base/strings/string16.h"
 #include "atom/browser/browser_observer.h"
 #include "atom/browser/window_list_observer.h"

 #if defined(OS_WIN)
 #include "base/files/file_path.h"
-#include "base/strings/string16.h"
 #endif

 namespace base {
@ -29,6 +29,8 @@ class MenuModel;

 namespace atom {

+class LoginHandler;
+
 // This class is used for control application-wide operations.
 class Browser : public WindowListObserver {
 public:
@ -40,6 +42,9 @@ class Browser : public WindowListObserver {
  // Try to close all windows and quit the application.
  void Quit();

+  // Exit the application immediately and set exit code.
+  void Exit(int code);
+
  // Cleanup everything and shutdown the application gracefully.
  void Shutdown();

@ -64,6 +69,9 @@ class Browser : public WindowListObserver {
  // Clear the recent documents list.
  void ClearRecentDocuments();

+  // Set the application user model ID.
+  void SetAppUserModelID(const base::string16& name);
+
 #if defined(OS_MACOSX)
  // Bounce the dock icon.
  enum BounceType {
@ -98,8 +106,10 @@ class Browser : public WindowListObserver {
  // Add a custom task to jump list.
  void SetUserTasks(const std::vector<UserTask>& tasks);

-  // Set the application user model ID, called when "SetName" is called.
-  void SetAppUserModelID(const std::string& name);
+  // Returns the application user model ID, if there isn't one, then create
+  // one from app's name.
+  // The returned string managed by Browser, and should not be modified.
+  PCWSTR GetAppUserModelID();
 #endif

  // Tell the application to open a file.
@ -116,11 +126,8 @@ 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);
+  // Request basic auth login.
+  void RequestLogin(LoginHandler* login_handler);

  void AddObserver(BrowserObserver* obs) {
    observers_.AddObserver(obs);
--- a/atom/browser/browser_linux.cc
+++ b/atom/browser/browser_linux.cc
@ -31,6 +31,9 @@ void Browser::AddRecentDocument(const base::FilePath& path) {
 void Browser::ClearRecentDocuments() {
 }

+void Browser::SetAppUserModelID(const base::string16& name) {
+}
+
 std::string Browser::GetExecutableFileVersion() const {
  return brightray::GetApplicationVersion();
 }
--- a/atom/browser/browser_mac.mm
+++ b/atom/browser/browser_mac.mm
@ -26,6 +26,9 @@ void Browser::AddRecentDocument(const base::FilePath& path) {
 void Browser::ClearRecentDocuments() {
 }

+void Browser::SetAppUserModelID(const base::string16& name) {
+}
+
 std::string Browser::GetExecutableFileVersion() const {
  return brightray::GetApplicationVersion();
 }
--- a/atom/browser/browser_observer.h
+++ b/atom/browser/browser_observer.h
@ -7,19 +7,10 @@

 #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 LoginHandler;
+
 class BrowserObserver {
 public:
  // The browser is about to close all windows.
@ -51,11 +42,8 @@ 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) {}
+  // The browser requests HTTP login.
+  virtual void OnLogin(LoginHandler* login_handler) {}

 protected:
  virtual ~BrowserObserver() {}
--- a/atom/browser/browser_win.cc
+++ b/atom/browser/browser_win.cc
@ -15,6 +15,7 @@
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/win_util.h"
@ -25,6 +26,8 @@ namespace atom {

 namespace {

+const wchar_t kAppUserModelIDFormat[] = L"electron.app.$1";
+
 BOOL CALLBACK WindowsEnumerationHandler(HWND hwnd, LPARAM param) {
  DWORD target_process_id = *reinterpret_cast<DWORD*>(param);
  DWORD process_id = 0;
@ -56,7 +59,7 @@ void Browser::AddRecentDocument(const base::FilePath& path) {
  if (SUCCEEDED(hr)) {
    SHARDAPPIDINFO info;
    info.psi = item;
-    info.pszAppID = app_user_model_id_.c_str();
+    info.pszAppID = GetAppUserModelID();
    SHAddToRecentDocs(SHARD_APPIDINFO, &info);
  }
 }
@ -66,16 +69,21 @@ void Browser::ClearRecentDocuments() {
  if (FAILED(destinations.CoCreateInstance(CLSID_ApplicationDestinations,
                                           NULL, CLSCTX_INPROC_SERVER)))
    return;
-  if (FAILED(destinations->SetAppID(app_user_model_id_.c_str())))
+  if (FAILED(destinations->SetAppID(GetAppUserModelID())))
    return;
  destinations->RemoveAllDestinations();
 }

+void Browser::SetAppUserModelID(const base::string16& name) {
+  app_user_model_id_ = name;
+  SetCurrentProcessExplicitAppUserModelID(app_user_model_id_.c_str());
+}
+
 void Browser::SetUserTasks(const std::vector<UserTask>& tasks) {
  CComPtr<ICustomDestinationList> destinations;
  if (FAILED(destinations.CoCreateInstance(CLSID_DestinationList)))
    return;
-  if (FAILED(destinations->SetAppID(app_user_model_id_.c_str())))
+  if (FAILED(destinations->SetAppID(GetAppUserModelID())))
    return;

  // Start a transaction that updates the JumpList of this application.
@ -117,10 +125,13 @@ void Browser::SetUserTasks(const std::vector<UserTask>& tasks) {
  destinations->CommitList();
 }

-void Browser::SetAppUserModelID(const std::string& name) {
-  app_user_model_id_ = base::string16(L"electron.app.");
-  app_user_model_id_ += base::UTF8ToUTF16(name);
-  SetCurrentProcessExplicitAppUserModelID(app_user_model_id_.c_str());
+PCWSTR Browser::GetAppUserModelID() {
+  if (app_user_model_id_.empty()) {
+    SetAppUserModelID(ReplaceStringPlaceholders(
+        kAppUserModelIDFormat, base::UTF8ToUTF16(GetName()), nullptr));
+  }
+
+  return app_user_model_id_.c_str();
 }

 std::string Browser::GetExecutableFileVersion() const {
--- a/atom/browser/default_app/default_app.js
+++ b/atom/browser/default_app/default_app.js
@ -1,5 +1,6 @@
-var app = require('app');
-var BrowserWindow = require('browser-window');
+const electron = require('electron');
+const app = electron.app;
+const BrowserWindow = electron.BrowserWindow;

 var mainWindow = null;

@ -12,9 +13,9 @@ app.on('ready', function() {
  mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
-    'auto-hide-menu-bar': true,
-    'use-content-size': true,
+    autoHideMenuBar: true,
+    useContentSize: true,
  });
-  mainWindow.loadUrl('file://' + __dirname + '/index.html');
+  mainWindow.loadURL('file://' + __dirname + '/index.html');
  mainWindow.focus();
 });
--- a/atom/browser/default_app/index.html
+++ b/atom/browser/default_app/index.html
@ -57,13 +57,17 @@
 </head>
 <body>
  <script>
-    var execPath = require('remote').process.execPath;
+    const electron = require('electron');
+    const remote = electron.remote;
+    const shell = electron.shell;
+
+    var execPath = remote.process.execPath;
    var command = execPath + ' path-to-your-app';

    document.onclick = function(e) {
      e.preventDefault();
      if (e.target.tagName == 'A')
-        require('shell').openExternal(e.target.href);
+        shell.openExternal(e.target.href);
      return false;
    };
    document.ondragover = document.ondrop = function(e) {
--- a/atom/browser/default_app/main.js
+++ b/atom/browser/default_app/main.js
@ -1,9 +1,11 @@
-var app = require('app');
-var dialog = require('dialog');
+const electron = require('electron');
+const app      = electron.app;
+const dialog   = electron.dialog;
+const shell    = electron.shell;
+const Menu     = electron.Menu;
+
 var fs = require('fs');
 var path = require('path');
-var Menu = require('menu');
-var BrowserWindow = require('browser-window');

 // Quit when all windows are closed and no other one is listening to this.
 app.on('window-all-closed', function() {
@ -142,19 +144,19 @@ app.once('ready', function() {
      submenu: [
        {
          label: 'Learn More',
-          click: function() { require('shell').openExternal('http://electron.atom.io') }
+          click: function() { shell.openExternal('http://electron.atom.io') }
        },
        {
          label: 'Documentation',
-          click: function() { require('shell').openExternal('https://github.com/atom/electron/tree/master/docs#readme') }
+          click: function() { shell.openExternal('https://github.com/atom/electron/tree/master/docs#readme') }
        },
        {
          label: 'Community Discussions',
-          click: function() { require('shell').openExternal('https://discuss.atom.io/c/electron') }
+          click: function() { shell.openExternal('https://discuss.atom.io/c/electron') }
        },
        {
          label: 'Search Issues',
-          click: function() { require('shell').openExternal('https://github.com/atom/electron/issues') }
+          click: function() { shell.openExternal('https://github.com/atom/electron/issues') }
        }
      ]
    },
@ -269,5 +271,5 @@ if (option.file && !option.webdriver) {
  console.log(helpMessage);
  process.exit(0);
 } else {
-  require('./default_app.js');
+  require('./default_app');
 }
--- a/atom/browser/javascript_environment.cc
+++ b/atom/browser/javascript_environment.cc
@ -4,7 +4,10 @@

 #include "atom/browser/javascript_environment.h"

+#include <string>
+
 #include "base/command_line.h"
+#include "content/public/common/content_switches.h"
 #include "gin/array_buffer.h"
 #include "gin/v8_initializer.h"

@ -27,6 +30,12 @@ bool JavascriptEnvironment::Initialize() {
    const char expose_debug_as[] = "--expose_debug_as=v8debug";
    v8::V8::SetFlagsFromString(expose_debug_as, sizeof(expose_debug_as) - 1);
  }
+
+  // --js-flags.
+  std::string js_flags = cmd->GetSwitchValueASCII(switches::kJavaScriptFlags);
+  if (!js_flags.empty())
+    v8::V8::SetFlagsFromString(js_flags.c_str(), js_flags.size());
+
  gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
                                 gin::ArrayBufferAllocator::SharedInstance());
  return true;
--- a/atom/browser/lib/chrome-extension.coffee
+++ b/atom/browser/lib/chrome-extension.coffee
@ -1,4 +1,4 @@
-app  = require 'app'
+electron = require 'electron'
 fs   = require 'fs'
 path = require 'path'
 url  = require 'url'
@ -40,6 +40,7 @@ loadedExtensions = null
 loadedExtensionsPath = null

 # Persistent loaded extensions.
+{app} = electron
 app.on 'will-quit', ->
  try
    loadedExtensions = Object.keys(extensionInfoMap).map (key) -> extensionInfoMap[key].srcDirectory
@ -51,11 +52,10 @@ app.on 'will-quit', ->

 # We can not use protocol or BrowserWindow until app is ready.
 app.once 'ready', ->
-  protocol = require 'protocol'
-  BrowserWindow = require 'browser-window'
+  {protocol, BrowserWindow} = electron

  # Load persistented extensions.
-  loadedExtensionsPath = path.join app.getDataPath(), 'DevTools Extensions'
+  loadedExtensionsPath = path.join app.getPath('userData'), 'DevTools Extensions'

  try
    loadedExtensions = JSON.parse fs.readFileSync(loadedExtensionsPath)
--- a/atom/browser/lib/guest-view-manager.coffee
+++ b/atom/browser/lib/guest-view-manager.coffee
@ -1,5 +1,5 @@
-ipc = require 'ipc'
-webContents = require 'web-contents'
+{ipcMain, webContents} = require 'electron'
+
 webViewManager = null  # Doesn't exist in early initialization.

 supportedWebViewEvents = [
@ -79,7 +79,7 @@ createGuest = (embedder, params) ->
      opts = {}
      opts.httpReferrer = params.httpreferrer if params.httpreferrer
      opts.userAgent = params.useragent if params.useragent
-      @loadUrl params.src, opts
+      @loadURL params.src, opts

    if params.allowtransparency?
      @setAllowTransparency params.allowtransparency
@ -118,11 +118,11 @@ attachGuest = (embedder, elementInstanceId, guestInstanceId, params) ->
    destroyGuest embedder, oldGuestInstanceId

  webPreferences =
-    'guest-instance-id': guestInstanceId
-    'node-integration': params.nodeintegration ? false
-    'plugins': params.plugins
-    'web-security': !params.disablewebsecurity
-  webPreferences['preload-url'] = params.preload if params.preload
+    guestInstanceId: guestInstanceId
+    nodeIntegration: params.nodeintegration ? false
+    plugins: params.plugins
+    webSecurity: !params.disablewebsecurity
+  webPreferences.preloadURL = params.preload if params.preload
  webViewManager.addGuest guestInstanceId, elementInstanceId, embedder, guest, webPreferences

  guest.attachParams = params
@ -140,19 +140,19 @@ destroyGuest = (embedder, id) ->
    delete reverseEmbedderElementsMap[id]
    delete embedderElementsMap[key]

-ipc.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_CREATE_GUEST', (event, params, requestId) ->
+ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_CREATE_GUEST', (event, params, requestId) ->
  event.sender.send "ATOM_SHELL_RESPONSE_#{requestId}", createGuest(event.sender, params)

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

-ipc.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_DESTROY_GUEST', (event, id) ->
+ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_DESTROY_GUEST', (event, id) ->
  destroyGuest event.sender, id

-ipc.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_SET_SIZE', (event, id, params) ->
+ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_SET_SIZE', (event, id, params) ->
  guestInstances[id]?.guest.setSize params

-ipc.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_SET_ALLOW_TRANSPARENCY', (event, id, allowtransparency) ->
+ipcMain.on 'ATOM_SHELL_GUEST_VIEW_MANAGER_SET_ALLOW_TRANSPARENCY', (event, id, allowtransparency) ->
  guestInstances[id]?.guest.setAllowTransparency allowtransparency

 # Returns WebContents from its guest id.
--- a/atom/browser/lib/guest-window-manager.coffee
+++ b/atom/browser/lib/guest-window-manager.coffee
@ -1,29 +1,37 @@
-ipc = require 'ipc'
+{ipcMain, BrowserWindow} = require 'electron'
 v8Util = process.atomBinding 'v8_util'
-BrowserWindow = require 'browser-window'

 frameToGuest = {}

+# Copy attribute of |parent| to |child| if it is not defined in |child|.
+mergeOptions = (child, parent) ->
+  for own key, value of parent when key not in child
+    if typeof value is 'object'
+      child[key] = mergeOptions {}, value
+    else
+      child[key] = value
+  child
+
 # Merge |options| with the |embedder|'s window's options.
 mergeBrowserWindowOptions = (embedder, options) ->
  if embedder.browserWindowOptions?
    # Inherit the original options if it is a BrowserWindow.
-    options.__proto__ = embedder.browserWindowOptions
+    mergeOptions options, embedder.browserWindowOptions
  else
    # Or only inherit web-preferences if it is a webview.
-    options['web-preferences'] ?= {}
-    options['web-preferences'].__proto__ = embedder.getWebPreferences()
+    options.webPreferences ?= {}
+    mergeOptions options.webPreferences, embedder.getWebPreferences()
  options

 # Create a new guest created by |embedder| with |options|.
 createGuest = (embedder, url, frameName, options) ->
  guest = frameToGuest[frameName]
  if frameName and guest?
-    guest.loadUrl url
+    guest.loadURL url
    return guest.id

  guest = new BrowserWindow(options)
-  guest.loadUrl url
+  guest.loadURL url

  # Remember the embedder, will be used by window.opener methods.
  v8Util.setHiddenValue guest.webContents, 'embedder', embedder
@ -49,7 +57,7 @@ createGuest = (embedder, url, frameName, options) ->
  guest.id

 # Routed window.open messages.
-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', (event, args...) ->
+ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', (event, args...) ->
  [url, frameName, options] = args
  options = mergeBrowserWindowOptions event.sender, options
  event.sender.emit 'new-window', event, url, frameName, 'new-window', options
@ -58,26 +66,26 @@ ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', (event, args...) ->
  else
    event.returnValue = createGuest event.sender, url, frameName, options

-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSE', (event, guestId) ->
+ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_CLOSE', (event, guestId) ->
  BrowserWindow.fromId(guestId)?.destroy()

-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', (event, guestId, method, args...) ->
+ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_METHOD', (event, guestId, method, args...) ->
  BrowserWindow.fromId(guestId)?[method] args...

-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', (event, guestId, message, targetOrigin) ->
+ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_POSTMESSAGE', (event, guestId, message, targetOrigin) ->
  guestContents = BrowserWindow.fromId(guestId)?.webContents
-  if guestContents?.getUrl().indexOf(targetOrigin) is 0 or targetOrigin is '*'
+  if guestContents?.getURL().indexOf(targetOrigin) is 0 or targetOrigin is '*'
    guestContents.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', guestId, message, targetOrigin

-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPENER_POSTMESSAGE', (event, guestId, message, targetOrigin, sourceOrigin) ->
+ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPENER_POSTMESSAGE', (event, guestId, message, targetOrigin, sourceOrigin) ->
  embedder = v8Util.getHiddenValue event.sender, 'embedder'
-  if embedder?.getUrl().indexOf(targetOrigin) is 0 or targetOrigin is '*'
+  if embedder?.getURL().indexOf(targetOrigin) is 0 or targetOrigin is '*'
    embedder.send 'ATOM_SHELL_GUEST_WINDOW_POSTMESSAGE', guestId, message, sourceOrigin

-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', (event, guestId, method, args...) ->
+ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', (event, guestId, method, args...) ->
  BrowserWindow.fromId(guestId)?.webContents?[method] args...

-ipc.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_GET_GUEST_ID', (event) ->
+ipcMain.on 'ATOM_SHELL_GUEST_WINDOW_MANAGER_GET_GUEST_ID', (event) ->
  embedder = v8Util.getHiddenValue event.sender, 'embedder'
  if embedder?
    guest = BrowserWindow.fromWebContents event.sender
--- a/atom/browser/lib/init.coffee
+++ b/atom/browser/lib/init.coffee
@ -13,10 +13,12 @@ require path.resolve(__dirname, '..', '..', 'common', 'lib', 'reset-search-paths
 # Import common settings.
 require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init')

-# Add browser/api/lib to module search paths, which contains javascript part of
-# Electron's built-in libraries.
 globalPaths = Module.globalPaths
-globalPaths.push path.resolve(__dirname, '..', 'api', 'lib')
+unless process.env.ELECTRON_HIDE_INTERNAL_MODULES
+  globalPaths.push path.resolve(__dirname, '..', 'api', 'lib')
+
+# Expose public APIs.
+globalPaths.push path.resolve(__dirname, '..', 'api', 'lib', 'exports')

 if process.platform is 'win32'
  # Redirect node's console to use our own implementations, since node can not
@ -44,15 +46,19 @@ process.on 'uncaughtException', (error) ->
    return

  # Show error in GUI.
+  {dialog} = require 'electron'
  stack = error.stack ? "#{error.name}: #{error.message}"
  message = "Uncaught Exception:\n#{stack}"
-  require('dialog').showErrorBox 'A JavaScript error occurred in the main process', message
+  dialog.showErrorBox 'A JavaScript error occurred in the main process', message

 # Emit 'exit' event on quit.
-app = require 'app'
+{app} = require 'electron'
 app.on 'quit', ->
  process.emit 'exit'

+# Map process.exit to app.exit, which quits gracefully.
+process.exit = app.exit
+
 # Load the RPC server.
 require './rpc-server'

--- a/atom/browser/lib/objects-registry.coffee
+++ b/atom/browser/lib/objects-registry.coffee
@ -1,4 +1,4 @@
-EventEmitter = require('events').EventEmitter
+{EventEmitter} = require 'events'
 v8Util = process.atomBinding 'v8_util'

 class ObjectsRegistry extends EventEmitter
--- a/atom/browser/lib/rpc-server.coffee
+++ b/atom/browser/lib/rpc-server.coffee
@ -1,7 +1,11 @@
-ipc = require 'ipc'
 path = require 'path'
-objectsRegistry = require './objects-registry.js'
+
+electron = require 'electron'
+{ipcMain} = electron
+objectsRegistry = require './objects-registry'
+
 v8Util = process.atomBinding 'v8_util'
+{IDWeakMap} = process.atomBinding 'id_weak_map'

 # Convert a real value into meta data.
 valueToMeta = (sender, value, optimizeSimpleObject=false) ->
@ -12,7 +16,7 @@ valueToMeta = (sender, value, optimizeSimpleObject=false) ->
  meta.type = 'array' if Array.isArray value
  meta.type = 'error' if value instanceof Error
  meta.type = 'date' if value instanceof Date
-  meta.type = 'promise' if value? and value.constructor.name is 'Promise'
+  meta.type = 'promise' if value?.constructor.name is 'Promise'

  # Treat simple objects as value.
  if optimizeSimpleObject and meta.type is 'object' and v8Util.getHiddenValue value, 'simple'
@ -32,14 +36,13 @@ valueToMeta = (sender, value, optimizeSimpleObject=false) ->
    # it.
    meta.id = objectsRegistry.add sender.getId(), value

-    meta.members = []
-    meta.members.push {name: prop, type: typeof field} for prop, field of value
+    meta.members = ({name, type: typeof field} for name, field of value)
  else if meta.type is 'buffer'
    meta.value = Array::slice.call value, 0
  else if meta.type is 'promise'
-    meta.then = valueToMeta(sender, value.then.bind(value))
+    meta.then = valueToMeta sender, value.then.bind(value)
  else if meta.type is 'error'
-    meta.message = value.message
+    meta.members = plainObjectToMeta value
  else if meta.type is 'date'
    meta.value = value.getTime()
  else
@ -48,6 +51,10 @@ valueToMeta = (sender, value, optimizeSimpleObject=false) ->

  meta

+# Convert object to meta by value.
+plainObjectToMeta = (obj) ->
+  Object.getOwnPropertyNames(obj).map (name) -> {name, value: obj[name]}
+
 # Convert Error into meta data.
 exceptionToMeta = (error) ->
  type: 'exception', message: error.message, stack: (error.stack || error)
@ -70,6 +77,13 @@ unwrapArgs = (sender, args) ->
        returnValue = metaToValue meta.value
        -> returnValue
      when 'function'
+        # Cache the callbacks in renderer.
+        unless sender.callbacks
+          sender.callbacks = new IDWeakMap
+          sender.on 'render-view-deleted', ->
+            sender.callbacks.clear()
+        return sender.callbacks.get meta.id if sender.callbacks.has meta.id
+
        rendererReleased = false
        objectsRegistry.once "clear-#{sender.getId()}", ->
          rendererReleased = true
@ -77,11 +91,13 @@ unwrapArgs = (sender, args) ->
        ret = ->
          if rendererReleased
            throw new Error("Attempting to call a function in a renderer window
-              that has been closed or released. Function provided here: #{meta.id}.")
+              that has been closed or released. Function provided here: #{meta.location}.")
          sender.send 'ATOM_RENDERER_CALLBACK', meta.id, valueToMeta(sender, arguments)
        v8Util.setDestructor ret, ->
          return if rendererReleased
+          sender.callbacks.remove meta.id
          sender.send 'ATOM_RENDERER_RELEASE_CALLBACK', meta.id
+        sender.callbacks.set meta.id, ret
        ret
      else throw new TypeError("Unknown type: #{meta.type}")

@ -90,40 +106,58 @@ unwrapArgs = (sender, args) ->
 # Call a function and send reply asynchronously if it's a an asynchronous
 # style function and the caller didn't pass a callback.
 callFunction = (event, func, caller, args) ->
-  if v8Util.getHiddenValue(func, 'asynchronous') and typeof args[args.length - 1] isnt 'function'
-    args.push (ret) ->
+  funcMarkedAsync = v8Util.getHiddenValue(func, 'asynchronous')
+  funcPassedCallback = args[args.length - 1] is 'function'
+
+  try
+    if funcMarkedAsync and not funcPassedCallback
+      args.push (ret) ->
+        event.returnValue = valueToMeta event.sender, ret, true
+      func.apply caller, args
+    else
+      ret = func.apply caller, args
      event.returnValue = valueToMeta event.sender, ret, true
-    func.apply caller, args
-  else
-    ret = func.apply caller, args
-    event.returnValue = valueToMeta event.sender, ret, true
+  catch e
+    # Catch functions thrown further down in function invocation and wrap
+    # them with the function name so it's easier to trace things like
+    # `Error processing argument -1.`
+    funcName = func.name ? "anonymous"
+    throw new Error("Could not call remote function `#{funcName}`.
+                     Check that the function signature is correct.
+                     Underlying error: #{e.message}")

 # Send by BrowserWindow when its render view is deleted.
 process.on 'ATOM_BROWSER_RELEASE_RENDER_VIEW', (id) ->
  objectsRegistry.clear id

-ipc.on 'ATOM_BROWSER_REQUIRE', (event, module) ->
+ipcMain.on 'ATOM_BROWSER_REQUIRE', (event, module) ->
  try
    event.returnValue = valueToMeta event.sender, process.mainModule.require(module)
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_GLOBAL', (event, name) ->
+ipcMain.on 'ATOM_BROWSER_GET_BUILTIN', (event, module) ->
+  try
+    event.returnValue = valueToMeta event.sender, electron[module]
+  catch e
+    event.returnValue = exceptionToMeta e
+
+ipcMain.on 'ATOM_BROWSER_GLOBAL', (event, name) ->
  try
    event.returnValue = valueToMeta event.sender, global[name]
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_CURRENT_WINDOW', (event) ->
+ipcMain.on 'ATOM_BROWSER_CURRENT_WINDOW', (event) ->
  try
    event.returnValue = valueToMeta event.sender, event.sender.getOwnerBrowserWindow()
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_CURRENT_WEB_CONTENTS', (event) ->
+ipcMain.on 'ATOM_BROWSER_CURRENT_WEB_CONTENTS', (event) ->
  event.returnValue = valueToMeta event.sender, event.sender

-ipc.on 'ATOM_BROWSER_CONSTRUCTOR', (event, id, args) ->
+ipcMain.on 'ATOM_BROWSER_CONSTRUCTOR', (event, id, args) ->
  try
    args = unwrapArgs event.sender, args
    constructor = objectsRegistry.get id
@ -134,7 +168,7 @@ ipc.on 'ATOM_BROWSER_CONSTRUCTOR', (event, id, args) ->
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_FUNCTION_CALL', (event, id, args) ->
+ipcMain.on 'ATOM_BROWSER_FUNCTION_CALL', (event, id, args) ->
  try
    args = unwrapArgs event.sender, args
    func = objectsRegistry.get id
@ -142,7 +176,7 @@ ipc.on 'ATOM_BROWSER_FUNCTION_CALL', (event, id, args) ->
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_MEMBER_CONSTRUCTOR', (event, id, method, args) ->
+ipcMain.on 'ATOM_BROWSER_MEMBER_CONSTRUCTOR', (event, id, method, args) ->
  try
    args = unwrapArgs event.sender, args
    constructor = objectsRegistry.get(id)[method]
@ -152,7 +186,7 @@ ipc.on 'ATOM_BROWSER_MEMBER_CONSTRUCTOR', (event, id, method, args) ->
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_MEMBER_CALL', (event, id, method, args) ->
+ipcMain.on 'ATOM_BROWSER_MEMBER_CALL', (event, id, method, args) ->
  try
    args = unwrapArgs event.sender, args
    obj = objectsRegistry.get id
@ -160,7 +194,7 @@ ipc.on 'ATOM_BROWSER_MEMBER_CALL', (event, id, method, args) ->
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_MEMBER_SET', (event, id, name, value) ->
+ipcMain.on 'ATOM_BROWSER_MEMBER_SET', (event, id, name, value) ->
  try
    obj = objectsRegistry.get id
    obj[name] = value
@ -168,19 +202,22 @@ ipc.on 'ATOM_BROWSER_MEMBER_SET', (event, id, name, value) ->
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_MEMBER_GET', (event, id, name) ->
+ipcMain.on 'ATOM_BROWSER_MEMBER_GET', (event, id, name) ->
  try
    obj = objectsRegistry.get id
    event.returnValue = valueToMeta event.sender, obj[name]
  catch e
    event.returnValue = exceptionToMeta e

-ipc.on 'ATOM_BROWSER_DEREFERENCE', (event, id) ->
+ipcMain.on 'ATOM_BROWSER_DEREFERENCE', (event, id) ->
  objectsRegistry.remove event.sender.getId(), id

-ipc.on 'ATOM_BROWSER_GUEST_WEB_CONTENTS', (event, guestInstanceId) ->
+ipcMain.on 'ATOM_BROWSER_GUEST_WEB_CONTENTS', (event, guestInstanceId) ->
  try
    guestViewManager = require './guest-view-manager'
    event.returnValue = valueToMeta event.sender, guestViewManager.getGuest(guestInstanceId)
  catch e
    event.returnValue = exceptionToMeta e
+
+ipcMain.on 'ATOM_BROWSER_LIST_MODULES', (event) ->
+  event.returnValue = (name for name of electron)
--- a/atom/browser/login_handler.cc
+++ b/atom/browser/login_handler.cc
@ -0,0 +1,109 @@
+// 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/login_handler.h"
+
+#include "atom/browser/browser.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/resource_dispatcher_host.h"
+#include "content/public/browser/resource_request_info.h"
+#include "content/public/browser/web_contents.h"
+#include "net/base/auth.h"
+#include "net/url_request/url_request.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+// Helper to remove the ref from an net::URLRequest to the LoginHandler.
+// Should only be called from the IO thread, since it accesses an
+// net::URLRequest.
+void ResetLoginHandlerForRequest(net::URLRequest* request) {
+  content::ResourceDispatcherHost::Get()->ClearLoginDelegateForRequest(request);
+}
+
+}  // namespace
+
+LoginHandler::LoginHandler(net::AuthChallengeInfo* auth_info,
+                           net::URLRequest* request)
+    : handled_auth_(false),
+      auth_info_(auth_info),
+      request_(request),
+      render_process_host_id_(0),
+      render_frame_id_(0) {
+  content::ResourceRequestInfo::ForRequest(request_)->GetAssociatedRenderFrame(
+      &render_process_host_id_,  &render_frame_id_);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&Browser::RequestLogin,
+                                     base::Unretained(Browser::Get()),
+                                     make_scoped_refptr(this)));
+}
+
+LoginHandler::~LoginHandler() {
+}
+
+content::WebContents* LoginHandler::GetWebContents() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  content::RenderFrameHost* rfh = content::RenderFrameHost::FromID(
+      render_process_host_id_, render_frame_id_);
+  return content::WebContents::FromRenderFrameHost(rfh);
+}
+
+void LoginHandler::Login(const base::string16& username,
+                         const base::string16& password) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (TestAndSetAuthHandled())
+    return;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&LoginHandler::DoLogin, this, username, password));
+}
+
+void LoginHandler::CancelAuth() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (TestAndSetAuthHandled())
+    return;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&LoginHandler::DoCancelAuth, this));
+}
+
+void LoginHandler::OnRequestCancelled() {
+  TestAndSetAuthHandled();
+  request_ = nullptr;
+}
+
+// Marks authentication as handled and returns the previous handled state.
+bool LoginHandler::TestAndSetAuthHandled() {
+  base::AutoLock lock(handled_auth_lock_);
+  bool was_handled = handled_auth_;
+  handled_auth_ = true;
+  return was_handled;
+}
+
+void LoginHandler::DoCancelAuth() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (request_) {
+    request_->CancelAuth();
+    // Verify that CancelAuth doesn't destroy the request via our delegate.
+    DCHECK(request_ != nullptr);
+    ResetLoginHandlerForRequest(request_);
+  }
+}
+
+void LoginHandler::DoLogin(const base::string16& username,
+                           const base::string16& password) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (request_) {
+    request_->SetAuth(net::AuthCredentials(username, password));
+    ResetLoginHandlerForRequest(request_);
+  }
+}
+
+}  // namespace atom
--- a/atom/browser/login_handler.h
+++ b/atom/browser/login_handler.h
@ -0,0 +1,76 @@
+// 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_LOGIN_HANDLER_H_
+#define ATOM_BROWSER_LOGIN_HANDLER_H_
+
+#include "base/strings/string16.h"
+#include "base/synchronization/lock.h"
+#include "content/public/browser/resource_dispatcher_host_login_delegate.h"
+
+namespace content {
+class WebContents;
+}
+
+namespace net {
+class AuthChallengeInfo;
+class URLRequest;
+}
+
+namespace atom {
+
+// Handles the HTTP basic auth, must be created on IO thread.
+class LoginHandler : public content::ResourceDispatcherHostLoginDelegate {
+ public:
+  LoginHandler(net::AuthChallengeInfo* auth_info, net::URLRequest* request);
+
+  // Returns the WebContents associated with the request, must be called on UI
+  // thread.
+  content::WebContents* GetWebContents() const;
+
+  // The auth is cancelled, must be called on UI thread.
+  void CancelAuth();
+
+  // Login with |username| and |password|, must be called on UI thread.
+  void Login(const base::string16& username, const base::string16& password);
+
+  const net::AuthChallengeInfo* auth_info() const { return auth_info_.get(); }
+  const net::URLRequest* request() const { return request_; }
+
+ protected:
+  ~LoginHandler() override;
+
+  // content::ResourceDispatcherHostLoginDelegate:
+  void OnRequestCancelled() override;
+
+ private:
+  // Must be called on IO thread.
+  void DoCancelAuth();
+  void DoLogin(const base::string16& username, const base::string16& password);
+
+  // Marks authentication as handled and returns the previous handled
+  // state.
+  bool TestAndSetAuthHandled();
+
+  // True if we've handled auth (Login or CancelAuth has been called).
+  bool handled_auth_;
+  mutable base::Lock handled_auth_lock_;
+
+  // Who/where/what asked for the authentication.
+  scoped_refptr<net::AuthChallengeInfo> auth_info_;
+
+  // The request that wants login data.
+  // This should only be accessed on the IO loop.
+  net::URLRequest* request_;
+
+  // Cached from the net::URLRequest, in case it goes NULL on us.
+  int render_process_host_id_;
+  int render_frame_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(LoginHandler);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_LOGIN_HANDLER_H_
--- a/atom/browser/native_window.cc
+++ b/atom/browser/native_window.cc
@ -56,16 +56,16 @@ NativeWindow::NativeWindow(
      aspect_ratio_(0.0),
      inspectable_web_contents_(inspectable_web_contents),
      weak_factory_(this) {
-  options.Get(switches::kFrame, &has_frame_);
-  options.Get(switches::kTransparent, &transparent_);
-  options.Get(switches::kEnableLargerThanScreen, &enable_larger_than_screen_);
+  options.Get(options::kFrame, &has_frame_);
+  options.Get(options::kTransparent, &transparent_);
+  options.Get(options::kEnableLargerThanScreen, &enable_larger_than_screen_);

  // Tell the content module to initialize renderer widget with transparent
  // mode.
  ui::GpuSwitchingManager::SetTransparent(transparent_);

  // Read icon before window is created.
-  options.Get(switches::kIcon, &icon_);
+  options.Get(options::kIcon, &icon_);

  WindowList::AddWindow(this);
 }
@ -91,25 +91,25 @@ void NativeWindow::InitFromOptions(const mate::Dictionary& options) {
  // Setup window from options.
  int x = -1, y = -1;
  bool center;
-  if (options.Get(switches::kX, &x) && options.Get(switches::kY, &y)) {
+  if (options.Get(options::kX, &x) && options.Get(options::kY, &y)) {
    SetPosition(gfx::Point(x, y));
-  } else if (options.Get(switches::kCenter, &center) && center) {
+  } else if (options.Get(options::kCenter, &center) && center) {
    Center();
  }
  // On Linux and Window we may already have maximum size defined.
  extensions::SizeConstraints size_constraints(GetContentSizeConstraints());
  int min_height = 0, min_width = 0;
-  if (options.Get(switches::kMinHeight, &min_height) |
-      options.Get(switches::kMinWidth, &min_width)) {
+  if (options.Get(options::kMinHeight, &min_height) |
+      options.Get(options::kMinWidth, &min_width)) {
    size_constraints.set_minimum_size(gfx::Size(min_width, min_height));
  }
  int max_height = INT_MAX, max_width = INT_MAX;
-  if (options.Get(switches::kMaxHeight, &max_height) |
-      options.Get(switches::kMaxWidth, &max_width)) {
+  if (options.Get(options::kMaxHeight, &max_height) |
+      options.Get(options::kMaxWidth, &max_width)) {
    size_constraints.set_maximum_size(gfx::Size(max_width, max_height));
  }
  bool use_content_size = false;
-  options.Get(switches::kUseContentSize, &use_content_size);
+  options.Get(options::kUseContentSize, &use_content_size);
  if (use_content_size) {
    SetContentSizeConstraints(size_constraints);
  } else {
@ -117,39 +117,39 @@ void NativeWindow::InitFromOptions(const mate::Dictionary& options) {
  }
 #if defined(OS_WIN) || defined(USE_X11)
  bool resizable;
-  if (options.Get(switches::kResizable, &resizable)) {
+  if (options.Get(options::kResizable, &resizable)) {
    SetResizable(resizable);
  }
 #endif
  bool top;
-  if (options.Get(switches::kAlwaysOnTop, &top) && top) {
+  if (options.Get(options::kAlwaysOnTop, &top) && top) {
    SetAlwaysOnTop(true);
  }
 #if defined(OS_MACOSX) || defined(OS_WIN)
  bool fullscreen;
-  if (options.Get(switches::kFullscreen, &fullscreen) && fullscreen) {
+  if (options.Get(options::kFullscreen, &fullscreen) && fullscreen) {
    SetFullScreen(true);
  }
 #endif
  bool skip;
-  if (options.Get(switches::kSkipTaskbar, &skip) && skip) {
+  if (options.Get(options::kSkipTaskbar, &skip) && skip) {
    SetSkipTaskbar(skip);
  }
  bool kiosk;
-  if (options.Get(switches::kKiosk, &kiosk) && kiosk) {
+  if (options.Get(options::kKiosk, &kiosk) && kiosk) {
    SetKiosk(kiosk);
  }
  std::string color;
-  if (options.Get(switches::kBackgroundColor, &color)) {
+  if (options.Get(options::kBackgroundColor, &color)) {
    SetBackgroundColor(color);
  }
  std::string title("Electron");
-  options.Get(switches::kTitle, &title);
+  options.Get(options::kTitle, &title);
  SetTitle(title);

  // Then show it.
  bool show = true;
-  options.Get(switches::kShow, &show);
+  options.Get(options::kShow, &show);
  if (show)
    Show();
 }
@ -465,8 +465,8 @@ void NativeWindow::NotifyWindowExecuteWindowsCommand(
 }

 #if defined(OS_WIN)
-void NativeWindow::NotifyWindowMessage(UINT message, WPARAM w_param,
-                                       LPARAM l_param) {
+void NativeWindow::NotifyWindowMessage(
+    UINT message, WPARAM w_param, LPARAM l_param) {
  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
                    OnWindowMessage(message, w_param, l_param));
 }
@ -512,7 +512,7 @@ void NativeWindow::TitleWasSet(content::NavigationEntry* entry,
  FOR_EACH_OBSERVER(NativeWindowObserver,
                    observers_,
                    OnPageTitleUpdated(&prevent_default, text));
-  if (!prevent_default)
+  if (!prevent_default && !is_closed_)
    SetTitle(text);
 }

--- a/atom/browser/native_window_mac.mm
+++ b/atom/browser/native_window_mac.mm
@ -211,6 +211,8 @@ bool ScopedDisableResize::disable_resize_ = false;
 }
@property BOOL acceptsFirstMouse;
@property BOOL disableAutoHideCursor;
+@property BOOL disableKeyOrMainWindow;
+
 - (void)setShell:(atom::NativeWindowMac*)shell;
 - (void)setEnableLargerThanScreen:(bool)enable;
@end
@ -257,6 +259,14 @@ bool ScopedDisableResize::disable_resize_ = false;
  return [children filteredArrayUsingPredicate:predicate];
 }

+- (BOOL)canBecomeMainWindow {
+  return !self.disableKeyOrMainWindow;
+}
+
+- (BOOL)canBecomeKeyWindow {
+  return !self.disableKeyOrMainWindow;
+}
+
@end

@interface ControlRegionView : NSView
@ -320,8 +330,8 @@ NativeWindowMac::NativeWindowMac(
      is_kiosk_(false),
      attention_request_id_(0) {
  int width = 800, height = 600;
-  options.Get(switches::kWidth, &width);
-  options.Get(switches::kHeight, &height);
+  options.Get(options::kWidth, &width);
+  options.Get(options::kHeight, &height);

  NSRect main_screen_rect = [[[NSScreen screens] objectAtIndex:0] frame];
  NSRect cocoa_bounds = NSMakeRect(
@ -330,15 +340,24 @@ NativeWindowMac::NativeWindowMac(
      width,
      height);

-  bool useStandardWindow = true;
-  options.Get(switches::kStandardWindow, &useStandardWindow);
  bool resizable = true;
-  options.Get(switches::kResizable, &resizable);
+  options.Get(options::kResizable, &resizable);

  // New title bar styles are available in Yosemite or newer
  std::string titleBarStyle;
  if (base::mac::IsOSYosemiteOrLater())
-    options.Get(switches::kTitleBarStyle, &titleBarStyle);
+    options.Get(options::kTitleBarStyle, &titleBarStyle);
+
+  std::string windowType;
+  options.Get(options::kType, &windowType);
+
+  bool useStandardWindow = true;
+  // eventually deprecate separate "standardWindow" option in favor of
+  // standard / textured window types
+  options.Get(options::kStandardWindow, &useStandardWindow);
+  if (windowType == "textured") {
+    useStandardWindow = false;
+  }

  NSUInteger styleMask = NSTitledWindowMask | NSClosableWindowMask |
                         NSMiniaturizableWindowMask;
@ -371,6 +390,15 @@ NativeWindowMac::NativeWindowMac(
    [window_ setBackgroundColor:[NSColor clearColor]];
  }

+  if (windowType == "desktop") {
+    [window_ setLevel:kCGDesktopWindowLevel - 1];
+    [window_ setDisableKeyOrMainWindow:YES];
+    [window_ setCollectionBehavior:
+        (NSWindowCollectionBehaviorCanJoinAllSpaces |
+         NSWindowCollectionBehaviorStationary |
+         NSWindowCollectionBehaviorIgnoresCycle)];
+  }
+
  // Remove non-transparent corners, see http://git.io/vfonD.
  if (!has_frame())
    [window_ setOpaque:NO];
@ -394,23 +422,23 @@ NativeWindowMac::NativeWindowMac(

  // On OS X the initial window size doesn't include window frame.
  bool use_content_size = false;
-  options.Get(switches::kUseContentSize, &use_content_size);
+  options.Get(options::kUseContentSize, &use_content_size);
  if (!has_frame() || !use_content_size)
    SetSize(gfx::Size(width, height));

  // Enable the NSView to accept first mouse event.
  bool acceptsFirstMouse = false;
-  options.Get(switches::kAcceptFirstMouse, &acceptsFirstMouse);
+  options.Get(options::kAcceptFirstMouse, &acceptsFirstMouse);
  [window_ setAcceptsFirstMouse:acceptsFirstMouse];

  // Disable auto-hiding cursor.
  bool disableAutoHideCursor = false;
-  options.Get(switches::kDisableAutoHideCursor, &disableAutoHideCursor);
+  options.Get(options::kDisableAutoHideCursor, &disableAutoHideCursor);
  [window_ setDisableAutoHideCursor:disableAutoHideCursor];

  // Disable fullscreen button when 'fullscreen' is specified to false.
  bool fullscreen;
-  if (!(options.Get(switches::kFullscreen, &fullscreen) &&
+  if (!(options.Get(options::kFullscreen, &fullscreen) &&
        !fullscreen)) {
    NSUInteger collectionBehavior = [window_ collectionBehavior];
    collectionBehavior |= NSWindowCollectionBehaviorFullScreenPrimary;
--- a/atom/browser/native_window_views.cc
+++ b/atom/browser/native_window_views.cc
@ -132,13 +132,13 @@ NativeWindowViews::NativeWindowViews(
      keyboard_event_handler_(new views::UnhandledKeyboardEventHandler),
      use_content_size_(false),
      resizable_(true) {
-  options.Get(switches::kTitle, &title_);
-  options.Get(switches::kAutoHideMenuBar, &menu_bar_autohide_);
+  options.Get(options::kTitle, &title_);
+  options.Get(options::kAutoHideMenuBar, &menu_bar_autohide_);

 #if defined(OS_WIN)
  // On Windows we rely on the CanResize() to indicate whether window can be
  // resized, and it should be set before window is created.
-  options.Get(switches::kResizable, &resizable_);
+  options.Get(options::kResizable, &resizable_);
 #endif

  if (enable_larger_than_screen())
@ -150,8 +150,8 @@ NativeWindowViews::NativeWindowViews(
        gfx::Size(), gfx::Size(INT_MAX / 10, INT_MAX / 10)));

  int width = 800, height = 600;
-  options.Get(switches::kWidth, &width);
-  options.Get(switches::kHeight, &height);
+  options.Get(options::kWidth, &width);
+  options.Get(options::kHeight, &height);
  gfx::Rect bounds(0, 0, width, height);
  widget_size_ = bounds.size();

@ -187,7 +187,7 @@ NativeWindowViews::NativeWindowViews(
  window_->Init(params);

  bool fullscreen = false;
-  options.Get(switches::kFullscreen, &fullscreen);
+  options.Get(options::kFullscreen, &fullscreen);

 #if defined(USE_X11)
  // Start monitoring window states.
@ -195,7 +195,7 @@ NativeWindowViews::NativeWindowViews(

  // Set _GTK_THEME_VARIANT to dark if we have "dark-theme" option set.
  bool use_dark_theme = false;
-  if (options.Get(switches::kDarkTheme, &use_dark_theme) && use_dark_theme) {
+  if (options.Get(options::kDarkTheme, &use_dark_theme) && use_dark_theme) {
    XDisplay* xdisplay = gfx::GetXDisplay();
    XChangeProperty(xdisplay, GetAcceleratedWidget(),
                    XInternAtom(xdisplay, "_GTK_THEME_VARIANT", False),
@ -209,7 +209,7 @@ NativeWindowViews::NativeWindowViews(
  // to manually set the _NET_WM_STATE.
  std::vector<::Atom> state_atom_list;
  bool skip_taskbar = false;
-  if (options.Get(switches::kSkipTaskbar, &skip_taskbar) && skip_taskbar) {
+  if (options.Get(options::kSkipTaskbar, &skip_taskbar) && skip_taskbar) {
    state_atom_list.push_back(GetAtom("_NET_WM_STATE_SKIP_TASKBAR"));
  }

@ -223,7 +223,7 @@ NativeWindowViews::NativeWindowViews(

  // Set the _NET_WM_WINDOW_TYPE.
  std::string window_type;
-  if (options.Get(switches::kType, &window_type))
+  if (options.Get(options::kType, &window_type))
    SetWindowType(GetAcceleratedWidget(), window_type);
 #endif

@ -274,7 +274,7 @@ NativeWindowViews::NativeWindowViews(

  gfx::Size size = bounds.size();
  if (has_frame() &&
-      options.Get(switches::kUseContentSize, &use_content_size_) &&
+      options.Get(options::kUseContentSize, &use_content_size_) &&
      use_content_size_)
    size = ContentSizeToWindowSize(size);

--- a/atom/browser/native_window_views_win.cc
+++ b/atom/browser/native_window_views_win.cc
@ -3,6 +3,7 @@
 // found in the LICENSE file.

 #include "atom/browser/native_window_views.h"
+#include "content/public/browser/browser_accessibility_state.h"

 namespace atom {

@ -83,6 +84,20 @@ bool NativeWindowViews::PreHandleMSG(
  NotifyWindowMessage(message, w_param, l_param);

  switch (message) {
+    // Screen readers send WM_GETOBJECT in order to get the accessibility
+    // object, so take this opportunity to push Chromium into accessible
+    // mode if it isn't already, always say we didn't handle the message
+    // because we still want Chromium to handle returning the actual
+    // accessibility object.
+    case WM_GETOBJECT: {
+      const DWORD obj_id = static_cast<DWORD>(l_param);
+      if (obj_id == OBJID_CLIENT) {
+        const auto axState = content::BrowserAccessibilityState::GetInstance();
+        if (axState && !axState->IsAccessibleBrowser())
+          axState->OnScreenReaderDetected();
+      }
+      return false;
+    }
    case WM_COMMAND:
      // Handle thumbar button click message.
      if (HIWORD(w_param) == THBN_CLICKED)
--- a/atom/browser/net/atom_cert_verifier.cc
+++ b/atom/browser/net/atom_cert_verifier.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/browser/net/atom_cert_verifier.h"
+
+#include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/net_converter.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/base/net_errors.h"
+#include "net/cert/crl_set.h"
+#include "net/cert/x509_certificate.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+void OnResult(
+    net::CertVerifyResult* verify_result,
+    const net::CompletionCallback& callback,
+    bool result) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(callback, result ? net::OK : net::ERR_FAILED));
+}
+
+}  // namespace
+
+AtomCertVerifier::AtomCertVerifier()
+    : default_cert_verifier_(net::CertVerifier::CreateDefault()) {
+}
+
+AtomCertVerifier::~AtomCertVerifier() {
+}
+
+void AtomCertVerifier::SetVerifyProc(const VerifyProc& proc) {
+  base::AutoLock auto_lock(lock_);
+  verify_proc_ = proc;
+}
+
+int AtomCertVerifier::Verify(
+    net::X509Certificate* cert,
+    const std::string& hostname,
+    const std::string& ocsp_response,
+    int flags,
+    net::CRLSet* crl_set,
+    net::CertVerifyResult* verify_result,
+    const net::CompletionCallback& callback,
+    scoped_ptr<Request>* out_req,
+    const net::BoundNetLog& net_log) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  VerifyProc proc;
+  {
+    base::AutoLock auto_lock(lock_);
+    proc = verify_proc_;
+  }
+
+  if (proc.is_null())
+    return default_cert_verifier_->Verify(
+        cert, hostname, ocsp_response, flags, crl_set, verify_result, callback,
+        out_req, net_log);
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(proc, hostname, make_scoped_refptr(cert),
+                 base::Bind(OnResult, verify_result, callback)));
+  return net::ERR_IO_PENDING;
+}
+
+bool AtomCertVerifier::SupportsOCSPStapling() {
+  return true;
+}
+
+}  // namespace atom
--- a/atom/browser/net/atom_cert_verifier.h
+++ b/atom/browser/net/atom_cert_verifier.h
@ -0,0 +1,51 @@
+// 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_NET_ATOM_CERT_VERIFIER_H_
+#define ATOM_BROWSER_NET_ATOM_CERT_VERIFIER_H_
+
+#include <string>
+
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
+#include "net/cert/cert_verifier.h"
+
+namespace atom {
+
+class AtomCertVerifier : public net::CertVerifier {
+ public:
+  AtomCertVerifier();
+  virtual ~AtomCertVerifier();
+
+  using VerifyProc =
+      base::Callback<void(const std::string& hostname,
+                          scoped_refptr<net::X509Certificate>,
+                          const base::Callback<void(bool)>&)>;
+
+  void SetVerifyProc(const VerifyProc& proc);
+
+ protected:
+  // net::CertVerifier:
+  int Verify(net::X509Certificate* cert,
+             const std::string& hostname,
+             const std::string& ocsp_response,
+             int flags,
+             net::CRLSet* crl_set,
+             net::CertVerifyResult* verify_result,
+             const net::CompletionCallback& callback,
+             scoped_ptr<Request>* out_req,
+             const net::BoundNetLog& net_log) override;
+  bool SupportsOCSPStapling() override;
+
+ private:
+  base::Lock lock_;
+  VerifyProc verify_proc_;
+  scoped_ptr<net::CertVerifier> default_cert_verifier_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomCertVerifier);
+};
+
+}   // namespace atom
+
+#endif  // ATOM_BROWSER_NET_ATOM_CERT_VERIFIER_H_
--- a/atom/browser/net/atom_ssl_config_service.cc
+++ b/atom/browser/net/atom_ssl_config_service.cc
@ -2,7 +2,7 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.

-#include "atom/browser/atom_ssl_config_service.h"
+#include "atom/browser/net/atom_ssl_config_service.h"

 #include <string>
 #include <vector>
--- a/atom/browser/net/atom_ssl_config_service.h
+++ b/atom/browser/net/atom_ssl_config_service.h
@ -2,8 +2,8 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.

-#ifndef ATOM_BROWSER_ATOM_SSL_CONFIG_SERVICE_H_
-#define ATOM_BROWSER_ATOM_SSL_CONFIG_SERVICE_H_
+#ifndef ATOM_BROWSER_NET_ATOM_SSL_CONFIG_SERVICE_H_
+#define ATOM_BROWSER_NET_ATOM_SSL_CONFIG_SERVICE_H_

 #include "net/ssl/ssl_config_service.h"

@ -25,4 +25,4 @@ class AtomSSLConfigService : public net::SSLConfigService {

 }   // namespace atom

-#endif  // ATOM_BROWSER_ATOM_SSL_CONFIG_SERVICE_H_
+#endif  // ATOM_BROWSER_NET_ATOM_SSL_CONFIG_SERVICE_H_
--- a/atom/browser/net/js_asker.cc
+++ b/atom/browser/net/js_asker.cc
@ -8,7 +8,6 @@

 #include "atom/common/native_mate_converters/callback.h"
 #include "atom/common/native_mate_converters/v8_value_converter.h"
-#include "native_mate/function_template.h"

 namespace atom {

@ -16,34 +15,14 @@ namespace internal {

 namespace {

-struct CallbackHolder {
-  ResponseCallback callback;
-};
-
-// Cached JavaScript version of |HandlerCallback|.
-v8::Persistent<v8::FunctionTemplate> g_handler_callback_;
-
 // The callback which is passed to |handler|.
-void HandlerCallback(v8::Isolate* isolate,
-                     v8::Local<v8::External> external,
-                     v8::Local<v8::Object> state,
-                     mate::Arguments* args) {
-  // Check if the callback has already been called.
-  v8::Local<v8::String> called_symbol = mate::StringToSymbol(isolate, "called");
-  if (state->Has(called_symbol))
-    return;  // no nothing
-  else
-    state->Set(called_symbol, v8::Boolean::New(isolate, true));
-
+void HandlerCallback(const ResponseCallback& callback, mate::Arguments* args) {
  // If there is no argument passed then we failed.
-  scoped_ptr<CallbackHolder> holder(
-      static_cast<CallbackHolder*>(external->Value()));
-  CHECK(holder);
  v8::Local<v8::Value> value;
  if (!args->GetNext(&value)) {
    content::BrowserThread::PostTask(
        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(holder->callback, false, nullptr));
+        base::Bind(callback, false, nullptr));
    return;
  }

@ -53,42 +32,7 @@ void HandlerCallback(v8::Isolate* isolate,
  scoped_ptr<base::Value> options(converter.FromV8Value(value, context));
  content::BrowserThread::PostTask(
      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(holder->callback, true, base::Passed(&options)));
-}
-
-// func.bind(func, arg1, arg2).
-// NB(zcbenz): Using C++11 version crashes VS.
-v8::Local<v8::Value> BindFunctionWith(v8::Isolate* isolate,
-                                      v8::Local<v8::Context> context,
-                                      v8::Local<v8::Function> func,
-                                      v8::Local<v8::Value> arg1,
-                                      v8::Local<v8::Value> arg2) {
-  v8::MaybeLocal<v8::Value> bind = func->Get(mate::StringToV8(isolate, "bind"));
-  CHECK(!bind.IsEmpty());
-  v8::Local<v8::Function> bind_func =
-      v8::Local<v8::Function>::Cast(bind.ToLocalChecked());
-  v8::Local<v8::Value> converted[] = { func, arg1, arg2 };
-  return bind_func->Call(
-      context, func, arraysize(converted), converted).ToLocalChecked();
-}
-
-// Generate the callback that will be passed to |handler|.
-v8::MaybeLocal<v8::Value> GenerateCallback(v8::Isolate* isolate,
-                                           v8::Local<v8::Context> context,
-                                           const ResponseCallback& callback) {
-  // The FunctionTemplate is cached.
-  if (g_handler_callback_.IsEmpty())
-    g_handler_callback_.Reset(
-        isolate,
-        mate::CreateFunctionTemplate(isolate, base::Bind(&HandlerCallback)));
-
-  v8::Local<v8::FunctionTemplate> handler_callback =
-      v8::Local<v8::FunctionTemplate>::New(isolate, g_handler_callback_);
-  CallbackHolder* holder = new CallbackHolder;
-  holder->callback = callback;
-  return BindFunctionWith(isolate, context, handler_callback->GetFunction(),
-                          v8::External::New(isolate, holder),
-                          v8::Object::New(isolate));
+      base::Bind(callback, true, base::Passed(&options)));
 }

 }  // namespace
@ -102,16 +46,9 @@ void AskForOptions(v8::Isolate* isolate,
  v8::HandleScope handle_scope(isolate);
  v8::Local<v8::Context> context = isolate->GetCurrentContext();
  v8::Context::Scope context_scope(context);
-  // We don't convert the callback to C++ directly because creating
-  // FunctionTemplate will cause memory leak since V8 never releases it. So we
-  // have to create the function object in JavaScript to work around it.
-  v8::MaybeLocal<v8::Value> wrapped_callback = GenerateCallback(
-      isolate, context, callback);
-  if (wrapped_callback.IsEmpty()) {
-    callback.Run(false, nullptr);
-    return;
-  }
-  handler.Run(request, wrapped_callback.ToLocalChecked());
+  handler.Run(request,
+              mate::ConvertToV8(isolate,
+                                base::Bind(&HandlerCallback, callback)));
 }

 bool IsErrorOptions(base::Value* value, int* error) {
--- a/atom/browser/net/url_request_async_asar_job.cc
+++ b/atom/browser/net/url_request_async_asar_job.cc
@ -6,13 +6,13 @@

 namespace atom {

-UrlRequestAsyncAsarJob::UrlRequestAsyncAsarJob(
+URLRequestAsyncAsarJob::URLRequestAsyncAsarJob(
    net::URLRequest* request,
    net::NetworkDelegate* network_delegate)
    : JsAsker<asar::URLRequestAsarJob>(request, network_delegate) {
 }

-void UrlRequestAsyncAsarJob::StartAsync(scoped_ptr<base::Value> options) {
+void URLRequestAsyncAsarJob::StartAsync(scoped_ptr<base::Value> options) {
  base::FilePath::StringType file_path;
  if (options->IsType(base::Value::TYPE_DICTIONARY)) {
    static_cast<base::DictionaryValue*>(options.get())->GetString(
--- a/atom/browser/net/url_request_async_asar_job.h
+++ b/atom/browser/net/url_request_async_asar_job.h
@ -11,15 +11,15 @@
 namespace atom {

 // Like URLRequestAsarJob, but asks the JavaScript handler for file path.
-class UrlRequestAsyncAsarJob : public JsAsker<asar::URLRequestAsarJob> {
+class URLRequestAsyncAsarJob : public JsAsker<asar::URLRequestAsarJob> {
 public:
-  UrlRequestAsyncAsarJob(net::URLRequest*, net::NetworkDelegate*);
+  URLRequestAsyncAsarJob(net::URLRequest*, net::NetworkDelegate*);

  // JsAsker:
  void StartAsync(scoped_ptr<base::Value> options) override;

 private:
-  DISALLOW_COPY_AND_ASSIGN(UrlRequestAsyncAsarJob);
+  DISALLOW_COPY_AND_ASSIGN(URLRequestAsyncAsarJob);
 };

 }  // namespace atom
--- a/atom/browser/resources/mac/Info.plist
+++ b/atom/browser/resources/mac/Info.plist
@ -17,9 +17,9 @@
  <key>CFBundleIconFile</key>
  <string>atom.icns</string>
  <key>CFBundleVersion</key>
-  <string>0.34.1</string>
+  <string>0.35.1</string>
  <key>CFBundleShortVersionString</key>
-  <string>0.34.1</string>
+  <string>0.35.1</string>
  <key>LSApplicationCategoryType</key>
  <string>public.app-category.developer-tools</string>
  <key>LSMinimumSystemVersion</key>
--- a/atom/browser/resources/win/atom.rc
+++ b/atom/browser/resources/win/atom.rc
@ -56,8 +56,8 @@ END
 //

 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 0,34,1,0
- PRODUCTVERSION 0,34,1,0
+ FILEVERSION 0,35,1,0
+ PRODUCTVERSION 0,35,1,0
 FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
 FILEFLAGS 0x1L
@ -74,12 +74,12 @@ BEGIN
        BEGIN
            VALUE "CompanyName", "GitHub, Inc."
            VALUE "FileDescription", "Electron"
-            VALUE "FileVersion", "0.34.1"
+            VALUE "FileVersion", "0.35.1"
            VALUE "InternalName", "electron.exe"
            VALUE "LegalCopyright", "Copyright (C) 2015 GitHub, Inc. All rights reserved."
            VALUE "OriginalFilename", "electron.exe"
            VALUE "ProductName", "Electron"
-            VALUE "ProductVersion", "0.34.1"
+            VALUE "ProductVersion", "0.35.1"
            VALUE "SquirrelAwareVersion", "1"
        END
    END
--- a/atom/browser/ui/tray_icon.cc
+++ b/atom/browser/ui/tray_icon.cc
@ -55,8 +55,24 @@ void TrayIcon::NotifyRightClicked(const gfx::Rect& bounds, int modifiers) {
                    OnRightClicked(bounds, modifiers));
 }

+void TrayIcon::NotifyDrop() {
+  FOR_EACH_OBSERVER(TrayIconObserver, observers_, OnDrop());
+}
+
 void TrayIcon::NotifyDropFiles(const std::vector<std::string>& files) {
  FOR_EACH_OBSERVER(TrayIconObserver, observers_, OnDropFiles(files));
 }

+void TrayIcon::NotifyDragEntered() {
+  FOR_EACH_OBSERVER(TrayIconObserver, observers_, OnDragEntered());
+}
+
+void TrayIcon::NotifyDragExited() {
+  FOR_EACH_OBSERVER(TrayIconObserver, observers_, OnDragExited());
+}
+
+void TrayIcon::NotifyDragEnded() {
+  FOR_EACH_OBSERVER(TrayIconObserver, observers_, OnDragEnded());
+}
+
 }  // namespace atom
--- a/atom/browser/ui/tray_icon.h
+++ b/atom/browser/ui/tray_icon.h
@ -61,7 +61,11 @@ class TrayIcon {
  void NotifyBalloonClosed();
  void NotifyRightClicked(const gfx::Rect& bounds = gfx::Rect(),
                          int modifiers = 0);
+  void NotifyDrop();
  void NotifyDropFiles(const std::vector<std::string>& files);
+  void NotifyDragEntered();
+  void NotifyDragExited();
+  void NotifyDragEnded();

 protected:
  TrayIcon();
--- a/atom/browser/ui/tray_icon_cocoa.mm
+++ b/atom/browser/ui/tray_icon_cocoa.mm
@ -40,15 +40,9 @@ const CGFloat kVerticalTitleMargin = 2;
  trayIcon_ = icon;
  isHighlightEnable_ = YES;

-  // Get the initial size.
-  NSStatusBar* statusBar = [NSStatusBar systemStatusBar];
-  NSRect frame = NSMakeRect(0, 0, [self fullWidth], [statusBar thickness]);
-
-  if ((self = [super initWithFrame:frame])) {
+  if ((self = [super initWithFrame: CGRectZero])) {
    // Setup the image view.
-    NSRect iconFrame = frame;
-    iconFrame.size.width = [self iconWidth];
-    image_view_.reset([[NSImageView alloc] initWithFrame:iconFrame]);
+    image_view_.reset([[NSImageView alloc] initWithFrame: CGRectZero]);
    [image_view_ setImageScaling:NSImageScaleNone];
    [image_view_ setImageAlignment:NSImageAlignCenter];
    [self addSubview:image_view_];
@ -56,17 +50,27 @@ const CGFloat kVerticalTitleMargin = 2;
    // Unregister image_view_ as a dragged destination, allows its parent view
    // (StatusItemView) handle dragging events.
    [image_view_ unregisterDraggedTypes];
-    NSArray* types = [NSArray arrayWithObjects:NSFilenamesPboardType, nil];
-    [self registerForDraggedTypes:types];
+    [self registerForDraggedTypes: @[NSFilenamesPboardType]];

    // Create the status item.
-    statusItem_.reset([[[NSStatusBar systemStatusBar]
-                        statusItemWithLength:NSWidth(frame)] retain]);
+    NSStatusItem * item = [[NSStatusBar systemStatusBar]
+                            statusItemWithLength:NSVariableStatusItemLength];
+    statusItem_.reset([item retain]);
    [statusItem_ setView:self];
+
+    // Finalize setup by sizing our views
+    [self updateDimensions];
  }
  return self;
 }

+- (void)updateDimensions {
+  NSStatusBar * bar = [NSStatusBar systemStatusBar];
+  [image_view_ setFrame: NSMakeRect(0, 0, [self iconWidth], [bar thickness])];
+  [self setFrame: NSMakeRect(0, 0, [self fullWidth], [bar thickness])];
+  [self setNeedsDisplay:YES];
+}
+
 - (void)removeItem {
  [[NSStatusBar systemStatusBar] removeStatusItem:statusItem_];
  statusItem_.reset();
@ -81,9 +85,7 @@ const CGFloat kVerticalTitleMargin = 2;
  // Draw background.
  BOOL highlight = [self shouldHighlight];
  CGFloat thickness = [[statusItem_ statusBar] thickness];
-  NSRect statusItemBounds = NSMakeRect(0, 0, [statusItem_ length], thickness);
-  [statusItem_ drawStatusBarBackgroundInRect:statusItemBounds
-                               withHighlight:highlight];
+  [statusItem_ drawStatusBarBackgroundInRect:self.bounds withHighlight:highlight];

  // Make use of NSImageView to draw the image, which can correctly draw
  // template image under dark menu bar.
@ -157,10 +159,10 @@ const CGFloat kVerticalTitleMargin = 2;
  NSColor* foregroundColor = highlight ?
      [NSColor whiteColor] :
      [NSColor colorWithRed:0.265625 green:0.25390625 blue:0.234375 alpha:1.0];
-  return [NSDictionary dictionaryWithObjectsAndKeys:
-             font, NSFontAttributeName,
-             foregroundColor, NSForegroundColorAttributeName,
-             nil];
+  return @{
+    NSFontAttributeName: font,
+    NSForegroundColorAttributeName: foregroundColor
+  };
 }

 - (NSDictionary*)titleAttributes {
@ -169,7 +171,7 @@ const CGFloat kVerticalTitleMargin = 2;

 - (void)setImage:(NSImage*)image {
  image_.reset([image copy]);
-  [self setNeedsDisplay:YES];
+  [self updateDimensions];
 }

 - (void)setAlternateImage:(NSImage*)image {
@ -181,12 +183,12 @@ const CGFloat kVerticalTitleMargin = 2;
 }

 - (void)setTitle:(NSString*)title {
-  if (title.length > 0)
+  if (title.length > 0) {
    title_.reset([title copy]);
-  else
+  } else {
    title_.reset();
-  [statusItem_ setLength:[self fullWidth]];
-  [self setNeedsDisplay:YES];
+  }
+  [self updateDimensions];
 }

 - (void)setMenuController:(AtomMenuController*)menu {
@ -254,9 +256,23 @@ const CGFloat kVerticalTitleMargin = 2;
 }

 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender {
+  trayIcon_->NotifyDragEntered();
  return NSDragOperationCopy;
 }

+- (void)draggingExited:(id <NSDraggingInfo>)sender {
+  trayIcon_->NotifyDragExited();
+}
+
+- (void)draggingEnded:(id <NSDraggingInfo>)sender {
+  trayIcon_->NotifyDragEnded();
+}
+
+- (BOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender {
+  trayIcon_->NotifyDrop();
+  return YES;
+}
+
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender {
  NSPasteboard* pboard = [sender draggingPasteboard];

--- a/atom/browser/ui/tray_icon_observer.h
+++ b/atom/browser/ui/tray_icon_observer.h
@ -22,7 +22,11 @@ class TrayIconObserver {
  virtual void OnBalloonClicked() {}
  virtual void OnBalloonClosed() {}
  virtual void OnRightClicked(const gfx::Rect& bounds, int modifiers) {}
+  virtual void OnDrop() {}
  virtual void OnDropFiles(const std::vector<std::string>& files) {}
+  virtual void OnDragEntered() {}
+  virtual void OnDragExited() {}
+  virtual void OnDragEnded() {}

 protected:
  virtual ~TrayIconObserver() {}
--- a/atom/browser/ui/win/notify_icon.cc
+++ b/atom/browser/ui/win/notify_icon.cc
@ -113,7 +113,7 @@ void NotifyIcon::SetToolTip(const std::string& tool_tip) {
  NOTIFYICONDATA icon_data;
  InitIconData(&icon_data);
  icon_data.uFlags |= NIF_TIP;
-  wcscpy_s(icon_data.szTip, base::UTF8ToUTF16(tool_tip).c_str());
+  wcsncpy_s(icon_data.szTip, base::UTF8ToUTF16(tool_tip).c_str(), _TRUNCATE);
  BOOL result = Shell_NotifyIcon(NIM_MODIFY, &icon_data);
  if (!result)
    LOG(WARNING) << "Unable to set tooltip for status tray icon";
@ -126,8 +126,8 @@ void NotifyIcon::DisplayBalloon(const gfx::Image& icon,
  InitIconData(&icon_data);
  icon_data.uFlags |= NIF_INFO;
  icon_data.dwInfoFlags = NIIF_INFO;
-  wcscpy_s(icon_data.szInfoTitle, title.c_str());
-  wcscpy_s(icon_data.szInfo, contents.c_str());
+  wcsncpy_s(icon_data.szInfoTitle, title.c_str(), _TRUNCATE);
+  wcsncpy_s(icon_data.szInfo, contents.c_str(), _TRUNCATE);
  icon_data.uTimeout = 0;

  base::win::Version win_version = base::win::GetVersion();
--- a/atom/browser/ui/win/taskbar_host.cc
+++ b/atom/browser/ui/win/taskbar_host.cc
@ -97,7 +97,8 @@ bool TaskbarHost::SetThumbarButtons(
    // Set tooltip.
    if (!button.tooltip.empty()) {
      thumb_button.dwMask |= THB_TOOLTIP;
-      wcscpy_s(thumb_button.szTip, base::UTF8ToUTF16(button.tooltip).c_str());
+      wcsncpy_s(thumb_button.szTip, base::UTF8ToUTF16(button.tooltip).c_str(),
+                _TRUNCATE);
    }

    // Save callback.
--- a/Show more
+++ b/Show more