Update brightray

Bring back the "subpixel-font-scaling" option

.gitignore

@@ -1,14 +1,13 @@
 .DS_Store
-atom-shell.zip
-version
 /build/
 /dist/
-/frameworks/
-/node/
+/external_binaries/
 /out/
 /vendor/brightray/vendor/download/
 /vendor/python_26/
+/vendor/npm/
 node_modules/
 *.xcodeproj
 *.swp
 *.pyc
+npm-debug.log

.gitmodules

@@ -1,15 +1,15 @@
 [submodule "vendor/brightray"]
 	path = vendor/brightray
-  url = https://github.com/brightray/brightray.git
+	url = https://github.com/atom/brightray.git
 [submodule "vendor/node"]
 	path = vendor/node
-  url = https://github.com/atom/node.git
-[submodule "vendor/gyp"]
-	path = vendor/gyp
-	url = https://github.com/svn2github/gyp.git
+	url = https://github.com/atom/node.git
 [submodule "vendor/depot_tools"]
 	path = vendor/depot_tools
 	url = https://chromium.googlesource.com/chromium/tools/depot_tools.git
-[submodule "vendor/apm"]
-	path = vendor/apm
-	url = https://github.com/github/apm.git
+[submodule "vendor/breakpad"]
+	path = vendor/breakpad
+	url = https://github.com/atom/chromium-breakpad.git
+[submodule "vendor/native_mate"]
+	path = vendor/native_mate
+	url = https://github.com/zcbenz/native-mate.git

.travis.yml

@@ -0,0 +1,15 @@
+language: cpp
+compiler: clang
+os:
+  - linux
+  - osx
+
+notifications:
+  email:
+    on_success: never
+    on_failure: change
+
+script: './script/cibuild'
+
+git:
+  depth: 10

LICENSE

@@ -1,28 +1,20 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Copyright (c) 2014 GitHub Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,19 +1,36 @@
-# Atom Shell
+# Atom Shell [![Build Status](https://travis-ci.org/atom/atom-shell.svg?branch=master)](https://travis-ci.org/atom/atom-shell)
 
-Experimental native layer for the [Atom](https://github.com/github/atom).
+The Atom Shell framework lets you write cross-platform desktop applications
+using JavaScript, HTML and CSS. It is based on [io.js](http://iojs.org) and
+[Chromium](http://www.chromium.org) and is used in the [Atom
+editor](https://github.com/atom/atom).
 
-## Development
+## Downloads
 
-### One-time setup
+Prebuilt binaries of atom-shell for Linux, Windows and Mac can be found on the
+[releases](https://github.com/atom/atom-shell/releases) page.
 
-    $ script/bootstrap
+You can also use [`npm`](https://docs.npmjs.com/) to install prebuilt atom-shell binaries:
 
-### Building
+```
+# Install globally in your $PATH
+npm install atom-shell -g
 
-    $ script/build
+# Install as a development dependency
+npm install atom-shell --save-dev
+```
 
-This will build the app into the `build` directory.
+### Mirrors
 
-## License
+- [China Mirror](https://npm.taobao.org/mirrors/atom-shell): Improve download speeds for Chinese user.
 
-See the [`LICENSE`](LICENSE) file.
+## Documentation
+
+Guides and the API reference are located in the
+[docs](https://github.com/atom/atom-shell/tree/master/docs) directory. It also
+contains documents describing how to build and contribute to atom-shell.
+
+## Community
+
+There is an [`atom-shell` category on the Atom forums](http://discuss.atom.io/category/atom-shell)
+as well as an `#atom-shell` channel on Freenode.

app/atom_library_main.cc

@@ -1,15 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "app/atom_library_main.h"
-
-#include "app/atom_main_delegate.h"
-#include "content/public/app/content_main.h"
-
-#if defined(OS_MACOSX)
-int AtomMain(int argc, const char* argv[]) {
-  atom::AtomMainDelegate delegate;
-  return content::ContentMain(argc, argv, &delegate);
-}
-#endif  // OS_MACOSX

app/atom_library_main.h

@@ -1,17 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_APP_ATOM_LIBRARY_MAIN_
-#define ATOM_APP_ATOM_LIBRARY_MAIN_
-
-#include "base/basictypes.h"
-
-#if defined(OS_MACOSX)
-extern "C" {
-__attribute__((visibility("default")))
-int AtomMain(int argc, const char* argv[]);
-}
-#endif  // OS_MACOSX
-
-#endif  // ATOM_APP_ATOM_LIBRARY_MAIN_

app/atom_main.cc

@@ -1,28 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/public/app/content_main.h"
-
-#if defined(OS_WIN)
-
-#include "app/atom_main_delegate.h"
-#include "content/public/app/startup_helper_win.h"
-#include "sandbox/win/src/sandbox_types.h"
-
-int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t*, int) {
-  sandbox::SandboxInterfaceInfo sandbox_info = {0};
-  content::InitializeSandboxInfo(&sandbox_info);
-  atom::AtomMainDelegate delegate;
-  return content::ContentMain(instance, &sandbox_info, &delegate);
-}
-
-#else
-
-#include "app/atom_library_main.h"
-
-int main(int argc, const char* argv[]) {
-  return AtomMain(argc, argv);
-}
-
-#endif  // OS_WIN

app/atom_main_delegate.cc

@@ -1,59 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "app/atom_main_delegate.h"
-
-#include "base/command_line.h"
-#include "base/logging.h"
-#include "browser/atom_browser_client.h"
-#include "content/public/common/content_switches.h"
-#include "renderer/atom_renderer_client.h"
-
-namespace atom {
-
-AtomMainDelegate::AtomMainDelegate() {
-}
-
-AtomMainDelegate::~AtomMainDelegate() {
-}
-
-bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
-  // Disable logging out to debug.log on Windows
-#if defined(OS_WIN)
-  logging::InitLogging(
-      L"debug.log",
-#if defined(DEBUG)
-      logging::LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG ,
-#else
-      logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
-#endif  // defined(NDEBUG)
-      logging::LOCK_LOG_FILE,
-      logging::DELETE_OLD_LOG_FILE,
-      logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
-  logging::SetLogItems(true, false, true, false);
-#endif  // defined(OS_WIN)
-
-  return brightray::MainDelegate::BasicStartupComplete(exit_code);
-}
-
-void AtomMainDelegate::PreSandboxStartup() {
-  brightray::MainDelegate::PreSandboxStartup();
-
-  // Disable renderer sandbox for most of node's functions.
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  command_line->AppendSwitch(switches::kNoSandbox);
-}
-
-content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
-  browser_client_.reset(new AtomBrowserClient);
-  return browser_client_.get();
-}
-
-content::ContentRendererClient*
-    AtomMainDelegate::CreateContentRendererClient() {
-  renderer_client_.reset(new AtomRendererClient);
-  return renderer_client_.get();
-}
-
-}  // namespace atom

app/atom_main_delegate.h

@@ -1,34 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_
-#define ATOM_APP_ATOM_MAIN_DELEGATE_
-
-#include "brightray/common/main_delegate.h"
-
-namespace atom {
-
-class AtomMainDelegate : public brightray::MainDelegate {
- public:
-  AtomMainDelegate();
-  ~AtomMainDelegate();
-
- protected:
-  virtual bool BasicStartupComplete(int* exit_code) OVERRIDE;
-  virtual void PreSandboxStartup() OVERRIDE;
-
- private:
-  virtual content::ContentBrowserClient* CreateContentBrowserClient() OVERRIDE;
-  virtual content::ContentRendererClient*
-      CreateContentRendererClient() OVERRIDE;
-
-  scoped_ptr<content::ContentBrowserClient> browser_client_;
-  scoped_ptr<content::ContentRendererClient> renderer_client_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomMainDelegate);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_

appveyor.yml

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

atom/app/atom_content_client.cc

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

atom/app/atom_content_client.h

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

atom/app/atom_library_main.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_ATOM_LIBRARY_MAIN_H_
+#define ATOM_APP_ATOM_LIBRARY_MAIN_H_
+
+#include "base/basictypes.h"
+
+#if defined(OS_MACOSX)
+extern "C" {
+__attribute__((visibility("default")))
+int AtomMain(int argc, const char* argv[]);
+
+__attribute__((visibility("default")))
+int AtomInitializeICUandStartNode(int argc, char *argv[]);
+}
+#endif  // OS_MACOSX
+
+#endif  // ATOM_APP_ATOM_LIBRARY_MAIN_H_

atom/app/atom_library_main.mm

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

atom/app/atom_main.cc

@@ -0,0 +1,186 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/app/atom_main.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(OS_WIN)
+#include <stdio.h>
+#include <io.h>
+#include <fcntl.h>
+
+#include <windows.h>
+#include <shellscalingapi.h>
+#include <tchar.h>
+#include <shellapi.h>
+
+#include "atom/app/atom_main_delegate.h"
+#include "atom/common/crash_reporter/win/crash_service_main.h"
+#include "base/environment.h"
+#include "base/win/windows_version.h"
+#include "content/public/app/startup_helper_win.h"
+#include "sandbox/win/src/sandbox_types.h"
+#include "ui/gfx/win/dpi.h"
+#elif defined(OS_LINUX)  // defined(OS_WIN)
+#include "atom/app/atom_main_delegate.h"  // NOLINT
+#include "content/public/app/content_main.h"
+#else  // defined(OS_LINUX)
+#include "atom/app/atom_library_main.h"
+#endif  // defined(OS_MACOSX)
+
+#include "atom/app/node_main.h"
+#include "base/i18n/icu_util.h"
+
+#if defined(OS_WIN)
+
+namespace {
+
+// Win8.1 supports monitor-specific DPI scaling.
+bool SetProcessDpiAwarenessWrapper(PROCESS_DPI_AWARENESS value) {
+  typedef HRESULT(WINAPI *SetProcessDpiAwarenessPtr)(PROCESS_DPI_AWARENESS);
+  SetProcessDpiAwarenessPtr set_process_dpi_awareness_func =
+      reinterpret_cast<SetProcessDpiAwarenessPtr>(
+          GetProcAddress(GetModuleHandleA("user32.dll"),
+                         "SetProcessDpiAwarenessInternal"));
+  if (set_process_dpi_awareness_func) {
+    HRESULT hr = set_process_dpi_awareness_func(value);
+    if (SUCCEEDED(hr)) {
+      VLOG(1) << "SetProcessDpiAwareness succeeded.";
+      return true;
+    } else if (hr == E_ACCESSDENIED) {
+      LOG(ERROR) << "Access denied error from SetProcessDpiAwareness. "
+          "Function called twice, or manifest was used.";
+    }
+  }
+  return false;
+}
+
+// This function works for Windows Vista through Win8. Win8.1 must use
+// SetProcessDpiAwareness[Wrapper].
+BOOL SetProcessDPIAwareWrapper() {
+  typedef BOOL(WINAPI *SetProcessDPIAwarePtr)(VOID);
+  SetProcessDPIAwarePtr set_process_dpi_aware_func =
+      reinterpret_cast<SetProcessDPIAwarePtr>(
+      GetProcAddress(GetModuleHandleA("user32.dll"),
+                      "SetProcessDPIAware"));
+  return set_process_dpi_aware_func &&
+    set_process_dpi_aware_func();
+}
+
+void EnableHighDPISupport() {
+  if (!SetProcessDpiAwarenessWrapper(PROCESS_SYSTEM_DPI_AWARE)) {
+    SetProcessDPIAwareWrapper();
+  }
+}
+
+}  // namespace
+
+int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
+  int argc = 0;
+  wchar_t** wargv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
+
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+
+  // Make output work in console if we are not in cygiwn.
+  std::string os;
+  if (env->GetVar("OS", &os) && os != "cygwin") {
+    AttachConsole(ATTACH_PARENT_PROCESS);
+
+    FILE* dontcare;
+    freopen_s(&dontcare, "CON", "w", stdout);
+    freopen_s(&dontcare, "CON", "w", stderr);
+    freopen_s(&dontcare, "CON", "r", stdin);
+  }
+
+  std::string node_indicator, crash_service_indicator;
+  if (env->GetVar("ATOM_SHELL_INTERNAL_RUN_AS_NODE", &node_indicator) &&
+      node_indicator == "1") {
+    // Convert argv to to UTF8
+    char** argv = new char*[argc];
+    for (int i = 0; i < argc; i++) {
+      // Compute the size of the required buffer
+      DWORD size = WideCharToMultiByte(CP_UTF8,
+                                       0,
+                                       wargv[i],
+                                       -1,
+                                       NULL,
+                                       0,
+                                       NULL,
+                                       NULL);
+      if (size == 0) {
+        // This should never happen.
+        fprintf(stderr, "Could not convert arguments to utf8.");
+        exit(1);
+      }
+      // Do the actual conversion
+      argv[i] = new char[size];
+      DWORD result = WideCharToMultiByte(CP_UTF8,
+                                         0,
+                                         wargv[i],
+                                         -1,
+                                         argv[i],
+                                         size,
+                                         NULL,
+                                         NULL);
+      if (result == 0) {
+        // This should never happen.
+        fprintf(stderr, "Could not convert arguments to utf8.");
+        exit(1);
+      }
+    }
+    // Now that conversion is done, we can finally start.
+    base::i18n::InitializeICU();
+    return atom::NodeMain(argc, argv);
+  } else if (env->GetVar("ATOM_SHELL_INTERNAL_CRASH_SERVICE",
+                         &crash_service_indicator) &&
+      crash_service_indicator == "1") {
+    return crash_service::Main(cmd);
+  }
+
+  sandbox::SandboxInterfaceInfo sandbox_info = {0};
+  content::InitializeSandboxInfo(&sandbox_info);
+  atom::AtomMainDelegate delegate;
+
+  // We don't want to set DPI awareness on pre-Win7 because we don't support
+  // DirectWrite there. GDI fonts are kerned very badly, so better to leave
+  // DPI-unaware and at effective 1.0. See also ShouldUseDirectWrite().
+  if (base::win::GetVersion() >= base::win::VERSION_WIN7)
+    EnableHighDPISupport();
+
+  content::ContentMainParams params(&delegate);
+  params.instance = instance;
+  params.sandbox_info = &sandbox_info;
+  return content::ContentMain(params);
+}
+
+#elif defined(OS_LINUX)  // defined(OS_WIN)
+
+int main(int argc, const char* argv[]) {
+  char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
+  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0) {
+    base::i18n::InitializeICU();
+    return atom::NodeMain(argc, const_cast<char**>(argv));
+  }
+
+  atom::AtomMainDelegate delegate;
+  content::ContentMainParams params(&delegate);
+  params.argc = argc;
+  params.argv = argv;
+  return content::ContentMain(params);
+}
+
+#else  // defined(OS_LINUX)
+
+int main(int argc, const char* argv[]) {
+  char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
+  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0) {
+    return AtomInitializeICUandStartNode(argc, const_cast<char**>(argv));
+  }
+
+  return AtomMain(argc, argv);
+}
+
+#endif  // defined(OS_MACOSX)

atom/app/atom_main.h

@@ -0,0 +1,10 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_ATOM_MAIN_H_
+#define ATOM_APP_ATOM_MAIN_H_
+
+#include "content/public/app/content_main.h"
+
+#endif  // ATOM_APP_ATOM_MAIN_H_

atom/app/atom_main_delegate.cc

@@ -0,0 +1,119 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/app/atom_main_delegate.h"
+
+#include <string>
+
+#include "atom/app/atom_content_client.h"
+#include "atom/browser/atom_browser_client.h"
+#include "atom/common/google_api_key.h"
+#include "atom/renderer/atom_renderer_client.h"
+#include "base/command_line.h"
+#include "base/debug/stack_trace.h"
+#include "base/environment.h"
+#include "base/logging.h"
+#include "content/public/common/content_switches.h"
+#include "ui/base/resource/resource_bundle.h"
+
+namespace atom {
+
+AtomMainDelegate::AtomMainDelegate() {
+}
+
+AtomMainDelegate::~AtomMainDelegate() {
+}
+
+bool AtomMainDelegate::BasicStartupComplete(int* exit_code) {
+  // Disable logging out to debug.log on Windows
+#if defined(OS_WIN)
+  logging::LoggingSettings settings;
+#if defined(DEBUG)
+  settings.logging_dest = logging::LOG_TO_ALL;
+  settings.log_file = L"debug.log";
+  settings.lock_log = logging::LOCK_LOG_FILE;
+  settings.delete_old = logging::DELETE_OLD_LOG_FILE;
+#else
+  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
+#endif
+  logging::InitLogging(settings);
+#endif  // defined(OS_WIN)
+
+  // Logging with pid and timestamp.
+  logging::SetLogItems(true, false, true, false);
+
+  // Enable convient stack printing.
+#if defined(DEBUG) && defined(OS_LINUX)
+  base::debug::EnableInProcessStackDumping();
+#endif
+
+  return brightray::MainDelegate::BasicStartupComplete(exit_code);
+}
+
+void AtomMainDelegate::PreSandboxStartup() {
+  brightray::MainDelegate::PreSandboxStartup();
+
+  // Set google API key.
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  if (!env->HasVar("GOOGLE_API_KEY"))
+    env->SetVar("GOOGLE_API_KEY", GOOGLEAPIS_API_KEY);
+
+  auto command_line = base::CommandLine::ForCurrentProcess();
+  std::string process_type = command_line->GetSwitchValueASCII(
+      switches::kProcessType);
+
+  // Only append arguments for browser process.
+  if (!process_type.empty())
+    return;
+
+  // Add a flag to mark the start of switches added by atom-shell.
+  command_line->AppendSwitch("atom-shell-switches-start");
+
+#if defined(OS_WIN)
+  // Disable the LegacyRenderWidgetHostHWND, it made frameless windows unable
+  // to move and resize. We may consider enabling it again after upgraded to
+  // 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);
+
+#if defined(OS_MACOSX)
+  // Enable AVFoundation.
+  command_line->AppendSwitch("enable-avfoundation");
+#endif
+
+  // Add a flag to mark the end of switches added by atom-shell.
+  command_line->AppendSwitch("atom-shell-switches-end");
+}
+
+content::ContentBrowserClient* AtomMainDelegate::CreateContentBrowserClient() {
+  browser_client_.reset(new AtomBrowserClient);
+  return browser_client_.get();
+}
+
+content::ContentRendererClient*
+    AtomMainDelegate::CreateContentRendererClient() {
+  renderer_client_.reset(new AtomRendererClient);
+  return renderer_client_.get();
+}
+
+scoped_ptr<brightray::ContentClient> AtomMainDelegate::CreateContentClient() {
+  return scoped_ptr<brightray::ContentClient>(new AtomContentClient).Pass();
+}
+
+void AtomMainDelegate::AddDataPackFromPath(
+    ui::ResourceBundle* bundle, const base::FilePath& pak_dir) {
+#if defined(OS_WIN)
+  bundle->AddDataPackFromPath(
+      pak_dir.Append(FILE_PATH_LITERAL("ui_resources_200_percent.pak")),
+      ui::SCALE_FACTOR_200P);
+  bundle->AddDataPackFromPath(
+      pak_dir.Append(FILE_PATH_LITERAL("content_resources_200_percent.pak")),
+      ui::SCALE_FACTOR_200P);
+#endif
+}
+
+}  // namespace atom

atom/app/atom_main_delegate.h

@@ -0,0 +1,44 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_ATOM_MAIN_DELEGATE_H_
+#define ATOM_APP_ATOM_MAIN_DELEGATE_H_
+
+#include "brightray/common/main_delegate.h"
+#include "brightray/common/content_client.h"
+
+namespace atom {
+
+class AtomMainDelegate : public brightray::MainDelegate {
+ public:
+  AtomMainDelegate();
+  ~AtomMainDelegate();
+
+ protected:
+  // content::ContentMainDelegate:
+  bool BasicStartupComplete(int* exit_code) override;
+  void PreSandboxStartup() override;
+  content::ContentBrowserClient* CreateContentBrowserClient() override;
+  content::ContentRendererClient* CreateContentRendererClient() override;
+
+  // brightray::MainDelegate:
+  scoped_ptr<brightray::ContentClient> CreateContentClient() override;
+  void AddDataPackFromPath(
+      ui::ResourceBundle* bundle, const base::FilePath& pak_dir) override;
+#if defined(OS_MACOSX)
+  void OverrideChildProcessPath() override;
+  void OverrideFrameworkBundlePath() override;
+#endif
+
+ private:
+  brightray::ContentClient content_client_;
+  scoped_ptr<content::ContentBrowserClient> browser_client_;
+  scoped_ptr<content::ContentRendererClient> renderer_client_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomMainDelegate);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_H_

atom/app/atom_main_delegate_mac.mm

@@ -0,0 +1,38 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/app/atom_main_delegate.h"
+
+#include "base/mac/bundle_locations.h"
+#include "base/files/file_path.h"
+#include "base/path_service.h"
+#include "brightray/common/mac/main_application_bundle.h"
+#include "content/public/common/content_paths.h"
+
+namespace atom {
+
+namespace {
+
+base::FilePath GetFrameworksPath() {
+  return brightray::MainApplicationBundlePath().Append("Contents")
+                                               .Append("Frameworks");
+}
+
+}  // namespace
+
+void AtomMainDelegate::OverrideFrameworkBundlePath() {
+  base::mac::SetOverrideFrameworkBundlePath(
+      GetFrameworksPath().Append(PRODUCT_NAME " Framework.framework"));
+}
+
+void AtomMainDelegate::OverrideChildProcessPath() {
+  base::FilePath helper_path =
+      GetFrameworksPath().Append(PRODUCT_NAME " Helper.app")
+                         .Append("Contents")
+                         .Append("MacOS")
+                         .Append(PRODUCT_NAME " Helper");
+  PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
+}
+
+}  // namespace atom

atom/app/node_main.cc

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

atom/app/node_main.h

@@ -0,0 +1,14 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_APP_NODE_MAIN_H_
+#define ATOM_APP_NODE_MAIN_H_
+
+namespace atom {
+
+int NodeMain(int argc, char *argv[]);
+
+}  // namespace atom
+
+#endif  // ATOM_APP_NODE_MAIN_H_

atom/browser/api/atom_api_app.cc

@@ -0,0 +1,292 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_app.h"
+
+#include <string>
+#include <vector>
+
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/browser.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "base/command_line.h"
+#include "base/environment.h"
+#include "base/files/file_path.h"
+#include "base/path_service.h"
+#include "brightray/browser/brightray_paths.h"
+#include "native_mate/callback.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+#include "net/base/load_flags.h"
+#include "net/proxy/proxy_service.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+#include "atom/common/node_includes.h"
+
+using atom::Browser;
+
+namespace mate {
+
+#if defined(OS_WIN)
+template<>
+struct Converter<Browser::UserTask> {
+  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+                     Browser::UserTask* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
+      return false;
+    if (!dict.Get("program", &(out->program)) ||
+        !dict.Get("title", &(out->title)))
+      return false;
+    if (dict.Get("iconPath", &(out->icon_path)) &&
+        !dict.Get("iconIndex", &(out->icon_index)))
+      return false;
+    dict.Get("arguments", &(out->arguments));
+    dict.Get("description", &(out->description));
+    return true;
+  }
+};
+#endif
+
+}  // namespace mate
+
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+// Return the path constant from string.
+int GetPathConstant(const std::string& name) {
+  if (name == "appData")
+    return brightray::DIR_APP_DATA;
+  else if (name == "userData")
+    return brightray::DIR_USER_DATA;
+  else if (name == "cache")
+    return brightray::DIR_CACHE;
+  else if (name == "userCache")
+    return brightray::DIR_USER_CACHE;
+  else if (name == "home")
+    return base::DIR_HOME;
+  else if (name == "temp")
+    return base::DIR_TEMP;
+  else if (name == "userDesktop")
+    return base::DIR_USER_DESKTOP;
+  else if (name == "exe")
+    return base::FILE_EXE;
+  else if (name == "module")
+    return base::FILE_MODULE;
+  else
+    return -1;
+}
+
+class ResolveProxyHelper {
+ public:
+  ResolveProxyHelper(const GURL& url, App::ResolveProxyCallback callback)
+      : callback_(callback) {
+    net::ProxyService* proxy_service = AtomBrowserContext::Get()->
+        url_request_context_getter()->GetURLRequestContext()->proxy_service();
+
+    // Start the request.
+    int result = proxy_service->ResolveProxy(
+        url, net::LOAD_NORMAL, &proxy_info_,
+        base::Bind(&ResolveProxyHelper::OnResolveProxyCompleted,
+                   base::Unretained(this)),
+        &pac_req_, nullptr, net::BoundNetLog());
+
+    // Completed synchronously.
+    if (result != net::ERR_IO_PENDING)
+      OnResolveProxyCompleted(result);
+  }
+
+  void OnResolveProxyCompleted(int result) {
+    std::string proxy;
+    if (result == net::OK)
+      proxy = proxy_info_.ToPacString();
+    callback_.Run(proxy);
+
+    delete this;
+  }
+
+ private:
+  App::ResolveProxyCallback callback_;
+  net::ProxyInfo proxy_info_;
+  net::ProxyService::PacRequest* pac_req_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
+};
+
+}  // namespace
+
+App::App() {
+  Browser::Get()->AddObserver(this);
+}
+
+App::~App() {
+  Browser::Get()->RemoveObserver(this);
+}
+
+void App::OnBeforeQuit(bool* prevent_default) {
+  *prevent_default = Emit("before-quit");
+}
+
+void App::OnWillQuit(bool* prevent_default) {
+  *prevent_default = Emit("will-quit");
+}
+
+void App::OnWindowAllClosed() {
+  Emit("window-all-closed");
+}
+
+void App::OnQuit() {
+  Emit("quit");
+}
+
+void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
+  *prevent_default = Emit("open-file", file_path);
+}
+
+void App::OnOpenURL(const std::string& url) {
+  Emit("open-url", url);
+}
+
+void App::OnActivateWithNoOpenWindows() {
+  Emit("activate-with-no-open-windows");
+}
+
+void App::OnWillFinishLaunching() {
+  Emit("will-finish-launching");
+}
+
+void App::OnFinishLaunching() {
+  Emit("ready");
+}
+
+base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
+  bool succeed = false;
+  base::FilePath path;
+  int key = GetPathConstant(name);
+  if (key >= 0)
+    succeed = PathService::Get(key, &path);
+  if (!succeed)
+    args->ThrowError("Failed to get path");
+  return path;
+}
+
+void App::SetPath(mate::Arguments* args,
+                  const std::string& name,
+                  const base::FilePath& path) {
+  bool succeed = false;
+  int key = GetPathConstant(name);
+  if (key >= 0)
+    succeed = PathService::Override(key, path);
+  if (!succeed)
+    args->ThrowError("Failed to set path");
+}
+
+void App::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
+  new ResolveProxyHelper(url, callback);
+}
+
+void App::SetDesktopName(const std::string& desktop_name) {
+#if defined(OS_LINUX)
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  env->SetVar("CHROME_DESKTOP", desktop_name);
+#endif
+}
+
+mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  auto browser = base::Unretained(Browser::Get());
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("quit", base::Bind(&Browser::Quit, browser))
+      .SetMethod("focus", base::Bind(&Browser::Focus, browser))
+      .SetMethod("getVersion", base::Bind(&Browser::GetVersion, browser))
+      .SetMethod("setVersion", base::Bind(&Browser::SetVersion, browser))
+      .SetMethod("getName", base::Bind(&Browser::GetName, browser))
+      .SetMethod("setName", base::Bind(&Browser::SetName, browser))
+      .SetMethod("isReady", base::Bind(&Browser::is_ready, browser))
+      .SetMethod("addRecentDocument",
+                 base::Bind(&Browser::AddRecentDocument, browser))
+      .SetMethod("clearRecentDocuments",
+                 base::Bind(&Browser::ClearRecentDocuments, browser))
+#if defined(OS_WIN)
+      .SetMethod("setUserTasks",
+                 base::Bind(&Browser::SetUserTasks, browser))
+#endif
+      .SetMethod("setPath", &App::SetPath)
+      .SetMethod("getPath", &App::GetPath)
+      .SetMethod("resolveProxy", &App::ResolveProxy)
+      .SetMethod("setDesktopName", &App::SetDesktopName);
+}
+
+// static
+mate::Handle<App> App::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new App);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+void AppendSwitch(const std::string& switch_string, mate::Arguments* args) {
+  auto command_line = base::CommandLine::ForCurrentProcess();
+  std::string value;
+  if (args->GetNext(&value))
+    command_line->AppendSwitchASCII(switch_string, value);
+  else
+    command_line->AppendSwitch(switch_string);
+}
+
+#if defined(OS_MACOSX)
+int DockBounce(const std::string& type) {
+  int request_id = -1;
+  if (type == "critical")
+    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_CRITICAL);
+  else if (type == "informational")
+    request_id = Browser::Get()->DockBounce(Browser::BOUNCE_INFORMATIONAL);
+  return request_id;
+}
+
+void DockSetMenu(atom::api::Menu* menu) {
+  Browser::Get()->DockSetMenu(menu->model());
+}
+#endif
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  auto command_line = base::CommandLine::ForCurrentProcess();
+
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("app", atom::api::App::Create(isolate));
+  dict.SetMethod("appendSwitch", &AppendSwitch);
+  dict.SetMethod("appendArgument",
+                 base::Bind(&base::CommandLine::AppendArg,
+                            base::Unretained(command_line)));
+#if defined(OS_MACOSX)
+  auto browser = base::Unretained(Browser::Get());
+  dict.SetMethod("dockBounce", &DockBounce);
+  dict.SetMethod("dockCancelBounce",
+                 base::Bind(&Browser::DockCancelBounce, browser));
+  dict.SetMethod("dockSetBadgeText",
+                 base::Bind(&Browser::DockSetBadgeText, browser));
+  dict.SetMethod("dockGetBadgeText",
+                 base::Bind(&Browser::DockGetBadgeText, browser));
+  dict.SetMethod("dockHide", base::Bind(&Browser::DockHide, browser));
+  dict.SetMethod("dockShow", base::Bind(&Browser::DockShow, browser));
+  dict.SetMethod("dockSetMenu", &DockSetMenu);
+#endif
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_app, Initialize)

