💄

Should make this automatic in future.

.gitignore

@@ -1,19 +1,11 @@
 .DS_Store
 /build/
 /dist/
-/external_binaries/
+/frameworks/
 /out/
 /vendor/brightray/vendor/download/
-/vendor/debian_wheezy_arm-sysroot/
-/vendor/debian_wheezy_i386-sysroot/
 /vendor/python_26/
-/vendor/npm/
-/vendor/llvm/
-/vendor/llvm-build/
-/vendor/.gclient
 node_modules/
 *.xcodeproj
 *.swp
 *.pyc
-debug.log
-npm-debug.log

.gitmodules

@@ -1,24 +1,15 @@
 [submodule "vendor/brightray"]
 	path = vendor/brightray
-	url = https://github.com/atom/brightray.git
+  url = https://github.com/brightray/brightray.git
 [submodule "vendor/node"]
 	path = vendor/node
-	url = https://github.com/atom/node.git
+  url = https://github.com/atom/node.git
+[submodule "vendor/gyp"]
+	path = vendor/gyp
+	url = https://github.com/svn2github/gyp.git
 [submodule "vendor/depot_tools"]
 	path = vendor/depot_tools
 	url = https://chromium.googlesource.com/chromium/tools/depot_tools.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
-[submodule "vendor/crashpad"]
-	path = vendor/crashpad
-	url = https://github.com/atom/crashpad.git
-[submodule "vendor/requests"]
-	path = vendor/requests
-	url = https://github.com/kennethreitz/requests
-[submodule "vendor/boto"]
-	path = vendor/boto
-	url = https://github.com/boto/boto.git
+[submodule "vendor/apm"]
+	path = vendor/apm
+	url = https://github.com/atom/apm.git

.travis.yml

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

CONTRIBUTING.md

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

LICENSE

@@ -1,20 +1,28 @@
-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.
+// 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.

README-ko.md

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

README.md