atom/browser/api/atom_api_app.h

@@ -0,0 +1,72 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_APP_H_
+#define ATOM_BROWSER_API_ATOM_API_APP_H_
+
+#include <string>
+
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/browser_observer.h"
+#include "base/callback.h"
+#include "native_mate/handle.h"
+
+class GURL;
+
+namespace base {
+class FilePath;
+}
+
+namespace mate {
+class Arguments;
+}
+
+namespace atom {
+
+namespace api {
+
+class App : public mate::EventEmitter,
+            public BrowserObserver {
+ public:
+  typedef base::Callback<void(std::string)> ResolveProxyCallback;
+
+  static mate::Handle<App> Create(v8::Isolate* isolate);
+
+ protected:
+  App();
+  virtual ~App();
+
+  // BrowserObserver:
+  void OnBeforeQuit(bool* prevent_default) override;
+  void OnWillQuit(bool* prevent_default) override;
+  void OnWindowAllClosed() override;
+  void OnQuit() override;
+  void OnOpenFile(bool* prevent_default, const std::string& file_path) override;
+  void OnOpenURL(const std::string& url) override;
+  void OnActivateWithNoOpenWindows() override;
+  void OnWillFinishLaunching() override;
+  void OnFinishLaunching() override;
+
+  // mate::Wrappable:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+
+ private:
+  // Get/Set the pre-defined path in PathService.
+  base::FilePath GetPath(mate::Arguments* args, const std::string& name);
+  void SetPath(mate::Arguments* args,
+               const std::string& name,
+               const base::FilePath& path);
+
+  void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
+  void SetDesktopName(const std::string& desktop_name);
+
+  DISALLOW_COPY_AND_ASSIGN(App);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_APP_H_

atom/browser/api/atom_api_auto_updater.cc

@@ -0,0 +1,89 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_auto_updater.h"
+
+#include "base/time/time.h"
+#include "atom/browser/auto_updater.h"
+#include "atom/browser/browser.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+AutoUpdater::AutoUpdater() {
+  auto_updater::AutoUpdater::SetDelegate(this);
+}
+
+AutoUpdater::~AutoUpdater() {
+  auto_updater::AutoUpdater::SetDelegate(NULL);
+}
+
+void AutoUpdater::OnError(const std::string& error) {
+  Emit("error", error);
+}
+
+void AutoUpdater::OnCheckingForUpdate() {
+  Emit("checking-for-update");
+}
+
+void AutoUpdater::OnUpdateAvailable() {
+  Emit("update-available");
+}
+
+void AutoUpdater::OnUpdateNotAvailable() {
+  Emit("update-not-available");
+}
+
+void AutoUpdater::OnUpdateDownloaded(const std::string& release_notes,
+                                     const std::string& release_name,
+                                     const base::Time& release_date,
+                                     const std::string& update_url,
+                                     const base::Closure& quit_and_install) {
+  quit_and_install_ = quit_and_install;
+  Emit("update-downloaded-raw", release_notes, release_name,
+       release_date.ToJsTime(), update_url);
+}
+
+mate::ObjectTemplateBuilder AutoUpdater::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("setFeedUrl", &auto_updater::AutoUpdater::SetFeedURL)
+      .SetMethod("checkForUpdates", &auto_updater::AutoUpdater::CheckForUpdates)
+      .SetMethod("_quitAndInstall", &AutoUpdater::QuitAndInstall);
+}
+
+void AutoUpdater::QuitAndInstall() {
+  if (quit_and_install_.is_null())
+    Browser::Get()->Shutdown();
+  else
+    quit_and_install_.Run();
+}
+
+// static
+mate::Handle<AutoUpdater> AutoUpdater::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new AutoUpdater);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("autoUpdater", atom::api::AutoUpdater::Create(isolate));
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_auto_updater, Initialize)

atom/browser/api/atom_api_auto_updater.h

@@ -0,0 +1,56 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_
+#define ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_
+
+#include <string>
+
+#include "base/callback.h"
+#include "atom/browser/api/event_emitter.h"
+#include "atom/browser/auto_updater_delegate.h"
+#include "native_mate/handle.h"
+
+namespace atom {
+
+namespace api {
+
+class AutoUpdater : public mate::EventEmitter,
+                    public auto_updater::AutoUpdaterDelegate {
+ public:
+  static mate::Handle<AutoUpdater> Create(v8::Isolate* isolate);
+
+ protected:
+  AutoUpdater();
+  virtual ~AutoUpdater();
+
+  // AutoUpdaterDelegate implementations.
+  void OnError(const std::string& error) override;
+  void OnCheckingForUpdate() override;
+  void OnUpdateAvailable() override;
+  void OnUpdateNotAvailable() override;
+  void OnUpdateDownloaded(
+      const std::string& release_notes,
+      const std::string& release_name,
+      const base::Time& release_date,
+      const std::string& update_url,
+      const base::Closure& quit_and_install) override;
+
+  // mate::Wrappable implementations:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+
+ private:
+  void QuitAndInstall();
+
+  base::Closure quit_and_install_;
+
+  DISALLOW_COPY_AND_ASSIGN(AutoUpdater);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_AUTO_UPDATER_H_

atom/browser/api/atom_api_content_tracing.cc

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

atom/browser/api/atom_api_dialog.cc

@@ -0,0 +1,120 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "atom/browser/api/atom_api_window.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/ui/file_dialog.h"
+#include "atom/browser/ui/message_box.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "native_mate/callback.h"
+#include "native_mate/dictionary.h"
+
+#include "atom/common/node_includes.h"
+
+namespace mate {
+
+template<>
+struct Converter<file_dialog::Filter> {
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     file_dialog::Filter* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
+      return false;
+    if (!dict.Get("name", &(out->first)))
+      return false;
+    if (!dict.Get("extensions", &(out->second)))
+      return false;
+    return true;
+  }
+};
+
+}  // namespace mate
+
+namespace {
+
+void ShowMessageBox(int type,
+                    const std::vector<std::string>& buttons,
+                    const std::vector<std::string>& texts,
+                    const gfx::ImageSkia& icon,
+                    atom::NativeWindow* window,
+                    mate::Arguments* args) {
+  // FIXME We are exceeding the parameters limit of base::Bind here, so we have
+  // to pass some parameters in an array. We should remove this once we have
+  // variadic template support in base::Bind.
+  const std::string& title = texts[0];
+  const std::string& message = texts[1];
+  const std::string& detail = texts[2];
+
+  v8::Handle<v8::Value> peek = args->PeekNext();
+  atom::MessageBoxCallback callback;
+  if (mate::Converter<atom::MessageBoxCallback>::FromV8(args->isolate(),
+                                                        peek,
+                                                        &callback)) {
+    atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons, title,
+                         message, detail, icon, callback);
+  } else {
+    int chosen = atom::ShowMessageBox(window, (atom::MessageBoxType)type,
+                                      buttons, title, message, detail, icon);
+    args->Return(chosen);
+  }
+}
+
+void ShowOpenDialog(const std::string& title,
+                    const base::FilePath& default_path,
+                    const file_dialog::Filters& filters,
+                    int properties,
+                    atom::NativeWindow* window,
+                    mate::Arguments* args) {
+  v8::Handle<v8::Value> peek = args->PeekNext();
+  file_dialog::OpenDialogCallback callback;
+  if (mate::Converter<file_dialog::OpenDialogCallback>::FromV8(args->isolate(),
+                                                               peek,
+                                                               &callback)) {
+    file_dialog::ShowOpenDialog(window, title, default_path, filters,
+                                properties, callback);
+  } else {
+    std::vector<base::FilePath> paths;
+    if (file_dialog::ShowOpenDialog(window, title, default_path, filters,
+                                    properties, &paths))
+      args->Return(paths);
+  }
+}
+
+void ShowSaveDialog(const std::string& title,
+                    const base::FilePath& default_path,
+                    const file_dialog::Filters& filters,
+                    atom::NativeWindow* window,
+                    mate::Arguments* args) {
+  v8::Handle<v8::Value> peek = args->PeekNext();
+  file_dialog::SaveDialogCallback callback;
+  if (mate::Converter<file_dialog::SaveDialogCallback>::FromV8(args->isolate(),
+                                                               peek,
+                                                               &callback)) {
+    file_dialog::ShowSaveDialog(window, title, default_path, filters, callback);
+  } else {
+    base::FilePath path;
+    if (file_dialog::ShowSaveDialog(window, title, default_path, filters,
+                                    &path))
+      args->Return(path);
+  }
+}
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  mate::Dictionary dict(context->GetIsolate(), exports);
+  dict.SetMethod("showMessageBox", &ShowMessageBox);
+  dict.SetMethod("showErrorBox", &atom::ShowErrorBox);
+  dict.SetMethod("showOpenDialog", &ShowOpenDialog);
+  dict.SetMethod("showSaveDialog", &ShowSaveDialog);
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_dialog, Initialize)

atom/browser/api/atom_api_global_shortcut.cc

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

atom/browser/api/atom_api_global_shortcut.h

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

atom/browser/api/atom_api_menu.cc

@@ -0,0 +1,200 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_menu.h"
+
+#include "atom/browser/native_window.h"
+#include "atom/common/native_mate_converters/accelerator_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "native_mate/callback.h"
+#include "native_mate/constructor.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+Menu::Menu()
+    : model_(new ui::SimpleMenuModel(this)),
+      parent_(NULL) {
+}
+
+Menu::~Menu() {
+}
+
+void Menu::AfterInit(v8::Isolate* isolate) {
+  mate::Dictionary wrappable(isolate, GetWrapper(isolate));
+  mate::Dictionary delegate;
+  if (!wrappable.Get("delegate", &delegate))
+    return;
+
+  delegate.Get("isCommandIdChecked", &is_checked_);
+  delegate.Get("isCommandIdEnabled", &is_enabled_);
+  delegate.Get("isCommandIdVisible", &is_visible_);
+  delegate.Get("getAcceleratorForCommandId", &get_accelerator_);
+  delegate.Get("executeCommand", &execute_command_);
+  delegate.Get("menuWillShow", &menu_will_show_);
+}
+
+bool Menu::IsCommandIdChecked(int command_id) const {
+  return is_checked_.Run(command_id);
+}
+
+bool Menu::IsCommandIdEnabled(int command_id) const {
+  return is_enabled_.Run(command_id);
+}
+
+bool Menu::IsCommandIdVisible(int command_id) const {
+  return is_visible_.Run(command_id);
+}
+
+bool Menu::GetAcceleratorForCommandId(int command_id,
+                                      ui::Accelerator* accelerator) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  v8::Handle<v8::Value> val = get_accelerator_.Run(command_id);
+  return mate::ConvertFromV8(isolate, val, accelerator);
+}
+
+void Menu::ExecuteCommand(int command_id, int event_flags) {
+  execute_command_.Run(command_id);
+}
+
+void Menu::MenuWillShow(ui::SimpleMenuModel* source) {
+  menu_will_show_.Run();
+}
+
+void Menu::AttachToWindow(Window* window) {
+  window->window()->SetMenu(model_.get());
+}
+
+void Menu::InsertItemAt(
+    int index, int command_id, const base::string16& label) {
+  model_->InsertItemAt(index, command_id, label);
+}
+
+void Menu::InsertSeparatorAt(int index) {
+  model_->InsertSeparatorAt(index, ui::NORMAL_SEPARATOR);
+}
+
+void Menu::InsertCheckItemAt(int index,
+                             int command_id,
+                             const base::string16& label) {
+  model_->InsertCheckItemAt(index, command_id, label);
+}
+
+void Menu::InsertRadioItemAt(int index,
+                             int command_id,
+                             const base::string16& label,
+                             int group_id) {
+  model_->InsertRadioItemAt(index, command_id, label, group_id);
+}
+
+void Menu::InsertSubMenuAt(int index,
+                           int command_id,
+                           const base::string16& label,
+                           Menu* menu) {
+  menu->parent_ = this;
+  model_->InsertSubMenuAt(index, command_id, label, menu->model_.get());
+}
+
+void Menu::SetIcon(int index, const gfx::Image& image) {
+  model_->SetIcon(index, image);
+}
+
+void Menu::SetSublabel(int index, const base::string16& sublabel) {
+  model_->SetSublabel(index, sublabel);
+}
+
+void Menu::Clear() {
+  model_->Clear();
+}
+
+int Menu::GetIndexOfCommandId(int command_id) {
+  return model_->GetIndexOfCommandId(command_id);
+}
+
+int Menu::GetItemCount() const {
+  return model_->GetItemCount();
+}
+
+int Menu::GetCommandIdAt(int index) const {
+  return model_->GetCommandIdAt(index);
+}
+
+base::string16 Menu::GetLabelAt(int index) const {
+  return model_->GetLabelAt(index);
+}
+
+base::string16 Menu::GetSublabelAt(int index) const {
+  return model_->GetSublabelAt(index);
+}
+
+bool Menu::IsItemCheckedAt(int index) const {
+  return model_->IsItemCheckedAt(index);
+}
+
+bool Menu::IsEnabledAt(int index) const {
+  return model_->IsEnabledAt(index);
+}
+
+bool Menu::IsVisibleAt(int index) const {
+  return model_->IsVisibleAt(index);
+}
+
+// static
+void Menu::BuildPrototype(v8::Isolate* isolate,
+                          v8::Handle<v8::ObjectTemplate> prototype) {
+  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("insertItem", &Menu::InsertItemAt)
+      .SetMethod("insertCheckItem", &Menu::InsertCheckItemAt)
+      .SetMethod("insertRadioItem", &Menu::InsertRadioItemAt)
+      .SetMethod("insertSeparator", &Menu::InsertSeparatorAt)
+      .SetMethod("insertSubMenu", &Menu::InsertSubMenuAt)
+      .SetMethod("setIcon", &Menu::SetIcon)
+      .SetMethod("setSublabel", &Menu::SetSublabel)
+      .SetMethod("clear", &Menu::Clear)
+      .SetMethod("getIndexOfCommandId", &Menu::GetIndexOfCommandId)
+      .SetMethod("getItemCount", &Menu::GetItemCount)
+      .SetMethod("getCommandIdAt", &Menu::GetCommandIdAt)
+      .SetMethod("getLabelAt", &Menu::GetLabelAt)
+      .SetMethod("getSublabelAt", &Menu::GetSublabelAt)
+      .SetMethod("isItemCheckedAt", &Menu::IsItemCheckedAt)
+      .SetMethod("isEnabledAt", &Menu::IsEnabledAt)
+      .SetMethod("isVisibleAt", &Menu::IsVisibleAt)
+      .SetMethod("attachToWindow", &Menu::AttachToWindow)
+      .SetMethod("_popup", &Menu::Popup)
+      .SetMethod("_popupAt", &Menu::PopupAt);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  using atom::api::Menu;
+  v8::Isolate* isolate = context->GetIsolate();
+  v8::Local<v8::Function> constructor = mate::CreateConstructor<Menu>(
+      isolate, "Menu", base::Bind(&Menu::Create));
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("Menu", static_cast<v8::Handle<v8::Value>>(constructor));
+#if defined(OS_MACOSX)
+  dict.SetMethod("setApplicationMenu", &Menu::SetApplicationMenu);
+  dict.SetMethod("sendActionToFirstResponder",
+                 &Menu::SendActionToFirstResponder);
+#endif
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_menu, Initialize)

atom/browser/api/atom_api_menu.h

@@ -0,0 +1,102 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_MENU_H_
+#define ATOM_BROWSER_API_ATOM_API_MENU_H_
+
+#include <string>
+
+#include "atom/browser/api/atom_api_window.h"
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+#include "ui/base/models/simple_menu_model.h"
+#include "native_mate/wrappable.h"
+
+namespace atom {
+
+namespace api {
+
+class Menu : public mate::Wrappable,
+             public ui::SimpleMenuModel::Delegate {
+ public:
+  static mate::Wrappable* Create();
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Handle<v8::ObjectTemplate> prototype);
+
+#if defined(OS_MACOSX)
+  // Set the global menubar.
+  static void SetApplicationMenu(Menu* menu);
+
+  // Fake sending an action from the application menu.
+  static void SendActionToFirstResponder(const std::string& action);
+#endif
+
+  ui::SimpleMenuModel* model() const { return model_.get(); }
+
+ protected:
+  Menu();
+  virtual ~Menu();
+
+  // mate::Wrappable:
+  void AfterInit(v8::Isolate* isolate) override;
+
+  // ui::SimpleMenuModel::Delegate implementations:
+  bool IsCommandIdChecked(int command_id) const override;
+  bool IsCommandIdEnabled(int command_id) const override;
+  bool IsCommandIdVisible(int command_id) const override;
+  bool GetAcceleratorForCommandId(int command_id,
+                                  ui::Accelerator* accelerator) override;
+  void ExecuteCommand(int command_id, int event_flags) override;
+  void MenuWillShow(ui::SimpleMenuModel* source) override;
+
+  virtual void AttachToWindow(Window* window);
+  virtual void Popup(Window* window) = 0;
+  virtual void PopupAt(Window* window, int x, int y) = 0;
+
+  scoped_ptr<ui::SimpleMenuModel> model_;
+  Menu* parent_;
+
+ private:
+  void InsertItemAt(int index, int command_id, const base::string16& label);
+  void InsertSeparatorAt(int index);
+  void InsertCheckItemAt(int index,
+                         int command_id,
+                         const base::string16& label);
+  void InsertRadioItemAt(int index,
+                         int command_id,
+                         const base::string16& label,
+                         int group_id);
+  void InsertSubMenuAt(int index,
+                       int command_id,
+                       const base::string16& label,
+                       Menu* menu);
+  void SetIcon(int index, const gfx::Image& image);
+  void SetSublabel(int index, const base::string16& sublabel);
+  void Clear();
+  int GetIndexOfCommandId(int command_id);
+  int GetItemCount() const;
+  int GetCommandIdAt(int index) const;
+  base::string16 GetLabelAt(int index) const;
+  base::string16 GetSublabelAt(int index) const;
+  bool IsItemCheckedAt(int index) const;
+  bool IsEnabledAt(int index) const;
+  bool IsVisibleAt(int index) const;
+
+  // Stored delegate methods.
+  base::Callback<bool(int)> is_checked_;
+  base::Callback<bool(int)> is_enabled_;
+  base::Callback<bool(int)> is_visible_;
+  base::Callback<v8::Handle<v8::Value>(int)> get_accelerator_;
+  base::Callback<void(int)> execute_command_;
+  base::Callback<void()> menu_will_show_;
+
+  DISALLOW_COPY_AND_ASSIGN(Menu);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_H_

atom/browser/api/atom_api_menu_mac.h

@@ -0,0 +1,39 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
+#define ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_
+
+#include "atom/browser/api/atom_api_menu.h"
+
+#include <string>
+
+#import "atom/browser/ui/cocoa/atom_menu_controller.h"
+
+namespace atom {
+
+namespace api {
+
+class MenuMac : public Menu {
+ protected:
+  MenuMac();
+
+  void Popup(Window* window) override;
+  void PopupAt(Window* window, int x, int y) override;
+
+  base::scoped_nsobject<AtomMenuController> menu_controller_;
+
+ private:
+  friend class Menu;
+
+  static void SendActionToFirstResponder(const std::string& action);
+
+  DISALLOW_COPY_AND_ASSIGN(MenuMac);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_MAC_H_

atom/browser/api/atom_api_menu_mac.mm

@@ -0,0 +1,96 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#import "atom/browser/api/atom_api_menu_mac.h"
+
+#include "atom/browser/native_window.h"
+#include "base/message_loop/message_loop.h"
+#include "base/strings/sys_string_conversions.h"
+#include "content/public/browser/web_contents.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+MenuMac::MenuMac() {
+}
+
+void MenuMac::Popup(Window* window) {
+  NativeWindow* native_window = window->window();
+  if (!native_window)
+    return;
+  content::WebContents* web_contents = native_window->GetWebContents();
+  if (!web_contents)
+    return;
+
+  NSWindow* nswindow = native_window->GetNativeWindow();
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:model_.get()]);
+
+  // Fake out a context menu event.
+  NSEvent* currentEvent = [NSApp currentEvent];
+  NSPoint position = [nswindow mouseLocationOutsideOfEventStream];
+  NSTimeInterval eventTime = [currentEvent timestamp];
+  NSEvent* clickEvent = [NSEvent mouseEventWithType:NSRightMouseDown
+                                           location:position
+                                      modifierFlags:NSRightMouseDownMask
+                                          timestamp:eventTime
+                                       windowNumber:[nswindow windowNumber]
+                                            context:nil
+                                        eventNumber:0
+                                         clickCount:1
+                                           pressure:1.0];
+
+  // Show the menu.
+  [NSMenu popUpContextMenu:[menu_controller menu]
+                 withEvent:clickEvent
+                   forView:web_contents->GetContentNativeView()];
+}
+
+void MenuMac::PopupAt(Window* window, int x, int y) {
+  NativeWindow* native_window = window->window();
+  if (!native_window)
+    return;
+  content::WebContents* web_contents = native_window->GetWebContents();
+  if (!web_contents)
+    return;
+
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:model_.get()]);
+  NSMenu* menu = [menu_controller menu];
+  NSView* view = web_contents->GetContentNativeView();
+
+  // Show the menu.
+  [menu popUpMenuPositioningItem:[menu itemAtIndex:0]
+                      atLocation:NSMakePoint(x, [view frame].size.height - y)
+                          inView:view];
+}
+
+// static
+void Menu::SetApplicationMenu(Menu* base_menu) {
+  MenuMac* menu = static_cast<MenuMac*>(base_menu);
+  base::scoped_nsobject<AtomMenuController> menu_controller(
+      [[AtomMenuController alloc] initWithModel:menu->model_.get()]);
+  [NSApp setMainMenu:[menu_controller menu]];
+
+  // Ensure the menu_controller_ is destroyed after main menu is set.
+  menu_controller.swap(menu->menu_controller_);
+}
+
+// static
+void Menu::SendActionToFirstResponder(const std::string& action) {
+  SEL selector = NSSelectorFromString(base::SysUTF8ToNSString(action));
+  [NSApp sendAction:selector to:nil from:[NSApp mainMenu]];
+}
+
+// static
+mate::Wrappable* Menu::Create() {
+  return new MenuMac();
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_menu_views.cc

@@ -0,0 +1,57 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_menu_views.h"
+
+#include "atom/browser/native_window_views.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "ui/gfx/screen.h"
+#include "ui/views/controls/menu/menu_runner.h"
+
+namespace atom {
+
+namespace api {
+
+MenuViews::MenuViews() {
+}
+
+void MenuViews::Popup(Window* window) {
+  PopupAtPoint(window, gfx::Screen::GetNativeScreen()->GetCursorScreenPoint());
+}
+
+void MenuViews::PopupAt(Window* window, int x, int y) {
+  NativeWindow* native_window = static_cast<NativeWindow*>(window->window());
+  if (!native_window)
+    return;
+  content::WebContents* web_contents = native_window->GetWebContents();
+  if (!web_contents)
+    return;
+  content::RenderWidgetHostView* view = web_contents->GetRenderWidgetHostView();
+  if (!view)
+    return;
+
+  gfx::Point origin = view->GetViewBounds().origin();
+  PopupAtPoint(window, gfx::Point(origin.x() + x, origin.y() + y));
+}
+
+void MenuViews::PopupAtPoint(Window* window, const gfx::Point& point) {
+  views::MenuRunner menu_runner(
+      model(),
+      views::MenuRunner::CONTEXT_MENU | views::MenuRunner::HAS_MNEMONICS);
+  ignore_result(menu_runner.RunMenuAt(
+      static_cast<NativeWindowViews*>(window->window())->widget(),
+      NULL,
+      gfx::Rect(point, gfx::Size()),
+      views::MENU_ANCHOR_TOPLEFT,
+      ui::MENU_SOURCE_MOUSE));
+}
+
+// static
+mate::Wrappable* Menu::Create() {
+  return new MenuViews();
+}
+
+}  // namespace api
+
+}  // namespace atom

atom/browser/api/atom_api_menu_views.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_
+#define ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_
+
+#include "atom/browser/api/atom_api_menu.h"
+#include "ui/gfx/screen.h"
+
+namespace atom {
+
+namespace api {
+
+class MenuViews : public Menu {
+ public:
+  MenuViews();
+
+ protected:
+  void Popup(Window* window) override;
+  void PopupAt(Window* window, int x, int y) override;
+
+ private:
+  void PopupAtPoint(Window* window, const gfx::Point& point);
+
+  DISALLOW_COPY_AND_ASSIGN(MenuViews);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_MENU_VIEWS_H_

atom/browser/api/atom_api_power_monitor.cc

@@ -0,0 +1,67 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_power_monitor.h"
+
+#include "base/power_monitor/power_monitor.h"
+#include "base/power_monitor/power_monitor_device_source.h"
+#include "native_mate/dictionary.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+PowerMonitor::PowerMonitor() {
+  base::PowerMonitor::Get()->AddObserver(this);
+}
+
+PowerMonitor::~PowerMonitor() {
+  base::PowerMonitor::Get()->RemoveObserver(this);
+}
+
+void PowerMonitor::OnPowerStateChange(bool on_battery_power) {
+  if (on_battery_power)
+    Emit("on-battery");
+  else
+    Emit("on-ac");
+}
+
+void PowerMonitor::OnSuspend() {
+  Emit("suspend");
+}
+
+void PowerMonitor::OnResume() {
+  Emit("resume");
+}
+
+// static
+mate::Handle<PowerMonitor> PowerMonitor::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new PowerMonitor);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+#if defined(OS_MACOSX)
+  base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
+#endif
+
+  using atom::api::PowerMonitor;
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Handle<PowerMonitor> power_monitor = PowerMonitor::Create(isolate);
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("powerMonitor", power_monitor);
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_power_monitor, Initialize)

atom/browser/api/atom_api_power_monitor.h

@@ -0,0 +1,39 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
+#define ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_
+
+#include "atom/browser/api/event_emitter.h"
+#include "base/compiler_specific.h"
+#include "base/power_monitor/power_observer.h"
+#include "native_mate/handle.h"
+
+namespace atom {
+
+namespace api {
+
+class PowerMonitor : public mate::EventEmitter,
+                     public base::PowerObserver {
+ public:
+  static mate::Handle<PowerMonitor> Create(v8::Isolate* isolate);
+
+ protected:
+  PowerMonitor();
+  virtual ~PowerMonitor();
+
+  // base::PowerObserver implementations:
+  void OnPowerStateChange(bool on_battery_power) override;
+  void OnSuspend() override;
+  void OnResume() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_POWER_MONITOR_H_

atom/browser/api/atom_api_protocol.cc

@@ -0,0 +1,342 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_protocol.h"
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/net/adapter_request_job.h"
+#include "atom/browser/net/atom_url_request_job_factory.h"
+#include "atom/common/native_mate_converters/file_path_converter.h"
+#include "content/public/browser/browser_thread.h"
+#include "native_mate/callback.h"
+#include "native_mate/dictionary.h"
+#include "net/url_request/url_request_context.h"
+
+#include "atom/common/node_includes.h"
+
+using content::BrowserThread;
+
+namespace mate {
+
+template<>
+struct Converter<const net::URLRequest*> {
+  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+                                    const net::URLRequest* val) {
+    return mate::ObjectTemplateBuilder(isolate)
+        .SetValue("method", val->method())
+        .SetValue("url", val->url().spec())
+        .SetValue("referrer", val->referrer())
+        .Build()->NewInstance();
+  }
+};
+
+}  // namespace mate
+
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
+
+class CustomProtocolRequestJob : public AdapterRequestJob {
+ public:
+  CustomProtocolRequestJob(Protocol* registry,
+                           ProtocolHandler* protocol_handler,
+                           net::URLRequest* request,
+                           net::NetworkDelegate* network_delegate)
+      : AdapterRequestJob(protocol_handler, request, network_delegate),
+        registry_(registry) {
+  }
+
+  // AdapterRequestJob:
+  void GetJobTypeInUI() override {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    // Call the JS handler.
+    Protocol::JsProtocolHandler callback =
+        registry_->GetProtocolHandler(request()->url().scheme());
+    v8::Handle<v8::Value> result = callback.Run(request());
+
+    // Determine the type of the job we are going to create.
+    if (result->IsString()) {
+      std::string data = mate::V8ToString(result);
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+          base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
+                     GetWeakPtr(), "text/plain", "UTF-8", data));
+      return;
+    } else if (result->IsObject()) {
+      v8::Handle<v8::Object> obj = result->ToObject();
+      mate::Dictionary dict(isolate, obj);
+      std::string name = mate::V8ToString(obj->GetConstructorName());
+      if (name == "RequestStringJob") {
+        std::string mime_type, charset, data;
+        dict.Get("mimeType", &mime_type);
+        dict.Get("charset", &charset);
+        dict.Get("data", &data);
+
+        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+            base::Bind(&AdapterRequestJob::CreateStringJobAndStart,
+                       GetWeakPtr(), mime_type, charset, data));
+        return;
+      } else if (name == "RequestBufferJob") {
+        std::string mime_type, encoding;
+        v8::Handle<v8::Value> buffer;
+        dict.Get("mimeType", &mime_type);
+        dict.Get("encoding", &encoding);
+        dict.Get("data", &buffer);
+
+        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+            base::Bind(&AdapterRequestJob::CreateBufferJobAndStart,
+                       GetWeakPtr(), mime_type, encoding, buffer->ToObject()));
+        return;
+      } else if (name == "RequestFileJob") {
+        base::FilePath path;
+        dict.Get("path", &path);
+
+        BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+            base::Bind(&AdapterRequestJob::CreateFileJobAndStart,
+                       GetWeakPtr(), path));
+        return;
+      }
+    }
+
+    // Try the default protocol handler if we have.
+    if (default_protocol_handler()) {
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+          base::Bind(&AdapterRequestJob::CreateJobFromProtocolHandlerAndStart,
+                     GetWeakPtr()));
+      return;
+    }
+
+    // Fallback to the not implemented error.
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+        base::Bind(&AdapterRequestJob::CreateErrorJobAndStart,
+                   GetWeakPtr(), net::ERR_NOT_IMPLEMENTED));
+  }
+
+ private:
+  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
+};
+
+// Always return the same CustomProtocolRequestJob for all requests, because
+// the content API needs the ProtocolHandler to return a job immediately, and
+// getting the real job from the JS requires asynchronous calls, so we have
+// to create an adapter job first.
+// Users can also pass an extra ProtocolHandler as the fallback one when
+// registered handler doesn't want to deal with the request.
+class CustomProtocolHandler : public ProtocolHandler {
+ public:
+  CustomProtocolHandler(api::Protocol* registry,
+                        ProtocolHandler* protocol_handler = NULL)
+      : registry_(registry), protocol_handler_(protocol_handler) {
+  }
+
+  net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override {
+    return new CustomProtocolRequestJob(registry_, protocol_handler_.get(),
+                                        request, network_delegate);
+  }
+
+  ProtocolHandler* ReleaseDefaultProtocolHandler() {
+    return protocol_handler_.release();
+  }
+
+  ProtocolHandler* original_handler() { return protocol_handler_.get(); }
+
+ private:
+  Protocol* registry_;  // Weak, the Protocol class is expected to live forever.
+  scoped_ptr<ProtocolHandler> protocol_handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
+};
+
+}  // namespace
+
+Protocol::Protocol()
+    : job_factory_(AtomBrowserContext::Get()->job_factory()) {
+  CHECK(job_factory_);
+}
+
+Protocol::JsProtocolHandler Protocol::GetProtocolHandler(
+    const std::string& scheme) {
+  return protocol_handlers_[scheme];
+}
+
+mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return mate::ObjectTemplateBuilder(isolate)
+      .SetMethod("registerProtocol",
+                 base::Bind(&Protocol::RegisterProtocol,
+                            base::Unretained(this)))
+      .SetMethod("unregisterProtocol",
+                 base::Bind(&Protocol::UnregisterProtocol,
+                            base::Unretained(this)))
+      .SetMethod("isHandledProtocol",
+                 base::Bind(&Protocol::IsHandledProtocol,
+                            base::Unretained(this)))
+      .SetMethod("interceptProtocol",
+                 base::Bind(&Protocol::InterceptProtocol,
+                            base::Unretained(this)))
+      .SetMethod("uninterceptProtocol",
+                 base::Bind(&Protocol::UninterceptProtocol,
+                            base::Unretained(this)));
+}
+
+void Protocol::RegisterProtocol(const std::string& scheme,
+                                const JsProtocolHandler& callback) {
+  if (ContainsKey(protocol_handlers_, scheme) ||
+      job_factory_->IsHandledProtocol(scheme))
+    return node::ThrowError("The scheme is already registered");
+
+  protocol_handlers_[scheme] = callback;
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::RegisterProtocolInIO,
+                                     base::Unretained(this), scheme));
+}
+
+void Protocol::UnregisterProtocol(const std::string& scheme) {
+  ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
+  if (it == protocol_handlers_.end())
+    return node::ThrowError("The scheme has not been registered");
+
+  protocol_handlers_.erase(it);
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::UnregisterProtocolInIO,
+                                     base::Unretained(this), scheme));
+}
+
+bool Protocol::IsHandledProtocol(const std::string& scheme) {
+  return job_factory_->IsHandledProtocol(scheme);
+}
+
+void Protocol::InterceptProtocol(const std::string& scheme,
+                                 const JsProtocolHandler& callback) {
+  if (!job_factory_->HasProtocolHandler(scheme))
+    return node::ThrowError("Scheme does not exist.");
+
+  if (ContainsKey(protocol_handlers_, scheme))
+    return node::ThrowError("Cannot intercept custom procotols");
+
+  protocol_handlers_[scheme] = callback;
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::InterceptProtocolInIO,
+                                     base::Unretained(this), scheme));
+}
+
+void Protocol::UninterceptProtocol(const std::string& scheme) {
+  ProtocolHandlersMap::iterator it(protocol_handlers_.find(scheme));
+  if (it == protocol_handlers_.end())
+    return node::ThrowError("The scheme has not been registered");
+
+  protocol_handlers_.erase(it);
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&Protocol::UninterceptProtocolInIO,
+                                     base::Unretained(this), scheme));
+}
+
+void Protocol::RegisterProtocolInIO(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  job_factory_->SetProtocolHandler(scheme, new CustomProtocolHandler(this));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "registered", scheme));
+}
+
+void Protocol::UnregisterProtocolInIO(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  job_factory_->SetProtocolHandler(scheme, NULL);
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "unregistered", scheme));
+}
+
+void Protocol::InterceptProtocolInIO(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  ProtocolHandler* original_handler = job_factory_->GetProtocolHandler(scheme);
+  if (original_handler == NULL) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
+        &Protocol::EmitEventInUI,
+        base::Unretained(this),
+        "error", "There is no protocol handler to intercpet"));
+    return;
+  }
+
+  job_factory_->ReplaceProtocol(
+      scheme, new CustomProtocolHandler(this, original_handler));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "intercepted", scheme));
+}
+
+void Protocol::UninterceptProtocolInIO(const std::string& scheme) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  CustomProtocolHandler* handler = static_cast<CustomProtocolHandler*>(
+      job_factory_->GetProtocolHandler(scheme));
+  if (handler->original_handler() == NULL) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
+        &Protocol::EmitEventInUI,
+        base::Unretained(this),
+        "error", "The protocol is not intercpeted"));
+    return;
+  }
+
+  // Reset the protocol handler to the orignal one and delete current protocol
+  // handler.
+  ProtocolHandler* original_handler = handler->ReleaseDefaultProtocolHandler();
+  delete job_factory_->ReplaceProtocol(scheme, original_handler);
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Protocol::EmitEventInUI,
+                                     base::Unretained(this),
+                                     "unintercepted", scheme));
+}
+
+void Protocol::EmitEventInUI(const std::string& event,
+                             const std::string& parameter) {
+  Emit(event, parameter);
+}
+
+// static
+mate::Handle<Protocol> Protocol::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new Protocol);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("protocol", atom::api::Protocol::Create(isolate));
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_protocol, Initialize)

atom/browser/api/atom_api_protocol.h