@@ -1,66 +1,20 @@
-[![Electron Logo](http://electron.atom.io/images/electron-logo.svg)](http://electron.atom.io/)
+# Atom Shell
 
-[![Build Status](https://travis-ci.org/atom/electron.svg?branch=master)](https://travis-ci.org/atom/electron)
-[![devDependency Status](https://david-dm.org/atom/electron/dev-status.svg)](https://david-dm.org/atom/electron#info=devDependencies)
-[![Join the Electron Community on Slack](http://atom-slack.herokuapp.com/badge.svg)](http://atom-slack.herokuapp.com/)
+Native layer for the [Atom](https://github.com/github/atom).
 
-:zap: *Formerly known as Atom Shell* :zap:
+## Features
 
-The Electron framework lets you write cross-platform desktop applications
-using JavaScript, HTML and CSS. It is based on [io.js](http://iojs.org) and
-[Chromium](http://www.chromium.org) and is used in the [Atom
-editor](https://github.com/atom/atom).
+* Write desktop applications with web techniques
+* Support built-in and third-party modules of node.js
+* Support native node.js modules
+* Extended built-in modules for desktop programming
+* JavaScript on browser side
+* Easy API for cross-process communication
 
-Follow [@ElectronJS](https://twitter.com/electronjs) on Twitter for important
-announcements.
+## Usage & Development
 
-This project adheres to the [Contributor Covenant 1.2](http://contributor-covenant.org/version/1/2/0).
-By participating, you are expected to uphold this code. Please report 
-unacceptable behavior to atom@github.com.
+See the docs [here](https://github.com/atom/atom-shell/tree/master/docs).
 
-## Downloads
+## License
 
-Prebuilt binaries and debug symbols of Electron for Linux, Windows and Mac can
-be found on the [releases](https://github.com/atom/electron/releases) page.
-
-You can also use [`npm`](https://docs.npmjs.com/) to install prebuilt electron
-binaries:
-
-```sh
-# Install the `electron` command globally in your $PATH
-npm install electron-prebuilt -g
-
-# Install as a development dependency
-npm install electron-prebuilt --save-dev
-```
-
-### Mirrors
-
-- [China](https://npm.taobao.org/mirrors/electron)
-
-## Documentation
-
-Guides and the API reference are located in the
-[docs](https://github.com/atom/electron/tree/master/docs) directory. It also
-contains documents describing how to build and contribute to Electron.
-
-## Documentation Translations
-
-- [Brazilian Portuguese](https://github.com/atom/electron/tree/master/docs-translations/pt-BR)
-- [Korean](https://github.com/atom/electron/tree/master/docs-translations/ko-KR)
-- [Japanese](https://github.com/atom/electron/tree/master/docs-translations/jp)
-- [Spanish](https://github.com/atom/electron/tree/master/docs-translations/es)
-- [Simplified Chinese](https://github.com/atom/electron/tree/master/docs-translations/zh-CN)
-- [Traditional Chinese](https://github.com/atom/electron/tree/master/docs-translations/zh-TW)
-
-## Community
-
-You can ask questions and interact with the community in the following 
-locations:
-- [`electron`](http://discuss.atom.io/category/electron) category on the Atom 
-forums
-- `#atom-shell` channel on Freenode
-- [`Atom`](http://atom-slack.herokuapp.com/) channel on Slack
-
-Check out [awesome-electron](https://github.com/sindresorhus/awesome-electron) 
-for a community maintained list of useful example apps, tools and resources.
+See the [`LICENSE`](LICENSE) file.

app/atom_library_main.cc

@@ -0,0 +1,15 @@
+// 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

@@ -0,0 +1,17 @@
+// 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

@@ -0,0 +1,83 @@
+// 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 <string.h>
+
+#include "content/public/app/content_main.h"
+
+namespace node {
+int Start(int argc, char *argv[]);
+}
+
+#if defined(OS_WIN)
+
+#include <windows.h>  // NOLINT
+#include <shellapi.h>  // NOLINT
+
+#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* cmd, int) {
+  int argc = 0;
+  wchar_t** wargv = ::CommandLineToArgvW(cmd, &argc);
+  if (argc > 1 && wcscmp(wargv[1], L"--atom-child_process-fork") == 0) {
+    // 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.
+    argv[1] = argv[0];
+    return node::Start(argc - 1, argv + 1);
+  }
+
+  sandbox::SandboxInterfaceInfo sandbox_info = {0};
+  content::InitializeSandboxInfo(&sandbox_info);
+  atom::AtomMainDelegate delegate;
+  return content::ContentMain(instance, &sandbox_info, &delegate);
+}
+
+#else  // defined(OS_WIN)
+
+#include "app/atom_library_main.h"
+
+int main(int argc, const char* argv[]) {
+  if (argc > 1 && strcmp(argv[1], "--atom-child_process-fork") == 0) {
+    argv[1] = argv[0];
+    return node::Start(argc - 1, const_cast<char**>(argv + 1));
+  }
+
+  return AtomMain(argc, argv);
+}
+
+#endif

app/atom_main_delegate.cc

@@ -0,0 +1,59 @@
+// 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

@@ -0,0 +1,34 @@
+// 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_

app/win/resource.h

@@ -1,10 +1,9 @@
 //{{NO_DEPENDENCIES}}
 // Microsoft Visual C++ generated include file.
-
-#define IDR_MAINFRAME 1
+// Used by brightray_example.rc
 
 // Next default values for new objects
-//
+// 
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
 #define _APS_NEXT_RESOURCE_VALUE        101

atom.gyp

@@ -1,34 +1,204 @@
 {
   'variables': {
-    'project_name%': 'electron',
-    'product_name%': 'Electron',
-    'company_name%': 'GitHub, Inc',
-    'company_abbr%': 'github',
-    'version%': '0.33.1',
-  },
-  'includes': [
-    'filenames.gypi',
-    'vendor/native_mate/native_mate_files.gypi',
-  ],
-  'target_defaults': {
-    'defines': [
-      'ATOM_PRODUCT_NAME="<(product_name)"',
-      'ATOM_PROJECT_NAME="<(project_name)"',
+    'project_name': 'atom',
+    'product_name': 'Atom',
+    'app_sources': [
+      'app/atom_main.cc',
+    ],
+    'bundle_sources': [
+      'browser/mac/atom.icns',
+    ],
+    'coffee_sources': [
+      'browser/api/lib/app.coffee',
+      'browser/api/lib/atom-delegate.coffee',
+      'browser/api/lib/auto-updater.coffee',
+      'browser/api/lib/browser-window.coffee',
+      'browser/api/lib/crash-reporter.coffee',
+      'browser/api/lib/dialog.coffee',
+      'browser/api/lib/ipc.coffee',
+      'browser/api/lib/menu.coffee',
+      'browser/api/lib/menu-item.coffee',
+      'browser/api/lib/power-monitor.coffee',
+      'browser/atom/atom.coffee',
+      'browser/atom/objects-registry.coffee',
+      'browser/atom/rpc-server.coffee',
+      'common/api/lib/callbacks-registry.coffee',
+      'common/api/lib/clipboard.coffee',
+      'common/api/lib/id-weak-map.coffee',
+      'common/api/lib/shell.coffee',
+      'renderer/api/lib/ipc.coffee',
+      'renderer/api/lib/remote.coffee',
+    ],
+    'lib_sources': [
+      'app/atom_main_delegate.cc',
+      'app/atom_main_delegate.h',
+      'browser/api/atom_api_app.cc',
+      'browser/api/atom_api_app.h',
+      'browser/api/atom_api_auto_updater.cc',
+      'browser/api/atom_api_auto_updater.h',
+      'browser/api/atom_api_browser_ipc.cc',
+      'browser/api/atom_api_browser_ipc.h',
+      'browser/api/atom_api_crash_reporter.h',
+      'browser/api/atom_api_crash_reporter.cc',
+      'browser/api/atom_api_dialog.cc',
+      'browser/api/atom_api_dialog.h',
+      'browser/api/atom_api_event.cc',
+      'browser/api/atom_api_event.h',
+      'browser/api/atom_api_event_emitter.cc',
+      'browser/api/atom_api_event_emitter.h',
+      'browser/api/atom_api_menu.cc',
+      'browser/api/atom_api_menu.h',
+      'browser/api/atom_api_menu_mac.h',
+      'browser/api/atom_api_menu_mac.mm',
+      'browser/api/atom_api_menu_win.cc',
+      'browser/api/atom_api_menu_win.h',
+      'browser/api/atom_api_power_monitor.cc',
+      'browser/api/atom_api_power_monitor.h',
+      'browser/api/atom_api_window.cc',
+      'browser/api/atom_api_window.h',
+      'browser/api/atom_browser_bindings.cc',
+      'browser/api/atom_browser_bindings.h',
+      'browser/auto_updater.cc',
+      'browser/auto_updater.h',
+      'browser/auto_updater_delegate.cc',
+      'browser/auto_updater_delegate.h',
+      'browser/auto_updater_mac.mm',
+      'browser/auto_updater_win.cc',
+      'browser/atom_application_mac.h',
+      'browser/atom_application_mac.mm',
+      'browser/atom_application_delegate_mac.h',
+      'browser/atom_application_delegate_mac.mm',
+      'browser/atom_browser_client.cc',
+      'browser/atom_browser_client.h',
+      'browser/atom_browser_context.cc',
+      'browser/atom_browser_context.h',
+      'browser/atom_browser_main_parts.cc',
+      'browser/atom_browser_main_parts.h',
+      'browser/atom_browser_main_parts_mac.mm',
+      'browser/atom_event_processing_window.h',
+      'browser/atom_event_processing_window.mm',
+      'browser/atom_javascript_dialog_manager.cc',
+      'browser/atom_javascript_dialog_manager.h',
+      'browser/browser.cc',
+      'browser/browser.h',
+      'browser/browser_mac.mm',
+      'browser/browser_win.cc',
+      'browser/browser_observer.h',
+      'browser/crash_reporter.h',
+      'browser/crash_reporter_mac.mm',
+      'browser/crash_reporter_win.cc',
+      'browser/native_window.cc',
+      'browser/native_window.h',
+      'browser/native_window_mac.h',
+      'browser/native_window_mac.mm',
+      'browser/native_window_win.cc',
+      'browser/native_window_win.h',
+      'browser/native_window_observer.h',
+      'browser/ui/accelerator_util.cc',
+      'browser/ui/accelerator_util.h',
+      'browser/ui/accelerator_util_mac.mm',
+      'browser/ui/accelerator_util_win.cc',
+      'browser/ui/atom_menu_controller_mac.h',
+      'browser/ui/atom_menu_controller_mac.mm',
+      'browser/ui/file_dialog.h',
+      'browser/ui/file_dialog_mac.mm',
+      'browser/ui/file_dialog_win.cc',
+      'browser/ui/message_box.h',
+      'browser/ui/message_box_mac.mm',
+      'browser/ui/message_box_win.cc',
+      'browser/ui/nsalert_synchronous_sheet_mac.h',
+      'browser/ui/nsalert_synchronous_sheet_mac.mm',
+      'browser/ui/win/menu_2.cc',
+      'browser/ui/win/menu_2.h',
+      'browser/ui/win/native_menu_win.cc',
+      'browser/ui/win/native_menu_win.h',
+      'browser/window_list.cc',
+      'browser/window_list.h',
+      'browser/window_list_observer.h',
+      'common/api/api_messages.cc',
+      'common/api/api_messages.h',
+      'common/api/atom_api_clipboard.cc',
+      'common/api/atom_api_clipboard.h',
+      'common/api/atom_api_id_weak_map.cc',
+      'common/api/atom_api_id_weak_map.h',
+      'common/api/atom_api_shell.cc',
+      'common/api/atom_api_shell.h',
+      'common/api/atom_api_v8_util.cc',
+      'common/api/atom_bindings.cc',
+      'common/api/atom_bindings.h',
+      'common/api/atom_extensions.cc',
+      'common/api/atom_extensions.h',
+      'common/api/object_life_monitor.cc',
+      'common/api/object_life_monitor.h',
+      'common/node_bindings.cc',
+      'common/node_bindings.h',
+      'common/node_bindings_mac.cc',
+      'common/node_bindings_mac.h',
+      'common/node_bindings_win.cc',
+      'common/node_bindings_win.h',
+      'common/options_switches.cc',
+      'common/options_switches.h',
+      'common/platform_util.h',
+      'common/platform_util_mac.mm',
+      'common/platform_util_win.cc',
+      'common/v8_value_converter_impl.cc',
+      'common/v8_value_converter_impl.h',
+      'renderer/api/atom_api_renderer_ipc.cc',
+      'renderer/api/atom_api_renderer_ipc.h',
+      'renderer/api/atom_renderer_bindings.cc',
+      'renderer/api/atom_renderer_bindings.h',
+      'renderer/atom_render_view_observer.cc',
+      'renderer/atom_render_view_observer.h',
+      'renderer/atom_renderer_client.cc',
+      'renderer/atom_renderer_client.h',
+    ],
+    'framework_sources': [
+      'app/atom_library_main.cc',
+      'app/atom_library_main.h',
     ],
     'conditions': [
-      ['OS=="mac"', {
-        'mac_framework_dirs': [
-          '<(source_root)/external_binaries',
+      ['OS=="win"', {
+        'app_sources': [
+          'app/win/resource.h',
+          'app/win/atom.rc',
+          '<(libchromiumcontent_src_dir)/content/app/startup_helper_win.cc',
         ],
-      }],
+      }],  # OS=="win"
     ],
+    'fix_framework_link_command': [
+      'install_name_tool',
+      '-change',
+      '@loader_path/../Frameworks/Sparkle.framework/Versions/A/Sparkle',
+      '@rpath/Sparkle.framework/Versions/A/Sparkle',
+      '-change',
+      '@executable_path/../Frameworks/Quincy.framework/Versions/A/Quincy',
+      '@rpath/Quincy.framework/Versions/A/Quincy',
+      '${BUILT_PRODUCTS_DIR}/${EXECUTABLE_PATH}'
+    ],
+    'atom_source_root': '<!(python tools/atom_source_root.py)',
+  },
+  'target_defaults': {
+    'mac_framework_dirs': [
+      '<(atom_source_root)/frameworks',
+    ],
+    'includes': [
+       # Rules for excluding e.g. foo_win.cc from the build on non-Windows.
+      'filename_rules.gypi',
+    ],
+    'configurations': {
+      'Debug': {
+        'defines': [
+          'DEBUG',
+        ],
+      },
+    },
   },
   'targets': [
     {
       'target_name': '<(project_name)',
       'type': 'executable',
       'dependencies': [
-        'compile_coffee',
+        'generated_sources',
         '<(project_name)_lib',
       ],
       'sources': [
@@ -49,8 +219,7 @@
             '<(project_name)_helper',
           ],
           'xcode_settings': {
-            'ATOM_BUNDLE_ID': 'com.<(company_abbr).<(project_name)',
-            'INFOPLIST_FILE': 'atom/browser/resources/mac/Info.plist',
+            'INFOPLIST_FILE': 'browser/mac/Info.plist',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@executable_path/../Frameworks',
             ],
@@ -63,20 +232,25 @@
               'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Frameworks',
               'files': [
                 '<(PRODUCT_DIR)/<(product_name) Helper.app',
-                '<(PRODUCT_DIR)/<(product_name) Framework.framework',
-                'external_binaries/Squirrel.framework',
-                'external_binaries/ReactiveCocoa.framework',
-                'external_binaries/Mantle.framework',
+                '<(PRODUCT_DIR)/<(product_name).framework',
+                'frameworks/Sparkle.framework',
+                'frameworks/Quincy.framework',
               ],
             },
             {
-              'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources',
+              'destination': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources/browser',
               'files': [
-                'atom/browser/default_app',
+                'browser/default_app',
               ],
             },
           ],
           'postbuilds': [
+            {
+              'postbuild_name': 'Fix Framework Link',
+              'action': [
+                '<@(fix_framework_link_command)',
+              ],
+            },
             {
               # This postbuid step is responsible for creating the following
               # helpers:
@@ -93,158 +267,42 @@
                 '<(product_name)',
               ],
             },
-              # The application doesn't have real localizations, it just has
-              # empty .lproj directories, which is enough to convince Cocoa
-              # atom-shell supports those languages.
-            {
-              'postbuild_name': 'Make Empty Localizations',
-              'variables': {
-                'apply_locales_cmd': ['python', 'tools/mac/apply_locales.py'],
-                'locale_dirs': [
-                  '>!@(<(apply_locales_cmd) -d ZZLOCALE.lproj <(locales))',
-                ],
-              },
-              'action': [
-                'tools/mac/make_locale_dirs.sh',
-                '<@(locale_dirs)',
-              ],
-            },
           ]
-        }, {  # OS=="mac"
-          'dependencies': [
-            'make_locale_paks',
-          ],
-        }],  # OS!="mac"
+        }],  # OS=="mac"
         ['OS=="win"', {
-          'include_dirs': [
-            '<(libchromiumcontent_dir)/gen/ui/resources',
-          ],
-          'msvs_settings': {
-            'VCManifestTool': {
-              'EmbedManifest': 'true',
-              'AdditionalManifestFiles': 'atom/browser/resources/win/atom.manifest',
-            }
-          },
           'copies': [
             {
-              'variables': {
-                'conditions': [
-                  ['libchromiumcontent_component', {
-                    'copied_libraries': [
-                      '<@(libchromiumcontent_shared_libraries)',
-                      '<@(libchromiumcontent_shared_v8_libraries)',
-                    ],
-                  }, {
-                    'copied_libraries': [
-                      '<(libchromiumcontent_dir)/pdf.dll',
-                    ],
-                  }],
-                ],
-              },
               'destination': '<(PRODUCT_DIR)',
               'files': [
-                '<@(copied_libraries)',
-                '<(libchromiumcontent_dir)/libEGL.dll',
-                '<(libchromiumcontent_dir)/libGLESv2.dll',
-                '<(libchromiumcontent_dir)/icudtl.dat',
-                '<(libchromiumcontent_dir)/content_resources_200_percent.pak',
-                '<(libchromiumcontent_dir)/content_shell.pak',
-                '<(libchromiumcontent_dir)/ui_resources_200_percent.pak',
-                '<(libchromiumcontent_dir)/natives_blob.bin',
-                '<(libchromiumcontent_dir)/snapshot_blob.bin',
-                'external_binaries/d3dcompiler_47.dll',
-                'external_binaries/xinput1_3.dll',
-                'external_binaries/msvcp120.dll',
-                'external_binaries/msvcr120.dll',
-                'external_binaries/vccorlib120.dll',
+                '<(libchromiumcontent_library_dir)/chromiumcontent.dll',
+                '<(libchromiumcontent_library_dir)/icudt.dll',
+                '<(libchromiumcontent_library_dir)/libGLESv2.dll',
+                '<(libchromiumcontent_resources_dir)/content_shell.pak',
               ],
             },
             {
-              'destination': '<(PRODUCT_DIR)/resources',
+              'destination': '<(PRODUCT_DIR)/resources/browser',
               'files': [
-                'atom/browser/default_app',
+                'browser/default_app',
               ]
             },
           ],
-        }, {
-          'dependencies': [
-            'vendor/breakpad/breakpad.gyp:dump_syms#host',
-          ],
         }],  # OS=="win"
-        ['OS=="linux"', {
-          'copies': [
-            {
-              'variables': {
-                'conditions': [
-                  ['libchromiumcontent_component', {
-                    'copied_libraries': [
-                      '<(PRODUCT_DIR)/lib/libnode.so',
-                      '<@(libchromiumcontent_shared_libraries)',
-                      '<@(libchromiumcontent_shared_v8_libraries)',
-                    ],
-                  }, {
-                    'copied_libraries': [
-                      '<(PRODUCT_DIR)/lib/libnode.so',
-                    ],
-                  }],
-                ],
-              },
-              'destination': '<(PRODUCT_DIR)',
-              'files': [
-                '<@(copied_libraries)',
-                '<(libchromiumcontent_dir)/icudtl.dat',
-                '<(libchromiumcontent_dir)/content_shell.pak',
-                '<(libchromiumcontent_dir)/natives_blob.bin',
-                '<(libchromiumcontent_dir)/snapshot_blob.bin',
-              ],
-            },
-            {
-              'destination': '<(PRODUCT_DIR)/resources',
-              'files': [
-                'atom/browser/default_app',
-              ]
-            },
-          ],
-        }],  # OS=="linux"
       ],
-    },  # target <(project_name)
+    },
     {
       'target_name': '<(project_name)_lib',
       'type': 'static_library',
       'dependencies': [
-        'atom_coffee2c',
         'vendor/brightray/brightray.gyp:brightray',
         'vendor/node/node.gyp:node',
       ],
-      'defines': [
-        # This is defined in skia/skia_common.gypi.
-        'SK_SUPPORT_LEGACY_GETTOPDEVICE',
-        # Disable warnings for g_settings_list_schemas.
-        'GLIB_DISABLE_DEPRECATION_WARNINGS',
-        # Defined in Chromium but not exposed in its gyp file.
-        'V8_USE_EXTERNAL_STARTUP_DATA',
-        'ENABLE_PLUGINS',
-      ],
       'sources': [
         '<@(lib_sources)',
       ],
       'include_dirs': [
         '.',
-        'chromium_src',
-        'vendor/brightray',
-        'vendor/native_mate',
-        # Include atom_natives.h.
-        '<(SHARED_INTERMEDIATE_DIR)',
-        # Include directories for uv and node.
-        'vendor/node/src',
-        'vendor/node/deps/http_parser',
-        'vendor/node/deps/uv/include',
-        # The `node.h` is using `#include"v8.h"`.
-        '<(libchromiumcontent_src_dir)/v8/include',
-        # The `node.h` is using `#include"ares.h"`.
-        'vendor/node/deps/cares/include',
-        # The `third_party/WebKit/Source/platform/weborigin/SchemeRegistry.h` is using `platform/PlatformExport.h`.
-        '<(libchromiumcontent_src_dir)/third_party/WebKit/Source',
+        'vendor',
       ],
       'direct_dependent_settings': {
         'include_dirs': [
@@ -255,125 +313,65 @@
         'vendor/brightray/brightray.gyp:brightray',
       ],
       'conditions': [
-        ['libchromiumcontent_component', {
-          'link_settings': {
-            'libraries': [ '<@(libchromiumcontent_v8_libraries)' ],
-          },
-        }],
         ['OS=="win"', {
-          'sources': [
-            '<@(lib_sources_win)',
-          ],
           'link_settings': {
             'libraries': [
               '-limm32.lib',
               '-loleacc.lib',
-              '-lcomctl32.lib',
-              '-lcomdlg32.lib',
-              '-lwininet.lib',
+              '-lComdlg32.lib',
+              '<(atom_source_root)/<(libchromiumcontent_library_dir)/chromiumviews.lib',
             ],
           },
-          'dependencies': [
-            # Node is built as static_library on Windows, so we also need to
-            # include its dependencies here.
-            'vendor/node/deps/cares/cares.gyp:cares',
-            'vendor/node/deps/http_parser/http_parser.gyp:http_parser',
-            'vendor/node/deps/uv/uv.gyp:libuv',
-            'vendor/node/deps/zlib/zlib.gyp:zlib',
-            # Build with breakpad support.
-            'vendor/breakpad/breakpad.gyp:breakpad_handler',
-            'vendor/breakpad/breakpad.gyp:breakpad_sender',
-          ],
-        }],  # OS=="win"
-        ['OS=="mac"', {
-          'dependencies': [
-            'vendor/crashpad/client/client.gyp:crashpad_client',
-            'vendor/crashpad/handler/handler.gyp:crashpad_handler',
-          ],
-        }],  # OS=="mac"
-        ['OS=="linux"', {
-          'link_settings': {
-            'ldflags': [
-              # Make binary search for libraries under current directory, so we
-              # don't have to manually set $LD_LIBRARY_PATH:
-              # http://serverfault.com/questions/279068/cant-find-so-in-the-same-directory-as-the-executable
-              '-rpath \$$ORIGIN',
-              # Make native module dynamic loading work.
-              '-rdynamic',
-            ],
-          },
-          # Required settings of using breakpad.
-          'cflags_cc': [
-            '-Wno-empty-body',
-            '-Wno-reserved-user-defined-literal',
-          ],
-          'include_dirs': [
-            'vendor/breakpad/src',
-          ],
-          'dependencies': [
-            'vendor/breakpad/breakpad.gyp:breakpad_client',
-          ],
-        }],  # OS=="linux"
+        }],
       ],
-    },  # target <(product_name)_lib
+    },
     {
-      'target_name': 'compile_coffee',
+      'target_name': 'generated_sources',
       'type': 'none',
-      'actions': [
-        {
-          'action_name': 'compile_coffee',
-          'variables': {
-            'conditions': [
-              ['OS=="mac"', {
-                'resources_path': '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources',
-              },{
-                'resources_path': '<(PRODUCT_DIR)/resources',
-              }],
-            ],
-          },
-          'inputs': [
-            '<@(coffee_sources)',
-          ],
-          'outputs': [
-            '<(resources_path)/atom.asar',
-          ],
-          'action': [
-            'python',
-            'tools/coffee2asar.py',
-            '<@(_outputs)',
-            '<@(_inputs)',
-          ],
-        }
+      'sources': [
+        '<@(coffee_sources)',
       ],
-    },  # target compile_coffee
-    {
-      'target_name': 'atom_coffee2c',
-      'type': 'none',
-      'actions': [
+      'rules': [
         {
-          'action_name': 'atom_coffee2c',
+          'rule_name': 'coffee',
+          'extension': 'coffee',
           'inputs': [
-            '<@(coffee2c_sources)',
+            'script/compile-coffee.py',
           ],
-          'outputs': [
-            '<(SHARED_INTERMEDIATE_DIR)/atom_natives.h',
+          'conditions': [
+            ['OS=="mac"', {
+              'outputs': [
+                '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
+              ],
+              'action': [
+                'python',
+                'script/compile-coffee.py',
+                '<(RULE_INPUT_PATH)',
+                '<(PRODUCT_DIR)/<(product_name).app/Contents/Resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
+              ],
+            }],  # OS=="mac"
+            ['OS=="win"', {
+              'outputs': [
+                '<(PRODUCT_DIR)/resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
+              ],
+              'action': [
+                'python',
+                'script/compile-coffee.py',
+                '<(RULE_INPUT_PATH)',
+                '<(PRODUCT_DIR)/resources/<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT).js',
+              ],
+            }],  # OS=="win"
           ],
-          'action': [
-            'python',
-            'tools/coffee2c.py',
-            '<@(_outputs)',
-            '<@(_inputs)',
-          ],
-        }
+        },
       ],
-    },  # target atom_coffee2c
+    },
   ],
   'conditions': [
     ['OS=="mac"', {
       'targets': [
         {
           'target_name': '<(project_name)_framework',
-          'product_name': '<(product_name) Framework',
+          'product_name': '<(product_name)',
           'type': 'shared_library',
           'dependencies': [
             '<(project_name)_lib',
@@ -384,7 +382,7 @@
           'include_dirs': [
             '.',
             'vendor',
-            '<(libchromiumcontent_src_dir)',
+            '<(libchromiumcontent_include_dir)',
           ],
           'export_dependent_settings': [
             '<(project_name)_lib',
@@ -392,24 +390,20 @@
           'link_settings': {
             'libraries': [
               '$(SDKROOT)/System/Library/Frameworks/Carbon.framework',
-              '$(SDKROOT)/System/Library/Frameworks/QuartzCore.framework',
-              'external_binaries/Squirrel.framework',
-              'external_binaries/ReactiveCocoa.framework',
-              'external_binaries/Mantle.framework',
+              'frameworks/Sparkle.framework',
+              'frameworks/Quincy.framework',
             ],
           },
           'mac_bundle': 1,
           'mac_bundle_resources': [
-            'atom/common/resources/mac/MainMenu.xib',
-            '<(libchromiumcontent_dir)/content_shell.pak',
-            '<(libchromiumcontent_dir)/icudtl.dat',
-            '<(libchromiumcontent_dir)/natives_blob.bin',
-            '<(libchromiumcontent_dir)/snapshot_blob.bin',
+            'browser/mac/MainMenu.xib',
+            '<(libchromiumcontent_resources_dir)/content_shell.pak',
           ],
           'xcode_settings': {
-            'ATOM_BUNDLE_ID': 'com.<(company_abbr).<(project_name).framework',
-            'INFOPLIST_FILE': 'atom/common/resources/mac/Info.plist',
-            'LD_DYLIB_INSTALL_NAME': '@rpath/<(product_name) Framework.framework/<(product_name) Framework',
+            'LIBRARY_SEARCH_PATHS': [
+              '<(libchromiumcontent_library_dir)',
+            ],
+            'LD_DYLIB_INSTALL_NAME': '@rpath/<(product_name).framework/<(product_name)',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@loader_path/Libraries',
             ],
@@ -419,60 +413,27 @@
           },
           'copies': [
             {
-              'variables': {
-                'conditions': [
-                  ['libchromiumcontent_component', {
-                    'copied_libraries': [
-                      '<(PRODUCT_DIR)/libnode.dylib',
-                      '<@(libchromiumcontent_shared_libraries)',
-                      '<@(libchromiumcontent_shared_v8_libraries)',
-                    ],
-                  }, {
-                    'copied_libraries': [
-                      '<(PRODUCT_DIR)/libnode.dylib',
-                    ],
-                  }],
-                ],
-              },
-              'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Libraries',
+              'destination': '<(PRODUCT_DIR)/<(product_name).framework/Versions/A/Libraries',
               'files': [
-                '<@(copied_libraries)',
-              ],
-            },
-            {
-              'destination': '<(PRODUCT_DIR)/<(product_name) Framework.framework/Versions/A/Resources',
-              'files': [
-                '<(PRODUCT_DIR)/crashpad_handler',
+                '<(libchromiumcontent_library_dir)/ffmpegsumo.so',
+                '<(libchromiumcontent_library_dir)/libchromiumcontent.dylib',
               ],
             },
           ],
           'postbuilds': [
             {
-              'postbuild_name': 'Fix path of libnode',
+              'postbuild_name': 'Fix Framework Link',
               'action': [
-                'install_name_tool',
-                '-change',
-                '/usr/local/lib/libnode.dylib',
-                '@rpath/libnode.dylib',
-                '${BUILT_PRODUCTS_DIR}/<(product_name) Framework.framework/Versions/A/<(product_name) Framework',
-              ],
-            },
-            {
-              'postbuild_name': 'Fix path of ffmpeg',
-              'action': [
-                'install_name_tool',
-                '-change',
-                '@loader_path/libffmpeg.dylib',
-                '@rpath/libffmpeg.dylib',
-                '${BUILT_PRODUCTS_DIR}/<(product_name) Framework.framework/Versions/A/<(product_name) Framework',
+                '<@(fix_framework_link_command)',
               ],
             },
             {
               'postbuild_name': 'Add symlinks for framework subdirectories',
               'action': [
                 'tools/mac/create-framework-subdir-symlinks.sh',
-                '<(product_name) Framework',
+                '<(product_name)',
                 'Libraries',
+                'Frameworks',
               ],
             },
           ],
@@ -492,39 +453,21 @@
           ],
           'mac_bundle': 1,
           'xcode_settings': {
-            'ATOM_BUNDLE_ID': 'com.<(company_abbr).<(project_name).helper',
-            'INFOPLIST_FILE': 'atom/renderer/resources/mac/Info.plist',
+            'INFOPLIST_FILE': 'renderer/mac/Info.plist',
             'LD_RUNPATH_SEARCH_PATHS': [
               '@executable_path/../../..',
             ],
           },
-        },  # target helper
-      ],
-    }, {  # OS=="mac"
-      'targets': [
-        {
-          'target_name': 'make_locale_paks',
-          'type': 'none',
-          'actions': [
+          'postbuilds': [
             {
-              'action_name': 'Make Empty Paks',
-              'inputs': [
-                'tools/make_locale_paks.py',
-              ],
-              'outputs': [
-                '<(PRODUCT_DIR)/locales'
-              ],
+              'postbuild_name': 'Fix Framework Link',
               'action': [
-                'python',
-                'tools/make_locale_paks.py',
-                '<(PRODUCT_DIR)',
-                '<@(locales)',
+                '<@(fix_framework_link_command)',
               ],
-              'msvs_cygwin_shell': 0,
             },
           ],
-        },
+        },  # target helper
       ],
-    }],  # OS!="mac"
+    }],  # OS==Mac
   ],
 }

atom/app/atom_content_client.cc

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

atom/app/atom_content_client.h

@@ -1,36 +0,0 @@
-// 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;
-  std::string GetUserAgent() const override;
-  void AddAdditionalSchemes(
-      std::vector<std::string>* standard_schemes,
-      std::vector<std::string>* savable_schemes) override;
-  void AddPepperPlugins(
-      std::vector<content::PepperPluginInfo>* plugins) override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AtomContentClient);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_APP_ATOM_CONTENT_CLIENT_H_

atom/app/atom_library_main.h

@@ -1,20 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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

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

atom/app/atom_main.cc

@@ -1,193 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/app/atom_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 "atom/common/atom_command_line.h"
-#include "base/at_exit.h"
-#include "base/i18n/icu_util.h"
-
-#if defined(OS_WIN)
-
-namespace {
-
-// Win8.1 supports monitor-specific DPI scaling.
-bool SetProcessDpiAwarenessWrapper(PROCESS_DPI_AWARENESS value) {
-  typedef HRESULT(WINAPI *SetProcessDpiAwarenessPtr)(PROCESS_DPI_AWARENESS);
-  SetProcessDpiAwarenessPtr set_process_dpi_awareness_func =
-      reinterpret_cast<SetProcessDpiAwarenessPtr>(
-          GetProcAddress(GetModuleHandleA("user32.dll"),
-                         "SetProcessDpiAwarenessInternal"));
-  if (set_process_dpi_awareness_func) {
-    HRESULT hr = set_process_dpi_awareness_func(value);
-    if (SUCCEEDED(hr)) {
-      VLOG(1) << "SetProcessDpiAwareness succeeded.";
-      return true;
-    } else if (hr == E_ACCESSDENIED) {
-      LOG(ERROR) << "Access denied error from SetProcessDpiAwareness. "
-          "Function called twice, or manifest was used.";
-    }
-  }
-  return false;
-}
-
-// This function works for Windows Vista through Win8. Win8.1 must use
-// SetProcessDpiAwareness[Wrapper].
-BOOL SetProcessDPIAwareWrapper() {
-  typedef BOOL(WINAPI *SetProcessDPIAwarePtr)(VOID);
-  SetProcessDPIAwarePtr set_process_dpi_aware_func =
-      reinterpret_cast<SetProcessDPIAwarePtr>(
-      GetProcAddress(GetModuleHandleA("user32.dll"),
-                      "SetProcessDPIAware"));
-  return set_process_dpi_aware_func &&
-    set_process_dpi_aware_func();
-}
-
-void EnableHighDPISupport() {
-  if (!SetProcessDpiAwarenessWrapper(PROCESS_SYSTEM_DPI_AWARE)) {
-    SetProcessDPIAwareWrapper();
-  }
-}
-
-}  // namespace
-
-int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
-  int argc = 0;
-  wchar_t** wargv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
-
-  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);
-  }
-
-  // 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);
-    }
-  }
-
-  std::string node_indicator, crash_service_indicator;
-  if (env->GetVar("ATOM_SHELL_INTERNAL_RUN_AS_NODE", &node_indicator) &&
-      node_indicator == "1") {
-    // Now that argv conversion is done, we can finally start.
-    base::AtExitManager atexit_manager;
-    base::i18n::InitializeICU();
-    return atom::NodeMain(argc, argv);
-  } else if (env->GetVar("ATOM_SHELL_INTERNAL_CRASH_SERVICE",
-                         &crash_service_indicator) &&
-      crash_service_indicator == "1") {
-    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;
-  atom::AtomCommandLine::Init(argc, argv);
-  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();
-    base::AtExitManager atexit_manager;
-    return atom::NodeMain(argc, const_cast<char**>(argv));
-  }
-
-  atom::AtomMainDelegate delegate;
-  content::ContentMainParams params(&delegate);
-  params.argc = argc;
-  params.argv = argv;
-  atom::AtomCommandLine::Init(argc, argv);
-  return content::ContentMain(params);
-}
-
-#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

@@ -1,10 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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

@@ -1,128 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/app/atom_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 "atom/utility/atom_content_utility_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
-  logging::LoggingSettings settings;
-#if defined(OS_WIN)
-#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  // defined(DEBUG)
-#else  // defined(OS_WIN)
-  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
-#endif  // !defined(OS_WIN)
-  logging::InitLogging(settings);
-
-  // Logging with pid and timestamp.
-  logging::SetLogItems(true, false, true, false);
-
-#if defined(DEBUG) && defined(OS_LINUX)
-  // Enable convient stack printing.
-  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);
-
-  if (process_type == switches::kUtilityProcess) {
-    AtomContentUtilityClient::PreSandboxStartup();
-  }
-
-  // Only append arguments for browser process.
-  if (!process_type.empty())
-    return;
-
-#if defined(OS_WIN)
-  // Disable the LegacyRenderWidgetHostHWND, it made frameless windows unable
-  // to move and resize. We may consider enabling it again after upgraded to
-  // Chrome 38, which should have fixed the problem.
-  command_line->AppendSwitch(switches::kDisableLegacyIntermediateWindow);
-#endif
-
-  // Disable renderer sandbox for most of node's functions.
-  command_line->AppendSwitch(switches::kNoSandbox);
-
-  // Allow file:// URIs to read other file:// URIs by default.
-  command_line->AppendSwitch(switches::kAllowFileAccessFromFiles);
-
-#if defined(OS_MACOSX)
-  // Enable AVFoundation.
-  command_line->AppendSwitch("enable-avfoundation");
-#endif
-}
-
-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();
-}
-
-content::ContentUtilityClient* AtomMainDelegate::CreateContentUtilityClient() {
-  utility_client_.reset(new AtomContentUtilityClient);
-  return utility_client_.get();
-}
-
-scoped_ptr<brightray::ContentClient> AtomMainDelegate::CreateContentClient() {
-  return scoped_ptr<brightray::ContentClient>(new AtomContentClient).Pass();
-}
-
-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

@@ -1,46 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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;
-  content::ContentUtilityClient* CreateContentUtilityClient() 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_;
-  scoped_ptr<content::ContentUtilityClient> utility_client_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomMainDelegate);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_APP_ATOM_MAIN_DELEGATE_H_

atom/app/atom_main_delegate_mac.mm

@@ -1,51 +0,0 @@
-// 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/files/file_util.h"
-#include "base/path_service.h"
-#include "brightray/common/application_info.h"
-#include "brightray/common/mac/main_application_bundle.h"
-#include "content/public/common/content_paths.h"
-
-namespace atom {
-
-namespace {
-
-base::FilePath GetFrameworksPath() {
-  return brightray::MainApplicationBundlePath().Append("Contents")
-                                               .Append("Frameworks");
-}
-
-base::FilePath GetHelperAppPath(const base::FilePath& frameworks_path,
-                                const std::string& name) {
-  return frameworks_path.Append(name + " Helper.app")
-                        .Append("Contents")
-                        .Append("MacOS")
-                        .Append(name + " Helper");
-}
-
-}  // namespace
-
-void AtomMainDelegate::OverrideFrameworkBundlePath() {
-  base::mac::SetOverrideFrameworkBundlePath(
-      GetFrameworksPath().Append(ATOM_PRODUCT_NAME " Framework.framework"));
-}
-
-void AtomMainDelegate::OverrideChildProcessPath() {
-  base::FilePath frameworks_path = GetFrameworksPath();
-  base::FilePath helper_path = GetHelperAppPath(frameworks_path,
-                                                ATOM_PRODUCT_NAME);
-  if (!base::PathExists(helper_path))
-    helper_path = GetHelperAppPath(frameworks_path,
-                                   brightray::GetApplicationName());
-  if (!base::PathExists(helper_path))
-    LOG(FATAL) << "Unable to find helper app";
-  PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
-}
-
-}  // namespace atom

atom/app/node_main.cc

@@ -1,77 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/app/node_main.h"
-
-#include "atom/app/uv_task_runner.h"
-#include "atom/browser/javascript_environment.h"
-#include "atom/browser/node_debugger.h"
-#include "atom/common/node_includes.h"
-#include "base/command_line.h"
-#include "base/thread_task_runner_handle.h"
-#include "gin/array_buffer.h"
-#include "gin/public/isolate_holder.h"
-#include "gin/v8_initializer.h"
-
-namespace atom {
-
-int NodeMain(int argc, char *argv[]) {
-  base::CommandLine::Init(argc, argv);
-
-  argv = uv_setup_args(argc, argv);
-  int exec_argc;
-  const char** exec_argv;
-  node::Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv);
-
-  int exit_code = 1;
-  {
-    // Feed gin::PerIsolateData with a task runner.
-    uv_loop_t* loop = uv_default_loop();
-    scoped_refptr<UvTaskRunner> uv_task_runner(new UvTaskRunner(loop));
-    base::ThreadTaskRunnerHandle handle(uv_task_runner);
-
-    gin::V8Initializer::LoadV8Snapshot();
-    gin::V8Initializer::LoadV8Natives();
-    gin::IsolateHolder::Initialize(
-        gin::IsolateHolder::kNonStrictMode,
-        gin::ArrayBufferAllocator::SharedInstance());
-
-    JavascriptEnvironment gin_env;
-    node::Environment* env = node::CreateEnvironment(
-        gin_env.isolate(), loop, gin_env.context(), argc, argv,
-        exec_argc, exec_argv);
-
-    // Start our custom debugger implementation.
-    NodeDebugger node_debugger(gin_env.isolate());
-    if (node_debugger.IsRunning())
-      env->AssignToContext(v8::Debug::GetDebugContext());
-
-    node::LoadEnvironment(env);
-
-    bool more;
-    do {
-      more = uv_run(env->event_loop(), UV_RUN_ONCE);
-      if (more == false) {
-        node::EmitBeforeExit(env);
-
-        // Emit `beforeExit` if the loop became alive either after emitting
-        // event, or after running some callbacks.
-        more = uv_loop_alive(env->event_loop());
-        if (uv_run(env->event_loop(), UV_RUN_NOWAIT) != 0)
-          more = true;
-      }
-    } while (more == true);
-
-    exit_code = node::EmitExit(env);
-    node::RunAtExit(env);
-
-    env->Dispose();
-  }
-
-  v8::V8::Dispose();
-
-  return exit_code;
-}
-
-}  // namespace atom

atom/app/node_main.h

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

atom/app/uv_task_runner.cc

@@ -1,55 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/app/uv_task_runner.h"
-
-#include "base/stl_util.h"
-
-namespace atom {
-
-UvTaskRunner::UvTaskRunner(uv_loop_t* loop) : loop_(loop) {
-}
-
-UvTaskRunner::~UvTaskRunner() {
-  for (auto& iter : tasks_) {
-    uv_unref(reinterpret_cast<uv_handle_t*>(iter.first));
-    delete iter.first;
-  }
-}
-
-bool UvTaskRunner::PostDelayedTask(const tracked_objects::Location& from_here,
-                                   const base::Closure& task,
-                                   base::TimeDelta delay) {
-  uv_timer_t* timer = new uv_timer_t;
-  timer->data = this;
-  uv_timer_init(loop_, timer);
-  uv_timer_start(timer, UvTaskRunner::OnTimeout, delay.InMilliseconds(), 0);
-  tasks_[timer] = task;
-  return true;
-}
-
-bool UvTaskRunner::RunsTasksOnCurrentThread() const {
-  return true;
-}
-
-bool UvTaskRunner::PostNonNestableDelayedTask(
-    const tracked_objects::Location& from_here,
-    const base::Closure& task,
-    base::TimeDelta delay) {
-  return PostDelayedTask(from_here, task, delay);;
-}
-
-// static
-void UvTaskRunner::OnTimeout(uv_timer_t* timer) {
-  UvTaskRunner* self = static_cast<UvTaskRunner*>(timer->data);
-  if (!ContainsKey(self->tasks_, timer))
-    return;
-
-  self->tasks_[timer].Run();
-  self->tasks_.erase(timer);
-  uv_unref(reinterpret_cast<uv_handle_t*>(timer));
-  delete timer;
-}
-
-}  // namespace atom

atom/app/uv_task_runner.h

@@ -1,44 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_APP_UV_TASK_RUNNER_H_
-#define ATOM_APP_UV_TASK_RUNNER_H_
-
-#include <map>
-
-#include "base/callback.h"
-#include "base/single_thread_task_runner.h"
-#include "vendor/node/deps/uv/include/uv.h"
-
-namespace atom {
-
-// TaskRunner implementation that posts tasks into libuv's default loop.
-class UvTaskRunner : public base::SingleThreadTaskRunner {
- public:
-  explicit UvTaskRunner(uv_loop_t* loop);
-  ~UvTaskRunner() override;
-
-  // base::SingleThreadTaskRunner:
-  bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const base::Closure& task,
-                       base::TimeDelta delay) override;
-  bool RunsTasksOnCurrentThread() const override;
-  bool PostNonNestableDelayedTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task,
-      base::TimeDelta delay) override;
-
- private:
-  static void OnTimeout(uv_timer_t* timer);
-
-  uv_loop_t* loop_;
-
-  std::map<uv_timer_t*, base::Closure> tasks_;
-
-  DISALLOW_COPY_AND_ASSIGN(UvTaskRunner);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_APP_UV_TASK_RUNNER_H_

atom/browser/api/atom_api_app.cc

@@ -1,354 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/atom_api_app.h"
-
-#include <string>
-#include <vector>
-
-#if defined(OS_WIN)
-#include <shlobj.h>
-#endif
-
-#include "atom/browser/api/atom_api_menu.h"
-#include "atom/browser/api/atom_api_session.h"
-#include "atom/browser/atom_browser_context.h"
-#include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/browser.h"
-#include "atom/browser/api/atom_api_web_contents.h"
-#include "atom/common/native_mate_converters/callback.h"
-#include "atom/common/native_mate_converters/file_path_converter.h"
-#include "atom/common/node_includes.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 "content/public/browser/client_certificate_delegate.h"
-#include "content/public/browser/gpu_data_manager.h"
-#include "native_mate/dictionary.h"
-#include "native_mate/object_template_builder.h"
-#include "net/ssl/ssl_cert_request_info.h"
-#include "ui/base/l10n/l10n_util.h"
-
-#if defined(OS_WIN)
-#include "base/strings/utf_string_conversions.h"
-#endif
-
-using atom::Browser;
-
-namespace mate {
-
-#if defined(OS_WIN)
-template<>
-struct Converter<Browser::UserTask> {
-  static bool FromV8(v8::Isolate* isolate, v8::Local<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
-
-template<>
-struct Converter<scoped_refptr<net::X509Certificate>> {
-  static v8::Local<v8::Value> ToV8(
-      v8::Isolate* isolate,
-      const scoped_refptr<net::X509Certificate>& val) {
-    mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    std::string encoded_data;
-    net::X509Certificate::GetPEMEncoded(
-        val->os_cert_handle(), &encoded_data);
-    dict.Set("data", encoded_data);
-    dict.Set("issuerName", val->issuer().GetDisplayName());
-    return dict.GetHandle();
-  }
-};
-
-}  // namespace mate
-
-
-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;
-}
-
-void OnClientCertificateSelected(
-    v8::Isolate* isolate,
-    std::shared_ptr<content::ClientCertificateDelegate> delegate,
-    mate::Arguments* args) {
-  v8::Locker locker(isolate);
-  v8::HandleScope handle_scope(isolate);
-  mate::Dictionary cert_data;
-  if (!(args->Length() == 1 && args->GetNext(&cert_data))) {
-    args->ThrowError();
-    return;
-  }
-
-  std::string encoded_data;
-  cert_data.Get("data", &encoded_data);
-
-  auto certs =
-      net::X509Certificate::CreateCertificateListFromBytes(
-          encoded_data.data(), encoded_data.size(),
-          net::X509Certificate::FORMAT_AUTO);
-
-  delegate->ContinueWithCertificate(certs[0].get());
-}
-
-}  // namespace
-
-App::App() {
-  Browser::Get()->AddObserver(this);
-  content::GpuDataManager::GetInstance()->AddObserver(this);
-}
-
-App::~App() {
-  Browser::Get()->RemoveObserver(this);
-  content::GpuDataManager::GetInstance()->RemoveObserver(this);
-}
-
-void App::OnBeforeQuit(bool* prevent_default) {
-  *prevent_default = Emit("before-quit");
-}
-
-void App::OnWillQuit(bool* prevent_default) {
-  *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::OnActivate(bool has_visible_windows) {
-  Emit("activate", has_visible_windows);
-}
-
-void App::OnWillFinishLaunching() {
-  Emit("will-finish-launching");
-}
-
-void App::OnFinishLaunching() {
-  // Create the defaultSession.
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  auto browser_context = static_cast<AtomBrowserContext*>(
-      AtomBrowserMainParts::Get()->browser_context());
-  auto handle = Session::CreateFrom(isolate(), browser_context);
-  default_session_.Reset(isolate(), handle.ToV8());
-
-  Emit("ready");
-}
-
-void App::OnSelectCertificate(
-    content::WebContents* web_contents,
-    net::SSLCertRequestInfo* cert_request_info,
-    scoped_ptr<content::ClientCertificateDelegate> delegate) {
-  std::shared_ptr<content::ClientCertificateDelegate>
-      shared_delegate(delegate.release());
-  bool prevent_default =
-      Emit("select-certificate",
-           api::WebContents::CreateFrom(isolate(), web_contents),
-           cert_request_info->host_and_port.ToString(),
-           cert_request_info->client_certs,
-           base::Bind(&OnClientCertificateSelected,
-                      isolate(),
-                      shared_delegate));
-
-  // Default to first certificate from the platform store.
-  if (!prevent_default)
-    shared_delegate->ContinueWithCertificate(
-        cert_request_info->client_certs[0].get());
-}
-
-void App::OnGpuProcessCrashed(base::TerminationStatus exit_code) {
-  Emit("gpu-process-crashed");
-}
-
-base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
-  bool succeed = false;
-  base::FilePath path;
-  int key = GetPathConstant(name);
-  if (key >= 0)
-    succeed = PathService::Get(key, &path);
-  if (!succeed)
-    args->ThrowError("Failed to get path");
-  return path;
-}
-
-void App::SetPath(mate::Arguments* args,
-                  const std::string& name,
-                  const base::FilePath& path) {
-  bool succeed = false;
-  int key = GetPathConstant(name);
-  if (key >= 0)
-    succeed = PathService::Override(key, path);
-  if (!succeed)
-    args->ThrowError("Failed to set path");
-}
-
-void App::SetDesktopName(const std::string& desktop_name) {
-#if defined(OS_LINUX)
-  scoped_ptr<base::Environment> env(base::Environment::Create());
-  env->SetVar("CHROME_DESKTOP", desktop_name);
-#endif
-}
-
-void App::SetAppUserModelId(const std::string& app_id) {
-#if defined(OS_WIN)
-  base::string16 app_id_utf16 = base::UTF8ToUTF16(app_id);
-  SetCurrentProcessExplicitAppUserModelID(app_id_utf16.c_str());
-#endif
-}
-
-std::string App::GetLocale() {
-  return l10n_util::GetApplicationLocale("");
-}
-
-v8::Local<v8::Value> App::DefaultSession(v8::Isolate* isolate) {
-  if (default_session_.IsEmpty())
-    return v8::Null(isolate);
-  else
-    return v8::Local<v8::Value>::New(isolate, default_session_);
-}
-
-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("setDesktopName", &App::SetDesktopName)
-      .SetMethod("setAppUserModelId", &App::SetAppUserModelId)
-      .SetMethod("getLocale", &App::GetLocale)
-      .SetProperty("defaultSession", &App::DefaultSession);
-}
-
-// 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::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<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

@@ -1,80 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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 "content/public/browser/gpu_data_manager_observer.h"
-#include "native_mate/handle.h"
-
-namespace base {
-class FilePath;
-}
-
-namespace mate {
-class Arguments;
-}
-
-namespace atom {
-
-namespace api {
-
-class App : public mate::EventEmitter,
-            public BrowserObserver,
-            public content::GpuDataManagerObserver {
- public:
-  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 OnActivate(bool has_visible_windows) override;
-  void OnWillFinishLaunching() override;
-  void OnFinishLaunching() override;
-  void OnSelectCertificate(
-      content::WebContents* web_contents,
-      net::SSLCertRequestInfo* cert_request_info,
-      scoped_ptr<content::ClientCertificateDelegate> delegate) override;
-
-  // content::GpuDataManagerObserver:
-  void OnGpuProcessCrashed(base::TerminationStatus exit_code) override;
-
-  // mate::Wrappable:
-  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) override;
-
- private:
-  // Get/Set the pre-defined path in PathService.
-  base::FilePath GetPath(mate::Arguments* args, const std::string& name);
-  void SetPath(mate::Arguments* args,
-               const std::string& name,
-               const base::FilePath& path);
-
-  void SetDesktopName(const std::string& desktop_name);
-  void SetAppUserModelId(const std::string& app_id);
-  std::string GetLocale();
-  v8::Local<v8::Value> DefaultSession(v8::Isolate* isolate);
-
-  v8::Global<v8::Value> default_session_;
-
-  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

@@ -1,88 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/atom_api_auto_updater.h"
-
-#include "base/time/time.h"
-#include "atom/browser/auto_updater.h"
-#include "atom/browser/browser.h"
-#include "atom/common/node_includes.h"
-#include "native_mate/dictionary.h"
-#include "native_mate/object_template_builder.h"
-
-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::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  v8::Isolate* isolate = context->GetIsolate();
-  mate::Dictionary dict(isolate, exports);
-  dict.Set("autoUpdater", atom::api::AutoUpdater::Create(isolate));
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_auto_updater, Initialize)

atom/browser/api/atom_api_auto_updater.h

@@ -1,56 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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

@@ -1,90 +0,0 @@
-// 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/callback.h"
-#include "atom/common/native_mate_converters/file_path_converter.h"
-#include "atom/common/node_includes.h"
-#include "base/bind.h"
-#include "base/files/file_util.h"
-#include "content/public/browser/tracing_controller.h"
-#include "native_mate/dictionary.h"
-
-using content::TracingController;
-
-namespace mate {
-
-template<>
-struct Converter<base::trace_event::TraceConfig> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     base::trace_event::TraceConfig* out) {
-    Dictionary options;
-    if (!ConvertFromV8(isolate, val, &options))
-      return false;
-    std::string category_filter, trace_options;
-    if (!options.Get("categoryFilter", &category_filter) ||
-        !options.Get("traceOptions", &trace_options))
-      return false;
-    *out = base::trace_event::TraceConfig(category_filter, trace_options);
-    return true;
-  }
-};
-
-}  // namespace mate
-
-namespace {
-
-using CompletionCallback = base::Callback<void(const base::FilePath&)>;
-
-scoped_refptr<TracingController::TraceDataSink> GetTraceDataSink(
-    const base::FilePath& path, const CompletionCallback& callback) {
-  base::FilePath result_file_path = path;
-  if (result_file_path.empty() && !base::CreateTemporaryFile(&result_file_path))
-    LOG(ERROR) << "Creating temporary file failed";
-
-  return TracingController::CreateFileSink(result_file_path,
-                                           base::Bind(callback,
-                                                      result_file_path));
-}
-
-void StopRecording(const base::FilePath& path,
-                   const CompletionCallback& callback) {
-  TracingController::GetInstance()->DisableRecording(
-      GetTraceDataSink(path, callback));
-}
-
-void CaptureMonitoringSnapshot(const base::FilePath& path,
-                               const CompletionCallback& callback) {
-  TracingController::GetInstance()->CaptureMonitoringSnapshot(
-      GetTraceDataSink(path, callback));
-}
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  auto controller = base::Unretained(TracingController::GetInstance());
-  mate::Dictionary dict(context->GetIsolate(), exports);
-  dict.SetMethod("getCategories", base::Bind(
-      &TracingController::GetCategories, controller));
-  dict.SetMethod("startRecording", base::Bind(
-      &TracingController::EnableRecording, controller));
-  dict.SetMethod("stopRecording", &StopRecording);
-  dict.SetMethod("startMonitoring", base::Bind(
-      &TracingController::EnableMonitoring, controller));
-  dict.SetMethod("stopMonitoring", base::Bind(
-      &TracingController::DisableMonitoring, controller));
-  dict.SetMethod("captureMonitoringSnapshot", &CaptureMonitoringSnapshot);
-  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_cookies.cc

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

atom/browser/api/atom_api_cookies.h

@@ -1,90 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_API_ATOM_API_COOKIES_H_
-#define ATOM_BROWSER_API_ATOM_API_COOKIES_H_
-
-#include <string>
-
-#include "base/callback.h"
-#include "native_mate/wrappable.h"
-#include "native_mate/handle.h"
-#include "net/cookies/canonical_cookie.h"
-
-namespace base {
-class DictionaryValue;
-}
-
-namespace content {
-class BrowserContext;
-}
-
-namespace mate {
-class Dictionary;
-}
-
-namespace net {
-class CookieStore;
-class URLRequestContextGetter;
-}
-
-namespace atom {
-
-namespace api {
-
-class Cookies : public mate::Wrappable {
- public:
-  // node.js style callback function(error, result)
-  typedef base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>
-      CookiesCallback;
-
-  static mate::Handle<Cookies> Create(v8::Isolate* isolate,
-                                      content::BrowserContext* browser_context);
-
- protected:
-  explicit Cookies(content::BrowserContext* browser_context);
-  ~Cookies();
-
-  void Get(const base::DictionaryValue& options,
-           const CookiesCallback& callback);
-  void Remove(const mate::Dictionary& details,
-              const CookiesCallback& callback);
-  void Set(const base::DictionaryValue& details,
-           const CookiesCallback& callback);
-
-  void GetCookiesOnIOThread(scoped_ptr<base::DictionaryValue> filter,
-                            const CookiesCallback& callback);
-  void OnGetCookies(scoped_ptr<base::DictionaryValue> filter,
-                    const CookiesCallback& callback,
-                    const net::CookieList& cookie_list);
-
-  void RemoveCookiesOnIOThread(const GURL& url,
-                               const std::string& name,
-                               const CookiesCallback& callback);
-  void OnRemoveCookies(const CookiesCallback& callback);
-
-  void SetCookiesOnIOThread(scoped_ptr<base::DictionaryValue> details,
-                            const GURL& url,
-                            const CookiesCallback& callback);
-  void OnSetCookies(const CookiesCallback& callback,
-                    bool set_success);
-
-  // mate::Wrappable:
-  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) override;
-
- private:
-  // Must be called on IO thread.
-  net::CookieStore* GetCookieStore();
-
-  net::URLRequestContextGetter* request_context_getter_;
-
-  DISALLOW_COPY_AND_ASSIGN(Cookies);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_COOKIES_H_

atom/browser/api/atom_api_dialog.cc

@@ -1,118 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include <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/callback.h"
-#include "atom/common/native_mate_converters/file_path_converter.h"
-#include "atom/common/native_mate_converters/image_converter.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::Local<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,
-                    int cancel_id,
-                    int options,
-                    const std::string& title,
-                    const std::string& message,
-                    const std::string& detail,
-                    const gfx::ImageSkia& icon,
-                    atom::NativeWindow* window,
-                    mate::Arguments* args) {
-  v8::Local<v8::Value> peek = args->PeekNext();
-  atom::MessageBoxCallback callback;
-  if (mate::Converter<atom::MessageBoxCallback>::FromV8(args->isolate(),
-                                                        peek,
-                                                        &callback)) {
-    atom::ShowMessageBox(window, (atom::MessageBoxType)type, buttons, cancel_id,
-                         options, title, message, detail, icon, callback);
-  } else {
-    int chosen = atom::ShowMessageBox(window, (atom::MessageBoxType)type,
-                                      buttons, cancel_id, options, 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::Local<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::Local<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::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  mate::Dictionary dict(context->GetIsolate(), exports);
-  dict.SetMethod("showMessageBox", &ShowMessageBox);
-  dict.SetMethod("showErrorBox", &atom::ShowErrorBox);
-  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

@@ -1,98 +0,0 @@
-// 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 "atom/common/native_mate_converters/callback.h"
-#include "base/stl_util.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::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  v8::Isolate* isolate = context->GetIsolate();
-  mate::Dictionary dict(isolate, exports);
-  dict.Set("globalShortcut", atom::api::GlobalShortcut::Create(isolate));
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_global_shortcut, Initialize)

atom/browser/api/atom_api_global_shortcut.h

@@ -1,55 +0,0 @@
-// 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

@@ -1,199 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/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/callback.h"
-#include "atom/common/native_mate_converters/image_converter.h"
-#include "atom/common/native_mate_converters/string16_converter.h"
-#include "native_mate/constructor.h"
-#include "native_mate/dictionary.h"
-#include "native_mate/object_template_builder.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace api {
-
-Menu::Menu()
-    : model_(new AtomMenuModel(this)),
-      parent_(NULL) {
-}
-
-Menu::~Menu() {
-}
-
-void Menu::AfterInit(v8::Isolate* isolate) {
-  mate::Dictionary wrappable(isolate, GetWrapper(isolate));
-  mate::Dictionary delegate;
-  if (!wrappable.Get("delegate", &delegate))
-    return;
-
-  delegate.Get("isCommandIdChecked", &is_checked_);
-  delegate.Get("isCommandIdEnabled", &is_enabled_);
-  delegate.Get("isCommandIdVisible", &is_visible_);
-  delegate.Get("getAcceleratorForCommandId", &get_accelerator_);
-  delegate.Get("executeCommand", &execute_command_);
-  delegate.Get("menuWillShow", &menu_will_show_);
-}
-
-bool Menu::IsCommandIdChecked(int command_id) const {
-  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::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  v8::Local<v8::Value> val = get_accelerator_.Run(command_id);
-  return mate::ConvertFromV8(isolate(), val, accelerator);
-}
-
-void Menu::ExecuteCommand(int command_id, int event_flags) {
-  execute_command_.Run(command_id);
-}
-
-void Menu::MenuWillShow(ui::SimpleMenuModel* source) {
-  menu_will_show_.Run();
-}
-
-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::SetRole(int index, const base::string16& role) {
-  model_->SetRole(index, role);
-}
-
-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::Local<v8::ObjectTemplate> prototype) {
-  mate::ObjectTemplateBuilder(isolate, prototype)
-      .SetMethod("insertItem", &Menu::InsertItemAt)
-      .SetMethod("insertCheckItem", &Menu::InsertCheckItemAt)
-      .SetMethod("insertRadioItem", &Menu::InsertRadioItemAt)
-      .SetMethod("insertSeparator", &Menu::InsertSeparatorAt)
-      .SetMethod("insertSubMenu", &Menu::InsertSubMenuAt)
-      .SetMethod("setIcon", &Menu::SetIcon)
-      .SetMethod("setSublabel", &Menu::SetSublabel)
-      .SetMethod("setRole", &Menu::SetRole)
-      .SetMethod("clear", &Menu::Clear)
-      .SetMethod("getIndexOfCommandId", &Menu::GetIndexOfCommandId)
-      .SetMethod("getItemCount", &Menu::GetItemCount)
-      .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("_popup", &Menu::Popup)
-      .SetMethod("_popupAt", &Menu::PopupAt);
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-
-namespace {
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  using atom::api::Menu;
-  v8::Isolate* isolate = context->GetIsolate();
-  v8::Local<v8::Function> constructor = mate::CreateConstructor<Menu>(
-      isolate, "Menu", base::Bind(&Menu::Create));
-  mate::Dictionary dict(isolate, exports);
-  dict.Set("Menu", static_cast<v8::Local<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

@@ -1,125 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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 "atom/browser/ui/atom_menu_model.h"
-#include "base/callback.h"
-#include "base/memory/scoped_ptr.h"
-#include "native_mate/wrappable.h"
-
-namespace atom {
-
-namespace api {
-
-class Menu : public mate::Wrappable,
-             public AtomMenuModel::Delegate {
- public:
-  static mate::Wrappable* Create();
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<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
-
-  AtomMenuModel* model() const { return model_.get(); }
-
- protected:
-  Menu();
-  virtual ~Menu();
-
-  // mate::Wrappable:
-  void AfterInit(v8::Isolate* isolate) override;
-
-  // ui::SimpleMenuModel::Delegate:
-  bool IsCommandIdChecked(int command_id) const override;
-  bool IsCommandIdEnabled(int command_id) const override;
-  bool IsCommandIdVisible(int command_id) const override;
-  bool GetAcceleratorForCommandId(int command_id,
-                                  ui::Accelerator* accelerator) override;
-  void ExecuteCommand(int command_id, int event_flags) override;
-  void MenuWillShow(ui::SimpleMenuModel* source) override;
-
-  virtual void Popup(Window* window) = 0;
-  virtual void PopupAt(Window* window, int x, int y) = 0;
-
-  scoped_ptr<AtomMenuModel> 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 SetRole(int index, const base::string16& role);
-  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::Local<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
-
-
-namespace mate {
-
-template<>
-struct Converter<atom::AtomMenuModel*> {
-  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
-                     atom::AtomMenuModel** out) {
-    // null would be tranfered to NULL.
-    if (val->IsNull()) {
-      *out = nullptr;
-      return true;
-    }
-
-    atom::api::Menu* menu;
-    if (!Converter<atom::api::Menu*>::FromV8(isolate, val, &menu))
-      return false;
-    *out = menu->model();
-    return true;
-  }
-};
-
-}  // namespace mate
-
-#endif  // ATOM_BROWSER_API_ATOM_API_MENU_H_

atom/browser/api/atom_api_menu_mac.h

@@ -1,39 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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

@@ -1,96 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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->web_contents();
-  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->web_contents();
-  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

@@ -1,57 +0,0 @@
-// 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->web_contents();
-  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

@@ -1,33 +0,0 @@
-// 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

@@ -1,73 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/atom_api_power_monitor.h"
-
-#include "atom/browser/browser.h"
-#include "atom/common/node_includes.h"
-#include "base/power_monitor/power_monitor.h"
-#include "base/power_monitor/power_monitor_device_source.h"
-#include "native_mate/dictionary.h"
-
-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
-v8::Local<v8::Value> PowerMonitor::Create(v8::Isolate* isolate) {
-  if (!Browser::Get()->is_ready()) {
-    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
-        isolate,
-        "Cannot initialize \"power-monitor\" module before app is ready")));
-    return v8::Null(isolate);
-  }
-
-  return CreateHandle(isolate, new PowerMonitor).ToV8();
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-
-namespace {
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-#if defined(OS_MACOSX)
-  base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
-#endif
-
-  using atom::api::PowerMonitor;
-  v8::Isolate* isolate = context->GetIsolate();
-  mate::Dictionary dict(isolate, exports);
-  dict.Set("powerMonitor", PowerMonitor::Create(isolate));
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_power_monitor, Initialize)

atom/browser/api/atom_api_power_monitor.h

@@ -1,39 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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 v8::Local<v8::Value> 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_power_save_blocker.cc

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

atom/browser/api/atom_api_power_save_blocker.h

@@ -1,59 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_API_ATOM_API_POWER_SAVE_BLOCKER_H_
-#define ATOM_BROWSER_API_ATOM_API_POWER_SAVE_BLOCKER_H_
-
-#include <map>
-
-#include "base/memory/scoped_ptr.h"
-#include "content/public/browser/power_save_blocker.h"
-#include "native_mate/handle.h"
-#include "native_mate/wrappable.h"
-
-namespace mate {
-class Dictionary;
-}
-
-namespace atom {
-
-namespace api {
-
-class PowerSaveBlocker : public mate::Wrappable {
- public:
-  static mate::Handle<PowerSaveBlocker> Create(v8::Isolate* isolate);
-
- protected:
-  PowerSaveBlocker();
-  virtual ~PowerSaveBlocker();
-
-  // mate::Wrappable implementations:
-  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) override;
-
- private:
-  void UpdatePowerSaveBlocker();
-  int Start(content::PowerSaveBlocker::PowerSaveBlockerType type);
-  bool Stop(int id);
-  bool IsStarted(int id);
-
-  scoped_ptr<content::PowerSaveBlocker> power_save_blocker_;
-
-  // Currnet blocker type used by |power_save_blocker_|
-  content::PowerSaveBlocker::PowerSaveBlockerType current_blocker_type_;
-
-  // Map from id to the corresponding blocker type for each request.
-  using PowerSaveBlockerTypeMap =
-      std::map<int, content::PowerSaveBlocker::PowerSaveBlockerType>;
-  PowerSaveBlockerTypeMap power_save_blocker_types_;
-
-
-  DISALLOW_COPY_AND_ASSIGN(PowerSaveBlocker);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_POWER_SAVE_BLOCKER_H_

atom/browser/api/atom_api_protocol.cc

@@ -1,181 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/atom_api_protocol.h"
-
-#include "atom/browser/atom_browser_client.h"
-#include "atom/browser/atom_browser_context.h"
-#include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/net/url_request_async_asar_job.h"
-#include "atom/browser/net/url_request_buffer_job.h"
-#include "atom/browser/net/url_request_fetch_job.h"
-#include "atom/browser/net/url_request_string_job.h"
-#include "atom/common/native_mate_converters/callback.h"
-#include "atom/common/node_includes.h"
-#include "native_mate/dictionary.h"
-
-using content::BrowserThread;
-
-namespace mate {
-
-template<>
-struct Converter<const net::URLRequest*> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const net::URLRequest* val) {
-    return mate::ObjectTemplateBuilder(isolate)
-        .SetValue("method", val->method())
-        .SetValue("url", val->url().spec())
-        .SetValue("referrer", val->referrer())
-        .Build()->NewInstance();
-  }
-};
-
-}  // namespace mate
-
-namespace atom {
-
-namespace api {
-
-Protocol::Protocol(AtomBrowserContext* browser_context)
-    : request_context_getter_(browser_context->GetRequestContext()),
-      job_factory_(browser_context->job_factory()) {
-  CHECK(job_factory_);
-}
-
-mate::ObjectTemplateBuilder Protocol::GetObjectTemplateBuilder(
-    v8::Isolate* isolate) {
-  return mate::ObjectTemplateBuilder(isolate)
-      .SetMethod("registerStandardSchemes", &Protocol::RegisterStandardSchemes)
-      .SetMethod("registerStringProtocol",
-                 &Protocol::RegisterProtocol<URLRequestStringJob>)
-      .SetMethod("registerBufferProtocol",
-                 &Protocol::RegisterProtocol<URLRequestBufferJob>)
-      .SetMethod("registerFileProtocol",
-                 &Protocol::RegisterProtocol<UrlRequestAsyncAsarJob>)
-      .SetMethod("registerHttpProtocol",
-                 &Protocol::RegisterProtocol<URLRequestFetchJob>)
-      .SetMethod("unregisterProtocol", &Protocol::UnregisterProtocol)
-      .SetMethod("isProtocolHandled", &Protocol::IsProtocolHandled)
-      .SetMethod("interceptStringProtocol",
-                 &Protocol::InterceptProtocol<URLRequestStringJob>)
-      .SetMethod("interceptBufferProtocol",
-                 &Protocol::InterceptProtocol<URLRequestBufferJob>)
-      .SetMethod("interceptFileProtocol",
-                 &Protocol::InterceptProtocol<UrlRequestAsyncAsarJob>)
-      .SetMethod("interceptHttpProtocol",
-                 &Protocol::InterceptProtocol<URLRequestFetchJob>)
-      .SetMethod("uninterceptProtocol", &Protocol::UninterceptProtocol);
-}
-
-void Protocol::RegisterStandardSchemes(
-    const std::vector<std::string>& schemes) {
-  atom::AtomBrowserClient::SetCustomSchemes(schemes);
-}
-
-void Protocol::UnregisterProtocol(
-    const std::string& scheme, mate::Arguments* args) {
-  CompletionCallback callback;
-  args->GetNext(&callback);
-  content::BrowserThread::PostTaskAndReplyWithResult(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::UnregisterProtocolInIO,
-                 base::Unretained(this), scheme),
-      base::Bind(&Protocol::OnIOCompleted,
-                 base::Unretained(this), callback));
-}
-
-Protocol::ProtocolError Protocol::UnregisterProtocolInIO(
-    const std::string& scheme) {
-  if (!job_factory_->HasProtocolHandler(scheme))
-    return PROTOCOL_NOT_REGISTERED;
-  job_factory_->SetProtocolHandler(scheme, nullptr);
-  return PROTOCOL_OK;
-}
-
-void Protocol::IsProtocolHandled(const std::string& scheme,
-                                    const BooleanCallback& callback) {
-  content::BrowserThread::PostTaskAndReplyWithResult(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::IsProtocolHandledInIO,
-                 base::Unretained(this), scheme),
-      callback);
-}
-
-bool Protocol::IsProtocolHandledInIO(const std::string& scheme) {
-  return job_factory_->IsHandledProtocol(scheme);
-}
-
-void Protocol::UninterceptProtocol(
-    const std::string& scheme, mate::Arguments* args) {
-  CompletionCallback callback;
-  args->GetNext(&callback);
-  content::BrowserThread::PostTaskAndReplyWithResult(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&Protocol::UninterceptProtocolInIO,
-                 base::Unretained(this), scheme),
-      base::Bind(&Protocol::OnIOCompleted,
-                 base::Unretained(this), callback));
-}
-
-Protocol::ProtocolError Protocol::UninterceptProtocolInIO(
-    const std::string& scheme) {
-  if (!original_protocols_.contains(scheme))
-    return PROTOCOL_NOT_INTERCEPTED;
-  job_factory_->ReplaceProtocol(scheme,
-                                original_protocols_.take_and_erase(scheme));
-  return PROTOCOL_OK;
-}
-
-void Protocol::OnIOCompleted(
-    const CompletionCallback& callback, ProtocolError error) {
-  // The completion callback is optional.
-  if (callback.is_null())
-    return;
-
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-
-  if (error == PROTOCOL_OK) {
-    callback.Run(v8::Null(isolate()));
-  } else {
-    std::string str = ErrorCodeToString(error);
-    callback.Run(v8::Exception::Error(mate::StringToV8(isolate(), str)));
-  }
-}
-
-std::string Protocol::ErrorCodeToString(ProtocolError error) {
-  switch (error) {
-    case PROTOCOL_FAIL: return "Failed to manipulate protocol factory";
-    case PROTOCOL_REGISTERED: return "The scheme has been registred";
-    case PROTOCOL_NOT_REGISTERED: return "The scheme has not been registred";
-    case PROTOCOL_INTERCEPTED: return "The scheme has been intercepted";
-    case PROTOCOL_NOT_INTERCEPTED: return "The scheme has not been intercepted";
-    default: return "Unexpected error";
-  }
-}
-
-// static
-mate::Handle<Protocol> Protocol::Create(
-    v8::Isolate* isolate, AtomBrowserContext* browser_context) {
-  return mate::CreateHandle(isolate, new Protocol(browser_context));
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-namespace {
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  v8::Isolate* isolate = context->GetIsolate();
-  mate::Dictionary dict(isolate, exports);
-  auto browser_context = static_cast<atom::AtomBrowserContext*>(
-      atom::AtomBrowserMainParts::Get()->browser_context());
-  dict.Set("protocol", atom::api::Protocol::Create(isolate, browser_context));
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_protocol, Initialize)

atom/browser/api/atom_api_protocol.h

@@ -1,192 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
-#define ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_
-
-#include <string>
-#include <map>
-#include <vector>
-
-#include "atom/browser/net/atom_url_request_job_factory.h"
-#include "base/callback.h"
-#include "base/containers/scoped_ptr_hash_map.h"
-#include "content/public/browser/browser_thread.h"
-#include "native_mate/arguments.h"
-#include "native_mate/dictionary.h"
-#include "native_mate/handle.h"
-#include "native_mate/wrappable.h"
-
-namespace net {
-class URLRequest;
-class URLRequestContextGetter;
-}
-
-namespace atom {
-
-class AtomBrowserContext;
-class AtomURLRequestJobFactory;
-
-namespace api {
-
-class Protocol : public mate::Wrappable {
- public:
-  using Handler =
-      base::Callback<void(const net::URLRequest*, v8::Local<v8::Value>)>;
-  using CompletionCallback = base::Callback<void(v8::Local<v8::Value>)>;
-  using BooleanCallback = base::Callback<void(bool)>;
-
-  static mate::Handle<Protocol> Create(
-      v8::Isolate* isolate, AtomBrowserContext* browser_context);
-
- protected:
-  explicit Protocol(AtomBrowserContext* browser_context);
-
-  // mate::Wrappable implementations:
-  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate);
-
- private:
-  // Possible errors.
-  enum ProtocolError {
-    PROTOCOL_OK,  // no error
-    PROTOCOL_FAIL,  // operation failed, should never occur
-    PROTOCOL_REGISTERED,
-    PROTOCOL_NOT_REGISTERED,
-    PROTOCOL_INTERCEPTED,
-    PROTOCOL_NOT_INTERCEPTED,
-  };
-
-  // The protocol handler that will create a protocol handler for certain
-  // request job.
-  template<typename RequestJob>
-  class CustomProtocolHandler
-      : public net::URLRequestJobFactory::ProtocolHandler {
-   public:
-    CustomProtocolHandler(
-        v8::Isolate* isolate,
-        net::URLRequestContextGetter* request_context,
-        const Handler& handler)
-        : isolate_(isolate),
-          request_context_(request_context),
-          handler_(handler) {}
-    ~CustomProtocolHandler() override {}
-
-    net::URLRequestJob* MaybeCreateJob(
-        net::URLRequest* request,
-        net::NetworkDelegate* network_delegate) const override {
-      RequestJob* request_job = new RequestJob(request, network_delegate);
-      request_job->SetHandlerInfo(isolate_, request_context_, handler_);
-      return request_job;
-    }
-
-   private:
-    v8::Isolate* isolate_;
-    net::URLRequestContextGetter* request_context_;
-    Protocol::Handler handler_;
-
-    DISALLOW_COPY_AND_ASSIGN(CustomProtocolHandler);
-  };
-
-  // Register schemes to standard scheme list.
-  void RegisterStandardSchemes(const std::vector<std::string>& schemes);
-
-  // Register the protocol with certain request job.
-  template<typename RequestJob>
-  void RegisterProtocol(const std::string& scheme,
-                        const Handler& handler,
-                        mate::Arguments* args) {
-    CompletionCallback callback;
-    args->GetNext(&callback);
-    content::BrowserThread::PostTaskAndReplyWithResult(
-        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&Protocol::RegisterProtocolInIO<RequestJob>,
-                   base::Unretained(this), scheme, handler),
-        base::Bind(&Protocol::OnIOCompleted,
-                   base::Unretained(this), callback));
-  }
-  template<typename RequestJob>
-  ProtocolError RegisterProtocolInIO(const std::string& scheme,
-                                     const Handler& handler) {
-    if (job_factory_->IsHandledProtocol(scheme))
-      return PROTOCOL_REGISTERED;
-    scoped_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
-        new CustomProtocolHandler<RequestJob>(
-            isolate(), request_context_getter_, handler));
-    if (job_factory_->SetProtocolHandler(scheme, protocol_handler.Pass()))
-      return PROTOCOL_OK;
-    else
-      return PROTOCOL_FAIL;
-  }
-
-  // Unregister the protocol handler that handles |scheme|.
-  void UnregisterProtocol(const std::string& scheme, mate::Arguments* args);
-  ProtocolError UnregisterProtocolInIO(const std::string& scheme);
-
-  // Whether the protocol has handler registered.
-  void IsProtocolHandled(const std::string& scheme,
-                         const BooleanCallback& callback);
-  bool IsProtocolHandledInIO(const std::string& scheme);
-
-  // Replace the protocol handler with a new one.
-  template<typename RequestJob>
-  void InterceptProtocol(const std::string& scheme,
-                         const Handler& handler,
-                         mate::Arguments* args) {
-    CompletionCallback callback;
-    args->GetNext(&callback);
-    content::BrowserThread::PostTaskAndReplyWithResult(
-        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&Protocol::InterceptProtocolInIO<RequestJob>,
-                   base::Unretained(this), scheme, handler),
-        base::Bind(&Protocol::OnIOCompleted,
-                   base::Unretained(this), callback));
-  }
-  template<typename RequestJob>
-  ProtocolError InterceptProtocolInIO(const std::string& scheme,
-                                      const Handler& handler) {
-    if (!job_factory_->IsHandledProtocol(scheme))
-      return PROTOCOL_NOT_REGISTERED;
-    // It is possible a protocol is handled but can not be intercepted.
-    if (!job_factory_->HasProtocolHandler(scheme))
-      return PROTOCOL_FAIL;
-    if (ContainsKey(original_protocols_, scheme))
-      return PROTOCOL_INTERCEPTED;
-    scoped_ptr<CustomProtocolHandler<RequestJob>> protocol_handler(
-        new CustomProtocolHandler<RequestJob>(
-            isolate(), request_context_getter_, handler));
-    original_protocols_.set(
-        scheme,
-        job_factory_->ReplaceProtocol(scheme, protocol_handler.Pass()));
-    return PROTOCOL_OK;
-  }
-
-  // Restore the |scheme| to its original protocol handler.
-  void UninterceptProtocol(const std::string& scheme, mate::Arguments* args);
-  ProtocolError UninterceptProtocolInIO(const std::string& scheme);
-
-  // Convert error code to JS exception and call the callback.
-  void OnIOCompleted(const CompletionCallback& callback, ProtocolError error);
-
-  // Convert error code to string.
-  std::string ErrorCodeToString(ProtocolError error);
-
-  net::URLRequestContextGetter* request_context_getter_;
-
-  // Map that stores the original protocols of schemes.
-  using OriginalProtocolsMap = base::ScopedPtrHashMap<
-      std::string,
-      scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>>;
-  OriginalProtocolsMap original_protocols_;
-
-  AtomURLRequestJobFactory* job_factory_;  // weak ref
-
-  DISALLOW_COPY_AND_ASSIGN(Protocol);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_ATOM_API_PROTOCOL_H_

atom/browser/api/atom_api_screen.cc

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

atom/browser/api/atom_api_screen.h

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

atom/browser/api/atom_api_session.cc

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

atom/browser/api/atom_api_session.h

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

atom/browser/api/atom_api_tray.cc

@@ -1,177 +0,0 @@
-// 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/browser.h"
-#include "atom/browser/ui/tray_icon.h"
-#include "atom/common/native_mate_converters/gfx_converter.h"
-#include "atom/common/native_mate_converters/image_converter.h"
-#include "atom/common/native_mate_converters/string16_converter.h"
-#include "atom/common/node_includes.h"
-#include "native_mate/constructor.h"
-#include "native_mate/dictionary.h"
-#include "ui/events/event_constants.h"
-#include "ui/gfx/image/image.h"
-
-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(v8::Isolate* isolate, const gfx::Image& image) {
-  if (!Browser::Get()->is_ready()) {
-    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
-        isolate, "Cannot create Tray before app is ready")));
-    return nullptr;
-  }
-  return new Tray(image);
-}
-
-void Tray::OnClicked(const gfx::Rect& bounds, int modifiers) {
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  EmitCustomEvent("clicked",
-                  ModifiersToObject(isolate(), modifiers), bounds);
-}
-
-void Tray::OnDoubleClicked(const gfx::Rect& bounds, int modifiers) {
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  EmitCustomEvent("double-clicked",
-                  ModifiersToObject(isolate(), modifiers), bounds);
-}
-
-void Tray::OnRightClicked(const gfx::Rect& bounds, int modifiers) {
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  EmitCustomEvent("right-clicked",
-                  ModifiersToObject(isolate(), modifiers), bounds);
-}
-
-void Tray::OnBalloonShow() {
-  Emit("balloon-show");
-}
-
-void Tray::OnBalloonClicked() {
-  Emit("balloon-clicked");
-}
-
-void Tray::OnBalloonClosed() {
-  Emit("balloon-closed");
-}
-
-void Tray::OnDropFiles(const std::vector<std::string>& files) {
-  Emit("drop-files", files);
-}
-
-bool Tray::IsDestroyed() const {
-  return !tray_icon_;
-}
-
-void Tray::Destroy() {
-  tray_icon_.reset();
-}
-
-void Tray::SetImage(mate::Arguments* args, const gfx::Image& image) {
-  tray_icon_->SetImage(image);
-}
-
-void Tray::SetPressedImage(mate::Arguments* args, const gfx::Image& image) {
-  tray_icon_->SetPressedImage(image);
-}
-
-void Tray::SetToolTip(mate::Arguments* args, const std::string& tool_tip) {
-  tray_icon_->SetToolTip(tool_tip);
-}
-
-void Tray::SetTitle(mate::Arguments* args, const std::string& title) {
-  tray_icon_->SetTitle(title);
-}
-
-void Tray::SetHighlightMode(mate::Arguments* args, bool highlight) {
-  tray_icon_->SetHighlightMode(highlight);
-}
-
-void Tray::DisplayBalloon(mate::Arguments* args,
-                          const mate::Dictionary& options) {
-  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::PopUpContextMenu(mate::Arguments* args) {
-  gfx::Point pos;
-  args->GetNext(&pos);
-  tray_icon_->PopUpContextMenu(pos);
-}
-
-void Tray::SetContextMenu(mate::Arguments* args, Menu* menu) {
-  tray_icon_->SetContextMenu(menu->model());
-}
-
-v8::Local<v8::Object> Tray::ModifiersToObject(v8::Isolate* isolate,
-                                              int modifiers) {
-  mate::Dictionary obj(isolate, v8::Object::New(isolate));
-  obj.Set("shiftKey", static_cast<bool>(modifiers & ui::EF_SHIFT_DOWN));
-  obj.Set("ctrlKey", static_cast<bool>(modifiers & ui::EF_CONTROL_DOWN));
-  obj.Set("altKey", static_cast<bool>(modifiers & ui::EF_ALT_DOWN));
-  obj.Set("metaKey", static_cast<bool>(modifiers & ui::EF_COMMAND_DOWN));
-  return obj.GetHandle();
-}
-
-// static
-void Tray::BuildPrototype(v8::Isolate* isolate,
-                          v8::Local<v8::ObjectTemplate> prototype) {
-  mate::ObjectTemplateBuilder(isolate, prototype)
-      .SetMethod("destroy", &Tray::Destroy, true)
-      .SetMethod("setImage", &Tray::SetImage)
-      .SetMethod("setPressedImage", &Tray::SetPressedImage)
-      .SetMethod("setToolTip", &Tray::SetToolTip)
-      .SetMethod("setTitle", &Tray::SetTitle)
-      .SetMethod("setHighlightMode", &Tray::SetHighlightMode)
-      .SetMethod("displayBalloon", &Tray::DisplayBalloon)
-      .SetMethod("popUpContextMenu", &Tray::PopUpContextMenu)
-      .SetMethod("_setContextMenu", &Tray::SetContextMenu);
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-
-namespace {
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  using atom::api::Tray;
-  v8::Isolate* isolate = context->GetIsolate();
-  v8::Local<v8::Function> constructor = mate::CreateConstructor<Tray>(
-      isolate, "Tray", base::Bind(&Tray::New));
-  mate::Dictionary dict(isolate, exports);
-  dict.Set("Tray", static_cast<v8::Local<v8::Value>>(constructor));
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_tray, Initialize)

atom/browser/api/atom_api_tray.h

@@ -1,78 +0,0 @@
-// 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 <vector>
-
-#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(v8::Isolate* isolate, const gfx::Image& image);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::ObjectTemplate> prototype);
-
- protected:
-  explicit Tray(const gfx::Image& image);
-  virtual ~Tray();
-
-  // TrayIconObserver:
-  void OnClicked(const gfx::Rect& bounds, int modifiers) override;
-  void OnDoubleClicked(const gfx::Rect& bounds, int modifiers) override;
-  void OnRightClicked(const gfx::Rect& bounds, int modifiers) override;
-  void OnBalloonShow() override;
-  void OnBalloonClicked() override;
-  void OnBalloonClosed() override;
-  void OnDropFiles(const std::vector<std::string>& files) override;
-
-  // mate::Wrappable:
-  bool IsDestroyed() const override;
-
-  void Destroy();
-  void SetImage(mate::Arguments* args, const gfx::Image& image);
-  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 PopUpContextMenu(mate::Arguments* args);
-  void SetContextMenu(mate::Arguments* args, Menu* menu);
-
- private:
-  v8::Local<v8::Object> ModifiersToObject(v8::Isolate* isolate, int modifiers);
-
-  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.h

@@ -1,250 +0,0 @@
-// 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 <vector>
-
-#include "atom/browser/api/frame_subscriber.h"
-#include "atom/browser/api/trackable_object.h"
-#include "atom/browser/common_web_contents_delegate.h"
-#include "content/public/browser/web_contents_observer.h"
-#include "content/public/common/favicon_url.h"
-#include "native_mate/handle.h"
-#include "ui/gfx/image/image.h"
-
-namespace blink {
-struct WebDeviceEmulationParams;
-}
-
-namespace brightray {
-class InspectableWebContents;
-}
-
-namespace mate {
-class Arguments;
-class Dictionary;
-}
-
-namespace atom {
-
-struct SetSizeParams;
-class AtomBrowserContext;
-class WebViewGuestDelegate;
-
-namespace api {
-
-class WebContents : public mate::TrackableObject<WebContents>,
-                    public CommonWebContentsDelegate,
-                    public content::WebContentsObserver {
- public:
-  // For node.js callback function type: function(error, buffer)
-  using PrintToPDFCallback =
-      base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>;
-
-  // Create from an existing WebContents.
-  static mate::Handle<WebContents> CreateFrom(
-      v8::Isolate* isolate, content::WebContents* web_contents);
-
-  // Create a new WebContents.
-  static mate::Handle<WebContents> Create(
-      v8::Isolate* isolate, const mate::Dictionary& options);
-
-  // mate::TrackableObject:
-  void Destroy() override;
-
-  bool IsAlive() const;
-  int GetID() const;
-  bool Equal(const WebContents* web_contents) const;
-  void LoadURL(const GURL& url, const mate::Dictionary& options);
-  GURL GetURL() const;
-  base::string16 GetTitle() const;
-  bool IsLoading() const;
-  bool IsWaitingForResponse() const;
-  void Stop();
-  void ReloadIgnoringCache();
-  void GoBack();
-  void GoForward();
-  void GoToOffset(int offset);
-  bool IsCrashed() const;
-  void SetUserAgent(const std::string& user_agent);
-  std::string GetUserAgent();
-  void InsertCSS(const std::string& css);
-  void ExecuteJavaScript(const base::string16& code,
-                         bool has_user_gesture);
-  void OpenDevTools(mate::Arguments* args);
-  void CloseDevTools();
-  bool IsDevToolsOpened();
-  void ToggleDevTools();
-  void EnableDeviceEmulation(const blink::WebDeviceEmulationParams& params);
-  void DisableDeviceEmulation();
-  void InspectElement(int x, int y);
-  void InspectServiceWorker();
-  v8::Local<v8::Value> Session(v8::Isolate* isolate);
-  void HasServiceWorker(const base::Callback<void(bool)>&);
-  void UnregisterServiceWorker(const base::Callback<void(bool)>&);
-  void SetAudioMuted(bool muted);
-  bool IsAudioMuted();
-  void Print(mate::Arguments* args);
-
-  // Print current page as PDF.
-  void PrintToPDF(const base::DictionaryValue& setting,
-                  const PrintToPDFCallback& callback);
-
-  // DevTools workspace api.
-  void AddWorkSpace(mate::Arguments* args, const base::FilePath& path);
-  void RemoveWorkSpace(mate::Arguments* args, const base::FilePath& path);
-
-  // Editing commands.
-  void Undo();
-  void Redo();
-  void Cut();
-  void Copy();
-  void Paste();
-  void PasteAndMatchStyle();
-  void Delete();
-  void SelectAll();
-  void Unselect();
-  void Replace(const base::string16& word);
-  void ReplaceMisspelling(const base::string16& word);
-
-  // Focus.
-  void Focus();
-  void TabTraverse(bool reverse);
-
-  // Send messages to browser.
-  bool SendIPCMessage(const base::string16& channel,
-                      const base::ListValue& args);
-
-  // Send WebInputEvent to the page.
-  void SendInputEvent(v8::Isolate* isolate, v8::Local<v8::Value> input_event);
-
-  // Subscribe to the frame updates.
-  void BeginFrameSubscription(
-      const FrameSubscriber::FrameCaptureCallback& callback);
-  void EndFrameSubscription();
-
-  // Methods for creating <webview>.
-  void SetSize(const SetSizeParams& params);
-  void SetAllowTransparency(bool allow);
-  bool IsGuest() const;
-
- protected:
-  explicit WebContents(content::WebContents* web_contents);
-  WebContents(v8::Isolate* isolate, const mate::Dictionary& options);
-  ~WebContents();
-
-  // mate::Wrappable:
-  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) override;
-  bool IsDestroyed() const override;
-
-  // content::WebContentsDelegate:
-  bool AddMessageToConsole(content::WebContents* source,
-                           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 std::string& frame_name,
-      const GURL& target_url,
-      const std::string& partition_id,
-      content::SessionStorageNamespace* session_storage_namespace) override;
-  content::WebContents* OpenURLFromTab(
-      content::WebContents* source,
-      const content::OpenURLParams& params) override;
-  void BeforeUnloadFired(content::WebContents* tab,
-                         bool proceed,
-                         bool* proceed_to_fire_unload) override;
-  void MoveContents(content::WebContents* source,
-                    const gfx::Rect& pos) override;
-  void CloseContents(content::WebContents* source) override;
-  void ActivateContents(content::WebContents* contents) override;
-  bool IsPopupOrPanel(const content::WebContents* source) const override;
-  void HandleKeyboardEvent(
-      content::WebContents* source,
-      const content::NativeWebKeyboardEvent& event) override;
-  void EnterFullscreenModeForTab(content::WebContents* source,
-                                 const GURL& origin) override;
-  void ExitFullscreenModeForTab(content::WebContents* source) override;
-  void RendererUnresponsive(content::WebContents* source) override;
-  void RendererResponsive(content::WebContents* source) override;
-
-  // content::WebContentsObserver:
-  void BeforeUnloadFired(const base::TimeTicks& proceed_time) override;
-  void RenderViewDeleted(content::RenderViewHost*) override;
-  void RenderProcessGone(base::TerminationStatus status) override;
-  void DocumentLoadedInFrame(
-      content::RenderFrameHost* render_frame_host) override;
-  void DidFinishLoad(content::RenderFrameHost* render_frame_host,
-                     const GURL& validated_url) override;
-  void DidFailLoad(content::RenderFrameHost* render_frame_host,
-                   const GURL& validated_url,
-                   int error_code,
-                   const base::string16& error_description,
-                   bool was_ignored_by_handler) override;
-  void DidFailProvisionalLoad(content::RenderFrameHost* render_frame_host,
-                              const GURL& validated_url,
-                              int error_code,
-                              const base::string16& error_description,
-                              bool was_ignored_by_handler) override;
-  void DidStartLoading() override;
-  void DidStopLoading() override;
-  void DidGetResourceResponseStart(
-      const content::ResourceRequestDetails& details) override;
-  void DidGetRedirectForResourceRequest(
-      content::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 WebContentsDestroyed() override;
-  void NavigationEntryCommitted(
-      const content::LoadCommittedDetails& load_details) override;
-  void TitleWasSet(content::NavigationEntry* entry, bool explicit_set) override;
-  void DidUpdateFaviconURL(
-      const std::vector<content::FaviconURL>& urls) override;
-  void PluginCrashed(const base::FilePath& plugin_path,
-                     base::ProcessId plugin_pid) override;
-
- private:
-  enum Type {
-    BROWSER_WINDOW,  // Used by BrowserWindow.
-    WEB_VIEW,  // Used by <webview>.
-    REMOTE,  // Thin wrap around an existing WebContents.
-  };
-
-  AtomBrowserContext* GetBrowserContext() const;
-
-  // Called when received a message from renderer.
-  void OnRendererMessage(const base::string16& channel,
-                         const base::ListValue& args);
-
-  // Called when received a synchronous message from renderer.
-  void OnRendererMessageSync(const base::string16& channel,
-                             const base::ListValue& args,
-                             IPC::Message* message);
-
-  v8::Global<v8::Value> session_;
-
-  scoped_ptr<WebViewGuestDelegate> guest_delegate_;
-
-  // The type of current WebContents.
-  Type type_;
-
-  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

@@ -1,71 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/atom_api_web_contents.h"
-#include "atom/browser/web_contents_preferences.h"
-#include "atom/browser/web_view_manager.h"
-#include "atom/common/native_mate_converters/value_converter.h"
-#include "atom/common/node_includes.h"
-#include "content/public/browser/browser_context.h"
-#include "native_mate/dictionary.h"
-
-using atom::WebContentsPreferences;
-
-namespace mate {
-
-template<>
-struct Converter<content::WebContents*> {
-  static bool FromV8(v8::Isolate* isolate, v8::Local<v8::Value> val,
-                     content::WebContents** out) {
-    atom::api::WebContents* contents;
-    if (!Converter<atom::api::WebContents*>::FromV8(isolate, val, &contents))
-      return false;
-    *out = contents->web_contents();
-    return true;
-  }
-};
-
-}  // namespace mate
-
-namespace {
-
-atom::WebViewManager* GetWebViewManager(content::WebContents* web_contents) {
-  auto context = web_contents->GetBrowserContext();
-  if (context) {
-    auto manager = context->GetGuestManager();
-    return static_cast<atom::WebViewManager*>(manager);
-  } else {
-    return nullptr;
-  }
-}
-
-void AddGuest(int guest_instance_id,
-              int element_instance_id,
-              content::WebContents* embedder,
-              content::WebContents* guest_web_contents,
-              const base::DictionaryValue& options) {
-  auto manager = GetWebViewManager(embedder);
-  if (manager)
-    manager->AddGuest(guest_instance_id, element_instance_id, embedder,
-                      guest_web_contents);
-
-  WebContentsPreferences::FromWebContents(guest_web_contents)->Merge(options);
-}
-
-void RemoveGuest(content::WebContents* embedder, int guest_instance_id) {
-  auto manager = GetWebViewManager(embedder);
-  if (manager)
-    manager->RemoveGuest(guest_instance_id);
-}
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  mate::Dictionary dict(context->GetIsolate(), exports);
-  dict.SetMethod("addGuest", &AddGuest);
-  dict.SetMethod("removeGuest", &RemoveGuest);
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_web_view_manager, Initialize)

atom/browser/api/atom_api_window.cc

@@ -1,647 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/atom_api_window.h"
-
-#include "atom/browser/api/atom_api_menu.h"
-#include "atom/browser/api/atom_api_web_contents.h"
-#include "atom/browser/browser.h"
-#include "atom/browser/native_window.h"
-#include "atom/common/native_mate_converters/callback.h"
-#include "atom/common/native_mate_converters/gfx_converter.h"
-#include "atom/common/native_mate_converters/gurl_converter.h"
-#include "atom/common/native_mate_converters/image_converter.h"
-#include "atom/common/native_mate_converters/string16_converter.h"
-#include "atom/common/node_includes.h"
-#include "atom/common/options_switches.h"
-#include "content/public/browser/render_process_host.h"
-#include "native_mate/constructor.h"
-#include "native_mate/dictionary.h"
-#include "ui/gfx/geometry/rect.h"
-
-#if defined(OS_WIN)
-#include "atom/browser/native_window_views.h"
-#include "atom/browser/ui/win/taskbar_host.h"
-#endif
-
-#if defined(OS_WIN)
-namespace mate {
-
-template<>
-struct Converter<atom::TaskbarHost::ThumbarButton> {
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
-                     atom::TaskbarHost::ThumbarButton* out) {
-    mate::Dictionary dict;
-    if (!ConvertFromV8(isolate, val, &dict))
-      return false;
-    dict.Get("click", &(out->clicked_callback));
-    dict.Get("tooltip", &(out->tooltip));
-    dict.Get("flags", &out->flags);
-    return dict.Get("icon", &(out->icon));
-  }
-};
-
-}  // namespace mate
-#endif
-
-namespace atom {
-
-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(v8::Isolate* isolate, const mate::Dictionary& options) {
-  // Use options['web-preferences'] to create WebContents.
-  mate::Dictionary web_preferences = mate::Dictionary::CreateEmpty(isolate);
-  options.Get(switches::kWebPreferences, &web_preferences);
-
-  // Be compatible with old options which are now in web_preferences.
-  v8::Local<v8::Value> value;
-  if (options.Get(switches::kNodeIntegration, &value))
-    web_preferences.Set(switches::kNodeIntegration, value);
-  if (options.Get(switches::kPreloadScript, &value))
-    web_preferences.Set(switches::kPreloadScript, value);
-  if (options.Get(switches::kZoomFactor, &value))
-    web_preferences.Set(switches::kZoomFactor, value);
-
-  // Creates the WebContents used by BrowserWindow.
-  auto web_contents = WebContents::Create(isolate, web_preferences);
-  web_contents_.Reset(isolate, web_contents.ToV8());
-  api_web_contents_ = web_contents.get();
-
-  // Creates BrowserWindow.
-  window_.reset(NativeWindow::Create(web_contents->managed_web_contents(),
-                                     options));
-  web_contents->SetOwnerWindow(window_.get());
-  window_->InitFromOptions(options);
-  window_->AddObserver(this);
-}
-
-Window::~Window() {
-  if (window_)
-    Destroy();
-}
-
-void Window::OnPageTitleUpdated(bool* prevent_default,
-                                const std::string& title) {
-  *prevent_default = Emit("page-title-updated", title);
-}
-
-void Window::WillCloseWindow(bool* prevent_default) {
-  *prevent_default = Emit("close");
-}
-
-void Window::OnWindowClosed() {
-  if (api_web_contents_) {
-    api_web_contents_->DestroyWebContents();
-    api_web_contents_ = nullptr;
-    web_contents_.Reset();
-  }
-
-  RemoveFromWeakMap();
-  window_->RemoveObserver(this);
-
-  Emit("closed");
-
-  // Clean up the resources after window has been closed.
-  base::MessageLoop::current()->DeleteSoon(FROM_HERE, window_.release());
-}
-
-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::OnWindowResize() {
-  Emit("resize");
-}
-
-void Window::OnWindowMove() {
-  Emit("move");
-}
-
-void Window::OnWindowMoved() {
-  Emit("moved");
-}
-
-void Window::OnWindowEnterFullScreen() {
-  Emit("enter-full-screen");
-}
-
-void Window::OnWindowLeaveFullScreen() {
-  Emit("leave-full-screen");
-}
-
-void Window::OnWindowEnterHtmlFullScreen() {
-  Emit("enter-html-full-screen");
-}
-
-void Window::OnWindowLeaveHtmlFullScreen() {
-  Emit("leave-html-full-screen");
-}
-
-void Window::OnRendererUnresponsive() {
-  Emit("unresponsive");
-}
-
-void Window::OnRendererResponsive() {
-  Emit("responsive");
-}
-
-void Window::OnDevToolsFocus() {
-  Emit("devtools-focused");
-}
-
-void Window::OnDevToolsOpened() {
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  auto handle = WebContents::CreateFrom(
-      isolate(), api_web_contents_->GetDevToolsWebContents());
-  devtools_web_contents_.Reset(isolate(), handle.ToV8());
-
-  Emit("devtools-opened");
-}
-
-void Window::OnDevToolsClosed() {
-  v8::Locker locker(isolate());
-  v8::HandleScope handle_scope(isolate());
-  devtools_web_contents_.Reset();
-
-  Emit("devtools-closed");
-}
-
-void Window::OnExecuteWindowsCommand(const std::string& command_name) {
-  Emit("app-command", command_name);
-}
-
-// static
-mate::Wrappable* Window::New(v8::Isolate* isolate,
-                             const mate::Dictionary& options) {
-  if (!Browser::Get()->is_ready()) {
-    isolate->ThrowException(v8::Exception::Error(mate::StringToV8(
-        isolate, "Cannot create BrowserWindow before app is ready")));
-    return nullptr;
-  }
-  return new Window(isolate, options);
-}
-
-bool Window::IsDestroyed() const {
-  return !window_ || window_->IsClosed();
-}
-
-void Window::Destroy() {
-  if (window_)
-    window_->CloseContents(nullptr);
-}
-
-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::SetBounds(const gfx::Rect& bounds) {
-  window_->SetBounds(bounds);
-}
-
-gfx::Rect Window::GetBounds() {
-  return window_->GetBounds();
-}
-
-void Window::SetSize(int width, int height) {
-  window_->SetSize(gfx::Size(width, height));
-}
-
-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::FocusOnWebView() {
-  window_->FocusOnWebView();
-}
-
-void Window::BlurWebView() {
-  window_->BlurWebView();
-}
-
-bool Window::IsWebViewFocused() {
-  return window_->IsWebViewFocused();
-}
-
-bool Window::IsDevToolsFocused() {
-  return window_->IsDevToolsFocused();
-}
-
-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::SetProgressBar(double progress) {
-  window_->SetProgressBar(progress);
-}
-
-void Window::SetOverlayIcon(const gfx::Image& overlay,
-                            const std::string& description) {
-  window_->SetOverlayIcon(overlay, description);
-}
-
-bool Window::SetThumbarButtons(mate::Arguments* args) {
-#if defined(OS_WIN)
-  std::vector<TaskbarHost::ThumbarButton> buttons;
-  if (!args->GetNext(&buttons)) {
-    args->ThrowError();
-    return false;
-  }
-  auto window = static_cast<NativeWindowViews*>(window_.get());
-  return window->taskbar_host().SetThumbarButtons(
-      window->GetAcceleratedWidget(), buttons);
-#else
-  return false;
-#endif
-}
-
-void Window::SetMenu(v8::Isolate* isolate, v8::Local<v8::Value> value) {
-  mate::Handle<Menu> menu;
-  if (value->IsObject() &&
-      mate::V8ToString(value->ToObject()->GetConstructorName()) == "Menu" &&
-      mate::ConvertFromV8(isolate, value, &menu)) {
-    menu_.Reset(isolate, menu.ToV8());
-    window_->SetMenu(menu->model());
-  } else if (value->IsNull()) {
-    menu_.Reset();
-    window_->SetMenu(nullptr);
-  } else {
-    isolate->ThrowException(v8::Exception::TypeError(
-        mate::StringToV8(isolate, "Invalid Menu")));
-  }
-}
-
-void Window::SetAutoHideMenuBar(bool auto_hide) {
-  window_->SetAutoHideMenuBar(auto_hide);
-}
-
-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
-
-void Window::SetAspectRatio(double aspect_ratio, mate::Arguments* args) {
-  gfx::Size extra_size;
-  args->GetNext(&extra_size);
-  window_->SetAspectRatio(aspect_ratio, extra_size);
-}
-
-void Window::SetVisibleOnAllWorkspaces(bool visible) {
-  return window_->SetVisibleOnAllWorkspaces(visible);
-}
-
-bool Window::IsVisibleOnAllWorkspaces() {
-  return window_->IsVisibleOnAllWorkspaces();
-}
-
-int32_t Window::ID() const {
-  return weak_map_id();
-}
-
-v8::Local<v8::Value> Window::WebContents(v8::Isolate* isolate) {
-  if (web_contents_.IsEmpty())
-    return v8::Null(isolate);
-  else
-    return v8::Local<v8::Value>::New(isolate, web_contents_);
-}
-
-v8::Local<v8::Value> Window::DevToolsWebContents(v8::Isolate* isolate) {
-  if (devtools_web_contents_.IsEmpty())
-    return v8::Null(isolate);
-  else
-    return v8::Local<v8::Value>::New(isolate, devtools_web_contents_);
-}
-
-// static
-void Window::BuildPrototype(v8::Isolate* isolate,
-                            v8::Local<v8::ObjectTemplate> prototype) {
-  mate::ObjectTemplateBuilder(isolate, prototype)
-      .SetMethod("destroy", &Window::Destroy, true)
-      .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("setAspectRatio", &Window::SetAspectRatio)
-      .SetMethod("getBounds", &Window::GetBounds)
-      .SetMethod("setBounds", &Window::SetBounds)
-      .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("focusOnWebView", &Window::FocusOnWebView)
-      .SetMethod("blurWebView", &Window::BlurWebView)
-      .SetMethod("isWebViewFocused", &Window::IsWebViewFocused)
-      .SetMethod("isDevToolsFocused", &Window::IsDevToolsFocused)
-      .SetMethod("capturePage", &Window::CapturePage)
-      .SetMethod("setProgressBar", &Window::SetProgressBar)
-      .SetMethod("setOverlayIcon", &Window::SetOverlayIcon)
-      .SetMethod("setThumbarButtons", &Window::SetThumbarButtons)
-      .SetMethod("setMenu", &Window::SetMenu)
-      .SetMethod("setAutoHideMenuBar", &Window::SetAutoHideMenuBar)
-      .SetMethod("isMenuBarAutoHide", &Window::IsMenuBarAutoHide)
-      .SetMethod("setMenuBarVisibility", &Window::SetMenuBarVisibility)
-      .SetMethod("isMenuBarVisible", &Window::IsMenuBarVisible)
-      .SetMethod("setVisibleOnAllWorkspaces",
-                 &Window::SetVisibleOnAllWorkspaces)
-      .SetMethod("isVisibleOnAllWorkspaces",
-                 &Window::IsVisibleOnAllWorkspaces)
-#if defined(OS_MACOSX)
-      .SetMethod("showDefinitionForSelection",
-                 &Window::ShowDefinitionForSelection)
-#endif
-      .SetProperty("id", &Window::ID, true)
-      .SetProperty("webContents", &Window::WebContents, true)
-      .SetProperty("devToolsWebContents", &Window::DevToolsWebContents, true);
-}
-
-}  // namespace api
-
-}  // namespace atom
-
-
-namespace {
-
-using atom::api::Window;
-
-void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
-                v8::Local<v8::Context> context, void* priv) {
-  v8::Isolate* isolate = context->GetIsolate();
-  v8::Local<v8::Function> constructor = mate::CreateConstructor<Window>(
-      isolate, "BrowserWindow", base::Bind(&Window::New));
-  mate::Dictionary browser_window(isolate, constructor);
-  browser_window.SetMethod("fromId",
-                           &mate::TrackableObject<Window>::FromWeakMapID);
-  browser_window.SetMethod("getAllWindows",
-                           &mate::TrackableObject<Window>::GetAll);
-
-  mate::Dictionary dict(isolate, exports);
-  dict.Set("BrowserWindow", browser_window);
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_browser_window, Initialize)

atom/browser/api/atom_api_window.h

@@ -1,193 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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/api/trackable_object.h"
-#include "atom/browser/native_window.h"
-#include "atom/browser/native_window_observer.h"
-#include "native_mate/handle.h"
-
-class GURL;
-
-namespace gfx {
-class Rect;
-}
-
-namespace mate {
-class Arguments;
-class Dictionary;
-}
-
-namespace atom {
-
-class NativeWindow;
-
-namespace api {
-
-class WebContents;
-
-class Window : public mate::TrackableObject<Window>,
-               public NativeWindowObserver {
- public:
-  static mate::Wrappable* New(v8::Isolate* isolate,
-                              const mate::Dictionary& options);
-
-  static void BuildPrototype(v8::Isolate* isolate,
-                             v8::Local<v8::ObjectTemplate> prototype);
-
-  NativeWindow* window() const { return window_.get(); }
-
- protected:
-  Window(v8::Isolate* isolate, const mate::Dictionary& options);
-  virtual ~Window();
-
-  // NativeWindowObserver:
-  void OnPageTitleUpdated(bool* prevent_default,
-                          const std::string& title) 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 OnWindowResize() override;
-  void OnWindowMove() override;
-  void OnWindowMoved() override;
-  void OnWindowEnterFullScreen() override;
-  void OnWindowLeaveFullScreen() override;
-  void OnWindowEnterHtmlFullScreen() override;
-  void OnWindowLeaveHtmlFullScreen() override;
-  void OnRendererUnresponsive() override;
-  void OnRendererResponsive() override;
-  void OnDevToolsFocus() override;
-  void OnDevToolsOpened() override;
-  void OnDevToolsClosed() override;
-  void OnExecuteWindowsCommand(const std::string& command_name) override;
-
-  // mate::Wrappable:
-  bool IsDestroyed() const override;
-
- private:
-  // mate::TrackableObject:
-  void Destroy() override;
-
-  // APIs for NativeWindow.
-  void 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 SetBounds(const gfx::Rect& bounds);
-  gfx::Rect GetBounds();
-  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 FocusOnWebView();
-  void BlurWebView();
-  bool IsWebViewFocused();
-  bool IsDevToolsFocused();
-  void SetRepresentedFilename(const std::string& filename);
-  std::string GetRepresentedFilename();
-  void SetDocumentEdited(bool edited);
-  bool IsDocumentEdited();
-  void CapturePage(mate::Arguments* args);
-  void SetProgressBar(double progress);
-  void SetOverlayIcon(const gfx::Image& overlay,
-                      const std::string& description);
-  bool SetThumbarButtons(mate::Arguments* args);
-  void SetMenu(v8::Isolate* isolate, v8::Local<v8::Value> menu);
-  void SetAutoHideMenuBar(bool auto_hide);
-  bool IsMenuBarAutoHide();
-  void SetMenuBarVisibility(bool visible);
-  bool IsMenuBarVisible();
-  void SetAspectRatio(double aspect_ratio, mate::Arguments* args);
-
-#if defined(OS_MACOSX)
-  void ShowDefinitionForSelection();
-#endif
-
-  void SetVisibleOnAllWorkspaces(bool visible);
-  bool IsVisibleOnAllWorkspaces();
-
-  int32_t ID() const;
-  v8::Local<v8::Value> WebContents(v8::Isolate* isolate);
-  v8::Local<v8::Value> DevToolsWebContents(v8::Isolate* isolate);
-
-  v8::Global<v8::Value> web_contents_;
-  v8::Global<v8::Value> devtools_web_contents_;
-  v8::Global<v8::Value> menu_;
-
-  api::WebContents* api_web_contents_;
-
-  scoped_ptr<NativeWindow> window_;
-
-  DISALLOW_COPY_AND_ASSIGN(Window);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-
-namespace mate {
-
-template<>
-struct Converter<atom::NativeWindow*> {
-  static bool FromV8(v8::Isolate* isolate, v8::Local<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

@@ -1,72 +0,0 @@
-// 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

@@ -1,52 +0,0 @@
-// 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

@@ -1,64 +0,0 @@
-// 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/dictionary.h"
-#include "native_mate/object_template_builder.h"
-
-namespace mate {
-
-namespace {
-
-v8::Persistent<v8::ObjectTemplate> event_template;
-
-void PreventDefault(mate::Arguments* args) {
-  mate::Dictionary self(args->isolate(), args->GetThis());
-  self.Set("defaultPrevented", true);
-}
-
-// 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() {
-}
-
-v8::Local<v8::Object> EventEmitter::CreateJSEvent(
-    v8::Isolate* isolate, content::WebContents* sender, IPC::Message* message) {
-  v8::Local<v8::Object> event;
-  bool use_native_event = sender && message;
-
-  if (use_native_event) {
-    mate::Handle<mate::Event> native_event = mate::Event::Create(isolate);
-    native_event->SetSenderAndMessage(sender, message);
-    event = v8::Local<v8::Object>::Cast(native_event.ToV8());
-  } else {
-    event = CreateEventObject(isolate);
-  }
-  mate::Dictionary(isolate, event).Set("sender", GetWrapper(isolate));
-  return event;
-}
-
-v8::Local<v8::Object> EventEmitter::CreateCustomEvent(
-    v8::Isolate* isolate, v8::Local<v8::Object> custom_event) {
-  v8::Local<v8::Object> event = CreateEventObject(isolate);
-  (void)event->SetPrototype(custom_event->CreationContext(), custom_event);
-  mate::Dictionary(isolate, event).Set("sender", GetWrapper(isolate));
-  return event;
-}
-
-}  // namespace mate

atom/browser/api/event_emitter.h

@@ -1,81 +0,0 @@
-// 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 "atom/common/api/event_emitter_caller.h"
-#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::Local<v8::Value>> ValueArray;
-
-  // this.emit(name, event, args...);
-  template<typename... Args>
-  bool EmitCustomEvent(const base::StringPiece& name,
-                       v8::Local<v8::Object> event,
-                       const Args&... args) {
-    return EmitWithEvent(name, CreateCustomEvent(isolate(), event), args...);
-  }
-
-  // this.emit(name, new Event(), args...);
-  template<typename... Args>
-  bool Emit(const base::StringPiece& name, const Args&... args) {
-    return EmitWithSender(name, nullptr, nullptr, args...);
-  }
-
-  // this.emit(name, new Event(sender, message), args...);
-  template<typename... Args>
-  bool EmitWithSender(const base::StringPiece& name,
-                      content::WebContents* sender,
-                      IPC::Message* message,
-                      const Args&... args) {
-    v8::Locker locker(isolate());
-    v8::HandleScope handle_scope(isolate());
-    v8::Local<v8::Object> event = CreateJSEvent(isolate(), sender, message);
-    return EmitWithEvent(name, event, args...);
-  }
-
- protected:
-  EventEmitter();
-
- private:
-  // this.emit(name, event, args...);
-  template<typename... Args>
-  bool EmitWithEvent(const base::StringPiece& name,
-                     v8::Local<v8::Object> event,
-                     const Args&... args) {
-    v8::Locker locker(isolate());
-    v8::HandleScope handle_scope(isolate());
-    EmitEvent(isolate(), GetWrapper(isolate()), name, event, args...);
-    return event->Get(
-        StringToV8(isolate(), "defaultPrevented"))->BooleanValue();
-  }
-
-  v8::Local<v8::Object> CreateJSEvent(v8::Isolate* isolate,
-                                      content::WebContents* sender,
-                                      IPC::Message* message);
-  v8::Local<v8::Object> CreateCustomEvent(
-      v8::Isolate* isolate, v8::Local<v8::Object> event);
-
-  DISALLOW_COPY_AND_ASSIGN(EventEmitter);
-};
-
-}  // namespace mate
-
-#endif  // ATOM_BROWSER_API_EVENT_EMITTER_H_

atom/browser/api/frame_subscriber.cc

@@ -1,66 +0,0 @@
-// 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/frame_subscriber.h"
-
-#include "atom/common/node_includes.h"
-#include "base/bind.h"
-#include "media/base/video_frame.h"
-#include "media/base/yuv_convert.h"
-
-namespace atom {
-
-namespace api {
-
-FrameSubscriber::FrameSubscriber(v8::Isolate* isolate,
-                                 const gfx::Size& size,
-                                 const FrameCaptureCallback& callback)
-    : isolate_(isolate), size_(size), callback_(callback) {
-}
-
-bool FrameSubscriber::ShouldCaptureFrame(
-    const gfx::Rect& damage_rect,
-    base::TimeTicks present_time,
-    scoped_refptr<media::VideoFrame>* storage,
-    DeliverFrameCallback* callback) {
-  *storage = media::VideoFrame::CreateFrame(media::VideoFrame::YV12, size_,
-                                            gfx::Rect(size_), size_,
-                                            base::TimeDelta());
-  *callback = base::Bind(&FrameSubscriber::OnFrameDelivered,
-                         base::Unretained(this),
-                         *storage);
-  return true;
-}
-
-void FrameSubscriber::OnFrameDelivered(
-    scoped_refptr<media::VideoFrame> frame, base::TimeTicks, bool result) {
-  if (!result)
-    return;
-
-  gfx::Rect rect = frame->visible_rect();
-  size_t rgb_arr_size = rect.width() * rect.height() * 4;
-  v8::MaybeLocal<v8::Object> buffer = node::Buffer::New(isolate_, rgb_arr_size);
-  if (buffer.IsEmpty())
-    return;
-
-  // Convert a frame of YUV to 32 bit ARGB.
-  media::ConvertYUVToRGB32(frame->data(media::VideoFrame::kYPlane),
-                           frame->data(media::VideoFrame::kUPlane),
-                           frame->data(media::VideoFrame::kVPlane),
-                           reinterpret_cast<uint8*>(
-                              node::Buffer::Data(buffer.ToLocalChecked())),
-                           rect.width(), rect.height(),
-                           frame->stride(media::VideoFrame::kYPlane),
-                           frame->stride(media::VideoFrame::kUVPlane),
-                           rect.width() * 4,
-                           media::YV12);
-
-  v8::Locker locker(isolate_);
-  v8::HandleScope handle_scope(isolate_);
-  callback_.Run(buffer.ToLocalChecked());
-}
-
-}  // namespace api
-
-}  // namespace atom

atom/browser/api/frame_subscriber.h

@@ -1,45 +0,0 @@
-// 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_FRAME_SUBSCRIBER_H_
-#define ATOM_BROWSER_API_FRAME_SUBSCRIBER_H_
-
-#include "base/callback.h"
-#include "content/public/browser/render_widget_host_view_frame_subscriber.h"
-#include "ui/gfx/geometry/size.h"
-#include "v8/include/v8.h"
-
-namespace atom {
-
-namespace api {
-
-class FrameSubscriber : public content::RenderWidgetHostViewFrameSubscriber {
- public:
-  using FrameCaptureCallback = base::Callback<void(v8::Local<v8::Value>)>;
-
-  FrameSubscriber(v8::Isolate* isolate,
-                  const gfx::Size& size,
-                  const FrameCaptureCallback& callback);
-
-  bool ShouldCaptureFrame(const gfx::Rect& damage_rect,
-                          base::TimeTicks present_time,
-                          scoped_refptr<media::VideoFrame>* storage,
-                          DeliverFrameCallback* callback) override;
-
- private:
-  void OnFrameDelivered(
-      scoped_refptr<media::VideoFrame> frame, base::TimeTicks, bool);
-
-  v8::Isolate* isolate_;
-  gfx::Size size_;
-  FrameCaptureCallback callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(FrameSubscriber);
-};
-
-}  // namespace api
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_API_FRAME_SUBSCRIBER_H_

atom/browser/api/lib/app.coffee

@@ -1,55 +0,0 @@
-EventEmitter = require('events').EventEmitter
-
-bindings = process.atomBinding 'app'
-sessionBindings = process.atomBinding 'session'
-
-app = bindings.app
-app.__proto__ = EventEmitter.prototype
-
-wrapSession = (session) ->
-  # session is an Event Emitter.
-  session.__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
-
-appPath = null
-app.setAppPath = (path) ->
-  appPath = path
-
-app.getAppPath = ->
-  appPath
-
-# Be compatible with old API.
-app.once 'ready', -> @emit 'finish-launching'
-app.terminate = app.quit
-app.exit = process.exit
-app.getHomeDir = -> @getPath 'home'
-app.getDataPath = -> @getPath 'userData'
-app.setDataPath = (path) -> @setPath 'userData', path
-app.resolveProxy = -> @defaultSession.resolveProxy.apply @defaultSession, arguments
-app.on 'activate', (event, hasVisibleWindows) -> @emit 'activate-with-no-open-windows' if not hasVisibleWindows
-
-# Session wrapper.
-sessionBindings._setWrapSession wrapSession
-process.once 'exit', sessionBindings._clearWrapSession
-
-# Only one App object pemitted.
-module.exports = app

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

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

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

@@ -1,24 +0,0 @@
-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

@@ -1,93 +0,0 @@
-EventEmitter = require('events').EventEmitter
-app = require 'app'
-ipc = require 'ipc'
-
-BrowserWindow = process.atomBinding('window').BrowserWindow
-BrowserWindow::__proto__ = EventEmitter.prototype
-
-BrowserWindow::_init = ->
-  # Simulate the application menu on platforms other than OS X.
-  if process.platform isnt 'darwin'
-    menu = app.getApplicationMenu()
-    @setMenu menu if menu?
-
-  # Make new windows requested by links behave like "window.open"
-  @webContents.on '-new-window', (event, url, frameName) ->
-    options = show: true, width: 800, height: 600
-    ipc.emit 'ATOM_SHELL_GUEST_WINDOW_MANAGER_WINDOW_OPEN', event, url, frameName, options
-
-  # window.resizeTo(...)
-  # window.moveTo(...)
-  @webContents.on 'move', (event, size) =>
-    @setBounds size
-
-  # Hide the auto-hide menu when webContents is focused.
-  @webContents.on 'activate', =>
-    if process.platform isnt 'darwin' and @isMenuBarAutoHide() and @isMenuBarVisible()
-      @setMenuBarVisibility false
-
-  # Forward the crashed event.
-  @webContents.on 'crashed', =>
-    @emit 'crashed'
-
-  # Sometimes the webContents doesn't get focus when window is shown, so we have
-  # to force focusing on webContents in this case. The safest way is to focus it
-  # when we first start to load URL, if we do it earlier it won't have effect,
-  # if we do it later we might move focus in the page.
-  # Though this hack is only needed on OS X when the app is launched from
-  # Finder, we still do it on all platforms in case of other bugs we don't know.
-  @webContents.once 'load-url', ->
-    @focus()
-
-  # Redirect focus/blur event to app instance too.
-  @on 'blur', (event) =>
-    app.emit 'browser-window-blur', event, this
-  @on 'focus', (event) =>
-    app.emit 'browser-window-focus', event, this
-
-  # Notify the creation of the window.
-  app.emit 'browser-window-created', {}, this
-
-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 window.webContents?.equal webContents
-
-BrowserWindow.fromDevToolsWebContents = (webContents) ->
-  windows = BrowserWindow.getAllWindows()
-  return window for window in windows when window.devToolsWebContents?.equal webContents
-
-# Helpers.
-BrowserWindow::loadUrl = -> @webContents.loadUrl.apply @webContents, arguments
-BrowserWindow::send = -> @webContents.send.apply @webContents, arguments
-
-# Be compatible with old API.
-BrowserWindow::undo = -> @webContents.undo()
-BrowserWindow::redo = -> @webContents.redo()
-BrowserWindow::cut = -> @webContents.cut()
-BrowserWindow::copy = -> @webContents.copy()
-BrowserWindow::paste = -> @webContents.paste()
-BrowserWindow::selectAll = -> @webContents.selectAll()
-BrowserWindow::restart = -> @webContents.reload()
-BrowserWindow::getUrl = -> @webContents.getUrl()
-BrowserWindow::reload = -> @webContents.reload.apply @webContents, arguments
-BrowserWindow::reloadIgnoringCache = -> @webContents.reloadIgnoringCache.apply @webContents, arguments
-BrowserWindow::getPageTitle = -> @webContents.getTitle()
-BrowserWindow::isLoading = -> @webContents.isLoading()
-BrowserWindow::isWaitingForResponse = -> @webContents.isWaitingForResponse()
-BrowserWindow::stop = -> @webContents.stop()
-BrowserWindow::isCrashed = -> @webContents.isCrashed()
-BrowserWindow::executeJavaScriptInDevTools = (code) -> @devToolsWebContents?.executeJavaScript code
-BrowserWindow::openDevTools = -> @webContents.openDevTools.apply @webContents, arguments
-BrowserWindow::closeDevTools = -> @webContents.closeDevTools()
-BrowserWindow::isDevToolsOpened = -> @webContents.isDevToolsOpened()
-BrowserWindow::toggleDevTools = -> @webContents.toggleDevTools()
-BrowserWindow::inspectElement = -> @webContents.inspectElement.apply @webContents, arguments
-BrowserWindow::inspectServiceWorker = -> @webContents.inspectServiceWorker()
-BrowserWindow::print = -> @webContents.print.apply @webContents, arguments
-BrowserWindow::printToPDF = -> @webContents.printToPDF.apply @webContents, arguments
-
-module.exports = BrowserWindow

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

@@ -1 +0,0 @@
-module.exports = process.atomBinding 'content_tracing'

atom/browser/api/lib/dialog.coffee

@@ -1,125 +0,0 @@
-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', 'error', 'question']
-
-messageBoxOptions =
-  noLink: 1 << 0
-
-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
-
-    # Choose a default button to get selected when dialog is cancelled.
-    unless options.cancelId?
-      options.cancelId = 0
-      for text, i in options.buttons
-        if text.toLowerCase() in ['cancel', 'no']
-          options.cancelId = i
-          break
-
-    flags = if options.noLink then messageBoxOptions.noLink else 0
-
-    binding.showMessageBox messageBoxType,
-                           options.buttons,
-                           options.cancelId,
-                           flags,
-                           options.title,
-                           options.message,
-                           options.detail,
-                           options.icon,
-                           window,
-                           callback
-
-  showErrorBox: (args...) ->
-    binding.showErrorBox args...
-
-# Mark standard asynchronous functions.
-for api in ['showMessageBox', 'showOpenDialog', 'showSaveDialog']
-  v8Util.setHiddenValue module.exports[api], 'asynchronous', true

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

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

atom/browser/api/lib/ipc.coffee

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

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

@@ -1,63 +0,0 @@
-BrowserWindow = require 'browser-window'
-v8Util = process.atomBinding 'v8_util'
-
-nextCommandId = 0
-
-# Maps role to methods of webContents
-rolesMap =
-  undo: 'undo'
-  redo: 'redo'
-  cut: 'cut'
-  copy: 'copy'
-  paste: 'paste'
-  selectall: 'selectAll'
-  minimize: 'minimize'
-  close: 'close'
-
-class MenuItem
-  @types = ['normal', 'separator', 'submenu', 'checkbox', 'radio']
-
-  constructor: (options) ->
-    Menu = require 'menu'
-
-    {click, @selector, @type, @role, @label, @sublabel, @accelerator, @icon, @enabled, @visible, @checked, @submenu} = options
-
-    @type = 'submenu' if not @type? and @submenu?
-    throw new Error('Invalid submenu') if @type is 'submenu' and @submenu?.constructor isnt Menu
-
-    @overrideReadOnlyProperty 'type', 'normal'
-    @overrideReadOnlyProperty 'role'
-    @overrideReadOnlyProperty 'accelerator'
-    @overrideReadOnlyProperty 'icon'
-    @overrideReadOnlyProperty 'submenu'
-    @overrideProperty 'label', ''
-    @overrideProperty 'sublabel', ''
-    @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 = (focusedWindow) =>
-      # Manually flip the checked flags when clicked.
-      @checked = !@checked if @type in ['checkbox', 'radio']
-
-      if @role and rolesMap[@role] and process.platform isnt 'darwin'
-        focusedWindow?[rolesMap[@role]]()
-      else if typeof click is 'function'
-        click this, focusedWindow
-      else if typeof @selector is 'string'
-        Menu.sendActionToFirstResponder @selector
-
-  overrideProperty: (name, defaultValue=null) ->
-    this[name] ?= defaultValue
-
-  overrideReadOnlyProperty: (name, defaultValue=null) ->
-    this[name] ?= defaultValue
-    Object.defineProperty this, name,
-      enumerable: true
-      writable: false
-      value: this[name]
-
-module.exports = MenuItem

atom/browser/api/lib/menu.coffee

@@ -1,176 +0,0 @@
-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
-
-# Returns the index of item according to |id|.
-indexOfItemById = (items, id) ->
-  return i for item, i in items when item.id is id
-  -1
-
-# Returns the index of where to insert the item according to |position|.
-indexToInsertByPosition = (items, position) ->
-  return items.length unless position
-
-  [query, id] = position.split '='
-  insertIndex = indexOfItemById items, id
-  if insertIndex is -1 and query isnt 'endof'
-    console.warn "Item with id '#{id}' is not found"
-    return items.length
-
-  switch query
-    when 'after'
-      insertIndex++
-    when 'endof'
-      # If the |id| doesn't exist, then create a new group with the |id|.
-      if insertIndex is -1
-        items.push id: id, type: 'separator'
-        insertIndex = items.length - 1
-
-      # Find the end of the group.
-      insertIndex++
-      while insertIndex < items.length and items[insertIndex].type isnt 'separator'
-        insertIndex++
-
-  insertIndex
-
-Menu = bindings.Menu
-Menu::__proto__ = EventEmitter.prototype
-
-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 BrowserWindow.getFocusedWindow()
-    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?
-  @setRole pos, item.role if item.role?
-
-  # 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 is null or menu.constructor is Menu
-  applicationMenu = menu  # Keep a reference.
-
-  if process.platform is 'darwin'
-    return if menu is null
-    menu._callMenuWillShow()
-    bindings.setApplicationMenu menu
-  else
-    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
-
-  positionedTemplate = []
-  insertIndex = 0
-
-  for item in template
-    if item.position
-      insertIndex = indexToInsertByPosition positionedTemplate, item.position
-    else
-      # If no |position| is specified, insert after last item.
-      insertIndex++
-    positionedTemplate.splice insertIndex, 0, item
-
-  menu = new Menu
-
-  for item in positionedTemplate
-    throw new TypeError('Invalid template for MenuItem') unless typeof item is 'object'
-
-    item.submenu = Menu.buildFromTemplate item.submenu if item.submenu?
-    menuItem = new MenuItem(item)
-    menuItem[key] = value for key, value of item when not menuItem[key]?
-    menu.append menuItem
-
-  menu
-
-module.exports = Menu

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

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

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

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

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

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

atom/browser/api/lib/protocol.coffee

@@ -1,24 +0,0 @@
-app = require 'app'
-throw new Error('Can not initialize protocol module before app is ready') unless app.isReady()
-
-protocol = process.atomBinding('protocol').protocol
-
-# Warn about removed APIs.
-logAndThrow = (callback, message) ->
-  console.error message
-  if callback then callback(new Error(message)) else throw new Error(message)
-protocol.registerProtocol = (scheme, handler, callback) ->
-  logAndThrow callback,
-              'registerProtocol API has been replaced by the
-               register[File/Http/Buffer/String]Protocol API family, please
-               switch to the new APIs.'
-protocol.isHandledProtocol = (scheme, callback) ->
-  logAndThrow callback,
-              'isHandledProtocol API has been replaced by isProtocolHandled.'
-protocol.interceptProtocol = (scheme, handler, callback) ->
-  logAndThrow callback,
-              'interceptProtocol API has been replaced by the
-               intercept[File/Http/Buffer/String]Protocol API family, please
-               switch to the new APIs.'
-
-module.exports = protocol

atom/browser/api/lib/screen.coffee

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

atom/browser/api/lib/tray.coffee

@@ -1,14 +0,0 @@
-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.
-
-# Keep compatibility with old APIs.
-Tray::popContextMenu = Tray::popUpContextMenu
-
-module.exports = Tray

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

@@ -1,112 +0,0 @@
-EventEmitter = require('events').EventEmitter
-NavigationController = require './navigation-controller'
-binding = process.atomBinding 'web_contents'
-ipc = require 'ipc'
-
-nextId = 0
-getNextId = -> ++nextId
-
-PDFPageSize =
-  A4:
-    custom_display_name: "A4"
-    height_microns: 297000
-    name: "ISO_A4"
-    is_default: "true"
-    width_microns: 210000
-  A3:
-    custom_display_name: "A3"
-    height_microns: 420000
-    name: "ISO_A3"
-    width_microns: 297000
-  Legal:
-    custom_display_name: "Legal"
-    height_microns: 355600
-    name: "NA_LEGAL"
-    width_microns: 215900
-  Letter:
-    custom_display_name: "Letter"
-    height_microns: 279400
-    name: "NA_LETTER"
-    width_microns: 215900
-  Tabloid:
-    height_microns: 431800
-    name: "NA_LEDGER"
-    width_microns: 279400
-    custom_display_name: "Tabloid"
-
-wrapWebContents = (webContents) ->
-  # webContents is an EventEmitter.
-  webContents.__proto__ = EventEmitter.prototype
-
-  # WebContents::send(channel, args..)
-  webContents.send = (channel, args...) ->
-    @_send channel, [args...]
-
-  # Make sure webContents.executeJavaScript would run the code only when the
-  # web contents has been loaded.
-  webContents.executeJavaScript = (code, hasUserGesture=false) ->
-    if @getUrl() and not @isLoading()
-      @_executeJavaScript code, hasUserGesture
-    else
-      webContents.once 'did-finish-load', @_executeJavaScript.bind(this, code, hasUserGesture)
-
-  # The navigation controller.
-  controller = new NavigationController(webContents)
-  for name, method of NavigationController.prototype when method instanceof Function
-    do (name, method) ->
-      webContents[name] = -> method.apply controller, arguments
-
-  # Dispatch IPC messages to the ipc module.
-  webContents.on 'ipc-message', (event, packed) ->
-    [channel, args...] = packed
-    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)
-    ipc.emit channel, event, args...
-
-  webContents.printToPDF = (options, callback) ->
-    printingSetting =
-      pageRage: []
-      mediaSize: {}
-      landscape: false
-      color: 2
-      headerFooterEnabled: false
-      marginsType: 0
-      isFirstRequest: false
-      requestID: getNextId()
-      previewModifiable: true
-      printToPDF: true
-      printWithCloudPrint: false
-      printWithPrivet: false
-      printWithExtension: false
-      deviceName: "Save as PDF"
-      generateDraftData: true
-      fitToPageEnabled: false
-      duplex: 0
-      copies: 1
-      collate: true
-      shouldPrintBackgrounds: false
-      shouldPrintSelectionOnly: false
-
-    if options.landscape
-      printingSetting.landscape = options.landscape
-    if options.marginsType
-      printingSetting.marginsType = options.marginsType
-    if options.printSelectionOnly
-      printingSetting.shouldPrintSelectionOnly = options.printSelectionOnly
-    if options.printBackground
-      printingSetting.shouldPrintBackgrounds = options.printBackground
-
-    if options.pageSize and PDFPageSize[options.pageSize]
-      printingSetting.mediaSize = PDFPageSize[options.pageSize]
-    else
-      printingSetting.mediaSize = PDFPageSize['A4']
-
-    @_printToPDF printingSetting, callback
-
-binding._setWrapWebContents wrapWebContents
-process.once 'exit', binding._clearWrapWebContents
-
-module.exports.create = (options={}) ->
-  binding.create(options)

atom/browser/api/trackable_object.cc

@@ -1,71 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/api/trackable_object.h"
-
-#include "atom/browser/atom_browser_main_parts.h"
-#include "base/bind.h"
-#include "base/supports_user_data.h"
-
-namespace mate {
-
-namespace {
-
-const char* kTrackedObjectKey = "TrackedObjectKey";
-
-class IDUserData : public base::SupportsUserData::Data {
- public:
-  explicit IDUserData(int32_t id) : id_(id) {}
-
-  operator int32_t() const { return id_; }
-
- private:
-  int32_t id_;
-
-  DISALLOW_COPY_AND_ASSIGN(IDUserData);
-};
-
-}  // namespace
-
-TrackableObjectBase::TrackableObjectBase()
-    : weak_map_id_(0), wrapped_(nullptr), weak_factory_(this) {
-  RegisterDestructionCallback(
-      base::Bind(&TrackableObjectBase::Destroy, weak_factory_.GetWeakPtr()));
-}
-
-TrackableObjectBase::~TrackableObjectBase() {
-}
-
-void TrackableObjectBase::AfterInit(v8::Isolate* isolate) {
-  if (wrapped_)
-    AttachAsUserData(wrapped_);
-}
-
-void TrackableObjectBase::AttachAsUserData(base::SupportsUserData* wrapped) {
-  if (weak_map_id_ != 0) {
-    wrapped->SetUserData(kTrackedObjectKey, new IDUserData(weak_map_id_));
-    wrapped_ = nullptr;
-  } else {
-    // If the TrackableObjectBase is not ready yet then delay SetUserData until
-    // AfterInit is called.
-    wrapped_ = wrapped;
-  }
-}
-
-// static
-int32_t TrackableObjectBase::GetIDFromWrappedClass(base::SupportsUserData* w) {
-  auto id = static_cast<IDUserData*>(w->GetUserData(kTrackedObjectKey));
-  if (id)
-    return *id;
-  else
-    return 0;
-}
-
-// static
-void TrackableObjectBase::RegisterDestructionCallback(
-    const base::Closure& closure) {
-  atom::AtomBrowserMainParts::Get()->RegisterDestructionCallback(closure);
-}
-
-}  // namespace mate

atom/browser/api/trackable_object.h

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

atom/browser/atom_access_token_store.cc

@@ -1,53 +0,0 @@
-// 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/browser/atom_browser_main_parts.h"
-#include "atom/common/google_api_key.h"
-#include "content/public/browser/geolocation_provider.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() {
-  content::GeolocationProvider::GetInstance()->UserDidOptIntoLocationServices();
-}
-
-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);
-
-  auto browser_context = AtomBrowserMainParts::Get()->browser_context();
-  callback.Run(access_token_set, browser_context->url_request_context_getter());
-}
-
-void AtomAccessTokenStore::SaveAccessToken(const GURL& server_url,
-                                           const base::string16& access_token) {
-}
-
-}  // namespace atom

atom/browser/atom_access_token_store.h

@@ -1,31 +0,0 @@
-// 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

@@ -1,246 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/atom_browser_client.h"
-
-#if defined(OS_WIN)
-#include <shlobj.h>
-#endif
-
-#include "atom/browser/atom_access_token_store.h"
-#include "atom/browser/atom_browser_context.h"
-#include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/atom_quota_permission_context.h"
-#include "atom/browser/atom_speech_recognition_manager_delegate.h"
-#include "atom/browser/browser.h"
-#include "atom/browser/native_window.h"
-#include "atom/browser/web_contents_preferences.h"
-#include "atom/browser/window_list.h"
-#include "atom/common/options_switches.h"
-#include "base/command_line.h"
-#include "base/files/file_util.h"
-#include "base/stl_util.h"
-#include "base/strings/string_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "chrome/browser/printing/printing_message_filter.h"
-#include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
-#include "chrome/browser/speech/tts_message_filter.h"
-#include "content/public/browser/browser_ppapi_host.h"
-#include "content/public/browser/client_certificate_delegate.h"
-#include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.h"
-#include "content/public/browser/site_instance.h"
-#include "content/public/browser/web_contents.h"
-#include "content/public/common/web_preferences.h"
-#include "net/cert/x509_certificate.h"
-#include "net/ssl/ssl_cert_request_info.h"
-#include "ppapi/host/ppapi_host.h"
-#include "ui/base/l10n/l10n_util.h"
-#include "v8/include/v8.h"
-
-namespace atom {
-
-namespace {
-
-// The default routing id of WebContents.
-// In Electron each RenderProcessHost only has one WebContents, so this ID is
-// same for every WebContents.
-int kDefaultRoutingID = 2;
-
-// Next navigation should not restart renderer process.
-bool g_suppress_renderer_process_restart = false;
-
-// Custom schemes to be registered to standard.
-std::string g_custom_schemes = "";
-
-scoped_refptr<net::X509Certificate> ImportCertFromFile(
-    const base::FilePath& path) {
-  if (path.empty())
-    return nullptr;
-
-  std::string cert_data;
-  if (!base::ReadFileToString(path, &cert_data))
-    return nullptr;
-
-  net::CertificateList certs =
-      net::X509Certificate::CreateCertificateListFromBytes(
-          cert_data.data(), cert_data.size(),
-          net::X509Certificate::FORMAT_AUTO);
-
-  if (certs.empty())
-    return nullptr;
-
-  return certs[0];
-}
-
-}  // namespace
-
-// static
-void AtomBrowserClient::SuppressRendererProcessRestartForOnce() {
-  g_suppress_renderer_process_restart = true;
-}
-
-void AtomBrowserClient::SetCustomSchemes(
-    const std::vector<std::string>& schemes) {
-  g_custom_schemes = JoinString(schemes, ',');
-}
-
-AtomBrowserClient::AtomBrowserClient() {
-}
-
-AtomBrowserClient::~AtomBrowserClient() {
-}
-
-void AtomBrowserClient::RenderProcessWillLaunch(
-    content::RenderProcessHost* host) {
-  int process_id = host->GetID();
-  host->AddFilter(new printing::PrintingMessageFilter(process_id));
-  host->AddFilter(new TtsMessageFilter(process_id, host->GetBrowserContext()));
-}
-
-content::SpeechRecognitionManagerDelegate*
-    AtomBrowserClient::CreateSpeechRecognitionManagerDelegate() {
-  return new AtomSpeechRecognitionManagerDelegate;
-}
-
-content::AccessTokenStore* AtomBrowserClient::CreateAccessTokenStore() {
-  return new AtomAccessTokenStore;
-}
-
-void AtomBrowserClient::OverrideWebkitPrefs(
-    content::RenderViewHost* host, 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;
-
-  // Custom preferences of guest page.
-  auto web_contents = content::WebContents::FromRenderViewHost(host);
-  WebContentsPreferences::OverrideWebkitPrefs(web_contents, prefs);
-}
-
-std::string AtomBrowserClient::GetApplicationLocale() {
-  return l10n_util::GetApplicationLocale("");
-}
-
-void AtomBrowserClient::OverrideSiteInstanceForNavigation(
-    content::BrowserContext* browser_context,
-    content::SiteInstance* current_instance,
-    const GURL& url,
-    content::SiteInstance** new_instance) {
-  if (g_suppress_renderer_process_restart) {
-    g_suppress_renderer_process_restart = false;
-    return;
-  }
-
-  // Restart renderer process for all navigations except "javacript:" scheme.
-  if (url.SchemeIs(url::kJavaScriptScheme))
-    return;
-
-  *new_instance = content::SiteInstance::CreateForURL(browser_context, url);
-
-  // Remember the original renderer process of the pending renderer process.
-  auto current_process = current_instance->GetProcess();
-  auto pending_process = (*new_instance)->GetProcess();
-  pending_processes_[pending_process->GetID()] = current_process->GetID();
-  // Clear the entry in map when process ends.
-  current_process->AddObserver(this);
-}
-
-void AtomBrowserClient::AppendExtraCommandLineSwitches(
-    base::CommandLine* command_line,
-    int process_id) {
-  std::string process_type = command_line->GetSwitchValueASCII("type");
-  if (process_type != "renderer")
-    return;
-
-  // The registered standard schemes.
-  if (!g_custom_schemes.empty())
-    command_line->AppendSwitchASCII(switches::kRegisterStandardSchemes,
-                                    g_custom_schemes);
-
-#if defined(OS_WIN)
-  // Append --app-user-model-id.
-  PWSTR current_app_id;
-  if (SUCCEEDED(GetCurrentProcessExplicitAppUserModelID(&current_app_id))) {
-    command_line->AppendSwitchNative(switches::kAppUserModelId, current_app_id);
-    CoTaskMemFree(current_app_id);
-  }
-#endif
-
-  // If the process is a pending process, we should use the old one.
-  if (ContainsKey(pending_processes_, process_id))
-    process_id = pending_processes_[process_id];
-
-  // Get the WebContents of the render process.
-  content::WebContents* web_contents = content::WebContents::FromRenderViewHost(
-      content::RenderViewHost::FromID(process_id, kDefaultRoutingID));
-  if (!web_contents)
-    return;
-
-  WebContentsPreferences::AppendExtraCommandLineSwitches(
-      web_contents, command_line);
-}
-
-void AtomBrowserClient::DidCreatePpapiPlugin(
-    content::BrowserPpapiHost* host) {
-  host->GetPpapiHost()->AddHostFactoryFilter(
-      make_scoped_ptr(new chrome::ChromeBrowserPepperHostFactory(host)));
-}
-
-content::QuotaPermissionContext*
-    AtomBrowserClient::CreateQuotaPermissionContext() {
-  return new AtomQuotaPermissionContext;
-}
-
-void AtomBrowserClient::SelectClientCertificate(
-    content::WebContents* web_contents,
-    net::SSLCertRequestInfo* cert_request_info,
-    scoped_ptr<content::ClientCertificateDelegate> delegate) {
-  // --client-certificate=`path`
-  auto cmd = base::CommandLine::ForCurrentProcess();
-  if (cmd->HasSwitch(switches::kClientCertificate)) {
-    auto cert_path = cmd->GetSwitchValuePath(switches::kClientCertificate);
-    auto certificate = ImportCertFromFile(cert_path);
-    if (certificate.get())
-      delegate->ContinueWithCertificate(certificate.get());
-    return;
-  }
-
-  if (!cert_request_info->client_certs.empty())
-    Browser::Get()->ClientCertificateSelector(web_contents,
-                                              cert_request_info,
-                                              delegate.Pass());
-}
-
-brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts(
-    const content::MainFunctionParams&) {
-  v8::V8::Initialize();  // Init V8 before creating main parts.
-  return new AtomBrowserMainParts;
-}
-
-void AtomBrowserClient::RenderProcessHostDestroyed(
-    content::RenderProcessHost* host) {
-  int process_id = host->GetID();
-  for (const auto& entry : pending_processes_) {
-    if (entry.first == process_id || entry.second == process_id) {
-      pending_processes_.erase(entry.first);
-      break;
-    }
-  }
-}
-
-}  // namespace atom

atom/browser/atom_browser_client.h

@@ -1,76 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
-#define ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "brightray/browser/browser_client.h"
-#include "content/public/browser/render_process_host_observer.h"
-
-namespace content {
-class QuotaPermissionContext;
-class ClientCertificateDelegate;
-}
-
-namespace net {
-class SSLCertRequestInfo;
-}
-
-namespace atom {
-
-class AtomBrowserClient : public brightray::BrowserClient,
-                          public content::RenderProcessHostObserver {
- public:
-  AtomBrowserClient();
-  virtual ~AtomBrowserClient();
-
-  // Don't force renderer process to restart for once.
-  static void SuppressRendererProcessRestartForOnce();
-  // Custom schemes to be registered to standard.
-  static void SetCustomSchemes(const std::vector<std::string>& schemes);
-
- protected:
-  // content::ContentBrowserClient:
-  void RenderProcessWillLaunch(content::RenderProcessHost* host) override;
-  content::SpeechRecognitionManagerDelegate*
-      CreateSpeechRecognitionManagerDelegate() override;
-  content::AccessTokenStore* CreateAccessTokenStore() override;
-  void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
-                           content::WebPreferences* prefs) override;
-  std::string GetApplicationLocale() override;
-  void OverrideSiteInstanceForNavigation(
-      content::BrowserContext* browser_context,
-      content::SiteInstance* current_instance,
-      const GURL& dest_url,
-      content::SiteInstance** new_instance) override;
-  void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
-                                      int child_process_id) override;
-  void DidCreatePpapiPlugin(content::BrowserPpapiHost* browser_host) override;
-  content::QuotaPermissionContext* CreateQuotaPermissionContext() override;
-  void SelectClientCertificate(
-      content::WebContents* web_contents,
-      net::SSLCertRequestInfo* cert_request_info,
-      scoped_ptr<content::ClientCertificateDelegate> delegate) override;
-
-  // brightray::BrowserClient:
-  brightray::BrowserMainParts* OverrideCreateBrowserMainParts(
-      const content::MainFunctionParams&) override;
-
-  // content::RenderProcessHostObserver:
-  void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
-
- private:
-  // pending_render_process => current_render_process.
-  std::map<int, int> pending_processes_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomBrowserClient);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_ATOM_BROWSER_CLIENT_H_

atom/browser/atom_browser_context.cc

@@ -1,176 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/atom_browser_context.h"
-
-#include "atom/browser/atom_browser_main_parts.h"
-#include "atom/browser/atom_download_manager_delegate.h"
-#include "atom/browser/browser.h"
-#include "atom/browser/net/atom_url_request_job_factory.h"
-#include "atom/browser/net/asar/asar_protocol_handler.h"
-#include "atom/browser/net/http_protocol_handler.h"
-#include "atom/browser/web_view_manager.h"
-#include "atom/common/atom_version.h"
-#include "atom/common/chrome_version.h"
-#include "atom/common/options_switches.h"
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/prefs/pref_registry_simple.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "base/threading/worker_pool.h"
-#include "chrome/common/pref_names.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/common/url_constants.h"
-#include "content/public/common/user_agent.h"
-#include "net/ftp/ftp_network_layer.h"
-#include "net/url_request/data_protocol_handler.h"
-#include "net/url_request/ftp_protocol_handler.h"
-#include "net/url_request/url_request_intercepting_job_factory.h"
-#include "net/url_request/url_request_context.h"
-#include "url/url_constants.h"
-
-using content::BrowserThread;
-
-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;
-  }
-};
-
-std::string RemoveWhitespace(const std::string& str) {
-  std::string trimmed;
-  if (base::RemoveChars(str, " ", &trimmed))
-    return trimmed;
-  else
-    return str;
-}
-
-}  // namespace
-
-AtomBrowserContext::AtomBrowserContext(const std::string& partition,
-                                       bool in_memory)
-    : brightray::BrowserContext(partition, in_memory),
-      job_factory_(new AtomURLRequestJobFactory) {
-}
-
-AtomBrowserContext::~AtomBrowserContext() {
-}
-
-std::string AtomBrowserContext::GetUserAgent() {
-  Browser* browser = Browser::Get();
-  std::string name = RemoveWhitespace(browser->GetName());
-  std::string user_agent;
-  if (name == ATOM_PRODUCT_NAME) {
-    user_agent = "Chrome/" CHROME_VERSION_STRING " "
-                 ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING;
-  } else {
-    user_agent = base::StringPrintf(
-        "%s/%s Chrome/%s " ATOM_PRODUCT_NAME "/" ATOM_VERSION_STRING,
-        name.c_str(),
-        browser->GetVersion().c_str(),
-        CHROME_VERSION_STRING);
-  }
-  return content::BuildUserAgentFromProduct(user_agent);
-}
-
-net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
-    content::ProtocolHandlerMap* handlers,
-    content::URLRequestInterceptorScopedVector* interceptors) {
-  scoped_ptr<AtomURLRequestJobFactory> job_factory(job_factory_);
-
-  for (auto& it : *handlers) {
-    job_factory->SetProtocolHandler(it.first,
-                                    make_scoped_ptr(it.second.release()));
-  }
-  handlers->clear();
-
-  job_factory->SetProtocolHandler(
-      url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler));
-  job_factory->SetProtocolHandler(
-      url::kFileScheme, make_scoped_ptr(new asar::AsarProtocolHandler(
-          BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
-  job_factory->SetProtocolHandler(
-      url::kHttpScheme,
-      make_scoped_ptr(new HttpProtocolHandler(url::kHttpScheme)));
-  job_factory->SetProtocolHandler(
-      url::kHttpsScheme,
-      make_scoped_ptr(new HttpProtocolHandler(url::kHttpsScheme)));
-  job_factory->SetProtocolHandler(
-      url::kWsScheme,
-      make_scoped_ptr(new HttpProtocolHandler(url::kWsScheme)));
-  job_factory->SetProtocolHandler(
-      url::kWssScheme,
-      make_scoped_ptr(new HttpProtocolHandler(url::kWssScheme)));
-
-  auto host_resolver =
-      url_request_context_getter()->GetURLRequestContext()->host_resolver();
-  job_factory->SetProtocolHandler(
-      url::kFtpScheme,
-      make_scoped_ptr(new net::FtpProtocolHandler(
-          new net::FtpNetworkLayer(host_resolver))));
-
-  // Set up interceptors in the reverse order.
-  scoped_ptr<net::URLRequestJobFactory> top_job_factory = job_factory.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::DownloadManagerDelegate*
-AtomBrowserContext::GetDownloadManagerDelegate() {
-  if (!download_manager_delegate_.get()) {
-    auto download_manager = content::BrowserContext::GetDownloadManager(this);
-    download_manager_delegate_.reset(
-        new AtomDownloadManagerDelegate(download_manager));
-  }
-  return download_manager_delegate_.get();
-}
-
-content::BrowserPluginGuestManager* AtomBrowserContext::GetGuestManager() {
-  if (!guest_manager_)
-    guest_manager_.reset(new WebViewManager);
-  return guest_manager_.get();
-}
-
-void AtomBrowserContext::RegisterPrefs(PrefRegistrySimple* pref_registry) {
-  pref_registry->RegisterFilePathPref(prefs::kSelectFileLastDirectory,
-                                      base::FilePath());
-  pref_registry->RegisterFilePathPref(prefs::kDownloadDefaultDirectory,
-                                      base::FilePath());
-}
-
-}  // namespace atom
-
-namespace brightray {
-
-// static
-scoped_refptr<BrowserContext> BrowserContext::Create(
-    const std::string& partition, bool in_memory) {
-  return make_scoped_refptr(new atom::AtomBrowserContext(partition, in_memory));
-}
-
-}  // namespace brightray

atom/browser/atom_browser_context.h

@@ -1,52 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
-#define ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_
-
-#include <string>
-
-#include "brightray/browser/browser_context.h"
-
-namespace atom {
-
-class AtomDownloadManagerDelegate;
-class AtomURLRequestJobFactory;
-class WebViewManager;
-
-class AtomBrowserContext : public brightray::BrowserContext {
- public:
-  AtomBrowserContext(const std::string& partition, bool in_memory);
-  ~AtomBrowserContext() override;
-
-  // brightray::URLRequestContextGetter::Delegate:
-  std::string GetUserAgent() override;
-  net::URLRequestJobFactory* CreateURLRequestJobFactory(
-      content::ProtocolHandlerMap* handlers,
-      content::URLRequestInterceptorScopedVector* interceptors) override;
-  net::HttpCache::BackendFactory* CreateHttpCacheBackendFactory(
-      const base::FilePath& base_path) override;
-
-  // content::BrowserContext:
-  content::DownloadManagerDelegate* GetDownloadManagerDelegate() override;
-  content::BrowserPluginGuestManager* GetGuestManager() override;
-
-  // brightray::BrowserContext:
-  void RegisterPrefs(PrefRegistrySimple* pref_registry) override;
-
-  AtomURLRequestJobFactory* job_factory() const { return job_factory_; }
-
- private:
-  scoped_ptr<AtomDownloadManagerDelegate> download_manager_delegate_;
-  scoped_ptr<WebViewManager> guest_manager_;
-
-  // Managed by brightray::BrowserContext.
-  AtomURLRequestJobFactory* job_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomBrowserContext);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_ATOM_BROWSER_CONTEXT_H_

atom/browser/atom_browser_main_parts.cc

@@ -1,129 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/atom_browser_main_parts.h"
-
-#include "atom/browser/api/trackable_object.h"
-#include "atom/browser/atom_browser_client.h"
-#include "atom/browser/atom_browser_context.h"
-#include "atom/browser/bridge_task_runner.h"
-#include "atom/browser/browser.h"
-#include "atom/browser/javascript_environment.h"
-#include "atom/browser/node_debugger.h"
-#include "atom/common/api/atom_bindings.h"
-#include "atom/common/node_bindings.h"
-#include "atom/common/node_includes.h"
-#include "base/command_line.h"
-#include "base/thread_task_runner_handle.h"
-#include "chrome/browser/browser_process.h"
-#include "v8/include/v8-debug.h"
-
-#if defined(USE_X11)
-#include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
-#endif
-
-namespace atom {
-
-// static
-AtomBrowserMainParts* AtomBrowserMainParts::self_ = NULL;
-
-AtomBrowserMainParts::AtomBrowserMainParts()
-    : fake_browser_process_(new BrowserProcess),
-      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_;
-}
-
-void AtomBrowserMainParts::RegisterDestructionCallback(
-    const base::Closure& callback) {
-  destruction_callbacks_.push_back(callback);
-}
-
-void AtomBrowserMainParts::PostEarlyInitialization() {
-  brightray::BrowserMainParts::PostEarlyInitialization();
-
-#if defined(USE_X11)
-  SetDPIFromGSettings();
-#endif
-
-  {
-    // Temporary set the bridge_task_runner_ as current thread's task runner,
-    // so we can fool gin::PerIsolateData to use it as its task runner, instead
-    // of getting current message loop's task runner, which is null for now.
-    bridge_task_runner_ = new BridgeTaskRunner;
-    base::ThreadTaskRunnerHandle handle(bridge_task_runner_);
-
-    // The ProxyResolverV8 has setup a complete V8 environment, in order to
-    // avoid conflicts we only initialize our V8 environment after that.
-    js_env_.reset(new JavascriptEnvironment);
-  }
-
-  node_bindings_->Initialize();
-
-  // 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
-}
-
-void AtomBrowserMainParts::PostMainMessageLoopRun() {
-  brightray::BrowserMainParts::PostMainMessageLoopRun();
-
-  // Make sure destruction callbacks are called before message loop is
-  // destroyed, otherwise some objects that need to be deleted on IO thread
-  // won't be freed.
-  for (const auto& callback : destruction_callbacks_)
-    callback.Run();
-}
-
-}  // namespace atom

atom/browser/atom_browser_main_parts.h

@@ -1,80 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
-#define ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_
-
-#include <list>
-#include <string>
-
-#include "base/callback.h"
-#include "base/timer/timer.h"
-#include "brightray/browser/browser_main_parts.h"
-#include "content/public/browser/browser_context.h"
-
-class BrowserProcess;
-
-namespace atom {
-
-class AtomBindings;
-class Browser;
-class JavascriptEnvironment;
-class NodeBindings;
-class NodeDebugger;
-class BridgeTaskRunner;
-
-class AtomBrowserMainParts : public brightray::BrowserMainParts {
- public:
-  AtomBrowserMainParts();
-  virtual ~AtomBrowserMainParts();
-
-  static AtomBrowserMainParts* Get();
-
-  // Register a callback that should be destroyed before JavaScript environment
-  // gets destroyed.
-  void RegisterDestructionCallback(const base::Closure& callback);
-
-  Browser* browser() { return browser_.get(); }
-
- protected:
-  // content::BrowserMainParts:
-  void PostEarlyInitialization() override;
-  void PreMainMessageLoopRun() override;
-  void PostMainMessageLoopRun() override;
-#if defined(OS_MACOSX)
-  void PreMainMessageLoopStart() override;
-  void PostDestroyThreads() override;
-#endif
-
- private:
-#if defined(USE_X11)
-  void SetDPIFromGSettings();
-#endif
-
-  // A fake BrowserProcess object that used to feed the source code from chrome.
-  scoped_ptr<BrowserProcess> fake_browser_process_;
-
-  // The gin::PerIsolateData requires a task runner to create, so we feed it
-  // with a task runner that will post all work to main loop.
-  scoped_refptr<BridgeTaskRunner> bridge_task_runner_;
-
-  scoped_ptr<Browser> browser_;
-  scoped_ptr<JavascriptEnvironment> js_env_;
-  scoped_ptr<NodeBindings> node_bindings_;
-  scoped_ptr<AtomBindings> atom_bindings_;
-  scoped_ptr<NodeDebugger> node_debugger_;
-
-  base::Timer gc_timer_;
-
-  // List of callbacks should be executed before destroying JS env.
-  std::list<base::Closure> destruction_callbacks_;
-
-  static AtomBrowserMainParts* self_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomBrowserMainParts);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_ATOM_BROWSER_MAIN_PARTS_H_

atom/browser/atom_browser_main_parts_linux.cc

@@ -1,73 +0,0 @@
-// 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 <gio/gio.h>
-
-#include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
-#include "ui/gfx/switches.h"
-
-namespace atom {
-
-namespace {
-
-const char* kInterfaceSchema = "org.gnome.desktop.interface";
-const char* kScaleFactor = "scaling-factor";
-
-bool SchemaExists(const char* schema_name) {
-  const gchar* const* schemas = g_settings_list_schemas();
-  while (*schemas) {
-    if (strcmp(schema_name, static_cast<const char*>(*schemas)) == 0)
-      return true;
-    schemas++;
-  }
-  return false;
-}
-
-bool KeyExists(GSettings* client, const char* key) {
-  gchar** keys = 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) {
-  GSettings* client = nullptr;
-  if (!SchemaExists(kInterfaceSchema) ||
-      !(client = g_settings_new(kInterfaceSchema))) {
-    VLOG(1) << "Cannot create gsettings client.";
-    return;
-  }
-
-  if (KeyExists(client, kScaleFactor))
-    *scale_factor = 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

@@ -1,42 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#include "atom/browser/atom_browser_main_parts.h"
-
-#include "atom/browser/mac/atom_application.h"
-#include "atom/browser/mac/atom_application_delegate.h"
-#include "base/mac/bundle_locations.h"
-#include "base/mac/foundation_util.h"
-#include "ui/base/l10n/l10n_util_mac.h"
-
-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];
-
-  NSBundle* frameworkBundle = base::mac::FrameworkBundle();
-  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_download_manager_delegate.cc

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

atom/browser/atom_download_manager_delegate.h

@@ -1,57 +0,0 @@
-// Copyright (c) 2015 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#ifndef ATOM_BROWSER_ATOM_DOWNLOAD_MANAGER_DELEGATE_H_
-#define ATOM_BROWSER_ATOM_DOWNLOAD_MANAGER_DELEGATE_H_
-
-#include <string>
-
-#include "base/memory/weak_ptr.h"
-#include "content/public/browser/download_manager_delegate.h"
-
-namespace content {
-class DownloadManager;
-}
-
-namespace atom {
-
-class AtomDownloadManagerDelegate : public content::DownloadManagerDelegate {
- public:
-  using CreateDownloadPathCallback =
-      base::Callback<void(const base::FilePath&)>;
-
-  explicit AtomDownloadManagerDelegate(content::DownloadManager* manager);
-  virtual ~AtomDownloadManagerDelegate();
-
-  // Generate default file path to save the download.
-  void CreateDownloadPath(const GURL& url,
-                          const std::string& suggested_filename,
-                          const std::string& content_disposition,
-                          const std::string& mime_type,
-                          const base::FilePath& path,
-                          const CreateDownloadPathCallback& callback);
-  void OnDownloadPathGenerated(uint32 download_id,
-                               const content::DownloadTargetCallback& callback,
-                               const base::FilePath& default_path);
-
-  // content::DownloadManagerDelegate:
-  void Shutdown() override;
-  bool DetermineDownloadTarget(
-      content::DownloadItem* download,
-      const content::DownloadTargetCallback& callback) override;
-  bool ShouldOpenDownload(
-      content::DownloadItem* download,
-      const content::DownloadOpenDelayedCallback& callback) override;
-  void GetNextId(const content::DownloadIdCallback& callback) override;
-
- private:
-  content::DownloadManager* download_manager_;
-  base::WeakPtrFactory<AtomDownloadManagerDelegate> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomDownloadManagerDelegate);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_ATOM_DOWNLOAD_MANAGER_DELEGATE_H_

atom/browser/atom_javascript_dialog_manager.cc

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

@@ -1,38 +0,0 @@
-// Copyright (c) 2013 GitHub, Inc.
-// Use of this source code is governed by the MIT license that can be
-// found in the LICENSE file.
-
-#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 ResetDialogState(content::WebContents* web_contents) override {};
-};
-
-}  // namespace atom
-
-#endif  // ATOM_BROWSER_ATOM_JAVASCRIPT_DIALOG_MANAGER_H_