@@ -0,0 +1,79 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
+#define ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
+
+#include <string>
+#include <map>
+
+#include "atom/browser/api/event_emitter.h"
+#include "base/callback.h"
+#include "native_mate/handle.h"
+
+namespace net {
+class URLRequest;
+}
+
+namespace atom {
+
+class AtomURLRequestJobFactory;
+
+namespace api {
+
+class Protocol : public mate::EventEmitter {
+ public:
+  typedef base::Callback<v8::Handle<v8::Value>(const net::URLRequest*)>
+          JsProtocolHandler;
+
+  static mate::Handle<Protocol> Create(v8::Isolate* isolate);
+
+  JsProtocolHandler GetProtocolHandler(const std::string& scheme);
+
+ protected:
+  Protocol();
+
+  // mate::Wrappable implementations:
+  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate);
+
+ private:
+  typedef std::map<std::string, JsProtocolHandler> ProtocolHandlersMap;
+
+  // Register/unregister an networking |scheme| which would be handled by
+  // |callback|.
+  void RegisterProtocol(const std::string& scheme,
+                        const JsProtocolHandler& callback);
+  void UnregisterProtocol(const std::string& scheme);
+
+  // Returns whether a scheme has been registered.
+  // FIXME Should accept a callback and be asynchronous so we do not have to use
+  // locks.
+  bool IsHandledProtocol(const std::string& scheme);
+
+  // Intercept/unintercept an existing protocol handler.
+  void InterceptProtocol(const std::string& scheme,
+                         const JsProtocolHandler& callback);
+  void UninterceptProtocol(const std::string& scheme);
+
+  // The networking related operations have to be done in IO thread.
+  void RegisterProtocolInIO(const std::string& scheme);
+  void UnregisterProtocolInIO(const std::string& scheme);
+  void InterceptProtocolInIO(const std::string& scheme);
+  void UninterceptProtocolInIO(const std::string& scheme);
+
+  // Do protocol.emit(event, parameter) under UI thread.
+  void EmitEventInUI(const std::string& event, const std::string& parameter);
+
+  AtomURLRequestJobFactory* job_factory_;
+  ProtocolHandlersMap protocol_handlers_;
+
+  DISALLOW_COPY_AND_ASSIGN(Protocol);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_

atom/browser/api/atom_api_screen.cc

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

atom/browser/api/atom_api_screen.h

@@ -0,0 +1,60 @@
+// Copyright (c) 2015 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_SCREEN_H_
+#define ATOM_BROWSER_API_ATOM_API_SCREEN_H_
+
+#include <vector>
+
+#include "atom/browser/api/event_emitter.h"
+#include "native_mate/handle.h"
+#include "ui/gfx/display_observer.h"
+
+namespace gfx {
+class Point;
+class Rect;
+class Screen;
+}
+
+namespace atom {
+
+namespace api {
+
+class Screen : public mate::EventEmitter,
+               public gfx::DisplayObserver {
+ public:
+  static v8::Handle<v8::Value> Create(v8::Isolate* isolate);
+
+ protected:
+  explicit Screen(gfx::Screen* screen);
+  virtual ~Screen();
+
+  gfx::Point GetCursorScreenPoint();
+  gfx::Display GetPrimaryDisplay();
+  std::vector<gfx::Display> GetAllDisplays();
+  gfx::Display GetDisplayNearestPoint(const gfx::Point& point);
+  gfx::Display GetDisplayMatching(const gfx::Rect& match_rect);
+
+  // gfx::DisplayObserver:
+  void OnDisplayAdded(const gfx::Display& new_display) override;
+  void OnDisplayRemoved(const gfx::Display& old_display) override;
+  void OnDisplayMetricsChanged(const gfx::Display& display,
+                               uint32_t changed_metrics) override;
+
+  // mate::Wrappable:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+
+ private:
+  gfx::Screen* screen_;
+  std::vector<gfx::Display> displays_;
+
+  DISALLOW_COPY_AND_ASSIGN(Screen);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_SCREEN_H_

atom/browser/api/atom_api_tray.cc

@@ -0,0 +1,156 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_tray.h"
+
+#include <string>
+
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/ui/tray_icon.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "native_mate/constructor.h"
+#include "native_mate/dictionary.h"
+#include "ui/gfx/image/image.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+Tray::Tray(const gfx::Image& image)
+    : tray_icon_(TrayIcon::Create()) {
+  tray_icon_->SetImage(image);
+  tray_icon_->AddObserver(this);
+}
+
+Tray::~Tray() {
+}
+
+// static
+mate::Wrappable* Tray::New(const gfx::Image& image) {
+  return new Tray(image);
+}
+
+void Tray::OnClicked() {
+  Emit("clicked");
+}
+
+void Tray::OnDoubleClicked() {
+  Emit("double-clicked");
+}
+
+void Tray::OnBalloonShow() {
+  Emit("balloon-show");
+}
+
+void Tray::OnBalloonClicked() {
+  Emit("balloon-clicked");
+}
+
+void Tray::OnBalloonClosed() {
+  Emit("balloon-closed");
+}
+
+void Tray::Destroy() {
+  tray_icon_.reset();
+}
+
+void Tray::SetImage(mate::Arguments* args, const gfx::Image& image) {
+  if (!CheckTrayLife(args))
+    return;
+  tray_icon_->SetImage(image);
+}
+
+void Tray::SetPressedImage(mate::Arguments* args, const gfx::Image& image) {
+  if (!CheckTrayLife(args))
+    return;
+  tray_icon_->SetPressedImage(image);
+}
+
+void Tray::SetToolTip(mate::Arguments* args, const std::string& tool_tip) {
+  if (!CheckTrayLife(args))
+    return;
+  tray_icon_->SetToolTip(tool_tip);
+}
+
+void Tray::SetTitle(mate::Arguments* args, const std::string& title) {
+  if (!CheckTrayLife(args))
+    return;
+  tray_icon_->SetTitle(title);
+}
+
+void Tray::SetHighlightMode(mate::Arguments* args, bool highlight) {
+  if (!CheckTrayLife(args))
+    return;
+  tray_icon_->SetHighlightMode(highlight);
+}
+
+void Tray::DisplayBalloon(mate::Arguments* args,
+                          const mate::Dictionary& options) {
+  if (!CheckTrayLife(args))
+    return;
+
+  gfx::Image icon;
+  options.Get("icon", &icon);
+  base::string16 title, content;
+  if (!options.Get("title", &title) ||
+      !options.Get("content", &content)) {
+    args->ThrowError("'title' and 'content' must be defined");
+    return;
+  }
+
+  tray_icon_->DisplayBalloon(icon, title, content);
+}
+
+void Tray::SetContextMenu(mate::Arguments* args, Menu* menu) {
+  if (!CheckTrayLife(args))
+    return;
+  tray_icon_->SetContextMenu(menu->model());
+}
+
+bool Tray::CheckTrayLife(mate::Arguments* args) {
+  if (!tray_icon_) {
+    args->ThrowError("Tray is already destroyed");
+    return false;
+  } else {
+    return true;
+  }
+}
+
+// static
+void Tray::BuildPrototype(v8::Isolate* isolate,
+                          v8::Handle<v8::ObjectTemplate> prototype) {
+  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("destroy", &Tray::Destroy)
+      .SetMethod("setImage", &Tray::SetImage)
+      .SetMethod("setPressedImage", &Tray::SetPressedImage)
+      .SetMethod("setToolTip", &Tray::SetToolTip)
+      .SetMethod("setTitle", &Tray::SetTitle)
+      .SetMethod("setHighlightMode", &Tray::SetHighlightMode)
+      .SetMethod("displayBalloon", &Tray::DisplayBalloon)
+      .SetMethod("_setContextMenu", &Tray::SetContextMenu);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  using atom::api::Tray;
+  v8::Isolate* isolate = context->GetIsolate();
+  v8::Handle<v8::Function> constructor = mate::CreateConstructor<Tray>(
+      isolate, "Tray", base::Bind(&Tray::New));
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("Tray", static_cast<v8::Handle<v8::Value>>(constructor));
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_tray, Initialize)

atom/browser/api/atom_api_tray.h

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

atom/browser/api/atom_api_web_contents.cc

@@ -0,0 +1,642 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_web_contents.h"
+
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/web_dialog_helper.h"
+#include "atom/browser/web_view_manager.h"
+#include "atom/common/api/api_messages.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
+#include "base/strings/utf_string_conversions.h"
+#include "brightray/browser/inspectable_web_contents.h"
+#include "content/public/browser/navigation_details.h"
+#include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
+#include "content/public/browser/resource_request_details.h"
+#include "content/public/browser/site_instance.h"
+#include "content/public/browser/web_contents.h"
+#include "native_mate/dictionary.h"
+#include "native_mate/object_template_builder.h"
+#include "vendor/brightray/browser/media/media_stream_devices_controller.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+v8::Persistent<v8::ObjectTemplate> template_;
+
+// Get the window that has the |guest| embedded.
+NativeWindow* GetWindowFromGuest(const content::WebContents* guest) {
+  WebViewManager::WebViewInfo info;
+  if (WebViewManager::GetInfoForProcess(guest->GetRenderProcessHost(), &info))
+    return NativeWindow::FromRenderView(
+        info.embedder->GetRenderProcessHost()->GetID(),
+        info.embedder->GetRoutingID());
+  else
+    return nullptr;
+}
+
+}  // namespace
+
+WebContents::WebContents(content::WebContents* web_contents)
+    : content::WebContentsObserver(web_contents),
+      guest_instance_id_(-1),
+      element_instance_id_(-1),
+      guest_opaque_(true),
+      guest_sizer_(nullptr),
+      auto_size_enabled_(false) {
+}
+
+WebContents::WebContents(const mate::Dictionary& options)
+    : guest_instance_id_(-1),
+      element_instance_id_(-1),
+      guest_opaque_(true),
+      guest_sizer_(nullptr),
+      auto_size_enabled_(false) {
+  options.Get("guestInstanceId", &guest_instance_id_);
+
+  auto browser_context = AtomBrowserContext::Get();
+  content::SiteInstance* site_instance = content::SiteInstance::CreateForURL(
+      browser_context, GURL("chrome-guest://fake-host"));
+
+  content::WebContents::CreateParams params(browser_context, site_instance);
+  bool is_guest;
+  if (options.Get("isGuest", &is_guest) && is_guest)
+    params.guest_delegate = this;
+
+  storage_.reset(brightray::InspectableWebContents::Create(params));
+  Observe(storage_->GetWebContents());
+  web_contents()->SetDelegate(this);
+}
+
+WebContents::~WebContents() {
+  Destroy();
+}
+
+bool WebContents::AddMessageToConsole(content::WebContents* source,
+                                      int32 level,
+                                      const base::string16& message,
+                                      int32 line_no,
+                                      const base::string16& source_id) {
+  Emit("console-message", level, message, line_no, source_id);
+  return true;
+}
+
+bool WebContents::ShouldCreateWebContents(
+    content::WebContents* web_contents,
+    int route_id,
+    int main_frame_route_id,
+    WindowContainerType window_container_type,
+    const base::string16& frame_name,
+    const GURL& target_url,
+    const std::string& partition_id,
+    content::SessionStorageNamespace* session_storage_namespace) {
+  Emit("-new-window",
+       target_url,
+       frame_name,
+       static_cast<int>(NEW_FOREGROUND_TAB));
+  return false;
+}
+
+void WebContents::CloseContents(content::WebContents* source) {
+  Emit("close");
+}
+
+content::WebContents* WebContents::OpenURLFromTab(
+    content::WebContents* source,
+    const content::OpenURLParams& params) {
+  if (params.disposition != CURRENT_TAB) {
+    Emit("-new-window", params.url, "", static_cast<int>(params.disposition));
+    return nullptr;
+  }
+
+  // Give user a chance to cancel navigation.
+  if (Emit("will-navigate", params.url))
+    return nullptr;
+
+  content::NavigationController::LoadURLParams load_url_params(params.url);
+  load_url_params.referrer = params.referrer;
+  load_url_params.transition_type = params.transition;
+  load_url_params.extra_headers = params.extra_headers;
+  load_url_params.should_replace_current_entry =
+      params.should_replace_current_entry;
+  load_url_params.is_renderer_initiated = params.is_renderer_initiated;
+  load_url_params.transferred_global_request_id =
+      params.transferred_global_request_id;
+
+  web_contents()->GetController().LoadURLWithParams(load_url_params);
+  return web_contents();
+}
+
+void WebContents::RunFileChooser(content::WebContents* guest,
+                                 const content::FileChooserParams& params) {
+  if (!web_dialog_helper_)
+    web_dialog_helper_.reset(new WebDialogHelper(GetWindowFromGuest(guest)));
+  web_dialog_helper_->RunFileChooser(guest, params);
+}
+
+void WebContents::EnumerateDirectory(content::WebContents* guest,
+                                     int request_id,
+                                     const base::FilePath& path) {
+  if (!web_dialog_helper_)
+    web_dialog_helper_.reset(new WebDialogHelper(GetWindowFromGuest(guest)));
+  web_dialog_helper_->EnumerateDirectory(guest, request_id, path);
+}
+
+bool WebContents::CheckMediaAccessPermission(content::WebContents* web_contents,
+                                             const GURL& security_origin,
+                                             content::MediaStreamType type) {
+  return true;
+}
+
+void WebContents::RequestMediaAccessPermission(
+    content::WebContents*,
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback) {
+  brightray::MediaStreamDevicesController controller(request, callback);
+  controller.TakeAction();
+}
+
+void WebContents::HandleKeyboardEvent(
+    content::WebContents* source,
+    const content::NativeWebKeyboardEvent& event) {
+  if (!attached())
+    return;
+
+  // Send the unhandled keyboard events back to the embedder to reprocess them.
+  embedder_web_contents_->GetDelegate()->HandleKeyboardEvent(
+      web_contents(), event);
+}
+
+void WebContents::RenderViewDeleted(content::RenderViewHost* render_view_host) {
+  Emit("render-view-deleted",
+       render_view_host->GetProcess()->GetID(),
+       render_view_host->GetRoutingID());
+}
+
+void WebContents::RenderProcessGone(base::TerminationStatus status) {
+  Emit("crashed");
+}
+
+void WebContents::DidFinishLoad(content::RenderFrameHost* render_frame_host,
+                                const GURL& validated_url) {
+  bool is_main_frame = !render_frame_host->GetParent();
+  Emit("did-frame-finish-load", is_main_frame);
+
+  if (is_main_frame)
+    Emit("did-finish-load");
+}
+
+// this error occurs when host could not be found
+void WebContents::DidFailProvisionalLoad(
+    content::RenderFrameHost* render_frame_host,
+    const GURL& validated_url,
+    int error_code,
+    const base::string16& error_description) {
+  Emit("did-fail-load", error_code, error_description);
+}
+
+void WebContents::DidFailLoad(content::RenderFrameHost* render_frame_host,
+                              const GURL& validated_url,
+                              int error_code,
+                              const base::string16& error_description) {
+  Emit("did-fail-load", error_code, error_description);
+}
+
+void WebContents::DidStartLoading(content::RenderViewHost* render_view_host) {
+  Emit("did-start-loading");
+}
+
+void WebContents::DidStopLoading(content::RenderViewHost* render_view_host) {
+  Emit("did-stop-loading");
+}
+
+void WebContents::DidGetRedirectForResourceRequest(
+    content::RenderFrameHost* render_frame_host,
+    const content::ResourceRedirectDetails& details) {
+  Emit("did-get-redirect-request",
+       details.url,
+       details.new_url,
+       (details.resource_type == content::RESOURCE_TYPE_MAIN_FRAME));
+}
+
+void WebContents::DidNavigateMainFrame(
+    const content::LoadCommittedDetails& details,
+    const content::FrameNavigateParams& params) {
+  if (details.is_navigation_to_different_page())
+    Emit("did-navigate-to-different-page");
+}
+
+bool WebContents::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(WebContents, message)
+    IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
+                                    OnRendererMessageSync)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+
+  return handled;
+}
+
+void WebContents::RenderViewReady() {
+  if (!is_guest())
+    return;
+
+  // We don't want to accidentally set the opacity of an interstitial page.
+  // WebContents::GetRenderWidgetHostView will return the RWHV of an
+  // interstitial page if one is showing at this time. We only want opacity
+  // to apply to web pages.
+  if (guest_opaque_) {
+    web_contents()
+        ->GetRenderViewHost()
+        ->GetView()
+        ->SetBackgroundColorToDefault();
+  } else {
+    web_contents()->GetRenderViewHost()->GetView()->SetBackgroundColor(
+        SK_ColorTRANSPARENT);
+  }
+}
+
+void WebContents::WebContentsDestroyed() {
+  // The RenderViewDeleted was not called when the WebContents is destroyed.
+  RenderViewDeleted(web_contents()->GetRenderViewHost());
+  Emit("destroyed");
+}
+
+void WebContents::NavigationEntryCommitted(
+    const content::LoadCommittedDetails& load_details) {
+  auto entry = web_contents()->GetController().GetLastCommittedEntry();
+  entry->SetVirtualURL(load_details.entry->GetOriginalRequestURL());
+}
+
+void WebContents::DidAttach(int guest_proxy_routing_id) {
+  Emit("did-attach");
+}
+
+void WebContents::ElementSizeChanged(const gfx::Size& size) {
+  element_size_ = size;
+
+  // Only resize if needed.
+  if (!size.IsEmpty())
+    guest_sizer_->SizeContents(size);
+}
+
+content::WebContents* WebContents::GetOwnerWebContents() const {
+  return embedder_web_contents_;
+}
+
+void WebContents::GuestSizeChanged(const gfx::Size& old_size,
+                                   const gfx::Size& new_size) {
+  if (!auto_size_enabled_)
+    return;
+  guest_size_ = new_size;
+  GuestSizeChangedDueToAutoSize(old_size, new_size);
+}
+
+void WebContents::RegisterDestructionCallback(
+    const DestructionCallback& callback) {
+  destruction_callback_ = callback;
+}
+
+void WebContents::SetGuestSizer(content::GuestSizer* guest_sizer) {
+  guest_sizer_ = guest_sizer;
+}
+
+void WebContents::WillAttach(content::WebContents* embedder_web_contents,
+                             int element_instance_id,
+                             bool is_full_page_plugin) {
+  embedder_web_contents_ = embedder_web_contents;
+  element_instance_id_ = element_instance_id;
+}
+
+void WebContents::Destroy() {
+  if (storage_) {
+    if (!destruction_callback_.is_null())
+      destruction_callback_.Run();
+
+    // When force destroying the "destroyed" event is not emitted.
+    WebContentsDestroyed();
+
+    Observe(nullptr);
+    storage_.reset();
+  }
+}
+
+bool WebContents::IsAlive() const {
+  return web_contents() != NULL;
+}
+
+void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
+  content::NavigationController::LoadURLParams params(url);
+
+  GURL http_referrer;
+  if (options.Get("httpreferrer", &http_referrer))
+    params.referrer = content::Referrer(http_referrer.GetAsReferrer(),
+                                        blink::WebReferrerPolicyDefault);
+
+  params.transition_type = ui::PAGE_TRANSITION_TYPED;
+  params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
+  web_contents()->GetController().LoadURLWithParams(params);
+}
+
+GURL WebContents::GetURL() const {
+  auto entry = web_contents()->GetController().GetLastCommittedEntry();
+  return entry->GetVirtualURL();
+}
+
+base::string16 WebContents::GetTitle() const {
+  return web_contents()->GetTitle();
+}
+
+bool WebContents::IsLoading() const {
+  return web_contents()->IsLoading();
+}
+
+bool WebContents::IsWaitingForResponse() const {
+  return web_contents()->IsWaitingForResponse();
+}
+
+void WebContents::Stop() {
+  web_contents()->Stop();
+}
+
+void WebContents::Reload(const mate::Dictionary& options) {
+  // Navigating to a URL would always restart the renderer process, we want this
+  // because normal reloading will break our node integration.
+  // This is done by AtomBrowserClient::ShouldSwapProcessesForNavigation.
+  LoadURL(GetURL(), options);
+}
+
+void WebContents::ReloadIgnoringCache(const mate::Dictionary& options) {
+  Reload(options);
+}
+
+bool WebContents::CanGoBack() const {
+  return web_contents()->GetController().CanGoBack();
+}
+
+bool WebContents::CanGoForward() const {
+  return web_contents()->GetController().CanGoForward();
+}
+
+bool WebContents::CanGoToOffset(int offset) const {
+  return web_contents()->GetController().CanGoToOffset(offset);
+}
+
+void WebContents::GoBack() {
+  web_contents()->GetController().GoBack();
+}
+
+void WebContents::GoForward() {
+  web_contents()->GetController().GoForward();
+}
+
+void WebContents::GoToIndex(int index) {
+  web_contents()->GetController().GoToIndex(index);
+}
+
+void WebContents::GoToOffset(int offset) {
+  web_contents()->GetController().GoToOffset(offset);
+}
+
+int WebContents::GetRoutingID() const {
+  return web_contents()->GetRoutingID();
+}
+
+int WebContents::GetProcessID() const {
+  return web_contents()->GetRenderProcessHost()->GetID();
+}
+
+bool WebContents::IsCrashed() const {
+  return web_contents()->IsCrashed();
+}
+
+void WebContents::SetUserAgent(const std::string& user_agent) {
+  web_contents()->SetUserAgentOverride(user_agent);
+}
+
+void WebContents::InsertCSS(const std::string& css) {
+  web_contents()->InsertCSS(css);
+}
+
+void WebContents::ExecuteJavaScript(const base::string16& code) {
+  web_contents()->GetMainFrame()->ExecuteJavaScript(code);
+}
+
+void WebContents::OpenDevTools() {
+  storage_->SetCanDock(false);
+  storage_->ShowDevTools();
+}
+
+void WebContents::CloseDevTools() {
+  storage_->CloseDevTools();
+}
+
+bool WebContents::IsDevToolsOpened() {
+  return storage_->IsDevToolsViewShowing();
+}
+
+void WebContents::Undo() {
+  web_contents()->Undo();
+}
+
+void WebContents::Redo() {
+  web_contents()->Redo();
+}
+
+void WebContents::Cut() {
+  web_contents()->Cut();
+}
+
+void WebContents::Copy() {
+  web_contents()->Copy();
+}
+
+void WebContents::Paste() {
+  web_contents()->Paste();
+}
+
+void WebContents::Delete() {
+  web_contents()->Delete();
+}
+
+void WebContents::SelectAll() {
+  web_contents()->SelectAll();
+}
+
+void WebContents::Unselect() {
+  web_contents()->Unselect();
+}
+
+void WebContents::Replace(const base::string16& word) {
+  web_contents()->Replace(word);
+}
+
+void WebContents::ReplaceMisspelling(const base::string16& word) {
+  web_contents()->ReplaceMisspelling(word);
+}
+
+bool WebContents::SendIPCMessage(const base::string16& channel,
+                                 const base::ListValue& args) {
+  return Send(new AtomViewMsg_Message(routing_id(), channel, args));
+}
+
+void WebContents::SetAutoSize(bool enabled,
+                              const gfx::Size& min_size,
+                              const gfx::Size& max_size) {
+  min_auto_size_ = min_size;
+  min_auto_size_.SetToMin(max_size);
+  max_auto_size_ = max_size;
+  max_auto_size_.SetToMax(min_size);
+
+  enabled &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty();
+  if (!enabled && !auto_size_enabled_)
+    return;
+
+  auto_size_enabled_ = enabled;
+
+  if (!attached())
+    return;
+
+  content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
+  if (auto_size_enabled_) {
+    rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
+  } else {
+    rvh->DisableAutoResize(element_size_);
+    guest_size_ = element_size_;
+    GuestSizeChangedDueToAutoSize(guest_size_, element_size_);
+  }
+}
+
+void WebContents::SetAllowTransparency(bool allow) {
+  if (guest_opaque_ != allow)
+    return;
+
+  guest_opaque_ = !allow;
+  if (!web_contents()->GetRenderViewHost()->GetView())
+    return;
+
+  if (guest_opaque_) {
+    web_contents()
+        ->GetRenderViewHost()
+        ->GetView()
+        ->SetBackgroundColorToDefault();
+  } else {
+    web_contents()->GetRenderViewHost()->GetView()->SetBackgroundColor(
+        SK_ColorTRANSPARENT);
+  }
+}
+
+mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  if (template_.IsEmpty())
+    template_.Reset(isolate, mate::ObjectTemplateBuilder(isolate)
+        .SetMethod("destroy", &WebContents::Destroy)
+        .SetMethod("isAlive", &WebContents::IsAlive)
+        .SetMethod("_loadUrl", &WebContents::LoadURL)
+        .SetMethod("getUrl", &WebContents::GetURL)
+        .SetMethod("getTitle", &WebContents::GetTitle)
+        .SetMethod("isLoading", &WebContents::IsLoading)
+        .SetMethod("isWaitingForResponse", &WebContents::IsWaitingForResponse)
+        .SetMethod("stop", &WebContents::Stop)
+        .SetMethod("_reload", &WebContents::Reload)
+        .SetMethod("_reloadIgnoringCache", &WebContents::ReloadIgnoringCache)
+        .SetMethod("canGoBack", &WebContents::CanGoBack)
+        .SetMethod("canGoForward", &WebContents::CanGoForward)
+        .SetMethod("canGoToOffset", &WebContents::CanGoToOffset)
+        .SetMethod("goBack", &WebContents::GoBack)
+        .SetMethod("goForward", &WebContents::GoForward)
+        .SetMethod("goToIndex", &WebContents::GoToIndex)
+        .SetMethod("goToOffset", &WebContents::GoToOffset)
+        .SetMethod("getRoutingId", &WebContents::GetRoutingID)
+        .SetMethod("getProcessId", &WebContents::GetProcessID)
+        .SetMethod("isCrashed", &WebContents::IsCrashed)
+        .SetMethod("setUserAgent", &WebContents::SetUserAgent)
+        .SetMethod("insertCSS", &WebContents::InsertCSS)
+        .SetMethod("_executeJavaScript", &WebContents::ExecuteJavaScript)
+        .SetMethod("openDevTools", &WebContents::OpenDevTools)
+        .SetMethod("closeDevTools", &WebContents::CloseDevTools)
+        .SetMethod("isDevToolsOpened", &WebContents::IsDevToolsOpened)
+        .SetMethod("undo", &WebContents::Undo)
+        .SetMethod("redo", &WebContents::Redo)
+        .SetMethod("cut", &WebContents::Cut)
+        .SetMethod("copy", &WebContents::Copy)
+        .SetMethod("paste", &WebContents::Paste)
+        .SetMethod("delete", &WebContents::Delete)
+        .SetMethod("selectAll", &WebContents::SelectAll)
+        .SetMethod("unselect", &WebContents::Unselect)
+        .SetMethod("replace", &WebContents::Replace)
+        .SetMethod("replaceMisspelling", &WebContents::ReplaceMisspelling)
+        .SetMethod("_send", &WebContents::SendIPCMessage)
+        .SetMethod("setAutoSize", &WebContents::SetAutoSize)
+        .SetMethod("setAllowTransparency", &WebContents::SetAllowTransparency)
+        .SetMethod("isGuest", &WebContents::is_guest)
+        .Build());
+
+  return mate::ObjectTemplateBuilder(
+      isolate, v8::Local<v8::ObjectTemplate>::New(isolate, template_));
+}
+
+void WebContents::OnRendererMessage(const base::string16& channel,
+                                    const base::ListValue& args) {
+  // webContents.emit(channel, new Event(), args...);
+  Emit(base::UTF16ToUTF8(channel), args);
+}
+
+void WebContents::OnRendererMessageSync(const base::string16& channel,
+                                        const base::ListValue& args,
+                                        IPC::Message* message) {
+  // webContents.emit(channel, new Event(sender, message), args...);
+  EmitWithSender(base::UTF16ToUTF8(channel), web_contents(), message, args);
+}
+
+void WebContents::GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
+                                                const gfx::Size& new_size) {
+  Emit("size-changed",
+       old_size.width(), old_size.height(),
+       new_size.width(), new_size.height());
+}
+
+// static
+mate::Handle<WebContents> WebContents::CreateFrom(
+    v8::Isolate* isolate, content::WebContents* web_contents) {
+  return mate::CreateHandle(isolate, new WebContents(web_contents));
+}
+
+// static
+mate::Handle<WebContents> WebContents::Create(
+    v8::Isolate* isolate, const mate::Dictionary& options) {
+  return mate::CreateHandle(isolate, new WebContents(options));
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  mate::Dictionary dict(isolate, exports);
+  dict.SetMethod("create", &atom::api::WebContents::Create);
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_web_contents, Initialize)

atom/browser/api/atom_api_web_contents.h

@@ -0,0 +1,247 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_WEB_CONTENTS_H_
+#define ATOM_BROWSER_API_ATOM_API_WEB_CONTENTS_H_
+
+#include <string>
+
+#include "atom/browser/api/event_emitter.h"
+#include "brightray/browser/default_web_contents_delegate.h"
+#include "content/public/browser/browser_plugin_guest_delegate.h"
+#include "content/public/browser/web_contents_delegate.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "native_mate/handle.h"
+
+namespace brightray {
+class InspectableWebContents;
+}
+
+namespace mate {
+class Dictionary;
+}
+
+namespace atom {
+
+class WebDialogHelper;
+
+namespace api {
+
+class WebContents : public mate::EventEmitter,
+                    public content::BrowserPluginGuestDelegate,
+                    public content::WebContentsDelegate,
+                    public content::WebContentsObserver {
+ public:
+  // Create from an existing WebContents.
+  static mate::Handle<WebContents> CreateFrom(
+      v8::Isolate* isolate, content::WebContents* web_contents);
+
+  // Create a new WebContents.
+  static mate::Handle<WebContents> Create(
+      v8::Isolate* isolate, const mate::Dictionary& options);
+
+  void Destroy();
+  bool IsAlive() const;
+  void LoadURL(const GURL& url, const mate::Dictionary& options);
+  GURL GetURL() const;
+  base::string16 GetTitle() const;
+  bool IsLoading() const;
+  bool IsWaitingForResponse() const;
+  void Stop();
+  void Reload(const mate::Dictionary& options);
+  void ReloadIgnoringCache(const mate::Dictionary& options);
+  bool CanGoBack() const;
+  bool CanGoForward() const;
+  bool CanGoToOffset(int offset) const;
+  void GoBack();
+  void GoForward();
+  void GoToIndex(int index);
+  void GoToOffset(int offset);
+  int GetRoutingID() const;
+  int GetProcessID() const;
+  bool IsCrashed() const;
+  void SetUserAgent(const std::string& user_agent);
+  void InsertCSS(const std::string& css);
+  void ExecuteJavaScript(const base::string16& code);
+  void OpenDevTools();
+  void CloseDevTools();
+  bool IsDevToolsOpened();
+
+  // Editing commands.
+  void Undo();
+  void Redo();
+  void Cut();
+  void Copy();
+  void Paste();
+  void Delete();
+  void SelectAll();
+  void Unselect();
+  void Replace(const base::string16& word);
+  void ReplaceMisspelling(const base::string16& word);
+
+  // Sending messages to browser.
+  bool SendIPCMessage(const base::string16& channel,
+                      const base::ListValue& args);
+
+  // Toggles autosize mode for corresponding <webview>.
+  void SetAutoSize(bool enabled,
+                   const gfx::Size& min_size,
+                   const gfx::Size& max_size);
+
+  // Sets the transparency of the guest.
+  void SetAllowTransparency(bool allow);
+
+  // Returns whether this is a guest view.
+  bool is_guest() const { return guest_instance_id_ != -1; }
+
+  // Returns whether this guest has an associated embedder.
+  bool attached() const { return !!embedder_web_contents_; }
+
+  content::WebContents* web_contents() const {
+    return content::WebContentsObserver::web_contents();
+  }
+
+ protected:
+  explicit WebContents(content::WebContents* web_contents);
+  explicit WebContents(const mate::Dictionary& options);
+  ~WebContents();
+
+  // mate::Wrappable:
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
+
+  // content::WebContentsDelegate:
+  bool AddMessageToConsole(content::WebContents* source,
+                           int32 level,
+                           const base::string16& message,
+                           int32 line_no,
+                           const base::string16& source_id) override;
+  bool ShouldCreateWebContents(
+      content::WebContents* web_contents,
+      int route_id,
+      int main_frame_route_id,
+      WindowContainerType window_container_type,
+      const base::string16& frame_name,
+      const GURL& target_url,
+      const std::string& partition_id,
+      content::SessionStorageNamespace* session_storage_namespace) override;
+  void CloseContents(content::WebContents* source) override;
+  content::WebContents* OpenURLFromTab(
+      content::WebContents* source,
+      const content::OpenURLParams& params) override;
+  void RunFileChooser(content::WebContents* web_contents,
+                      const content::FileChooserParams& params) override;
+  void EnumerateDirectory(content::WebContents* web_contents,
+                          int request_id,
+                          const base::FilePath& path) override;
+  bool CheckMediaAccessPermission(content::WebContents* web_contents,
+                                  const GURL& security_origin,
+                                  content::MediaStreamType type) override;
+  void RequestMediaAccessPermission(
+      content::WebContents*,
+      const content::MediaStreamRequest&,
+      const content::MediaResponseCallback&) override;
+  void HandleKeyboardEvent(
+      content::WebContents* source,
+      const content::NativeWebKeyboardEvent& event) override;
+
+  // content::WebContentsObserver:
+  void RenderViewDeleted(content::RenderViewHost*) override;
+  void RenderProcessGone(base::TerminationStatus status) override;
+  void DidFinishLoad(content::RenderFrameHost* render_frame_host,
+                     const GURL& validated_url) override;
+  void DidFailLoad(content::RenderFrameHost* render_frame_host,
+                   const GURL& validated_url,
+                   int error_code,
+                   const base::string16& error_description) override;
+  void DidFailProvisionalLoad(content::RenderFrameHost* render_frame_host,
+                              const GURL& validated_url,
+                              int error_code,
+                              const base::string16& error_description) override;
+  void DidStartLoading(content::RenderViewHost* render_view_host) override;
+  void DidStopLoading(content::RenderViewHost* render_view_host) override;
+  void DidGetRedirectForResourceRequest(
+      content::RenderFrameHost* render_frame_host,
+      const content::ResourceRedirectDetails& details) override;
+  void DidNavigateMainFrame(
+      const content::LoadCommittedDetails& details,
+      const content::FrameNavigateParams& params) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void RenderViewReady() override;
+  void WebContentsDestroyed() override;
+  void NavigationEntryCommitted(
+      const content::LoadCommittedDetails& load_details) override;
+
+  // content::BrowserPluginGuestDelegate:
+  void DidAttach(int guest_proxy_routing_id) final;
+  void ElementSizeChanged(const gfx::Size& size) final;
+  content::WebContents* GetOwnerWebContents() const final;
+  void GuestSizeChanged(const gfx::Size& old_size,
+                        const gfx::Size& new_size) final;
+  void RegisterDestructionCallback(const DestructionCallback& callback) final;
+  void SetGuestSizer(content::GuestSizer* guest_sizer) final;
+  void WillAttach(content::WebContents* embedder_web_contents,
+                  int element_instance_id,
+                  bool is_full_page_plugin) final;
+
+ private:
+  // Called when received a message from renderer.
+  void OnRendererMessage(const base::string16& channel,
+                         const base::ListValue& args);
+
+  // Called when received a synchronous message from renderer.
+  void OnRendererMessageSync(const base::string16& channel,
+                             const base::ListValue& args,
+                             IPC::Message* message);
+
+  void GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
+                                     const gfx::Size& new_size);
+
+  scoped_ptr<WebDialogHelper> web_dialog_helper_;
+
+  // Unique ID for a guest WebContents.
+  int guest_instance_id_;
+
+  // |element_instance_id_| is an identifer that's unique to a particular
+  // element.
+  int element_instance_id_;
+
+  DestructionCallback destruction_callback_;
+
+  // Stores whether the contents of the guest can be transparent.
+  bool guest_opaque_;
+
+  // Stores the WebContents that managed by this class.
+  scoped_ptr<brightray::InspectableWebContents> storage_;
+
+  // The WebContents that attaches this guest view.
+  content::WebContents* embedder_web_contents_;
+
+  // The size of the container element.
+  gfx::Size element_size_;
+
+  // The size of the guest content. Note: In autosize mode, the container
+  // element may not match the size of the guest.
+  gfx::Size guest_size_;
+
+  // A pointer to the guest_sizer.
+  content::GuestSizer* guest_sizer_;
+
+  // Indicates whether autosize mode is enabled or not.
+  bool auto_size_enabled_;
+
+  // The maximum size constraints of the container element in autosize mode.
+  gfx::Size max_auto_size_;
+
+  // The minimum size constraints of the container element in autosize mode.
+  gfx::Size min_auto_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebContents);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_WEB_CONTENTS_H_

atom/browser/api/atom_api_web_view_manager.cc

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

atom/browser/api/atom_api_window.cc

@@ -0,0 +1,524 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_window.h"
+
+#include "atom/browser/api/atom_api_web_contents.h"
+#include "atom/browser/browser.h"
+#include "atom/browser/native_window.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "content/public/browser/render_process_host.h"
+#include "native_mate/callback.h"
+#include "native_mate/constructor.h"
+#include "native_mate/dictionary.h"
+
+#include "atom/common/node_includes.h"
+
+namespace {
+
+struct PrintSettings {
+  bool silent;
+  bool print_background;
+};
+
+}  // namespace
+
+namespace mate {
+
+template<>
+struct Converter<PrintSettings> {
+  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+                     PrintSettings* out) {
+    mate::Dictionary dict;
+    if (!ConvertFromV8(isolate, val, &dict))
+      return false;
+    dict.Get("silent", &(out->silent));
+    dict.Get("printBackground", &(out->print_background));
+    return true;
+  }
+};
+
+}  // namespace mate
+
+namespace atom {
+
+namespace api {
+
+namespace {
+
+void OnCapturePageDone(
+    v8::Isolate* isolate,
+    const base::Callback<void(const gfx::Image&)>& callback,
+    const SkBitmap& bitmap) {
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  callback.Run(gfx::Image::CreateFrom1xBitmap(bitmap));
+}
+
+}  // namespace
+
+
+Window::Window(const mate::Dictionary& options)
+    : window_(NativeWindow::Create(options)) {
+  window_->InitFromOptions(options);
+  window_->AddObserver(this);
+}
+
+Window::~Window() {
+  if (window_)
+    Destroy();
+}
+
+void Window::OnPageTitleUpdated(bool* prevent_default,
+                                const std::string& title) {
+  *prevent_default = Emit("page-title-updated", title);
+}
+
+void Window::WillCreatePopupWindow(const base::string16& frame_name,
+                                   const GURL& target_url,
+                                   const std::string& partition_id,
+                                   WindowOpenDisposition disposition) {
+  Emit("-new-window", target_url, frame_name, static_cast<int>(disposition));
+}
+
+void Window::WillNavigate(bool* prevent_default, const GURL& url) {
+  *prevent_default = Emit("-will-navigate", url);
+}
+
+void Window::WillCloseWindow(bool* prevent_default) {
+  *prevent_default = Emit("close");
+}
+
+void Window::OnWindowClosed() {
+  Emit("closed");
+
+  window_->RemoveObserver(this);
+}
+
+void Window::OnWindowBlur() {
+  Emit("blur");
+}
+
+void Window::OnWindowFocus() {
+  Emit("focus");
+}
+
+void Window::OnWindowMaximize() {
+  Emit("maximize");
+}
+
+void Window::OnWindowUnmaximize() {
+  Emit("unmaximize");
+}
+
+void Window::OnWindowMinimize() {
+  Emit("minimize");
+}
+
+void Window::OnWindowRestore() {
+  Emit("restore");
+}
+
+void Window::OnWindowEnterFullScreen() {
+  Emit("enter-full-screen");
+}
+
+void Window::OnWindowLeaveFullScreen() {
+  Emit("leave-full-screen");
+}
+
+void Window::OnRendererUnresponsive() {
+  Emit("unresponsive");
+}
+
+void Window::OnRendererResponsive() {
+  Emit("responsive");
+}
+
+// static
+mate::Wrappable* Window::New(v8::Isolate* isolate,
+                             const mate::Dictionary& options) {
+  if (Browser::Get()->is_ready()) {
+    return new Window(options);
+  } else {
+    isolate->ThrowException(v8::Exception::TypeError(mate::StringToV8(
+        isolate, "Can not create BrowserWindow before app is ready")));
+    return nullptr;
+  }
+}
+
+void Window::Destroy() {
+  window_->DestroyWebContents();
+  window_->CloseImmediately();
+}
+
+void Window::Close() {
+  window_->Close();
+}
+
+bool Window::IsClosed() {
+  return window_->IsClosed();
+}
+
+void Window::Focus() {
+  window_->Focus(true);
+}
+
+bool Window::IsFocused() {
+  return window_->IsFocused();
+}
+
+void Window::Show() {
+  window_->Show();
+}
+
+void Window::ShowInactive() {
+  window_->ShowInactive();
+}
+
+void Window::Hide() {
+  window_->Hide();
+}
+
+bool Window::IsVisible() {
+  return window_->IsVisible();
+}
+
+void Window::Maximize() {
+  window_->Maximize();
+}
+
+void Window::Unmaximize() {
+  window_->Unmaximize();
+}
+
+bool Window::IsMaximized() {
+  return window_->IsMaximized();
+}
+
+void Window::Minimize() {
+  window_->Minimize();
+}
+
+void Window::Restore() {
+  window_->Restore();
+}
+
+bool Window::IsMinimized() {
+  return window_->IsMinimized();
+}
+
+void Window::SetFullScreen(bool fullscreen) {
+  window_->SetFullScreen(fullscreen);
+}
+
+bool Window::IsFullscreen() {
+  return window_->IsFullscreen();
+}
+
+void Window::SetSize(int width, int height) {
+  window_->SetSize(gfx::Size(width, height));
+}
+
+std::vector<int> Window::GetSize() {
+  std::vector<int> result(2);
+  gfx::Size size = window_->GetSize();
+  result[0] = size.width();
+  result[1] = size.height();
+  return result;
+}
+
+void Window::SetContentSize(int width, int height) {
+  window_->SetContentSize(gfx::Size(width, height));
+}
+
+std::vector<int> Window::GetContentSize() {
+  std::vector<int> result(2);
+  gfx::Size size = window_->GetContentSize();
+  result[0] = size.width();
+  result[1] = size.height();
+  return result;
+}
+
+void Window::SetMinimumSize(int width, int height) {
+  window_->SetMinimumSize(gfx::Size(width, height));
+}
+
+std::vector<int> Window::GetMinimumSize() {
+  std::vector<int> result(2);
+  gfx::Size size = window_->GetMinimumSize();
+  result[0] = size.width();
+  result[1] = size.height();
+  return result;
+}
+
+void Window::SetMaximumSize(int width, int height) {
+  window_->SetMaximumSize(gfx::Size(width, height));
+}
+
+std::vector<int> Window::GetMaximumSize() {
+  std::vector<int> result(2);
+  gfx::Size size = window_->GetMaximumSize();
+  result[0] = size.width();
+  result[1] = size.height();
+  return result;
+}
+
+void Window::SetResizable(bool resizable) {
+  window_->SetResizable(resizable);
+}
+
+bool Window::IsResizable() {
+  return window_->IsResizable();
+}
+
+void Window::SetAlwaysOnTop(bool top) {
+  window_->SetAlwaysOnTop(top);
+}
+
+bool Window::IsAlwaysOnTop() {
+  return window_->IsAlwaysOnTop();
+}
+
+void Window::Center() {
+  window_->Center();
+}
+
+void Window::SetPosition(int x, int y) {
+  window_->SetPosition(gfx::Point(x, y));
+}
+
+std::vector<int> Window::GetPosition() {
+  std::vector<int> result(2);
+  gfx::Point pos = window_->GetPosition();
+  result[0] = pos.x();
+  result[1] = pos.y();
+  return result;
+}
+
+void Window::SetTitle(const std::string& title) {
+  window_->SetTitle(title);
+}
+
+std::string Window::GetTitle() {
+  return window_->GetTitle();
+}
+
+void Window::FlashFrame(bool flash) {
+  window_->FlashFrame(flash);
+}
+
+void Window::SetSkipTaskbar(bool skip) {
+  window_->SetSkipTaskbar(skip);
+}
+
+void Window::SetKiosk(bool kiosk) {
+  window_->SetKiosk(kiosk);
+}
+
+bool Window::IsKiosk() {
+  return window_->IsKiosk();
+}
+
+void Window::OpenDevTools() {
+  window_->OpenDevTools();
+}
+
+void Window::CloseDevTools() {
+  window_->CloseDevTools();
+}
+
+bool Window::IsDevToolsOpened() {
+  return window_->IsDevToolsOpened();
+}
+
+void Window::InspectElement(int x, int y) {
+  window_->InspectElement(x, y);
+}
+
+void Window::FocusOnWebView() {
+  window_->FocusOnWebView();
+}
+
+void Window::BlurWebView() {
+  window_->BlurWebView();
+}
+
+bool Window::IsWebViewFocused() {
+  return window_->IsWebViewFocused();
+}
+
+void Window::SetRepresentedFilename(const std::string& filename) {
+  window_->SetRepresentedFilename(filename);
+}
+
+std::string Window::GetRepresentedFilename() {
+  return window_->GetRepresentedFilename();
+}
+
+void Window::SetDocumentEdited(bool edited) {
+  window_->SetDocumentEdited(edited);
+}
+
+bool Window::IsDocumentEdited() {
+  return window_->IsDocumentEdited();
+}
+
+void Window::CapturePage(mate::Arguments* args) {
+  gfx::Rect rect;
+  base::Callback<void(const gfx::Image&)> callback;
+
+  if (!(args->Length() == 1 && args->GetNext(&callback)) &&
+      !(args->Length() == 2 && args->GetNext(&rect)
+                            && args->GetNext(&callback))) {
+    args->ThrowError();
+    return;
+  }
+
+  window_->CapturePage(
+      rect, base::Bind(&OnCapturePageDone, args->isolate(), callback));
+}
+
+void Window::Print(mate::Arguments* args) {
+  PrintSettings settings = { false, false };;
+  if (args->Length() == 1 && !args->GetNext(&settings)) {
+    args->ThrowError();
+    return;
+  }
+
+  window_->Print(settings.silent, settings.print_background);
+}
+
+void Window::SetProgressBar(double progress) {
+  window_->SetProgressBar(progress);
+}
+
+void Window::SetOverlayIcon(const gfx::Image& overlay,
+                            const std::string& description) {
+  window_->SetOverlayIcon(overlay, description);
+}
+
+void Window::SetAutoHideMenuBar(bool auto_hide) {
+  window_->SetAutoHideMenuBar(auto_hide);
+}
+
+bool Window::IsMenuBarAutoHide() {
+  return window_->IsMenuBarAutoHide();
+}
+
+void Window::SetMenuBarVisibility(bool visible) {
+  window_->SetMenuBarVisibility(visible);
+}
+
+bool Window::IsMenuBarVisible() {
+  return window_->IsMenuBarVisible();
+}
+
+#if defined(OS_MACOSX)
+void Window::ShowDefinitionForSelection() {
+  window_->ShowDefinitionForSelection();
+}
+#endif
+
+mate::Handle<WebContents> Window::GetWebContents(v8::Isolate* isolate) const {
+  return WebContents::CreateFrom(isolate, window_->GetWebContents());
+}
+
+mate::Handle<WebContents> Window::GetDevToolsWebContents(
+    v8::Isolate* isolate) const {
+  return WebContents::CreateFrom(isolate, window_->GetDevToolsWebContents());
+}
+
+// static
+void Window::BuildPrototype(v8::Isolate* isolate,
+                            v8::Handle<v8::ObjectTemplate> prototype) {
+  mate::ObjectTemplateBuilder(isolate, prototype)
+      .SetMethod("destroy", &Window::Destroy)
+      .SetMethod("close", &Window::Close)
+      .SetMethod("isClosed", &Window::IsClosed)
+      .SetMethod("focus", &Window::Focus)
+      .SetMethod("isFocused", &Window::IsFocused)
+      .SetMethod("show", &Window::Show)
+      .SetMethod("showInactive", &Window::ShowInactive)
+      .SetMethod("hide", &Window::Hide)
+      .SetMethod("isVisible", &Window::IsVisible)
+      .SetMethod("maximize", &Window::Maximize)
+      .SetMethod("unmaximize", &Window::Unmaximize)
+      .SetMethod("isMaximized", &Window::IsMaximized)
+      .SetMethod("minimize", &Window::Minimize)
+      .SetMethod("restore", &Window::Restore)
+      .SetMethod("isMinimized", &Window::IsMinimized)
+      .SetMethod("setFullScreen", &Window::SetFullScreen)
+      .SetMethod("isFullScreen", &Window::IsFullscreen)
+      .SetMethod("getSize", &Window::GetSize)
+      .SetMethod("setSize", &Window::SetSize)
+      .SetMethod("getContentSize", &Window::GetContentSize)
+      .SetMethod("setContentSize", &Window::SetContentSize)
+      .SetMethod("setMinimumSize", &Window::SetMinimumSize)
+      .SetMethod("getMinimumSize", &Window::GetMinimumSize)
+      .SetMethod("setMaximumSize", &Window::SetMaximumSize)
+      .SetMethod("getMaximumSize", &Window::GetMaximumSize)
+      .SetMethod("setResizable", &Window::SetResizable)
+      .SetMethod("isResizable", &Window::IsResizable)
+      .SetMethod("setAlwaysOnTop", &Window::SetAlwaysOnTop)
+      .SetMethod("isAlwaysOnTop", &Window::IsAlwaysOnTop)
+      .SetMethod("center", &Window::Center)
+      .SetMethod("setPosition", &Window::SetPosition)
+      .SetMethod("getPosition", &Window::GetPosition)
+      .SetMethod("setTitle", &Window::SetTitle)
+      .SetMethod("getTitle", &Window::GetTitle)
+      .SetMethod("flashFrame", &Window::FlashFrame)
+      .SetMethod("setSkipTaskbar", &Window::SetSkipTaskbar)
+      .SetMethod("setKiosk", &Window::SetKiosk)
+      .SetMethod("isKiosk", &Window::IsKiosk)
+      .SetMethod("setRepresentedFilename", &Window::SetRepresentedFilename)
+      .SetMethod("getRepresentedFilename", &Window::GetRepresentedFilename)
+      .SetMethod("setDocumentEdited", &Window::SetDocumentEdited)
+      .SetMethod("isDocumentEdited", &Window::IsDocumentEdited)
+      .SetMethod("_openDevTools", &Window::OpenDevTools)
+      .SetMethod("closeDevTools", &Window::CloseDevTools)
+      .SetMethod("isDevToolsOpened", &Window::IsDevToolsOpened)
+      .SetMethod("inspectElement", &Window::InspectElement)
+      .SetMethod("focusOnWebView", &Window::FocusOnWebView)
+      .SetMethod("blurWebView", &Window::BlurWebView)
+      .SetMethod("isWebViewFocused", &Window::IsWebViewFocused)
+      .SetMethod("capturePage", &Window::CapturePage)
+      .SetMethod("print", &Window::Print)
+      .SetMethod("setProgressBar", &Window::SetProgressBar)
+      .SetMethod("setOverlayIcon", &Window::SetOverlayIcon)
+      .SetMethod("setAutoHideMenuBar", &Window::SetAutoHideMenuBar)
+      .SetMethod("isMenuBarAutoHide", &Window::IsMenuBarAutoHide)
+      .SetMethod("setMenuBarVisibility", &Window::SetMenuBarVisibility)
+      .SetMethod("isMenuBarVisible", &Window::IsMenuBarVisible)
+#if defined(OS_MACOSX)
+      .SetMethod("showDefinitionForSelection",
+                 &Window::ShowDefinitionForSelection)
+#endif
+      .SetMethod("_getWebContents", &Window::GetWebContents)
+      .SetMethod("_getDevToolsWebContents", &Window::GetDevToolsWebContents);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
+                v8::Handle<v8::Context> context, void* priv) {
+  using atom::api::Window;
+  v8::Isolate* isolate = context->GetIsolate();
+  v8::Local<v8::Function> constructor = mate::CreateConstructor<Window>(
+      isolate, "BrowserWindow", base::Bind(&Window::New));
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("BrowserWindow", static_cast<v8::Handle<v8::Value>>(constructor));
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_window, Initialize)

atom/browser/api/atom_api_window.h

@@ -0,0 +1,169 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_WINDOW_H_
+#define ATOM_BROWSER_API_ATOM_API_WINDOW_H_
+
+#include <string>
+#include <vector>
+
+#include "base/memory/scoped_ptr.h"
+#include "ui/gfx/image/image.h"
+#include "atom/browser/native_window_observer.h"
+#include "atom/browser/api/event_emitter.h"
+#include "native_mate/handle.h"
+
+class GURL;
+
+namespace mate {
+class Arguments;
+class Dictionary;
+}
+
+namespace atom {
+
+class NativeWindow;
+
+namespace api {
+
+class WebContents;
+
+class Window : public mate::EventEmitter,
+               public NativeWindowObserver {
+ public:
+  static mate::Wrappable* New(v8::Isolate* isolate,
+                              const mate::Dictionary& options);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Handle<v8::ObjectTemplate> prototype);
+
+  NativeWindow* window() const { return window_.get(); }
+
+ protected:
+  explicit Window(const mate::Dictionary& options);
+  virtual ~Window();
+
+  // NativeWindowObserver:
+  void OnPageTitleUpdated(bool* prevent_default,
+                          const std::string& title) override;
+  void WillCreatePopupWindow(const base::string16& frame_name,
+                             const GURL& target_url,
+                             const std::string& partition_id,
+                             WindowOpenDisposition disposition) override;
+  void WillNavigate(bool* prevent_default, const GURL& url) override;
+  void WillCloseWindow(bool* prevent_default) override;
+  void OnWindowClosed() override;
+  void OnWindowBlur() override;
+  void OnWindowFocus() override;
+  void OnWindowMaximize() override;
+  void OnWindowUnmaximize() override;
+  void OnWindowMinimize() override;
+  void OnWindowRestore() override;
+  void OnWindowEnterFullScreen() override;
+  void OnWindowLeaveFullScreen() override;
+  void OnRendererUnresponsive() override;
+  void OnRendererResponsive() override;
+
+ private:
+  // APIs for NativeWindow.
+  void Destroy();
+  void Close();
+  bool IsClosed();
+  void Focus();
+  bool IsFocused();
+  void Show();
+  void ShowInactive();
+  void Hide();
+  bool IsVisible();
+  void Maximize();
+  void Unmaximize();
+  bool IsMaximized();
+  void Minimize();
+  void Restore();
+  bool IsMinimized();
+  void SetFullScreen(bool fullscreen);
+  bool IsFullscreen();
+  void SetSize(int width, int height);
+  std::vector<int> GetSize();
+  void SetContentSize(int width, int height);
+  std::vector<int> GetContentSize();
+  void SetMinimumSize(int width, int height);
+  std::vector<int> GetMinimumSize();
+  void SetMaximumSize(int width, int height);
+  std::vector<int> GetMaximumSize();
+  void SetResizable(bool resizable);
+  bool IsResizable();
+  void SetAlwaysOnTop(bool top);
+  bool IsAlwaysOnTop();
+  void Center();
+  void SetPosition(int x, int y);
+  std::vector<int> GetPosition();
+  void SetTitle(const std::string& title);
+  std::string GetTitle();
+  void FlashFrame(bool flash);
+  void SetSkipTaskbar(bool skip);
+  void SetKiosk(bool kiosk);
+  bool IsKiosk();
+  void OpenDevTools();
+  void CloseDevTools();
+  bool IsDevToolsOpened();
+  void InspectElement(int x, int y);
+  void FocusOnWebView();
+  void BlurWebView();
+  bool IsWebViewFocused();
+  void SetRepresentedFilename(const std::string& filename);
+  std::string GetRepresentedFilename();
+  void SetDocumentEdited(bool edited);
+  bool IsDocumentEdited();
+  void CapturePage(mate::Arguments* args);
+  void Print(mate::Arguments* args);
+  void SetProgressBar(double progress);
+  void SetOverlayIcon(const gfx::Image& overlay,
+                      const std::string& description);
+  void SetAutoHideMenuBar(bool auto_hide);
+  bool IsMenuBarAutoHide();
+  void SetMenuBarVisibility(bool visible);
+  bool IsMenuBarVisible();
+
+#if defined(OS_MACOSX)
+  void ShowDefinitionForSelection();
+#endif
+
+  // APIs for WebContents.
+  mate::Handle<WebContents> GetWebContents(v8::Isolate* isolate) const;
+  mate::Handle<WebContents> GetDevToolsWebContents(v8::Isolate* isolate) const;
+
+  scoped_ptr<NativeWindow> window_;
+
+  DISALLOW_COPY_AND_ASSIGN(Window);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace mate {
+
+template<>
+struct Converter<atom::NativeWindow*> {
+  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+                     atom::NativeWindow** out) {
+    // null would be tranfered to NULL.
+    if (val->IsNull()) {
+      *out = NULL;
+      return true;
+    }
+
+    atom::api::Window* window;
+    if (!Converter<atom::api::Window*>::FromV8(isolate, val, &window))
+      return false;
+    *out = window->window();
+    return true;
+  }
+};
+
+}  // namespace mate
+
+#endif  // ATOM_BROWSER_API_ATOM_API_WINDOW_H_

atom/browser/api/event.cc

@@ -0,0 +1,72 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/event.h"
+
+#include "atom/common/api/api_messages.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "content/public/browser/web_contents.h"
+#include "native_mate/object_template_builder.h"
+
+namespace mate {
+
+namespace {
+
+v8::Persistent<v8::ObjectTemplate> template_;
+
+}  // namespace
+
+Event::Event()
+    : sender_(NULL),
+      message_(NULL) {
+}
+
+Event::~Event() {
+}
+
+ObjectTemplateBuilder Event::GetObjectTemplateBuilder(v8::Isolate* isolate) {
+  if (template_.IsEmpty())
+    template_.Reset(isolate, ObjectTemplateBuilder(isolate)
+        .SetMethod("preventDefault", &Event::PreventDefault)
+        .SetMethod("sendReply", &Event::SendReply)
+        .Build());
+
+  return ObjectTemplateBuilder(
+      isolate, v8::Local<v8::ObjectTemplate>::New(isolate, template_));
+}
+
+void Event::SetSenderAndMessage(content::WebContents* sender,
+                                IPC::Message* message) {
+  DCHECK(!sender_);
+  DCHECK(!message_);
+  sender_ = sender;
+  message_ = message;
+
+  Observe(sender);
+}
+
+void Event::WebContentsDestroyed() {
+  sender_ = NULL;
+  message_ = NULL;
+}
+
+void Event::PreventDefault(v8::Isolate* isolate) {
+  GetWrapper(isolate)->Set(StringToV8(isolate, "defaultPrevented"),
+                           v8::True(isolate));
+}
+
+bool Event::SendReply(const base::string16& json) {
+  if (message_ == NULL || sender_ == NULL)
+    return false;
+
+  AtomViewHostMsg_Message_Sync::WriteReplyParams(message_, json);
+  return sender_->Send(message_);
+}
+
+// static
+Handle<Event> Event::Create(v8::Isolate* isolate) {
+  return CreateHandle(isolate, new Event);
+}
+
+}  // namespace mate

atom/browser/api/event.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_EVENT_H_
+#define ATOM_BROWSER_API_EVENT_H_
+
+#include "content/public/browser/web_contents_observer.h"
+#include "native_mate/wrappable.h"
+#include "native_mate/handle.h"
+
+namespace IPC {
+class Message;
+}
+
+namespace mate {
+
+class Event : public Wrappable,
+              public content::WebContentsObserver {
+ public:
+  static Handle<Event> Create(v8::Isolate* isolate);
+
+  // Pass the sender and message to be replied.
+  void SetSenderAndMessage(content::WebContents* sender, IPC::Message* message);
+
+  // event.PreventDefault().
+  void PreventDefault(v8::Isolate* isolate);
+
+  // event.sendReply(json), used for replying synchronous message.
+  bool SendReply(const base::string16& json);
+
+ protected:
+  Event();
+  virtual ~Event();
+
+  // Wrappable implementations:
+  ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate) override;
+
+  // content::WebContentsObserver implementations:
+  void WebContentsDestroyed() override;
+
+ private:
+  // Replyer for the synchronous messages.
+  content::WebContents* sender_;
+  IPC::Message* message_;
+
+  DISALLOW_COPY_AND_ASSIGN(Event);
+};
+
+}  // namespace mate
+
+#endif  // ATOM_BROWSER_API_EVENT_H_

atom/browser/api/event_emitter.cc

@@ -0,0 +1,68 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/event_emitter.h"
+
+#include "atom/browser/api/event.h"
+#include "native_mate/arguments.h"
+#include "native_mate/object_template_builder.h"
+
+#include "atom/common/node_includes.h"
+
+namespace mate {
+
+namespace {
+
+v8::Persistent<v8::ObjectTemplate> event_template;
+
+void PreventDefault(mate::Arguments* args) {
+  args->GetThis()->Set(StringToV8(args->isolate(), "defaultPrevented"),
+                       v8::True(args->isolate()));
+}
+
+// Create a pure JavaScript Event object.
+v8::Local<v8::Object> CreateEventObject(v8::Isolate* isolate) {
+  if (event_template.IsEmpty()) {
+    event_template.Reset(isolate, ObjectTemplateBuilder(isolate)
+        .SetMethod("preventDefault", &PreventDefault)
+        .Build());
+  }
+
+  return v8::Local<v8::ObjectTemplate>::New(
+      isolate, event_template)->NewInstance();
+}
+
+}  // namespace
+
+EventEmitter::EventEmitter() {
+}
+
+bool EventEmitter::CallEmit(v8::Isolate* isolate,
+                            const base::StringPiece& name,
+                            content::WebContents* sender,
+                            IPC::Message* message,
+                            ValueArray args) {
+  v8::Handle<v8::Object> event;
+  bool use_native_event = sender && message;
+
+  if (use_native_event) {
+    mate::Handle<mate::Event> native_event = mate::Event::Create(isolate);
+    native_event->SetSenderAndMessage(sender, message);
+    event = v8::Handle<v8::Object>::Cast(native_event.ToV8());
+  } else {
+    event = CreateEventObject(isolate);
+  }
+
+  // args = [name, event, args...];
+  args.insert(args.begin(), event);
+  args.insert(args.begin(), mate::StringToV8(isolate, name));
+
+  // this.emit.apply(this, args);
+  node::MakeCallback(isolate, GetWrapper(isolate), "emit", args.size(),
+                     &args[0]);
+
+  return event->Get(StringToV8(isolate, "defaultPrevented"))->BooleanValue();
+}
+
+}  // namespace mate

atom/browser/api/event_emitter.h

@@ -0,0 +1,63 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_EVENT_EMITTER_H_
+#define ATOM_BROWSER_API_EVENT_EMITTER_H_
+
+#include <vector>
+
+#include "native_mate/wrappable.h"
+
+namespace content {
+class WebContents;
+}
+
+namespace IPC {
+class Message;
+}
+
+namespace mate {
+
+// Provide helperers to emit event in JavaScript.
+class EventEmitter : public Wrappable {
+ public:
+  typedef std::vector<v8::Handle<v8::Value>> ValueArray;
+
+ protected:
+  EventEmitter();
+
+  // this.emit(name, new Event(), args...);
+  template<typename... Args>
+  bool Emit(const base::StringPiece& name, const Args&... args) {
+    return EmitWithSender(name, nullptr, nullptr, args...);
+  }
+
+  // this.emit(name, new Event(sender, message), args...);
+  template<typename... Args>
+  bool EmitWithSender(const base::StringPiece& name,
+                      content::WebContents* sender,
+                      IPC::Message* message,
+                      const Args&... args) {
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    ValueArray converted = { ConvertToV8(isolate, args)... };
+    return CallEmit(isolate, name, sender, message, converted);
+  }
+
+ private:
+  // Lower level implementations.
+  bool CallEmit(v8::Isolate* isolate,
+                const base::StringPiece& name,
+                content::WebContents* sender,
+                IPC::Message* message,
+                ValueArray args);
+
+  DISALLOW_COPY_AND_ASSIGN(EventEmitter);
+};
+
+}  // namespace mate
+
+#endif  // ATOM_BROWSER_API_EVENT_EMITTER_H_

atom/browser/api/lib/app.coffee

@@ -0,0 +1,37 @@
+EventEmitter = require('events').EventEmitter
+
+bindings = process.atomBinding 'app'
+
+app = bindings.app
+app.__proto__ = EventEmitter.prototype
+
+app.setApplicationMenu = (menu) ->
+  require('menu').setApplicationMenu menu
+
+app.getApplicationMenu = ->
+  require('menu').getApplicationMenu()
+
+app.commandLine =
+  appendSwitch: bindings.appendSwitch,
+  appendArgument: bindings.appendArgument
+
+if process.platform is 'darwin'
+  app.dock =
+    bounce: (type='informational') -> bindings.dockBounce type
+    cancelBounce: bindings.dockCancelBounce
+    setBadge: bindings.dockSetBadgeText
+    getBadge: bindings.dockGetBadgeText
+    hide: bindings.dockHide
+    show: bindings.dockShow
+    setMenu: bindings.dockSetMenu
+
+# Be compatible with old API.
+app.once 'ready', -> app.emit 'finish-launching'
+app.terminate = app.quit
+app.exit = process.exit
+app.getHomeDir = -> app.getPath 'home'
+app.getDataPath = -> app.getPath 'userData'
+app.setDataPath = (path) -> app.setPath 'userData', path
+
+# Only one App object pemitted.
+module.exports = app

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

@@ -0,0 +1,6 @@
+module.exports =
+  browserMainParts:
+    preMainMessageLoopRun: ->
+
+setImmediate ->
+  module.exports.browserMainParts.preMainMessageLoopRun()

atom/browser/api/lib/auto-updater.coffee

@@ -0,0 +1,24 @@
+autoUpdater = process.atomBinding('auto_updater').autoUpdater
+EventEmitter = require('events').EventEmitter
+
+autoUpdater.__proto__ = EventEmitter.prototype
+
+autoUpdater.on 'update-downloaded-raw', (args...) ->
+  args[3] = new Date(args[3])  # releaseDate
+  @emit 'update-downloaded', args..., => @quitAndInstall()
+
+autoUpdater.quitAndInstall = ->
+  # If we don't have any window then quitAndInstall immediately.
+  BrowserWindow = require 'browser-window'
+  windows = BrowserWindow.getAllWindows()
+  if windows.length is 0
+    @_quitAndInstall()
+    return
+
+  # Do the restart after all windows have been closed.
+  app = require 'app'
+  app.removeAllListeners 'window-all-closed'
+  app.once 'window-all-closed', @_quitAndInstall.bind(this)
+  win.close() for win in windows
+
+module.exports = autoUpdater

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

@@ -0,0 +1,110 @@
+EventEmitter = require('events').EventEmitter
+IDWeakMap = require 'id-weak-map'
+app = require 'app'
+ipc = require 'ipc'
+wrapWebContents = require('web-contents').wrap
+
+BrowserWindow = process.atomBinding('window').BrowserWindow
+BrowserWindow::__proto__ = EventEmitter.prototype
+
+# Store all created windows in the weak map.
+BrowserWindow.windows = new IDWeakMap
+
+BrowserWindow::_init = ->
+  # Simulate the application menu on platforms other than OS X.
+  if process.platform isnt 'darwin'
+    menu = app.getApplicationMenu()
+    @setMenu menu if menu?
+
+  @webContents = @getWebContents()
+  @devToolsWebContents = null
+  @webContents.once 'destroyed', => @webContents = null
+
+  # Remember the window ID.
+  Object.defineProperty this, 'id',
+    value: BrowserWindow.windows.add(this)
+    enumerable: true
+
+  # Make new windows requested by links behave like "window.open"
+  @on '-new-window', (event, url, frameName) =>
+    event.sender = @webContents
+    options = show: true, width: 800, height: 600
+    ipc.emit 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', event, url, frameName, options
+
+  # Redirect "will-navigate" to webContents.
+  @on '-will-navigate', (event, url) =>
+    @webContents.emit 'will-navigate', event, url
+
+  # Remove the window from weak map immediately when it's destroyed, since we
+  # could be iterating windows before GC happened.
+  @once 'closed', =>
+    BrowserWindow.windows.remove @id if BrowserWindow.windows.has @id
+
+BrowserWindow::openDevTools = ->
+  @_openDevTools()
+
+  # Force devToolsWebContents to be created.
+  @devToolsWebContents = @getDevToolsWebContents()
+  @devToolsWebContents.once 'destroyed', => @devToolsWebContents = null
+
+  # Emit devtools events.
+  @devToolsWebContents.once 'did-finish-load', => @emit 'devtools-opened'
+  @devToolsWebContents.once 'destroyed', => @emit 'devtools-closed'
+
+BrowserWindow::toggleDevTools = ->
+  if @isDevToolsOpened() then @closeDevTools() else @openDevTools()
+
+BrowserWindow::getWebContents = ->
+  wrapWebContents @_getWebContents()
+
+BrowserWindow::getDevToolsWebContents = ->
+  wrapWebContents @_getDevToolsWebContents()
+
+BrowserWindow::setMenu = (menu) ->
+  if process.platform is 'darwin'
+    throw new Error('BrowserWindow.setMenu is not available on OS X')
+
+  throw new TypeError('Invalid menu') unless menu?.constructor?.name is 'Menu'
+
+  @menu = menu  # Keep a reference of menu in case of GC.
+  @menu.attachToWindow this
+
+BrowserWindow.getAllWindows = ->
+  windows = BrowserWindow.windows
+  windows.get key for key in windows.keys()
+
+BrowserWindow.getFocusedWindow = ->
+  windows = BrowserWindow.getAllWindows()
+  return window for window in windows when window.isFocused()
+
+BrowserWindow.fromWebContents = (webContents) ->
+  windows = BrowserWindow.getAllWindows()
+  return window for window in windows when webContents.equal window.webContents
+
+BrowserWindow.fromDevToolsWebContents = (webContents) ->
+  windows = BrowserWindow.getAllWindows()
+  return window for window in windows when webContents.equal window.devToolsWebContents
+
+BrowserWindow.fromId = (id) ->
+  BrowserWindow.windows.get id
+
+# Helpers.
+BrowserWindow::loadUrl = -> @webContents.loadUrl.apply @webContents, arguments
+BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
+
+# Be compatible with old API.
+BrowserWindow::restart = -> @webContents.reload()
+BrowserWindow::getUrl = -> @webContents.getUrl()
+BrowserWindow::reload = -> @webContents.reload.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::getRoutingId = -> @webContents.getRoutingId()
+BrowserWindow::getProcessId = -> @webContents.getProcessId()
+BrowserWindow::isCrashed = -> @webContents.isCrashed()
+BrowserWindow::executeJavaScriptInDevTools = (code) ->
+  @devToolsWebContents.executeJavaScript code
+
+module.exports = BrowserWindow

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

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

atom/browser/api/lib/dialog.coffee

@@ -0,0 +1,107 @@
+binding = process.atomBinding 'dialog'
+v8Util = process.atomBinding 'v8_util'
+app = require 'app'
+BrowserWindow = require 'browser-window'
+
+fileDialogProperties =
+  openFile:        1 << 0
+  openDirectory:   1 << 1
+  multiSelections: 1 << 2
+  createDirectory: 1 << 3
+
+messageBoxTypes = ['none', 'info', 'warning']
+
+parseArgs = (window, options, callback) ->
+  unless window is null or window?.constructor is BrowserWindow
+    # Shift.
+    callback = options
+    options = window
+    window = null
+  if not callback? and typeof options is 'function'
+    # Shift.
+    callback = options
+    options = null
+  [window, options, callback]
+
+checkAppInitialized = ->
+  throw new Error('dialog module can only be used after app is ready') unless app.isReady()
+
+module.exports =
+  showOpenDialog: (args...) ->
+    checkAppInitialized()
+    [window, options, callback] = parseArgs args...
+
+    options ?= title: 'Open', properties: ['openFile']
+    options.properties ?= ['openFile']
+    throw new TypeError('Properties need to be array') unless Array.isArray options.properties
+
+    properties = 0
+    for prop, value of fileDialogProperties
+      properties |= value if prop in options.properties
+
+    options.title ?= ''
+    options.defaultPath ?= ''
+    options.filters ?= []
+
+    wrappedCallback =
+      if typeof callback is 'function'
+        (success, result) -> callback(if success then result)
+      else
+        null
+
+    binding.showOpenDialog String(options.title),
+                           String(options.defaultPath),
+                           options.filters
+                           properties,
+                           window,
+                           wrappedCallback
+
+  showSaveDialog: (args...) ->
+    checkAppInitialized()
+    [window, options, callback] = parseArgs args...
+
+    options ?= title: 'Save'
+    options.title ?= ''
+    options.defaultPath ?= ''
+    options.filters ?= []
+
+    wrappedCallback =
+      if typeof callback is 'function'
+        (success, result) -> callback(if success then result)
+      else
+        null
+
+    binding.showSaveDialog String(options.title),
+                           String(options.defaultPath),
+                           options.filters
+                           window,
+                           wrappedCallback
+
+  showMessageBox: (args...) ->
+    checkAppInitialized()
+    [window, options, callback] = parseArgs args...
+
+    options ?= type: 'none'
+    options.type ?= 'none'
+    messageBoxType = messageBoxTypes.indexOf options.type
+    throw new TypeError('Invalid message box type') unless messageBoxType > -1
+
+    throw new TypeError('Buttons need to be array') unless Array.isArray options.buttons
+
+    options.title ?= ''
+    options.message ?= ''
+    options.detail ?= ''
+    options.icon ?= null
+
+    binding.showMessageBox messageBoxType,
+                           options.buttons,
+                           [options.title, options.message, options.detail],
+                           options.icon,
+                           window,
+                           callback
+
+  showErrorBox: (args...) ->
+    binding.showErrorBox args...
+
+# Mark standard asynchronous functions.
+v8Util.setHiddenValue f, 'asynchronous', true for k, f of module.exports

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

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

atom/browser/api/lib/ipc.coffee

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

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

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

atom/browser/api/lib/menu.coffee

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

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

@@ -0,0 +1,6 @@
+powerMonitor = process.atomBinding('power_monitor').powerMonitor
+EventEmitter = require('events').EventEmitter
+
+powerMonitor.__proto__ = EventEmitter.prototype
+
+module.exports = powerMonitor

atom/browser/api/lib/protocol.coffee

@@ -0,0 +1,33 @@
+app = require 'app'
+throw new Error('Can not initialize protocol module before app is ready') unless app.isReady()
+
+protocol = process.atomBinding('protocol').protocol
+EventEmitter = require('events').EventEmitter
+
+protocol.__proto__ = EventEmitter.prototype
+
+protocol.RequestStringJob =
+class RequestStringJob
+  constructor: ({mimeType, charset, data}) ->
+    if typeof data isnt 'string' and not data instanceof Buffer
+      throw new TypeError('Data should be string or Buffer')
+
+    @mimeType = mimeType ? 'text/plain'
+    @charset = charset ? 'UTF-8'
+    @data = String data
+
+protocol.RequestBufferJob =
+class RequestBufferJob
+  constructor: ({mimeType, encoding, data}) ->
+    if not data instanceof Buffer
+      throw new TypeError('Data should be Buffer')
+
+    @mimeType = mimeType ? 'application/octet-stream'
+    @encoding = encoding ? 'utf8'
+    @data = new Buffer(data)
+
+protocol.RequestFileJob =
+class RequestFileJob
+  constructor: (@path) ->
+
+module.exports = protocol

atom/browser/api/lib/screen.coffee

@@ -0,0 +1,6 @@
+EventEmitter = require('events').EventEmitter
+
+screen = process.atomBinding('screen').screen
+screen.__proto__ = EventEmitter.prototype
+
+module.exports = screen

atom/browser/api/lib/tray.coffee

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

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

@@ -0,0 +1,64 @@
+EventEmitter = require('events').EventEmitter
+binding = process.atomBinding 'web_contents'
+ipc = require 'ipc'
+
+module.exports.wrap = (webContents) ->
+  return null unless webContents.isAlive()
+
+  # webContents is an EventEmitter.
+  webContents.__proto__ = EventEmitter.prototype
+
+  # WebContents::send(channel, args..)
+  webContents.send = (channel, args...) ->
+    @_send channel, [args...]
+
+  # Make sure webContents.executeJavaScript would run the code only when the
+  # web contents has been loaded.
+  webContents.loaded = false
+  webContents.once 'did-finish-load', -> @loaded = true
+  webContents.executeJavaScript = (code) ->
+    if @loaded
+      @_executeJavaScript code
+    else
+      webContents.once 'did-finish-load', @_executeJavaScript.bind(this, code)
+
+  # The processId and routingId and identify a webContents.
+  webContents.getId = -> "#{@getProcessId()}-#{@getRoutingId()}"
+  webContents.equal = (other) -> @getId() is other.getId()
+
+  # Provide a default parameter for |urlOptions|.
+  webContents.loadUrl = (url, urlOptions={}) -> @_loadUrl url, urlOptions
+  webContents.reload = (urlOptions={}) -> @_reload urlOptions
+  webContents.reloadIgnoringCache = (urlOptions={}) -> @_reloadIgnoringCache urlOptions
+
+  # Translate |disposition| to string for 'new-window' event.
+  webContents.on '-new-window', (args..., disposition) ->
+    disposition =
+      switch disposition
+        when 2 then 'default'
+        when 4 then 'foreground-tab'
+        when 5 then 'background-tab'
+        when 6, 7 then 'new-window'
+        else 'other'
+    @emit 'new-window', args..., disposition
+
+  # Tell the rpc server that a render view has been deleted and we need to
+  # release all objects owned by it.
+  webContents.on 'render-view-deleted', (event, processId, routingId) ->
+    process.emit 'ATOM_BROWSER_RELEASE_RENDER_VIEW', "#{processId}-#{routingId}"
+
+  # Dispatch IPC messages to the ipc module.
+  webContents.on 'ipc-message', (event, packed) ->
+    [channel, args...] = packed
+    Object.defineProperty event, 'sender', value: webContents
+    ipc.emit channel, event, args...
+  webContents.on 'ipc-message-sync', (event, packed) ->
+    [channel, args...] = packed
+    Object.defineProperty event, 'returnValue', set: (value) -> event.sendReply JSON.stringify(value)
+    Object.defineProperty event, 'sender', value: webContents
+    ipc.emit channel, event, args...
+
+  webContents
+
+module.exports.create = (options={}) ->
+  @wrap binding.create(options)

atom/browser/atom_access_token_store.cc

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

atom/browser/atom_access_token_store.h

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

atom/browser/atom_browser_client.cc

@@ -0,0 +1,191 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_browser_client.h"
+
+#include "atom/browser/atom_access_token_store.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/atom_resource_dispatcher_host_delegate.h"
+#include "atom/browser/atom_speech_recognition_manager_delegate.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/web_view_manager.h"
+#include "atom/browser/window_list.h"
+#include "atom/common/options_switches.h"
+#include "base/command_line.h"
+#include "base/strings/string_number_conversions.h"
+#include "chrome/browser/printing/printing_message_filter.h"
+#include "chrome/browser/speech/tts_message_filter.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/resource_dispatcher_host.h"
+#include "content/public/browser/site_instance.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/web_preferences.h"
+#include "ui/base/l10n/l10n_util.h"
+
+namespace atom {
+
+namespace {
+
+struct FindByProcessId {
+  explicit FindByProcessId(int child_process_id)
+      : child_process_id_(child_process_id) {
+  }
+
+  bool operator() (NativeWindow* const window) {
+    content::WebContents* web_contents = window->GetWebContents();
+    if (!web_contents)
+      return false;
+
+    int id = window->GetWebContents()->GetRenderProcessHost()->GetID();
+    return id == child_process_id_;
+  }
+
+  int child_process_id_;
+};
+
+}  // namespace
+
+AtomBrowserClient::AtomBrowserClient()
+    : dying_render_process_(NULL) {
+}
+
+AtomBrowserClient::~AtomBrowserClient() {
+}
+
+void AtomBrowserClient::RenderProcessWillLaunch(
+    content::RenderProcessHost* host) {
+  int id = host->GetID();
+  host->AddFilter(new printing::PrintingMessageFilter(host->GetID()));
+  host->AddFilter(new TtsMessageFilter(id, host->GetBrowserContext()));
+}
+
+content::SpeechRecognitionManagerDelegate*
+    AtomBrowserClient::CreateSpeechRecognitionManagerDelegate() {
+  return new AtomSpeechRecognitionManagerDelegate;
+}
+
+content::AccessTokenStore* AtomBrowserClient::CreateAccessTokenStore() {
+  return new AtomAccessTokenStore;
+}
+
+void AtomBrowserClient::ResourceDispatcherHostCreated() {
+  resource_dispatcher_delegate_.reset(new AtomResourceDispatcherHostDelegate);
+  content::ResourceDispatcherHost::Get()->SetDelegate(
+      resource_dispatcher_delegate_.get());
+}
+
+void AtomBrowserClient::OverrideWebkitPrefs(
+    content::RenderViewHost* render_view_host,
+    const GURL& url,
+    content::WebPreferences* prefs) {
+  prefs->javascript_enabled = true;
+  prefs->web_security_enabled = true;
+  prefs->javascript_can_open_windows_automatically = true;
+  prefs->plugins_enabled = true;
+  prefs->dom_paste_enabled = true;
+  prefs->java_enabled = false;
+  prefs->allow_scripts_to_close_windows = true;
+  prefs->javascript_can_access_clipboard = true;
+  prefs->local_storage_enabled = true;
+  prefs->databases_enabled = true;
+  prefs->application_cache_enabled = true;
+  prefs->allow_universal_access_from_file_urls = true;
+  prefs->allow_file_access_from_file_urls = true;
+  prefs->experimental_webgl_enabled = true;
+  prefs->allow_displaying_insecure_content = false;
+  prefs->allow_running_insecure_content = false;
+
+  // Turn off web security for devtools.
+  if (url.SchemeIs("chrome-devtools")) {
+    prefs->web_security_enabled = false;
+    return;
+  }
+
+  // Custom preferences of guest page.
+  auto process = render_view_host->GetProcess();
+  WebViewManager::WebViewInfo info;
+  if (WebViewManager::GetInfoForProcess(process, &info)) {
+    prefs->web_security_enabled = !info.disable_web_security;
+    return;
+  }
+
+  NativeWindow* window = NativeWindow::FromRenderView(
+      process->GetID(), render_view_host->GetRoutingID());
+  if (window)
+    window->OverrideWebkitPrefs(url, prefs);
+}
+
+bool AtomBrowserClient::ShouldSwapBrowsingInstancesForNavigation(
+    content::SiteInstance* site_instance,
+    const GURL& current_url,
+    const GURL& new_url) {
+  if (site_instance->HasProcess())
+    dying_render_process_ = site_instance->GetProcess();
+
+  // Restart renderer process for all navigations, this relies on a patch to
+  // Chromium: http://git.io/_PaNyg.
+  return true;
+}
+
+std::string AtomBrowserClient::GetApplicationLocale() {
+  return l10n_util::GetApplicationLocale("");
+}
+
+void AtomBrowserClient::AppendExtraCommandLineSwitches(
+    base::CommandLine* command_line,
+    int child_process_id) {
+  WindowList* list = WindowList::GetInstance();
+  NativeWindow* window = NULL;
+
+  // Find the owner of this child process.
+  WindowList::const_iterator iter = std::find_if(
+      list->begin(), list->end(), FindByProcessId(child_process_id));
+  if (iter != list->end())
+    window = *iter;
+
+  // If the render process is a newly started one, which means the window still
+  // uses the old going-to-be-swapped render process, then we try to find the
+  // window from the swapped render process.
+  if (window == NULL && dying_render_process_ != NULL) {
+    child_process_id = dying_render_process_->GetID();
+    WindowList::const_iterator iter = std::find_if(
+        list->begin(), list->end(), FindByProcessId(child_process_id));
+    if (iter != list->end())
+      window = *iter;
+  }
+
+  if (window != NULL) {
+    window->AppendExtraCommandLineSwitches(command_line, child_process_id);
+  } else {
+    // Append commnad line arguments for guest web view.
+    auto child_process = content::RenderProcessHost::FromID(child_process_id);
+    WebViewManager::WebViewInfo info;
+    if (WebViewManager::GetInfoForProcess(child_process, &info)) {
+      command_line->AppendSwitchASCII(
+          switches::kGuestInstanceID,
+          base::IntToString(info.guest_instance_id));
+      command_line->AppendSwitchASCII(
+          switches::kNodeIntegration,
+          info.node_integration ? "true" : "false");
+      if (info.plugins)
+        command_line->AppendSwitch(switches::kEnablePlugins);
+      if (!info.preload_script.empty())
+        command_line->AppendSwitchPath(
+            switches::kPreloadScript,
+            info.preload_script);
+    }
+  }
+
+  dying_render_process_ = NULL;
+}
+
+brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
+    const content::MainFunctionParams&) {
+  v8::V8::Initialize();  // Init V8 before creating main parts.
+  return new AtomBrowserMainParts;
+}
+
+}  // namespace atom

atom/browser/atom_browser_client.h

@@ -0,0 +1,53 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
+#define ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
+
+#include <string>
+
+#include "brightray/browser/browser_client.h"
+
+namespace atom {
+
+class AtomResourceDispatcherHostDelegate;
+
+class AtomBrowserClient : public brightray::BrowserClient {
+ public:
+  AtomBrowserClient();
+  virtual ~AtomBrowserClient();
+
+ protected:
+  // content::ContentBrowserClient:
+  void RenderProcessWillLaunch(content::RenderProcessHost* host) override;
+  content::SpeechRecognitionManagerDelegate*
+      CreateSpeechRecognitionManagerDelegate() override;
+  content::AccessTokenStore* CreateAccessTokenStore() override;
+  void ResourceDispatcherHostCreated() override;
+  void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
+                           const GURL& url,
+                           content::WebPreferences* prefs) override;
+  bool ShouldSwapBrowsingInstancesForNavigation(
+      content::SiteInstance* site_instance,
+      const GURL& current_url,
+      const GURL& new_url) override;
+  std::string GetApplicationLocale() override;
+  void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
+                                      int child_process_id) override;
+
+ private:
+  brightray::BrowserMainParts* OverrideCreateBrowserMainParts(
+      const content::MainFunctionParams&) override;
+
+  scoped_ptr<AtomResourceDispatcherHostDelegate> resource_dispatcher_delegate_;
+
+  // The render process which would be swapped out soon.
+  content::RenderProcessHost* dying_render_process_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_

atom/browser/atom_browser_context.cc

@@ -0,0 +1,96 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_browser_context.h"
+
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/net/atom_url_request_job_factory.h"
+#include "atom/browser/net/asar/asar_protocol_handler.h"
+#include "atom/browser/web_view_manager.h"
+#include "atom/common/options_switches.h"
+#include "base/command_line.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/worker_pool.h"
+#include "chrome/browser/browser_process.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/common/url_constants.h"
+#include "net/url_request/data_protocol_handler.h"
+#include "net/url_request/url_request_intercepting_job_factory.h"
+#include "url/url_constants.h"
+
+using content::BrowserThread;
+
+namespace atom {
+
+namespace {
+
+class NoCacheBackend : public net::HttpCache::BackendFactory {
+  int CreateBackend(net::NetLog* net_log,
+                    scoped_ptr<disk_cache::Backend>* backend,
+                    const net::CompletionCallback& callback) override {
+    return net::ERR_FAILED;
+  }
+};
+
+}  // namespace
+
+AtomBrowserContext::AtomBrowserContext()
+    : fake_browser_process_(new BrowserProcess),
+      job_factory_(new AtomURLRequestJobFactory) {
+}
+
+AtomBrowserContext::~AtomBrowserContext() {
+}
+
+net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
+    content::ProtocolHandlerMap* handlers,
+    content::URLRequestInterceptorScopedVector* interceptors) {
+  scoped_ptr<AtomURLRequestJobFactory> job_factory(job_factory_);
+
+  for (content::ProtocolHandlerMap::iterator it = handlers->begin();
+       it != handlers->end(); ++it)
+    job_factory->SetProtocolHandler(it->first, it->second.release());
+  handlers->clear();
+
+  job_factory->SetProtocolHandler(
+      url::kDataScheme, new net::DataProtocolHandler);
+  job_factory->SetProtocolHandler(
+      url::kFileScheme, new asar::AsarProtocolHandler(
+          BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
+
+  // Set up interceptors in the reverse order.
+  scoped_ptr<net::URLRequestJobFactory> top_job_factory = job_factory.Pass();
+  content::URLRequestInterceptorScopedVector::reverse_iterator it;
+  for (it = interceptors->rbegin(); it != interceptors->rend(); ++it)
+    top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
+        top_job_factory.Pass(), make_scoped_ptr(*it)));
+  interceptors->weak_clear();
+
+  return top_job_factory.release();
+}
+
+net::HttpCache::BackendFactory*
+AtomBrowserContext::CreateHttpCacheBackendFactory(
+    const base::FilePath& base_path) {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kDisableHttpCache))
+    return new NoCacheBackend;
+  else
+    return brightray::BrowserContext::CreateHttpCacheBackendFactory(base_path);
+}
+
+content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
+  if (!guest_manager_)
+    guest_manager_.reset(new WebViewManager(this));
+  return guest_manager_.get();
+}
+
+// static
+AtomBrowserContext* AtomBrowserContext::Get() {
+  return static_cast<AtomBrowserContext*>(
+      AtomBrowserMainParts::Get()->browser_context());
+}
+
+}  // namespace atom

atom/browser/atom_browser_context.h

@@ -0,0 +1,49 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
+#define ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
+
+#include "brightray/browser/browser_context.h"
+
+class BrowserProcess;
+
+namespace atom {
+
+class AtomURLRequestJobFactory;
+class WebViewManager;
+
+class AtomBrowserContext : public brightray::BrowserContext {
+ public:
+  AtomBrowserContext();
+  virtual ~AtomBrowserContext();
+
+  // Returns the browser context singleton.
+  static AtomBrowserContext* Get();
+
+  // brightray::URLRequestContextGetter::Delegate:
+  net::URLRequestJobFactory* CreateURLRequestJobFactory(
+      content::ProtocolHandlerMap* handlers,
+      content::URLRequestInterceptorScopedVector* interceptors) override;
+  net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
+      const base::FilePath& base_path) override;
+
+  // content::BrowserContext:
+  content::BrowserPluginGuestManager* GetGuestManager() override;
+
+  AtomURLRequestJobFactory* job_factory() const { return job_factory_; }
+
+ private:
+  // A fake BrowserProcess object that used to feed the source code from chrome.
+  scoped_ptr<BrowserProcess> fake_browser_process_;
+  scoped_ptr<WebViewManager> guest_manager_;
+
+  AtomURLRequestJobFactory* job_factory_;  // Weak reference.
+
+  DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_

atom/browser/atom_browser_main_parts.cc

@@ -0,0 +1,106 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_browser_main_parts.h"
+
+#include "atom/browser/atom_browser_client.h"
+#include "atom/browser/atom_browser_context.h"
+#include "atom/browser/browser.h"
+#include "atom/browser/javascript_environment.h"
+#include "atom/browser/node_debugger.h"
+#include "atom/common/api/atom_bindings.h"
+#include "atom/common/node_bindings.h"
+#include "base/command_line.h"
+#include "v8/include/v8-debug.h"
+
+#if defined(USE_X11)
+#include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
+#endif
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+// static
+AtomBrowserMainParts* AtomBrowserMainParts::self_ = NULL;
+
+AtomBrowserMainParts::AtomBrowserMainParts()
+    : browser_(new Browser),
+      node_bindings_(NodeBindings::Create(true)),
+      atom_bindings_(new AtomBindings),
+      gc_timer_(true, true) {
+  DCHECK(!self_) << "Cannot have two AtomBrowserMainParts";
+  self_ = this;
+}
+
+AtomBrowserMainParts::~AtomBrowserMainParts() {
+}
+
+// static
+AtomBrowserMainParts* AtomBrowserMainParts::Get() {
+  DCHECK(self_);
+  return self_;
+}
+
+brightray::BrowserContext* AtomBrowserMainParts::CreateBrowserContext() {
+  return new AtomBrowserContext();
+}
+
+void AtomBrowserMainParts::PostEarlyInitialization() {
+  brightray::BrowserMainParts::PostEarlyInitialization();
+
+#if defined(USE_X11)
+  SetDPIFromGSettings();
+#endif
+
+  // The ProxyResolverV8 has setup a complete V8 environment, in order to avoid
+  // conflicts we only initialize our V8 environment after that.
+  js_env_.reset(new JavascriptEnvironment);
+
+  node_bindings_->Initialize();
+
+  // Support the "--debug" switch.
+  node_debugger_.reset(new NodeDebugger(js_env_->isolate()));
+
+  // Create the global environment.
+  global_env = node_bindings_->CreateEnvironment(js_env_->context());
+
+  // Make sure node can get correct environment when debugging.
+  if (node_debugger_->IsRunning())
+    global_env->AssignToContext(v8::Debug::GetDebugContext());
+
+  // Add atom-shell extended APIs.
+  atom_bindings_->BindTo(js_env_->isolate(), global_env->process_object());
+
+  // Load everything.
+  node_bindings_->LoadEnvironment(global_env);
+}
+
+void AtomBrowserMainParts::PreMainMessageLoopRun() {
+  // Run user's main script before most things get initialized, so we can have
+  // a chance to setup everything.
+  node_bindings_->PrepareMessageLoop();
+  node_bindings_->RunMessageLoop();
+
+  // Start idle gc.
+  gc_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMinutes(1),
+      base::Bind(base::IgnoreResult(&v8::Isolate::IdleNotification),
+                 base::Unretained(js_env_->isolate()),
+                 1000));
+
+  brightray::BrowserMainParts::PreMainMessageLoopRun();
+
+#if defined(USE_X11)
+  libgtk2ui::GtkInitFromCommandLine(*base::CommandLine::ForCurrentProcess());
+#endif
+
+#if !defined(OS_MACOSX)
+  // The corresponding call in OS X is in AtomApplicationDelegate.
+  Browser::Get()->WillFinishLaunching();
+  Browser::Get()->DidFinishLaunching();
+#endif
+}
+
+}  // namespace atom

atom/browser/atom_browser_main_parts.h

@@ -0,0 +1,60 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
+#define ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
+
+#include "base/timer/timer.h"
+#include "brightray/browser/browser_main_parts.h"
+
+namespace atom {
+
+class AtomBindings;
+class Browser;
+class JavascriptEnvironment;
+class NodeBindings;
+class NodeDebugger;
+
+class AtomBrowserMainParts : public brightray::BrowserMainParts {
+ public:
+  AtomBrowserMainParts();
+  virtual ~AtomBrowserMainParts();
+
+  static AtomBrowserMainParts* Get();
+
+  Browser* browser() { return browser_.get(); }
+
+ protected:
+  // Implementations of brightray::BrowserMainParts.
+  brightray::BrowserContext* CreateBrowserContext() override;
+
+  // Implementations of content::BrowserMainParts.
+  void PostEarlyInitialization() override;
+  void PreMainMessageLoopRun() override;
+#if defined(OS_MACOSX)
+  void PreMainMessageLoopStart() override;
+  void PostDestroyThreads() override;
+#endif
+
+ private:
+#if defined(USE_X11)
+  void SetDPIFromGSettings();
+#endif
+
+  scoped_ptr<Browser> browser_;
+  scoped_ptr<JavascriptEnvironment> js_env_;
+  scoped_ptr<NodeBindings> node_bindings_;
+  scoped_ptr<AtomBindings> atom_bindings_;
+  scoped_ptr<NodeDebugger> node_debugger_;
+
+  base::Timer gc_timer_;
+
+  static AtomBrowserMainParts* self_;
+
+  DISALLOW_COPY_AND_ASSIGN(AtomBrowserMainParts);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_

atom/browser/atom_browser_main_parts_linux.cc

@@ -0,0 +1,82 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_browser_main_parts.h"
+
+#include "base/command_line.h"
+#include "base/strings/string_number_conversions.h"
+#include "library_loaders/libgio.h"
+#include "ui/gfx/switches.h"
+
+namespace atom {
+
+namespace {
+
+const char* kInterfaceSchema = "org.gnome.desktop.interface";
+const char* kScaleFactor = "scaling-factor";
+
+bool SchemaExists(const LibGioLoader& libgio_loader, const char* schema_name) {
+  const gchar* const* schemas = libgio_loader.g_settings_list_schemas();
+  while (*schemas) {
+    if (strcmp(schema_name, static_cast<const char*>(*schemas)) == 0)
+      return true;
+    schemas++;
+  }
+  return false;
+}
+
+bool KeyExists(const LibGioLoader& libgio_loader, GSettings* client,
+               const char* key) {
+  gchar** keys = libgio_loader.g_settings_list_keys(client);
+  if (!keys)
+    return false;
+
+  gchar** iter = keys;
+  while (*iter) {
+    if (strcmp(*iter, key) == 0)
+      break;
+    iter++;
+  }
+
+  bool exists = *iter != NULL;
+  g_strfreev(keys);
+  return exists;
+}
+
+void GetDPIFromGSettings(guint* scale_factor) {
+  LibGioLoader libgio_loader;
+
+  // Try also without .0 at the end; on some systems this may be required.
+  if (!libgio_loader.Load("libgio-2.0.so.0") &&
+      !libgio_loader.Load("libgio-2.0.so")) {
+    VLOG(1) << "Cannot load gio library. Will fall back to gconf.";
+    return;
+  }
+
+  GSettings* client = nullptr;
+  if (!SchemaExists(libgio_loader, kInterfaceSchema) ||
+      !(client = libgio_loader.g_settings_new(kInterfaceSchema))) {
+    VLOG(1) << "Cannot create gsettings client.";
+    return;
+  }
+
+  if (KeyExists(libgio_loader, client, kScaleFactor))
+    *scale_factor = libgio_loader.g_settings_get_uint(client, kScaleFactor);
+
+  g_object_unref(client);
+}
+
+}  // namespace
+
+void AtomBrowserMainParts::SetDPIFromGSettings() {
+  guint scale_factor = 1;
+  GetDPIFromGSettings(&scale_factor);
+  if (scale_factor == 0)
+    scale_factor = 1;
+
+  base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kForceDeviceScaleFactor, base::UintToString(scale_factor));
+}
+
+}  // namespace atom

atom/browser/atom_browser_main_parts_mac.mm

@@ -0,0 +1,48 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_browser_main_parts.h"
+
+#import "atom/browser/mac/atom_application.h"
+#import "atom/browser/mac/atom_application_delegate.h"
+#include "base/files/file_path.h"
+#import "base/mac/foundation_util.h"
+#include "ui/base/l10n/l10n_util_mac.h"
+#import "vendor/brightray/common/mac/main_application_bundle.h"
+
+namespace atom {
+
+void AtomBrowserMainParts::PreMainMessageLoopStart() {
+  // Initialize locale setting.
+  l10n_util::OverrideLocaleWithCocoaLocale();
+
+  // Force the NSApplication subclass to be used.
+  NSApplication* application = [AtomApplication sharedApplication];
+
+  AtomApplicationDelegate* delegate = [[AtomApplicationDelegate alloc] init];
+  [NSApp setDelegate:(id<NSFileManagerDelegate>)delegate];
+
+  base::FilePath frameworkPath = brightray::MainApplicationBundlePath()
+      .Append("Contents")
+      .Append("Frameworks")
+      .Append(PRODUCT_NAME " Framework.framework");
+  NSBundle* frameworkBundle = [NSBundle
+       bundleWithPath:base::mac::FilePathToNSString(frameworkPath)];
+  NSNib* mainNib = [[NSNib alloc] initWithNibNamed:@"MainMenu"
+                                            bundle:frameworkBundle];
+  [mainNib instantiateWithOwner:application topLevelObjects:nil];
+  [mainNib release];
+
+  // Prevent Cocoa from turning command-line arguments into
+  // |-application:openFiles:|, since we already handle them directly.
+  [[NSUserDefaults standardUserDefaults]
+      setObject:@"NO" forKey:@"NSTreatUnknownArgumentsAsOpen"];
+}
+
+void AtomBrowserMainParts::PostDestroyThreads() {
+  [[NSApp delegate] release];
+  [NSApp setDelegate:nil];
+}
+
+}  // namespace atom

atom/browser/atom_javascript_dialog_manager.cc

@@ -0,0 +1,36 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_javascript_dialog_manager.h"
+
+#include <string>
+
+#include "base/strings/utf_string_conversions.h"
+
+namespace atom {
+
+void AtomJavaScriptDialogManager::RunJavaScriptDialog(
+    content::WebContents* web_contents,
+    const GURL& origin_url,
+    const std::string& accept_lang,
+    content::JavaScriptMessageType javascript_message_type,
+    const base::string16& message_text,
+    const base::string16& default_prompt_text,
+    const DialogClosedCallback& callback,
+    bool* did_suppress_message) {
+  callback.Run(false, base::string16());
+}
+
+void AtomJavaScriptDialogManager::RunBeforeUnloadDialog(
+    content::WebContents* web_contents,
+    const base::string16& message_text,
+    bool is_reload,
+    const DialogClosedCallback& callback) {
+
+  bool prevent_reload = message_text.empty() ||
+                        message_text == base::ASCIIToUTF16("false");
+  callback.Run(!prevent_reload, message_text);
+}
+
+}  // namespace atom

atom/browser/atom_javascript_dialog_manager.h

@@ -0,0 +1,38 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_
+#define ATOM_BROWSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_
+
+#include <string>
+
+#include "content/public/browser/javascript_dialog_manager.h"
+
+namespace atom {
+
+class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
+ public:
+  // content::JavaScriptDialogManager implementations.
+  void RunJavaScriptDialog(
+      content::WebContents* web_contents,
+      const GURL& origin_url,
+      const std::string& accept_lang,
+      content::JavaScriptMessageType javascript_message_type,
+      const base::string16& message_text,
+      const base::string16& default_prompt_text,
+      const DialogClosedCallback& callback,
+      bool* did_suppress_message) override;
+  void RunBeforeUnloadDialog(
+      content::WebContents* web_contents,
+      const base::string16& message_text,
+      bool is_reload,
+      const DialogClosedCallback& callback) override;
+  void CancelActiveAndPendingDialogs(
+      content::WebContents* web_contents) override {}
+  void WebContentsDestroyed(content::WebContents* web_contents) override {}
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_

atom/browser/atom_resource_dispatcher_host_delegate.cc

@@ -0,0 +1,33 @@
+// Copyright (c) 2014 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/atom_resource_dispatcher_host_delegate.h"
+
+#include <string>
+
+#include "base/logging.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/resource_request_info.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_request.h"
+
+namespace atom {
+
+AtomResourceDispatcherHostDelegate::AtomResourceDispatcherHostDelegate() {
+}
+
+void AtomResourceDispatcherHostDelegate::OnResponseStarted(
+    net::URLRequest* request,
+    content::ResourceContext* resource_context,
+    content::ResourceResponse* response,
+    IPC::Sender* sender) {
+  // Remove the "X-Frame-Options" from response headers for devtools.
+  if (request->url().SchemeIs("chrome-devtools")) {
+    net::HttpResponseHeaders* response_headers = request->response_headers();
+    if (response_headers && response_headers->HasHeader("x-frame-options"))
+      response_headers->RemoveHeader("x-frame-options");
+  }
+}
+
+}  // namespace atom

atom/browser/atom_resource_dispatcher_host_delegate.h

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

atom/browser/atom_speech_recognition_manager_delegate.cc

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

atom/browser/atom_speech_recognition_manager_delegate.h

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

atom/browser/auto_updater.cc

@@ -1,8 +1,8 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#include "browser/auto_updater.h"
+#include "atom/browser/auto_updater.h"
 
 namespace auto_updater {
 

atom/browser/auto_updater.h

@@ -1,5 +1,5 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
 #ifndef ATOM_BROWSER_AUTO_UPDATER_H_
@@ -19,13 +19,8 @@ class AutoUpdater {
   static AutoUpdaterDelegate* GetDelegate();
   static void SetDelegate(AutoUpdaterDelegate* delegate);
 
-  static void Init();
-
   static void SetFeedURL(const std::string& url);
-  static void SetAutomaticallyChecksForUpdates(bool yes);
-  static void SetAutomaticallyDownloadsUpdates(bool yes);
   static void CheckForUpdates();
-  static void CheckForUpdatesInBackground();
 
  private:
   static AutoUpdaterDelegate* delegate_;

atom/browser/auto_updater_delegate.h

@@ -0,0 +1,45 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_
+#define ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_
+
+#include <string>
+
+#include "base/callback_forward.h"
+
+namespace base {
+class Time;
+}
+
+namespace auto_updater {
+
+class AutoUpdaterDelegate {
+ public:
+  // An error happened.
+  virtual void OnError(const std::string& error) {}
+
+  // Checking to see if there is an update
+  virtual void OnCheckingForUpdate() {}
+
+  // There is an update available and it is being downloaded
+  virtual void OnUpdateAvailable() {}
+
+  // There is no available update.
+  virtual void OnUpdateNotAvailable() {}
+
+  // There is a new update which has been downloaded.
+  virtual void OnUpdateDownloaded(const std::string& release_notes,
+                                  const std::string& release_name,
+                                  const base::Time& release_date,
+                                  const std::string& update_url,
+                                  const base::Closure& quit_and_install) {}
+
+ protected:
+  virtual ~AutoUpdaterDelegate() {}
+};
+
+}  // namespace auto_updater
+
+#endif  // ATOM_BROWSER_AUTO_UPDATER_DELEGATE_H_

atom/browser/auto_updater_linux.cc

@@ -0,0 +1,17 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/auto_updater.h"
+
+namespace auto_updater {
+
+// static
+void AutoUpdater::SetFeedURL(const std::string& url) {
+}
+
+// static
+void AutoUpdater::CheckForUpdates() {
+}
+
+}  // namespace auto_updater

atom/browser/auto_updater_mac.mm

@@ -0,0 +1,95 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/auto_updater.h"
+
+#import <ReactiveCocoa/RACCommand.h>
+#import <ReactiveCocoa/RACSignal.h>
+#import <ReactiveCocoa/NSObject+RACPropertySubscribing.h>
+#import <Squirrel/Squirrel.h>
+
+#include "base/bind.h"
+#include "base/time/time.h"
+#include "base/strings/sys_string_conversions.h"
+#include "atom/browser/auto_updater_delegate.h"
+
+#include <iostream>
+
+namespace auto_updater {
+
+namespace {
+
+// The gloal SQRLUpdater object.
+SQRLUpdater* g_updater = nil;
+
+void RelaunchToInstallUpdate() {
+  [[g_updater relaunchToInstallUpdate] subscribeError:^(NSError* error) {
+    AutoUpdaterDelegate* delegate = AutoUpdater::GetDelegate();
+    if (delegate)
+      delegate->OnError(base::SysNSStringToUTF8(error.localizedDescription));
+  }];
+}
+
+}  // namespace
+
+// static
+void AutoUpdater::SetFeedURL(const std::string& feed) {
+  if (g_updater == nil) {
+    // Initialize the SQRLUpdater.
+    NSURL* url = [NSURL URLWithString:base::SysUTF8ToNSString(feed)];
+    NSURLRequest* urlRequest = [NSURLRequest requestWithURL:url];
+    g_updater = [[SQRLUpdater alloc] initWithUpdateRequest:urlRequest];
+
+    AutoUpdaterDelegate* delegate = GetDelegate();
+    if (!delegate)
+      return;
+
+    [[g_updater rac_valuesForKeyPath:@"state" observer:g_updater]
+      subscribeNext:^(NSNumber *stateNumber) {
+        int state = [stateNumber integerValue];
+        // Dispatching the event on main thread.
+        dispatch_async(dispatch_get_main_queue(), ^{
+          if (state == SQRLUpdaterStateCheckingForUpdate)
+            delegate->OnCheckingForUpdate();
+          else if (state == SQRLUpdaterStateDownloadingUpdate)
+            delegate->OnUpdateAvailable();
+        });
+    }];
+  }
+}
+
+// static
+void AutoUpdater::CheckForUpdates() {
+  AutoUpdaterDelegate* delegate = GetDelegate();
+  if (!delegate)
+    return;
+
+  [[[[g_updater.checkForUpdatesCommand
+      execute:nil]
+      // Send a `nil` after everything...
+      concat:[RACSignal return:nil]]
+      // But only take the first value. If an update is sent, we'll get that.
+      // Otherwise, we'll get our inserted `nil` value.
+      take:1]
+      subscribeNext:^(SQRLDownloadedUpdate *downloadedUpdate) {
+        if (downloadedUpdate) {
+          SQRLUpdate* update = downloadedUpdate.update;
+          // There is a new update that has been downloaded.
+          delegate->OnUpdateDownloaded(
+            base::SysNSStringToUTF8(update.releaseNotes),
+            base::SysNSStringToUTF8(update.releaseName),
+            base::Time::FromDoubleT(update.releaseDate.timeIntervalSince1970),
+            base::SysNSStringToUTF8(update.updateURL.absoluteString),
+            base::Bind(RelaunchToInstallUpdate));
+        } else {
+          // When the completed event is sent with no update, then we know there
+          // is no update available.
+          delegate->OnUpdateNotAvailable();
+        }
+      } error:^(NSError *error) {
+        delegate->OnError(base::SysNSStringToUTF8(error.localizedDescription));
+      }];
+}
+
+}  // namespace auto_updater

atom/browser/auto_updater_win.cc

@@ -0,0 +1,17 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/auto_updater.h"
+
+namespace auto_updater {
+
+// static
+void AutoUpdater::SetFeedURL(const std::string& url) {
+}
+
+// static
+void AutoUpdater::CheckForUpdates() {
+}
+
+}  // namespace auto_updater

atom/browser/browser.cc

@@ -0,0 +1,142 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/browser.h"
+
+#include <string>
+
+#include "atom/browser/atom_browser_main_parts.h"
+#include "atom/browser/window_list.h"
+#include "base/message_loop/message_loop.h"
+
+namespace atom {
+
+Browser::Browser()
+    : is_quiting_(false),
+      is_ready_(false) {
+  WindowList::AddObserver(this);
+}
+
+Browser::~Browser() {
+  WindowList::RemoveObserver(this);
+}
+
+// static
+Browser* Browser::Get() {
+  return AtomBrowserMainParts::Get()->browser();
+}
+
+void Browser::Quit() {
+  is_quiting_ = HandleBeforeQuit();
+  if (!is_quiting_)
+    return;
+
+  atom::WindowList* window_list = atom::WindowList::GetInstance();
+  if (window_list->size() == 0)
+    NotifyAndShutdown();
+
+  window_list->CloseAllWindows();
+}
+
+void Browser::Shutdown() {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnQuit());
+
+  is_quiting_ = true;
+  base::MessageLoop::current()->Quit();
+}
+
+std::string Browser::GetVersion() const {
+  if (version_override_.empty()) {
+    std::string version = GetExecutableFileVersion();
+    if (!version.empty())
+      return version;
+  }
+
+  return version_override_;
+}
+
+void Browser::SetVersion(const std::string& version) {
+  version_override_ = version;
+}
+
+std::string Browser::GetName() const {
+  if (name_override_.empty()) {
+    std::string name = GetExecutableFileProductName();
+    if (!name.empty())
+      return name;
+  }
+
+  return name_override_;
+}
+
+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) {
+  bool prevent_default = false;
+  FOR_EACH_OBSERVER(BrowserObserver,
+                    observers_,
+                    OnOpenFile(&prevent_default, file_path));
+
+  return prevent_default;
+}
+
+void Browser::OpenURL(const std::string& url) {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnOpenURL(url));
+}
+
+void Browser::ActivateWithNoOpenWindows() {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnActivateWithNoOpenWindows());
+}
+
+void Browser::WillFinishLaunching() {
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWillFinishLaunching());
+}
+
+void Browser::DidFinishLaunching() {
+  is_ready_ = true;
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnFinishLaunching());
+}
+
+void Browser::NotifyAndShutdown() {
+  bool prevent_default = false;
+  FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWillQuit(&prevent_default));
+
+  if (prevent_default) {
+    is_quiting_ = false;
+    return;
+  }
+
+  Shutdown();
+}
+
+bool Browser::HandleBeforeQuit() {
+  bool prevent_default = false;
+  FOR_EACH_OBSERVER(BrowserObserver,
+                    observers_,
+                    OnBeforeQuit(&prevent_default));
+
+  return !prevent_default;
+}
+
+void Browser::OnWindowCloseCancelled(NativeWindow* window) {
+  if (is_quiting_)
+    // Once a beforeunload handler has prevented the closing, we think the quit
+    // is cancelled too.
+    is_quiting_ = false;
+}
+
+void Browser::OnWindowAllClosed() {
+  if (is_quiting_)
+    NotifyAndShutdown();
+  else
+    FOR_EACH_OBSERVER(BrowserObserver, observers_, OnWindowAllClosed());
+}
+
+}  // namespace atom

atom/browser/browser.h

@@ -0,0 +1,167 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_BROWSER_H_
+#define ATOM_BROWSER_BROWSER_H_
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/observer_list.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 {
+class FilePath;
+}
+
+namespace ui {
+class MenuModel;
+}
+
+namespace atom {
+
+// This class is used for control application-wide operations.
+class Browser : public WindowListObserver {
+ public:
+  Browser();
+  ~Browser();
+
+  static Browser* Get();
+
+  // Try to close all windows and quit the application.
+  void Quit();
+
+  // Cleanup everything and shutdown the application gracefully.
+  void Shutdown();
+
+  // Focus the application.
+  void Focus();
+
+  // Returns the version of the executable (or bundle).
+  std::string GetVersion() const;
+
+  // Overrides the application version.
+  void SetVersion(const std::string& version);
+
+  // Returns the application's name, default is just Atom-Shell.
+  std::string GetName() const;
+
+  // Overrides the application name.
+  void SetName(const std::string& name);
+
+  // Add the |path| to recent documents list.
+  void AddRecentDocument(const base::FilePath& path);
+
+  // Clear the recent documents list.
+  void ClearRecentDocuments();
+
+#if defined(OS_MACOSX)
+  // Bounce the dock icon.
+  enum BounceType {
+    BOUNCE_CRITICAL = 0,
+    BOUNCE_INFORMATIONAL = 10,
+  };
+  int DockBounce(BounceType type);
+  void DockCancelBounce(int request_id);
+
+  // Set/Get dock's badge text.
+  void DockSetBadgeText(const std::string& label);
+  std::string DockGetBadgeText();
+
+  // Hide/Show dock.
+  void DockHide();
+  void DockShow();
+
+  // Set docks' menu.
+  void DockSetMenu(ui::MenuModel* model);
+#endif  // defined(OS_MACOSX)
+
+#if defined(OS_WIN)
+  struct UserTask {
+    base::FilePath program;
+    base::string16 arguments;
+    base::string16 title;
+    base::string16 description;
+    base::FilePath icon_path;
+    int icon_index;
+  };
+
+  // Add a custom task to jump list.
+  void SetUserTasks(const std::vector<UserTask>& tasks);
+
+  // Set the application user model ID, called when "SetName" is called.
+  void SetAppUserModelID(const std::string& name);
+#endif
+
+  // Tell the application to open a file.
+  bool OpenFile(const std::string& file_path);
+
+  // Tell the application to open a url.
+  void OpenURL(const std::string& url);
+
+  // Tell the application that application is activated with no open windows.
+  void ActivateWithNoOpenWindows();
+
+  // Tell the application the loading has been done.
+  void WillFinishLaunching();
+  void DidFinishLaunching();
+
+  void AddObserver(BrowserObserver* obs) {
+    observers_.AddObserver(obs);
+  }
+
+  void RemoveObserver(BrowserObserver* obs) {
+    observers_.RemoveObserver(obs);
+  }
+
+  bool is_quiting() const { return is_quiting_; }
+  bool is_ready() const { return is_ready_; }
+
+ protected:
+  // Returns the version of application bundle or executable file.
+  std::string GetExecutableFileVersion() const;
+
+  // Returns the name of application bundle or executable file.
+  std::string GetExecutableFileProductName() const;
+
+  // Send the will-quit message and then shutdown the application.
+  void NotifyAndShutdown();
+
+  // Send the before-quit message and start closing windows.
+  bool HandleBeforeQuit();
+
+  bool is_quiting_;
+
+ private:
+  // WindowListObserver implementations:
+  void OnWindowCloseCancelled(NativeWindow* window) override;
+  void OnWindowAllClosed() override;
+
+  // Observers of the browser.
+  ObserverList<BrowserObserver> observers_;
+
+  // Whether "ready" event has been emitted.
+  bool is_ready_;
+
+  std::string version_override_;
+  std::string name_override_;
+
+#if defined(OS_WIN)
+  base::string16 app_user_model_id_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(Browser);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_BROWSER_H_

atom/browser/browser_linux.cc

@@ -0,0 +1,41 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/browser.h"
+
+#include <stdlib.h>
+
+#include "atom/browser/native_window.h"
+#include "atom/browser/window_list.h"
+#include "atom/common/atom_version.h"
+
+namespace atom {
+
+void Browser::Focus() {
+  // Focus on the first visible window.
+  WindowList* list = WindowList::GetInstance();
+  for (WindowList::iterator iter = list->begin(); iter != list->end(); ++iter) {
+    NativeWindow* window = *iter;
+    if (window->IsVisible()) {
+      window->Focus(true);
+      break;
+    }
+  }
+}
+
+void Browser::AddRecentDocument(const base::FilePath& path) {
+}
+
+void Browser::ClearRecentDocuments() {
+}
+
+std::string Browser::GetExecutableFileVersion() const {
+  return ATOM_VERSION_STRING;
+}
+
+std::string Browser::GetExecutableFileProductName() const {
+  return "Atom-Shell";
+}
+
+}  // namespace atom

atom/browser/browser_mac.mm

@@ -0,0 +1,78 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/browser.h"
+
+#import "atom/browser/mac/atom_application.h"
+#import "atom/browser/mac/atom_application_delegate.h"
+#include "atom/browser/native_window.h"
+#include "atom/browser/window_list.h"
+#import "base/mac/bundle_locations.h"
+#import "base/mac/foundation_util.h"
+#include "base/strings/sys_string_conversions.h"
+
+namespace atom {
+
+void Browser::Focus() {
+  [[AtomApplication sharedApplication] activateIgnoringOtherApps:YES];
+}
+
+void Browser::AddRecentDocument(const base::FilePath& path) {
+  NSURL* u = [NSURL fileURLWithPath:base::mac::FilePathToNSString(path)];
+  [[NSDocumentController sharedDocumentController] noteNewRecentDocumentURL:u];
+}
+
+void Browser::ClearRecentDocuments() {
+}
+
+std::string Browser::GetExecutableFileVersion() const {
+  NSDictionary* infoDictionary = base::mac::OuterBundle().infoDictionary;
+  NSString *version = [infoDictionary objectForKey:@"CFBundleVersion"];
+  return base::SysNSStringToUTF8(version);
+}
+
+std::string Browser::GetExecutableFileProductName() const {
+  NSDictionary* infoDictionary = base::mac::OuterBundle().infoDictionary;
+  NSString *version = [infoDictionary objectForKey:@"CFBundleName"];
+  return base::SysNSStringToUTF8(version);
+}
+
+int Browser::DockBounce(BounceType type) {
+  return [[AtomApplication sharedApplication] requestUserAttention:(NSRequestUserAttentionType)type];
+}
+
+void Browser::DockCancelBounce(int rid) {
+  [[AtomApplication sharedApplication] cancelUserAttentionRequest:rid];
+}
+
+void Browser::DockSetBadgeText(const std::string& label) {
+  NSDockTile *tile = [[AtomApplication sharedApplication] dockTile];
+  [tile setBadgeLabel:base::SysUTF8ToNSString(label)];
+}
+
+std::string Browser::DockGetBadgeText() {
+  NSDockTile *tile = [[AtomApplication sharedApplication] dockTile];
+  return base::SysNSStringToUTF8([tile badgeLabel]);
+}
+
+void Browser::DockHide() {
+  WindowList* list = WindowList::GetInstance();
+  for (WindowList::iterator it = list->begin(); it != list->end(); ++it)
+    [(*it)->GetNativeWindow() setCanHide:NO];
+
+  ProcessSerialNumber psn = { 0, kCurrentProcess };
+  TransformProcessType(&psn, kProcessTransformToUIElementApplication);
+}
+
+void Browser::DockShow() {
+  ProcessSerialNumber psn = { 0, kCurrentProcess };
+  TransformProcessType(&psn, kProcessTransformToForegroundApplication);
+}
+
+void Browser::DockSetMenu(ui::MenuModel* model) {
+  AtomApplicationDelegate* delegate = (AtomApplicationDelegate*)[NSApp delegate];
+  [delegate setApplicationDockMenu:model];
+}
+
+}  // namespace atom

atom/browser/browser_observer.h

@@ -1,9 +1,9 @@
-// Copyright (c) 2013 GitHub, Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-#ifndef ATOM_BROSER_BROWSER_OBSERVER_H_
-#define ATOM_BROSER_BROWSER_OBSERVER_H_
+#ifndef ATOM_BROWSER_BROWSER_OBSERVER_H_
+#define ATOM_BROWSER_BROWSER_OBSERVER_H_
 
 #include <string>
 
@@ -11,6 +11,9 @@ namespace atom {
 
 class BrowserObserver {
  public:
+  // The browser is about to close all windows.
+  virtual void OnBeforeQuit(bool* prevent_default) {}
+
   // The browser has closed all windows and will quit.
   virtual void OnWillQuit(bool* prevent_default) {}
 
@@ -18,6 +21,9 @@ class BrowserObserver {
   // method will not be called, instead it will call OnWillQuit.
   virtual void OnWindowAllClosed() {}
 
+  // The browser is quitting.
+  virtual void OnQuit() {}
+
   // The browser has opened a file by double clicking in Finder or dragging the
   // file to the Dock icon. (OS X only)
   virtual void OnOpenFile(bool* prevent_default,
@@ -26,6 +32,10 @@ class BrowserObserver {
   // Browser is used to open a url.
   virtual void OnOpenURL(const std::string& url) {}
 
+  // The browser is activated with no open windows (usually by clicking on the
+  // dock icon).
+  virtual void OnActivateWithNoOpenWindows() {}
+
   // The browser has finished loading.
   virtual void OnWillFinishLaunching() {}
   virtual void OnFinishLaunching() {}
@@ -36,4 +46,4 @@ class BrowserObserver {
 
 }  // namespace atom
 
-#endif  // ATOM_BROSER_BROWSER_OBSERVER_H_
+#endif  // ATOM_BROWSER_BROWSER_OBSERVER_H_

atom/browser/browser_win.cc

@@ -0,0 +1,148 @@
+// Copyright (c) 2013 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/browser.h"
+
+#include <atlbase.h>
+#include <propkey.h>
+#include <windows.h>
+#include <shlobj.h>
+#include <shobjidl.h>
+
+#include "base/base_paths.h"
+#include "base/file_version_info.h"
+#include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/path_service.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/win/win_util.h"
+#include "base/win/windows_version.h"
+#include "atom/common/atom_version.h"
+
+namespace atom {
+
+namespace {
+
+BOOL CALLBACK WindowsEnumerationHandler(HWND hwnd, LPARAM param) {
+  DWORD target_process_id = *reinterpret_cast<DWORD*>(param);
+  DWORD process_id = 0;
+
+  GetWindowThreadProcessId(hwnd, &process_id);
+  if (process_id == target_process_id) {
+    SetFocus(hwnd);
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+}  // namespace
+
+void Browser::Focus() {
+  // On Windows we just focus on the first window found for this process.
+  DWORD pid = GetCurrentProcessId();
+  EnumWindows(&WindowsEnumerationHandler, reinterpret_cast<LPARAM>(&pid));
+}
+
+void Browser::AddRecentDocument(const base::FilePath& path) {
+  if (base::win::GetVersion() < base::win::VERSION_WIN7)
+    return;
+
+  CComPtr<IShellItem> item;
+  HRESULT hr = SHCreateItemFromParsingName(
+      path.value().c_str(), NULL, IID_PPV_ARGS(&item));
+  if (SUCCEEDED(hr)) {
+    SHARDAPPIDINFO info;
+    info.psi = item;
+    info.pszAppID = app_user_model_id_.c_str();
+    SHAddToRecentDocs(SHARD_APPIDINFO, &info);
+  }
+}
+
+void Browser::ClearRecentDocuments() {
+  CComPtr<IApplicationDestinations> destinations;
+  if (FAILED(destinations.CoCreateInstance(CLSID_ApplicationDestinations,
+                                           NULL, CLSCTX_INPROC_SERVER)))
+    return;
+  if (FAILED(destinations->SetAppID(app_user_model_id_.c_str())))
+    return;
+  destinations->RemoveAllDestinations();
+}
+
+void Browser::SetUserTasks(const std::vector<UserTask>& tasks) {
+  CComPtr<ICustomDestinationList> destinations;
+  if (FAILED(destinations.CoCreateInstance(CLSID_DestinationList)))
+    return;
+  if (FAILED(destinations->SetAppID(app_user_model_id_.c_str())))
+    return;
+
+  // Start a transaction that updates the JumpList of this application.
+  UINT max_slots;
+  CComPtr<IObjectArray> removed;
+  if (FAILED(destinations->BeginList(&max_slots, IID_PPV_ARGS(&removed))))
+    return;
+
+  CComPtr<IObjectCollection> collection;
+  if (FAILED(collection.CoCreateInstance(CLSID_EnumerableObjectCollection)))
+    return;
+
+  for (auto& task : tasks) {
+    CComPtr<IShellLink> link;
+    if (FAILED(link.CoCreateInstance(CLSID_ShellLink)) ||
+        FAILED(link->SetPath(task.program.value().c_str())) ||
+        FAILED(link->SetArguments(task.arguments.c_str())) ||
+        FAILED(link->SetDescription(task.description.c_str())))
+      return;
+
+    if (!task.icon_path.empty() &&
+        FAILED(link->SetIconLocation(task.icon_path.value().c_str(),
+                                     task.icon_index)))
+      return;
+
+    CComQIPtr<IPropertyStore> property_store = link;
+    if (!base::win::SetStringValueForPropertyStore(property_store, PKEY_Title,
+                                                   task.title.c_str()))
+      return;
+
+    if (FAILED(collection->AddObject(link)))
+      return;
+  }
+
+  // When the list is empty "AddUserTasks" could fail, so we don't check return
+  // value for it.
+  CComQIPtr<IObjectArray> task_array = collection;
+  destinations->AddUserTasks(task_array);
+  destinations->CommitList();
+}
+
+void Browser::SetAppUserModelID(const std::string& name) {
+  app_user_model_id_ = base::string16(L"atom-shell.app.");
+  app_user_model_id_ += base::UTF8ToUTF16(name);
+  SetCurrentProcessExplicitAppUserModelID(app_user_model_id_.c_str());
+}
+
+std::string Browser::GetExecutableFileVersion() const {
+  base::FilePath path;
+  if (PathService::Get(base::FILE_EXE, &path)) {
+    scoped_ptr<FileVersionInfo> version_info(
+        FileVersionInfo::CreateFileVersionInfo(path));
+    return base::UTF16ToUTF8(version_info->product_version());
+  }
+
+  return ATOM_VERSION_STRING;
+}
+
+std::string Browser::GetExecutableFileProductName() const {
+  base::FilePath path;
+  if (PathService::Get(base::FILE_EXE, &path)) {
+    scoped_ptr<FileVersionInfo> version_info(
+        FileVersionInfo::CreateFileVersionInfo(path));
+    return base::UTF16ToUTF8(version_info->product_name());
+  }
+
+  return "Atom-Shell";
+}
+
+}  // namespace atom

atom/browser/default_app/default_app.js

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

atom/browser/default_app/index.html

@@ -0,0 +1,121 @@
+<html>
+<head>
+  <title>Atom Shell</title>
+  <style>
+    body {
+      color: #555;
+      font-family: 'Open Sans',Helvetica,Arial,sans-serif;
+      padding: 30px;
+    }
+
+    h2 {
+      color: #2b6cc2;
+      font-family: "Crimson Text",Georgia,serif;
+      font-weight: 400;
+      line-height: 1.1;
+      letter-spacing: -0.015em;
+    }
+
+    a {
+      color: #2b6cc2;
+      text-decoration: none;
+    }
+    a:hover {
+      text-decoration: underline;
+    }
+
+    pre, code {
+      font-family: "Menlo","Lucida Console",monospace;
+      border: 1px solid #ddd;
+      background-color: #f8f8f8;
+      border-radius: 3px;
+    }
+
+    pre {
+      white-space: pre-wrap;
+      font-size: 13px;
+      line-height: 19px;
+      overflow: auto;
+      padding: 6px 10px;
+    }
+
+    #holder {
+      border: 4px dashed #ccc;
+      margin: 0 auto;
+      height: 300px;
+      color: #ccc;
+      font-size: 40px;
+      line-height: 300px;
+      text-align: center;
+      -webkit-user-select: none;
+    }
+    #holder.hover {
+      border: 4px dashed #999;
+      color: #eee;
+    }
+  </style>
+</head>
+<body>
+  <script>
+    var execPath = require('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);
+      return false;
+    };
+    document.ondragover = document.ondrop = function(e) {
+      e.preventDefault();
+      return false;
+    };
+  </script>
+
+  <h2 style="-webkit-app-region: drag">Welcome to Atom Shell</h2>
+
+  <p>
+  To run your app with atom-shell, execute the following command under your
+  Console (or Terminal):
+  </p>
+
+  <script>document.write('<pre>' + command + '</pre>')</script>
+
+  <p>
+  The <code>path-to-your-app</code> should be the path to your own atom-shell
+  app, you can read the <a href='https://github.com/atom/atom-shell/blob/master/docs/tutorial/quick-start.md'>quick start</a>
+  guide in atom-shell's <a href='https://github.com/atom/atom-shell/blob/master/docs'>docs</a>
+  on how to write one.
+  </p>
+
+  <p>
+  Or you can just drag your app here to run it:
+  </p>
+
+  <div id="holder">
+    Drag your app here to run it
+  </div>
+
+  <script>
+    var holder = document.getElementById('holder');
+    holder.ondragover = function () {
+      this.className = 'hover';
+      return false;
+    };
+    holder.ondragleave = holder.ondragend = function () {
+      this.className = '';
+      return false;
+    };
+    holder.ondrop = function (e) {
+      this.className = '';
+      e.preventDefault();
+
+      var file = e.dataTransfer.files[0];
+      require('child_process').execFile(execPath, [file.path], {
+        detached: true, stdio: 'ignore'
+      }).unref();
+      return false;
+    };
+  </script>
+</body>
+</html>