Bump v0.21.0

Upgrade to Chrome 40

README.md

@@ -10,6 +10,10 @@ editor](https://github.com/atom/atom).
 Prebuilt binaries of atom-shell for Linux, Windows and Mac can be found on the
 [releases](https://github.com/atom/atom-shell/releases) page.
 
+### Mirrors
+
+- [China Mirror](https://npm.taobao.org/mirrors/atom-shell): Improve download speeds for Chinese user.
+
 ## Documentation
 
 Guides and the API reference are located in the

atom.gyp

@@ -25,6 +25,7 @@
       'atom/browser/api/lib/menu-item.coffee',
       'atom/browser/api/lib/power-monitor.coffee',
       'atom/browser/api/lib/protocol.coffee',
+      'atom/browser/api/lib/screen.coffee',
       'atom/browser/api/lib/tray.coffee',
       'atom/browser/api/lib/web-contents.coffee',
       'atom/browser/lib/chrome-extension.coffee',
@@ -38,7 +39,6 @@
       'atom/common/api/lib/crash-reporter.coffee',
       'atom/common/api/lib/id-weak-map.coffee',
       'atom/common/api/lib/original-fs.coffee',
-      'atom/common/api/lib/screen.coffee',
       'atom/common/api/lib/shell.coffee',
       'atom/common/lib/init.coffee',
       'atom/common/lib/asar.coffee',
@@ -52,6 +52,7 @@
       'atom/renderer/lib/web-view/web-view-constants.coffee',
       'atom/renderer/api/lib/ipc.coffee',
       'atom/renderer/api/lib/remote.coffee',
+      'atom/renderer/api/lib/screen.coffee',
       'atom/renderer/api/lib/web-frame.coffee',
     ],
     'lib_sources': [
@@ -78,6 +79,8 @@
       'atom/browser/api/atom_api_power_monitor.h',
       'atom/browser/api/atom_api_protocol.cc',
       'atom/browser/api/atom_api_protocol.h',
+      'atom/browser/api/atom_api_screen.cc',
+      'atom/browser/api/atom_api_screen.h',
       'atom/browser/api/atom_api_tray.cc',
       'atom/browser/api/atom_api_tray.h',
       'atom/browser/api/atom_api_web_contents.cc',
@@ -199,8 +202,6 @@
       'atom/common/api/atom_api_crash_reporter.cc',
       'atom/common/api/atom_api_id_weak_map.cc',
       'atom/common/api/atom_api_id_weak_map.h',
-      'atom/common/api/atom_api_screen.cc',
-      'atom/common/api/atom_api_screen.h',
       'atom/common/api/atom_api_shell.cc',
       'atom/common/api/atom_api_v8_util.cc',
       'atom/common/api/atom_bindings.cc',
@@ -234,6 +235,7 @@
       'atom/common/native_mate_converters/accelerator_converter.cc',
       'atom/common/native_mate_converters/accelerator_converter.h',
       'atom/common/native_mate_converters/file_path_converter.h',
+      'atom/common/native_mate_converters/gfx_converter.cc',
       'atom/common/native_mate_converters/gfx_converter.h',
       'atom/common/native_mate_converters/gurl_converter.h',
       'atom/common/native_mate_converters/image_converter.cc',
@@ -264,8 +266,6 @@
       'atom/renderer/api/atom_api_spell_check_client.h',
       'atom/renderer/api/atom_api_web_frame.cc',
       'atom/renderer/api/atom_api_web_frame.h',
-      'atom/renderer/api/atom_renderer_bindings.cc',
-      'atom/renderer/api/atom_renderer_bindings.h',
       'atom/renderer/atom_render_view_observer.cc',
       'atom/renderer/atom_render_view_observer.h',
       'atom/renderer/atom_renderer_client.cc',
@@ -340,8 +340,8 @@
       'chromium_src/chrome/browser/ui/views/color_chooser_win.cc',
     ],
     'framework_sources': [
-      'atom/app/atom_library_main.cc',
       'atom/app/atom_library_main.h',
+      'atom/app/atom_library_main.mm',
     ],
     'locales': [
       'am', 'ar', 'bg', 'bn', 'ca', 'cs', 'da', 'de', 'el', 'en-GB',
@@ -801,6 +801,9 @@
             'vendor',
             '<(libchromiumcontent_include_dir)',
           ],
+          'defines': [
+            'PRODUCT_NAME="<(product_name)"',
+          ],
           'export_dependent_settings': [
             '<(project_name)_lib',
           ],

atom/app/atom_content_client.h

@@ -19,10 +19,10 @@ class AtomContentClient : public brightray::ContentClient {
 
  protected:
   // content::ContentClient:
-  virtual std::string GetProduct() const OVERRIDE;
-  virtual void AddAdditionalSchemes(
+  std::string GetProduct() const override;
+  void AddAdditionalSchemes(
       std::vector<std::string>* standard_schemes,
-      std::vector<std::string>* savable_schemes) OVERRIDE;
+      std::vector<std::string>* savable_schemes) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AtomContentClient);

atom/app/atom_library_main.h

@@ -11,6 +11,9 @@
 extern "C" {
 __attribute__((visibility("default")))
 int AtomMain(int argc, const char* argv[]);
+
+__attribute__((visibility("default")))
+void AtomInitializeICU();
 }
 #endif  // OS_MACOSX
 

atom/app/atom_library_main.mm

@@ -5,6 +5,9 @@
 #include "atom/app/atom_library_main.h"
 
 #include "atom/app/atom_main_delegate.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)
@@ -15,4 +18,13 @@ int AtomMain(int argc, const char* argv[]) {
   params.argv = argv;
   return content::ContentMain(params);
 }
+
+void AtomInitializeICU() {
+  base::mac::SetOverrideFrameworkBundlePath(
+      brightray::MainApplicationBundlePath()
+          .Append("Contents")
+          .Append("Frameworks")
+          .Append(PRODUCT_NAME " Framework.framework"));
+  base::i18n::InitializeICU();
+}
 #endif  // OS_MACOSX

atom/app/atom_main.cc

@@ -13,11 +13,14 @@
 #include <fcntl.h>
 
 #include <windows.h>
+#include <shellscalingapi.h>
+#include <tchar.h>
 #include <shellapi.h>
 
 #include "atom/app/atom_main_delegate.h"
 #include "atom/common/crash_reporter/win/crash_service_main.h"
 #include "base/environment.h"
+#include "base/win/windows_version.h"
 #include "content/public/app/startup_helper_win.h"
 #include "sandbox/win/src/sandbox_types.h"
 #include "ui/gfx/win/dpi.h"
@@ -28,6 +31,8 @@
 #include "atom/app/atom_library_main.h"
 #endif  // defined(OS_MACOSX)
 
+#include "base/i18n/icu_util.h"
+
 // Declaration of node::Start.
 namespace node {
 int Start(int argc, char *argv[]);
@@ -35,6 +40,48 @@ int Start(int argc, char *argv[]);
 
 #if defined(OS_WIN)
 
+namespace {
+
+// Win8.1 supports monitor-specific DPI scaling.
+bool SetProcessDpiAwarenessWrapper(PROCESS_DPI_AWARENESS value) {
+  typedef HRESULT(WINAPI *SetProcessDpiAwarenessPtr)(PROCESS_DPI_AWARENESS);
+  SetProcessDpiAwarenessPtr set_process_dpi_awareness_func =
+      reinterpret_cast<SetProcessDpiAwarenessPtr>(
+          GetProcAddress(GetModuleHandleA("user32.dll"),
+                         "SetProcessDpiAwarenessInternal"));
+  if (set_process_dpi_awareness_func) {
+    HRESULT hr = set_process_dpi_awareness_func(value);
+    if (SUCCEEDED(hr)) {
+      VLOG(1) << "SetProcessDpiAwareness succeeded.";
+      return true;
+    } else if (hr == E_ACCESSDENIED) {
+      LOG(ERROR) << "Access denied error from SetProcessDpiAwareness. "
+          "Function called twice, or manifest was used.";
+    }
+  }
+  return false;
+}
+
+// This function works for Windows Vista through Win8. Win8.1 must use
+// SetProcessDpiAwareness[Wrapper].
+BOOL SetProcessDPIAwareWrapper() {
+  typedef BOOL(WINAPI *SetProcessDPIAwarePtr)(VOID);
+  SetProcessDPIAwarePtr set_process_dpi_aware_func =
+      reinterpret_cast<SetProcessDPIAwarePtr>(
+      GetProcAddress(GetModuleHandleA("user32.dll"),
+                      "SetProcessDPIAware"));
+  return set_process_dpi_aware_func &&
+    set_process_dpi_aware_func();
+}
+
+void EnableHighDPISupport() {
+  if (!SetProcessDpiAwarenessWrapper(PROCESS_SYSTEM_DPI_AWARE)) {
+    SetProcessDPIAwareWrapper();
+  }
+}
+
+}  // namespace
+
 int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   int argc = 0;
   wchar_t** wargv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
@@ -89,6 +136,7 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
       }
     }
     // Now that conversion is done, we can finally start.
+    base::i18n::InitializeICU();
     return node::Start(argc, argv);
   } else if (env->GetVar("ATOM_SHELL_INTERNAL_CRASH_SERVICE",
                          &crash_service_indicator) &&
@@ -100,8 +148,11 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
   content::InitializeSandboxInfo(&sandbox_info);
   atom::AtomMainDelegate delegate;
 
-  // Now chrome relies on a regkey to enable high dpi support.
-  gfx::EnableHighDPISupport();
+  // We don't want to set DPI awareness on pre-Win7 because we don't support
+  // DirectWrite there. GDI fonts are kerned very badly, so better to leave
+  // DPI-unaware and at effective 1.0. See also ShouldUseDirectWrite().
+  if (base::win::GetVersion() >= base::win::VERSION_WIN7)
+    EnableHighDPISupport();
 
   content::ContentMainParams params(&delegate);
   params.instance = instance;
@@ -113,8 +164,10 @@ int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE, wchar_t* cmd, int) {
 
 int main(int argc, const char* argv[]) {
   char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
-  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0)
+  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0) {
+    base::i18n::InitializeICU();
     return node::Start(argc, const_cast<char**>(argv));
+  }
 
   atom::AtomMainDelegate delegate;
   content::ContentMainParams params(&delegate);
@@ -127,8 +180,10 @@ int main(int argc, const char* argv[]) {
 
 int main(int argc, const char* argv[]) {
   char* node_indicator = getenv("ATOM_SHELL_INTERNAL_RUN_AS_NODE");
-  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0)
+  if (node_indicator != NULL && strcmp(node_indicator, "1") == 0) {
+    AtomInitializeICU();
     return node::Start(argc, const_cast<char**>(argv));
+  }
 
   return AtomMain(argc, argv);
 }

atom/browser/api/atom_api_app.cc

@@ -12,11 +12,11 @@
 #include "atom/browser/browser.h"
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/native_mate_converters/gurl_converter.h"
-#include "base/values.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
+#include "brightray/browser/brightray_paths.h"
 #include "native_mate/callback.h"
 #include "native_mate/dictionary.h"
 #include "native_mate/object_template_builder.h"
@@ -27,10 +27,6 @@
 
 #include "atom/common/node_includes.h"
 
-#if defined(OS_LINUX)
-#include "base/nix/xdg_util.h"
-#endif
-
 using atom::Browser;
 
 namespace mate {
@@ -65,6 +61,30 @@ namespace api {
 
 namespace {
 
+// Return the path constant from string.
+int GetPathConstant(const std::string& name) {
+  if (name == "appData")
+    return brightray::DIR_APP_DATA;
+  else if (name == "userData")
+    return brightray::DIR_USER_DATA;
+  else if (name == "cache")
+    return brightray::DIR_CACHE;
+  else if (name == "userCache")
+    return brightray::DIR_USER_CACHE;
+  else if (name == "home")
+    return base::DIR_HOME;
+  else if (name == "temp")
+    return base::DIR_TEMP;
+  else if (name == "userDesktop")
+    return base::DIR_USER_DESKTOP;
+  else if (name == "exe")
+    return base::FILE_EXE;
+  else if (name == "module")
+    return base::FILE_MODULE;
+  else
+    return -1;
+}
+
 class ResolveProxyHelper {
  public:
   ResolveProxyHelper(const GURL& url, App::ResolveProxyCallback callback)
@@ -124,15 +144,11 @@ void App::OnQuit() {
 }
 
 void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
-  base::ListValue args;
-  args.AppendString(file_path);
-  *prevent_default = Emit("open-file", args);
+  *prevent_default = Emit("open-file", file_path);
 }
 
 void App::OnOpenURL(const std::string& url) {
-  base::ListValue args;
-  args.AppendString(url);
-  Emit("open-url", args);
+  Emit("open-url", url);
 }
 
 void App::OnActivateWithNoOpenWindows() {
@@ -147,19 +163,26 @@ void App::OnFinishLaunching() {
   Emit("ready");
 }
 
-base::FilePath App::GetDataPath() {
+base::FilePath App::GetPath(mate::Arguments* args, const std::string& name) {
+  bool succeed = false;
   base::FilePath path;
-#if defined(OS_LINUX)
-  scoped_ptr<base::Environment> env(base::Environment::Create());
-  path = base::nix::GetXDGDirectory(env.get(),
-                                    base::nix::kXdgConfigHomeEnvVar,
-                                    base::nix::kDotConfigDir);
-#else
-  PathService::Get(base::DIR_APP_DATA, &path);
-#endif
+  int key = GetPathConstant(name);
+  if (key >= 0)
+    succeed = PathService::Get(key, &path);
+  if (!succeed)
+    args->ThrowError("Failed to get path");
+  return path;
+}
 
-  return path.Append(base::FilePath::FromUTF8Unsafe(
-      Browser::Get()->GetName()));
+void App::SetPath(mate::Arguments* args,
+                  const std::string& name,
+                  const base::FilePath& path) {
+  bool succeed = false;
+  int key = GetPathConstant(name);
+  if (key >= 0)
+    succeed = PathService::Override(key, path);
+  if (!succeed)
+    args->ThrowError("Failed to set path");
 }
 
 void App::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
@@ -192,7 +215,8 @@ mate::ObjectTemplateBuilder App::GetObjectTemplateBuilder(
       .SetMethod("setUserTasks",
                  base::Bind(&Browser::SetUserTasks, browser))
 #endif
-      .SetMethod("getDataPath", &App::GetDataPath)
+      .SetMethod("setPath", &App::SetPath)
+      .SetMethod("getPath", &App::GetPath)
       .SetMethod("resolveProxy", &App::ResolveProxy)
       .SetMethod("setDesktopName", &App::SetDesktopName);
 }

atom/browser/api/atom_api_app.h

@@ -18,6 +18,10 @@ namespace base {
 class FilePath;
 }
 
+namespace mate {
+class Arguments;
+}
+
 namespace atom {
 
 namespace api {
@@ -48,7 +52,12 @@ class App : public mate::EventEmitter,
       v8::Isolate* isolate) override;
 
  private:
-  base::FilePath GetDataPath();
+  // Get/Set the pre-defined path in PathService.
+  base::FilePath GetPath(mate::Arguments* args, const std::string& name);
+  void SetPath(mate::Arguments* args,
+               const std::string& name,
+               const base::FilePath& path);
+
   void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
   void SetDesktopName(const std::string& desktop_name);
 

atom/browser/api/atom_api_auto_updater.cc

@@ -5,7 +5,6 @@
 #include "atom/browser/api/atom_api_auto_updater.h"
 
 #include "base/time/time.h"
-#include "base/values.h"
 #include "atom/browser/auto_updater.h"
 #include "atom/browser/browser.h"
 #include "native_mate/dictionary.h"
@@ -26,9 +25,7 @@ AutoUpdater::~AutoUpdater() {
 }
 
 void AutoUpdater::OnError(const std::string& error) {
-  base::ListValue args;
-  args.AppendString(error);
-  Emit("error", args);
+  Emit("error", error);
 }
 
 void AutoUpdater::OnCheckingForUpdate() {
@@ -49,13 +46,8 @@ void AutoUpdater::OnUpdateDownloaded(const std::string& release_notes,
                                      const std::string& update_url,
                                      const base::Closure& quit_and_install) {
   quit_and_install_ = quit_and_install;
-
-  base::ListValue args;
-  args.AppendString(release_notes);
-  args.AppendString(release_name);
-  args.AppendDouble(release_date.ToJsTime());
-  args.AppendString(update_url);
-  Emit("update-downloaded-raw", args);
+  Emit("update-downloaded-raw", release_notes, release_name,
+       release_date.ToJsTime(), update_url);
 }
 
 mate::ObjectTemplateBuilder AutoUpdater::GetObjectTemplateBuilder(

atom/browser/api/atom_api_auto_updater.h

@@ -26,20 +26,20 @@ class AutoUpdater : public mate::EventEmitter,
   virtual ~AutoUpdater();
 
   // AutoUpdaterDelegate implementations.
-  virtual void OnError(const std::string& error) OVERRIDE;
-  virtual void OnCheckingForUpdate() OVERRIDE;
-  virtual void OnUpdateAvailable() OVERRIDE;
-  virtual void OnUpdateNotAvailable() OVERRIDE;
-  virtual void OnUpdateDownloaded(
+  void OnError(const std::string& error) override;
+  void OnCheckingForUpdate() override;
+  void OnUpdateAvailable() override;
+  void OnUpdateNotAvailable() override;
+  void OnUpdateDownloaded(
       const std::string& release_notes,
       const std::string& release_name,
       const base::Time& release_date,
       const std::string& update_url,
-      const base::Closure& quit_and_install) OVERRIDE;
+      const base::Closure& quit_and_install) override;
 
   // mate::Wrappable implementations:
-  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate);
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
 
  private:
   void QuitAndInstall();

atom/browser/api/atom_api_global_shortcut.h

@@ -28,8 +28,8 @@ class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
   virtual ~GlobalShortcut();
 
   // mate::Wrappable implementations:
-  virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
-      v8::Isolate* isolate) OVERRIDE;
+  mate::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override;
 
  private:
   typedef std::map<ui::Accelerator, base::Closure> AcceleratorCallbackMap;
@@ -41,7 +41,7 @@ class GlobalShortcut : public extensions::GlobalShortcutListener::Observer,
   void UnregisterAll();
 
   // GlobalShortcutListener::Observer implementation.
-  virtual void OnKeyPressed(const ui::Accelerator& accelerator) OVERRIDE;
+  void OnKeyPressed(const ui::Accelerator& accelerator) override;
 
   AcceleratorCallbackMap accelerator_callback_map_;
 

atom/browser/api/atom_api_menu_mac.h

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

atom/browser/api/atom_api_menu_views.h

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

atom/browser/api/atom_api_power_monitor.h

@@ -24,9 +24,9 @@ class PowerMonitor : public mate::EventEmitter,
   virtual ~PowerMonitor();
 
   // base::PowerObserver implementations:
-  virtual void OnPowerStateChange(bool on_battery_power) OVERRIDE;
-  virtual void OnSuspend() OVERRIDE;
-  virtual void OnResume() OVERRIDE;
+  void OnPowerStateChange(bool on_battery_power) override;
+  void OnSuspend() override;
+  void OnResume() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PowerMonitor);

atom/browser/api/atom_api_protocol.cc

@@ -53,7 +53,7 @@ class CustomProtocolRequestJob : public AdapterRequestJob {
   }
 
   // AdapterRequestJob:
-  virtual void GetJobTypeInUI() OVERRIDE {
+  void GetJobTypeInUI() override {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
@@ -128,9 +128,9 @@ class CustomProtocolHandler : public ProtocolHandler {
       : registry_(registry), protocol_handler_(protocol_handler) {
   }
 
-  virtual net::URLRequestJob* MaybeCreateJob(
+  net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     return new CustomProtocolRequestJob(registry_, protocol_handler_.get(),
                                         request, network_delegate);
   }
@@ -305,9 +305,7 @@ void Protocol::UninterceptProtocolInIO(const std::string& scheme) {
 
 void Protocol::EmitEventInUI(const std::string& event,
                              const std::string& parameter) {
-  base::ListValue args;
-  args.AppendString(parameter);
-  Emit(event, args);
+  Emit(event, parameter);
 }
 
 // static

atom/browser/api/atom_api_screen.cc

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

atom/browser/api/atom_api_screen.h

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

atom/browser/api/atom_api_web_contents.cc

@@ -88,12 +88,7 @@ bool WebContents::AddMessageToConsole(content::WebContents* source,
                                       const base::string16& message,
                                       int32 line_no,
                                       const base::string16& source_id) {
-  base::ListValue args;
-  args.AppendInteger(level);
-  args.AppendString(message);
-  args.AppendInteger(line_no);
-  args.AppendString(source_id);
-  Emit("console-message", args);
+  Emit("console-message", level, message, line_no, source_id);
   return true;
 }
 
@@ -105,11 +100,10 @@ bool WebContents::ShouldCreateWebContents(
     const GURL& target_url,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace) {
-  base::ListValue args;
-  args.AppendString(target_url.spec());
-  args.AppendString(frame_name);
-  args.AppendInteger(NEW_FOREGROUND_TAB);
-  Emit("-new-window", args);
+  Emit("-new-window",
+       target_url,
+       frame_name,
+       static_cast<int>(NEW_FOREGROUND_TAB));
   return false;
 }
 
@@ -121,18 +115,12 @@ content::WebContents* WebContents::OpenURLFromTab(
     content::WebContents* source,
     const content::OpenURLParams& params) {
   if (params.disposition != CURRENT_TAB) {
-    base::ListValue args;
-    args.AppendString(params.url.spec());
-    args.AppendString("");
-    args.AppendInteger(params.disposition);
-    Emit("-new-window", args);
+    Emit("-new-window", params.url, "", static_cast<int>(params.disposition));
     return nullptr;
   }
 
   // Give user a chance to cancel navigation.
-  base::ListValue args;
-  args.AppendString(params.url.spec());
-  if (Emit("will-navigate", args))
+  if (Emit("will-navigate", params.url))
     return nullptr;
 
   content::NavigationController::LoadURLParams load_url_params(params.url);
@@ -164,6 +152,12 @@ void WebContents::EnumerateDirectory(content::WebContents* guest,
   web_dialog_helper_->EnumerateDirectory(guest, request_id, path);
 }
 
+bool WebContents::CheckMediaAccessPermission(content::WebContents* web_contents,
+                                             const GURL& security_origin,
+                                             content::MediaStreamType type) {
+  return true;
+}
+
 void WebContents::RequestMediaAccessPermission(
     content::WebContents*,
     const content::MediaStreamRequest& request,
@@ -184,10 +178,9 @@ void WebContents::HandleKeyboardEvent(
 }
 
 void WebContents::RenderViewDeleted(content::RenderViewHost* render_view_host) {
-  base::ListValue args;
-  args.AppendInteger(render_view_host->GetProcess()->GetID());
-  args.AppendInteger(render_view_host->GetRoutingID());
-  Emit("render-view-deleted", args);
+  Emit("render-view-deleted",
+       render_view_host->GetProcess()->GetID(),
+       render_view_host->GetRoutingID());
 }
 
 void WebContents::RenderProcessGone(base::TerminationStatus status) {
@@ -197,10 +190,7 @@ void WebContents::RenderProcessGone(base::TerminationStatus status) {
 void WebContents::DidFinishLoad(content::RenderFrameHost* render_frame_host,
                                 const GURL& validated_url) {
   bool is_main_frame = !render_frame_host->GetParent();
-
-  base::ListValue args;
-  args.AppendBoolean(is_main_frame);
-  Emit("did-frame-finish-load", args);
+  Emit("did-frame-finish-load", is_main_frame);
 
   if (is_main_frame)
     Emit("did-finish-load");
@@ -210,10 +200,7 @@ void WebContents::DidFailLoad(content::RenderFrameHost* render_frame_host,
                               const GURL& validated_url,
                               int error_code,
                               const base::string16& error_description) {
-  base::ListValue args;
-  args.AppendInteger(error_code);
-  args.AppendString(error_description);
-  Emit("did-fail-load", args);
+  Emit("did-fail-load", error_code, error_description);
 }
 
 void WebContents::DidStartLoading(content::RenderViewHost* render_view_host) {
@@ -227,12 +214,10 @@ void WebContents::DidStopLoading(content::RenderViewHost* render_view_host) {
 void WebContents::DidGetRedirectForResourceRequest(
     content::RenderViewHost* render_view_host,
     const content::ResourceRedirectDetails& details) {
-  base::ListValue args;
-  args.AppendString(details.url.spec());
-  args.AppendString(details.new_url.spec());
-  args.AppendBoolean(
-      details.resource_type == content::RESOURCE_TYPE_MAIN_FRAME);
-  Emit("did-get-redirect-request", args);
+  Emit("did-get-redirect-request",
+       details.url,
+       details.new_url,
+       (details.resource_type == content::RESOURCE_TYPE_MAIN_FRAME));
 }
 
 void WebContents::DidNavigateMainFrame(
@@ -262,14 +247,14 @@ void WebContents::RenderViewReady() {
   // WebContents::GetRenderWidgetHostView will return the RWHV of an
   // interstitial page if one is showing at this time. We only want opacity
   // to apply to web pages.
-  web_contents()->GetRenderViewHost()->GetView()->
-      SetBackgroundOpaque(guest_opaque_);
-
-  content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
-  if (auto_size_enabled_) {
-    rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
+  if (guest_opaque_) {
+    web_contents()
+        ->GetRenderViewHost()
+        ->GetView()
+        ->SetBackgroundColorToDefault();
   } else {
-    rvh->DisableAutoResize(element_size_);
+    web_contents()->GetRenderViewHost()->GetView()->SetBackgroundColor(
+        SK_ColorTRANSPARENT);
   }
 }
 
@@ -433,6 +418,46 @@ bool WebContents::IsDevToolsOpened() {
   return storage_->IsDevToolsViewShowing();
 }
 
+void WebContents::Undo() {
+  web_contents()->Undo();
+}
+
+void WebContents::Redo() {
+  web_contents()->Redo();
+}
+
+void WebContents::Cut() {
+  web_contents()->Cut();
+}
+
+void WebContents::Copy() {
+  web_contents()->Copy();
+}
+
+void WebContents::Paste() {
+  web_contents()->Paste();
+}
+
+void WebContents::Delete() {
+  web_contents()->Delete();
+}
+
+void WebContents::SelectAll() {
+  web_contents()->SelectAll();
+}
+
+void WebContents::Unselect() {
+  web_contents()->Unselect();
+}
+
+void WebContents::Replace(const base::string16& word) {
+  web_contents()->Replace(word);
+}
+
+void WebContents::ReplaceMisspelling(const base::string16& word) {
+  web_contents()->ReplaceMisspelling(word);
+}
+
 bool WebContents::SendIPCMessage(const base::string16& channel,
                                  const base::ListValue& args) {
   return Send(new AtomViewMsg_Message(routing_id(), channel, args));
@@ -473,7 +498,15 @@ void WebContents::SetAllowTransparency(bool allow) {
   if (!web_contents()->GetRenderViewHost()->GetView())
     return;
 
-  web_contents()->GetRenderViewHost()->GetView()->SetBackgroundOpaque(!allow);
+  if (guest_opaque_) {
+    web_contents()
+        ->GetRenderViewHost()
+        ->GetView()
+        ->SetBackgroundColorToDefault();
+  } else {
+    web_contents()->GetRenderViewHost()->GetView()->SetBackgroundColor(
+        SK_ColorTRANSPARENT);
+  }
 }
 
 mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
@@ -503,13 +536,23 @@ mate::ObjectTemplateBuilder WebContents::GetObjectTemplateBuilder(
         .SetMethod("setUserAgent", &WebContents::SetUserAgent)
         .SetMethod("insertCSS", &WebContents::InsertCSS)
         .SetMethod("_executeJavaScript", &WebContents::ExecuteJavaScript)
+        .SetMethod("openDevTools", &WebContents::OpenDevTools)
+        .SetMethod("closeDevTools", &WebContents::CloseDevTools)
+        .SetMethod("isDevToolsOpened", &WebContents::IsDevToolsOpened)
+        .SetMethod("undo", &WebContents::Undo)
+        .SetMethod("redo", &WebContents::Redo)
+        .SetMethod("cut", &WebContents::Cut)
+        .SetMethod("copy", &WebContents::Copy)
+        .SetMethod("paste", &WebContents::Paste)
+        .SetMethod("delete", &WebContents::Delete)
+        .SetMethod("selectAll", &WebContents::SelectAll)
+        .SetMethod("unselect", &WebContents::Unselect)
+        .SetMethod("replace", &WebContents::Replace)
+        .SetMethod("replaceMisspelling", &WebContents::ReplaceMisspelling)
         .SetMethod("_send", &WebContents::SendIPCMessage)
         .SetMethod("setAutoSize", &WebContents::SetAutoSize)
         .SetMethod("setAllowTransparency", &WebContents::SetAllowTransparency)
         .SetMethod("isGuest", &WebContents::is_guest)
-        .SetMethod("openDevTools", &WebContents::OpenDevTools)
-        .SetMethod("closeDevTools", &WebContents::CloseDevTools)
-        .SetMethod("isDevToolsOpened", &WebContents::IsDevToolsOpened)
         .Build());
 
   return mate::ObjectTemplateBuilder(
@@ -526,17 +569,14 @@ void WebContents::OnRendererMessageSync(const base::string16& channel,
                                         const base::ListValue& args,
                                         IPC::Message* message) {
   // webContents.emit(channel, new Event(sender, message), args...);
-  Emit(base::UTF16ToUTF8(channel), args, web_contents(), message);
+  EmitWithSender(base::UTF16ToUTF8(channel), web_contents(), message, args);
 }
 
 void WebContents::GuestSizeChangedDueToAutoSize(const gfx::Size& old_size,
                                                 const gfx::Size& new_size) {
-  base::ListValue args;
-  args.AppendInteger(old_size.width());
-  args.AppendInteger(old_size.height());
-  args.AppendInteger(new_size.width());
-  args.AppendInteger(new_size.height());
-  Emit("size-changed", args);
+  Emit("size-changed",
+       old_size.width(), old_size.height(),
+       new_size.width(), new_size.height());
 }
 
 // static

atom/browser/api/atom_api_web_contents.h

@@ -67,6 +67,20 @@ class WebContents : public mate::EventEmitter,
   void OpenDevTools();
   void CloseDevTools();
   bool IsDevToolsOpened();
+
+  // Editing commands.
+  void Undo();
+  void Redo();
+  void Cut();
+  void Copy();
+  void Paste();
+  void Delete();
+  void SelectAll();
+  void Unselect();
+  void Replace(const base::string16& word);
+  void ReplaceMisspelling(const base::string16& word);
+
+  // Sending messages to browser.
   bool SendIPCMessage(const base::string16& channel,
                       const base::ListValue& args);
 
@@ -120,6 +134,9 @@ class WebContents : public mate::EventEmitter,
   void EnumerateDirectory(content::WebContents* web_contents,
                           int request_id,
                           const base::FilePath& path) override;
+  bool CheckMediaAccessPermission(content::WebContents* web_contents,
+                                  const GURL& security_origin,
+                                  content::MediaStreamType type) override;
   void RequestMediaAccessPermission(
       content::WebContents*,
       const content::MediaStreamRequest&,

atom/browser/api/atom_api_window.cc

@@ -8,6 +8,8 @@
 #include "atom/browser/browser.h"
 #include "atom/browser/native_window.h"
 #include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/gurl_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
 #include "content/public/browser/render_process_host.h"
 #include "native_mate/callback.h"
 #include "native_mate/constructor.h"
@@ -76,26 +78,18 @@ Window::~Window() {
 
 void Window::OnPageTitleUpdated(bool* prevent_default,
                                 const std::string& title) {
-  base::ListValue args;
-  args.AppendString(title);
-  *prevent_default = Emit("page-title-updated", args);
+  *prevent_default = Emit("page-title-updated", title);
 }
 
 void Window::WillCreatePopupWindow(const base::string16& frame_name,
                                    const GURL& target_url,
                                    const std::string& partition_id,
                                    WindowOpenDisposition disposition) {
-  base::ListValue args;
-  args.AppendString(target_url.spec());
-  args.AppendString(frame_name);
-  args.AppendInteger(disposition);
-  Emit("-new-window", args);
+  Emit("-new-window", target_url, frame_name, static_cast<int>(disposition));
 }
 
 void Window::WillNavigate(bool* prevent_default, const GURL& url) {
-  base::ListValue args;
-  args.AppendString(url.spec());
-  *prevent_default = Emit("-will-navigate", args);
+  *prevent_default = Emit("-will-navigate", url);
 }
 
 void Window::WillCloseWindow(bool* prevent_default) {

atom/browser/api/event.h

@@ -34,10 +34,10 @@ class Event : public Wrappable,
   virtual ~Event();
 
   // Wrappable implementations:
-  virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate);
+  ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate) override;
 
   // content::WebContentsObserver implementations:
-  virtual void WebContentsDestroyed() OVERRIDE;
+  void WebContentsDestroyed() override;
 
  private:
   // Replyer for the synchronous messages.

atom/browser/api/event_emitter.cc

@@ -5,9 +5,6 @@
 #include "atom/browser/api/event_emitter.h"
 
 #include "atom/browser/api/event.h"
-#include "atom/common/native_mate_converters/v8_value_converter.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/values.h"
 #include "native_mate/arguments.h"
 #include "native_mate/object_template_builder.h"
 
@@ -41,43 +38,11 @@ v8::Local<v8::Object> CreateEventObject(v8::Isolate* isolate) {
 EventEmitter::EventEmitter() {
 }
 
-bool EventEmitter::Emit(const base::StringPiece& name) {
-  return Emit(name, base::ListValue());
-}
-
-bool EventEmitter::Emit(const base::StringPiece& name,
-                        const base::ListValue& args) {
-  return Emit(name, args, NULL, NULL);
-}
-
-bool EventEmitter::Emit(const base::StringPiece& name,
-                        const base::ListValue& args,
-                        content::WebContents* sender,
-                        IPC::Message* message) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  v8::Locker locker(isolate);
-  v8::HandleScope handle_scope(isolate);
-
-  v8::Handle<v8::Context> context = isolate->GetCurrentContext();
-  scoped_ptr<atom::V8ValueConverter> converter(new atom::V8ValueConverter);
-
-  // v8_args = [args...];
-  Arguments v8_args;
-  v8_args.reserve(args.GetSize());
-  for (size_t i = 0; i < args.GetSize(); i++) {
-    const base::Value* value(NULL);
-    if (args.Get(i, &value))
-      v8_args.push_back(converter->ToV8Value(value, context));
-  }
-
-  return Emit(isolate, name, v8_args, sender, message);
-}
-
-bool EventEmitter::Emit(v8::Isolate* isolate,
-                        const base::StringPiece& name,
-                        Arguments args,
-                        content::WebContents* sender,
-                        IPC::Message* message) {
+bool EventEmitter::CallEmit(v8::Isolate* isolate,
+                            const base::StringPiece& name,
+                            content::WebContents* sender,
+                            IPC::Message* message,
+                            ValueArray args) {
   v8::Handle<v8::Object> event;
   bool use_native_event = sender && message;
 

atom/browser/api/event_emitter.h

@@ -9,10 +9,6 @@
 
 #include "native_mate/wrappable.h"
 
-namespace base {
-class ListValue;
-}
-
 namespace content {
 class WebContents;
 }
@@ -26,29 +22,39 @@ namespace mate {
 // Provide helperers to emit event in JavaScript.
 class EventEmitter : public Wrappable {
  public:
-  typedef std::vector<v8::Handle<v8::Value>> Arguments;
+  typedef std::vector<v8::Handle<v8::Value>> ValueArray;
 
  protected:
   EventEmitter();
 
-  // this.emit(name, new Event());
-  bool Emit(const base::StringPiece& name);
-
   // this.emit(name, new Event(), args...);
-  bool Emit(const base::StringPiece& name, const base::ListValue& args);
+  template<typename... Args>
+  bool Emit(const base::StringPiece& name, const Args&... args) {
+    return EmitWithSender(name, nullptr, nullptr, args...);
+  }
 
   // this.emit(name, new Event(sender, message), args...);
-  bool Emit(const base::StringPiece& name, const base::ListValue& args,
-            content::WebContents* sender, IPC::Message* message);
+  template<typename... Args>
+  bool EmitWithSender(const base::StringPiece& name,
+                      content::WebContents* sender,
+                      IPC::Message* message,
+                      const Args&... args) {
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Locker locker(isolate);
+    v8::HandleScope handle_scope(isolate);
 
-  // Lower level implementations.
-  bool Emit(v8::Isolate* isolate,
-            const base::StringPiece& name,
-            Arguments args,
-            content::WebContents* sender = nullptr,
-            IPC::Message* message = nullptr);
+    ValueArray converted = { ConvertToV8(isolate, args)... };
+    return CallEmit(isolate, name, sender, message, converted);
+  }
 
  private:
+  // Lower level implementations.
+  bool CallEmit(v8::Isolate* isolate,
+                const base::StringPiece& name,
+                content::WebContents* sender,
+                IPC::Message* message,
+                ValueArray args);
+
   DISALLOW_COPY_AND_ASSIGN(EventEmitter);
 };
 

atom/browser/api/lib/app.coffee

@@ -5,9 +5,6 @@ bindings = process.atomBinding 'app'
 app = bindings.app
 app.__proto__ = EventEmitter.prototype
 
-app.getHomeDir = ->
-  process.env[if process.platform is 'win32' then 'USERPROFILE' else 'HOME']
-
 app.setApplicationMenu = (menu) ->
   require('menu').setApplicationMenu menu
 
@@ -32,6 +29,9 @@ if process.platform is 'darwin'
 app.once 'ready', -> app.emit 'finish-launching'
 app.terminate = app.quit
 app.exit = process.exit
+app.getHomeDir = -> app.getPath 'home'
+app.getDataPath = -> app.getPath 'userData'
+app.setDataPath = (path) -> app.setPath 'userData', path
 
 # Only one App object pemitted.
 module.exports = app

atom/browser/api/lib/screen.coffee

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

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

@@ -9,8 +9,8 @@ module.exports.wrap = (webContents) ->
   webContents.__proto__ = EventEmitter.prototype
 
   # WebContents::send(channel, args..)
-  webContents.send = (args...) ->
-    @_send 'ATOM_INTERNAL_MESSAGE', [args...]
+  webContents.send = (channel, args...) ->
+    @_send channel, [args...]
 
   # Make sure webContents.executeJavaScript would run the code only when the
   # web contents has been loaded.
@@ -48,10 +48,12 @@ module.exports.wrap = (webContents) ->
     process.emit 'ATOM_BROWSER_RELEASE_RENDER_VIEW', "#{processId}-#{routingId}"
 
   # Dispatch IPC messages to the ipc module.
-  webContents.on 'ipc-message', (event, channel, args...) ->
+  webContents.on 'ipc-message', (event, packed) ->
+    [channel, args...] = packed
     Object.defineProperty event, 'sender', value: webContents
     ipc.emit channel, event, args...
-  webContents.on 'ipc-message-sync', (event, channel, args...) ->
+  webContents.on 'ipc-message-sync', (event, packed) ->
+    [channel, args...] = packed
     Object.defineProperty event, 'returnValue', set: (value) -> event.sendReply JSON.stringify(value)
     Object.defineProperty event, 'sender', value: webContents
     ipc.emit channel, event, args...

atom/browser/atom_access_token_store.h

@@ -17,10 +17,10 @@ class AtomAccessTokenStore : public content::AccessTokenStore {
   virtual ~AtomAccessTokenStore();
 
   // content::AccessTokenStore:
-  virtual void LoadAccessTokens(
-      const LoadAccessTokensCallbackType& callback) OVERRIDE;
-  virtual void SaveAccessToken(const GURL& server_url,
-                               const base::string16& access_token) OVERRIDE;
+  void LoadAccessTokens(
+      const LoadAccessTokensCallbackType& callback) override;
+  void SaveAccessToken(const GURL& server_url,
+                       const base::string16& access_token) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AtomAccessTokenStore);

atom/browser/atom_browser_context.cc

@@ -68,8 +68,7 @@ net::URLRequestJobFactory* AtomBrowserContext::CreateURLRequestJobFactory(
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
 
   // Set up interceptors in the reverse order.
-  scoped_ptr<net::URLRequestJobFactory> top_job_factory =
-      job_factory.PassAs<net::URLRequestJobFactory>();
+  scoped_ptr<net::URLRequestJobFactory> top_job_factory = job_factory.Pass();
   content::URLRequestInterceptorScopedVector::reverse_iterator it;
   for (it = interceptors->rbegin(); it != interceptors->rend(); ++it)
     top_job_factory.reset(new net::URLRequestInterceptingJobFactory(

atom/browser/atom_browser_main_parts.cc

@@ -72,6 +72,9 @@ void AtomBrowserMainParts::PostEarlyInitialization() {
 
   // Add atom-shell extended APIs.
   atom_bindings_->BindTo(js_env_->isolate(), global_env->process_object());
+
+  // Load everything.
+  node_bindings_->LoadEnvironment(global_env);
 }
 
 void AtomBrowserMainParts::PreMainMessageLoopRun() {

atom/browser/atom_browser_main_parts.h

@@ -27,14 +27,14 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
 
  protected:
   // Implementations of brightray::BrowserMainParts.
-  virtual brightray::BrowserContext* CreateBrowserContext() OVERRIDE;
+  brightray::BrowserContext* CreateBrowserContext() override;
 
   // Implementations of content::BrowserMainParts.
-  virtual void PostEarlyInitialization() OVERRIDE;
-  virtual void PreMainMessageLoopRun() OVERRIDE;
+  void PostEarlyInitialization() override;
+  void PreMainMessageLoopRun() override;
 #if defined(OS_MACOSX)
-  virtual void PreMainMessageLoopStart() OVERRIDE;
-  virtual void PostDestroyThreads() OVERRIDE;
+  void PreMainMessageLoopStart() override;
+  void PostDestroyThreads() override;
 #endif
 
  private:

atom/browser/atom_javascript_dialog_manager.h

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

atom/browser/default_app/main.js

@@ -41,6 +41,8 @@ if (option.file && !option.webdriver) {
         app.setName(packageJson.productName);
       else if (packageJson.name)
         app.setName(packageJson.name);
+      app.setPath('userData', path.join(app.getPath('appData'), app.getName()));
+      app.setPath('userCache', path.join(app.getPath('cache'), app.getName()));
     }
 
     // Run the app.

atom/browser/lib/chrome-extension.coffee

@@ -34,15 +34,9 @@ getExtensionInfoFromPath = (srcDirectory) ->
       srcDirectory: srcDirectory
     extensionInfoMap[manifest.name]
 
-# Load persistented extensions.
-loadedExtensionsPath = path.join app.getDataPath(), 'DevTools Extensions'
-
-try
-  loadedExtensions = JSON.parse fs.readFileSync(loadedExtensionsPath)
-  loadedExtensions = [] unless Array.isArray loadedExtensions
-  # Preheat the extensionInfo cache.
-  getExtensionInfoFromPath srcDirectory for srcDirectory in loadedExtensions
-catch e
+# The loaded extensions cache and its persistent path.
+loadedExtensions = null
+loadedExtensionsPath = null
 
 # Persistent loaded extensions.
 app.on 'will-quit', ->
@@ -59,6 +53,16 @@ app.once 'ready', ->
   protocol = require 'protocol'
   BrowserWindow = require 'browser-window'
 
+  # Load persistented extensions.
+  loadedExtensionsPath = path.join app.getDataPath(), 'DevTools Extensions'
+
+  try
+    loadedExtensions = JSON.parse fs.readFileSync(loadedExtensionsPath)
+    loadedExtensions = [] unless Array.isArray loadedExtensions
+    # Preheat the extensionInfo cache.
+    getExtensionInfoFromPath srcDirectory for srcDirectory in loadedExtensions
+  catch e
+
   # The chrome-extension: can map a extension URL request to real file path.
   protocol.registerProtocol 'chrome-extension', (request) ->
     parsed = url.parse request.url

atom/browser/lib/guest-view-manager.coffee

@@ -68,7 +68,8 @@ createGuest = (embedder, params) ->
         embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_DISPATCH_EVENT-#{guest.viewInstanceId}", event, args...
 
   # Dispatch guest's IPC messages to embedder.
-  guest.on 'ipc-message-host', (_, channel, args...) ->
+  guest.on 'ipc-message-host', (_, packed) ->
+    [channel, args...] = packed
     embedder.send "ATOM_SHELL_GUEST_VIEW_INTERNAL_IPC_MESSAGE-#{guest.viewInstanceId}", channel, args...
 
   # Autosize.

atom/browser/lib/init.coffee

@@ -23,75 +23,81 @@ process.argv.splice startMark, endMark - startMark + 1
 globalPaths = module.globalPaths
 globalPaths.push path.join process.resourcesPath, 'atom', 'browser', 'api', 'lib'
 
-# Following operations need extra bindings by AtomBindings.
-process.once 'BIND_DONE', ->
-  # Import common settings.
-  require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init.js')
+# Import common settings.
+require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init')
 
-  if process.platform is 'win32'
-    # Redirect node's console to use our own implementations, since node can not
-    # handle console output when running as GUI program.
-    print = (args...) ->
-      process.log util.format(args...)
-    console.log = console.error = console.warn = print
-    process.stdout.write = process.stderr.write = print
+if process.platform is 'win32'
+  # Redirect node's console to use our own implementations, since node can not
+  # handle console output when running as GUI program.
+  print = (args...) ->
+    process.log util.format(args...)
+  console.log = console.error = console.warn = print
+  process.stdout.write = process.stderr.write = print
 
-    # Always returns EOF for stdin stream.
-    Readable = require('stream').Readable
-    stdin = new Readable
-    stdin.push null
-    process.__defineGetter__ 'stdin', -> stdin
+  # Always returns EOF for stdin stream.
+  Readable = require('stream').Readable
+  stdin = new Readable
+  stdin.push null
+  process.__defineGetter__ 'stdin', -> stdin
 
-  # Don't quit on fatal error.
-  process.on 'uncaughtException', (error) ->
-    # Show error in GUI.
-    stack = error.stack ? "#{error.name}: #{error.message}"
-    message = "Uncaught Exception:\n#{stack}"
-    require('dialog').showErrorBox 'A JavaScript error occured in the browser process', message
+# Don't quit on fatal error.
+process.on 'uncaughtException', (error) ->
+  # Do nothing if the user has a custom uncaught exception handler.
+  if process.listeners('uncaughtException').length > 1
+    return
 
-  # Emit 'exit' event on quit.
-  require('app').on 'quit', ->
-    process.emit 'exit'
+  # Show error in GUI.
+  stack = error.stack ? "#{error.name}: #{error.message}"
+  message = "Uncaught Exception:\n#{stack}"
+  require('dialog').showErrorBox 'A JavaScript error occured in the browser process', message
 
-  # Load the RPC server.
-  require './rpc-server'
+# Emit 'exit' event on quit.
+app = require 'app'
+app.on 'quit', ->
+  process.emit 'exit'
 
-  # Load the guest view manager.
-  require './guest-view-manager'
-  require './guest-window-manager'
+# Load the RPC server.
+require './rpc-server'
 
-  # Now we try to load app's package.json.
-  packageJson = null
+# Load the guest view manager.
+require './guest-view-manager'
+require './guest-window-manager'
 
-  searchPaths = [ 'app', 'app.asar', 'default_app' ]
-  for packagePath in searchPaths
-    try
-      packagePath = path.join process.resourcesPath, packagePath
-      packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
-      break
-    catch e
-      continue
+# Now we try to load app's package.json.
+packageJson = null
 
-  throw new Error("Unable to find a valid app") unless packageJson?
+searchPaths = [ 'app', 'app.asar', 'default_app' ]
+for packagePath in searchPaths
+  try
+    packagePath = path.join process.resourcesPath, packagePath
+    packageJson = JSON.parse(fs.readFileSync(path.join(packagePath, 'package.json')))
+    break
+  catch e
+    continue
 
-  # Set application's version.
-  app = require 'app'
-  app.setVersion packageJson.version if packageJson.version?
+throw new Error("Unable to find a valid app") unless packageJson?
 
-  # Set application's name.
-  if packageJson.productName?
-    app.setName packageJson.productName
-  else if packageJson.name?
-    app.setName packageJson.name
+# Set application's version.
+app.setVersion packageJson.version if packageJson.version?
 
-  # Set application's desktop name.
-  if packageJson.desktopName?
-    app.setDesktopName packageJson.desktopName
-  else
-    app.setDesktopName '#{app.getName()}.desktop'
+# Set application's name.
+if packageJson.productName?
+  app.setName packageJson.productName
+else if packageJson.name?
+  app.setName packageJson.name
 
-  # Load the chrome extension support.
-  require './chrome-extension.js'
+# Set application's desktop name.
+if packageJson.desktopName?
+  app.setDesktopName packageJson.desktopName
+else
+  app.setDesktopName "#{app.getName()}.desktop"
 
-  # Finally load app's main.js and transfer control to C++.
-  module._load path.join(packagePath, packageJson.main), module, true
+# Set the user path according to application's name.
+app.setPath 'userData', path.join(app.getPath('appData'), app.getName())
+app.setPath 'userCache', path.join(app.getPath('cache'), app.getName())
+
+# Load the chrome extension support.
+require './chrome-extension'
+
+# Finally load app's main.js and transfer control to C++.
+module._load path.join(packagePath, packageJson.main), module, true

atom/browser/native_window.cc

@@ -21,7 +21,7 @@
 #include "atom/common/native_mate_converters/file_path_converter.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/prefs/pref_service.h"
 #include "base/message_loop/message_loop.h"
@@ -57,6 +57,10 @@
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size.h"
 
+#if defined(OS_WIN)
+#include "ui/gfx/switches.h"
+#endif
+
 using content::NavigationEntry;
 using content::RenderWidgetHostView;
 using content::RenderWidgetHost;

atom/browser/native_window_views.cc

@@ -129,7 +129,7 @@ class NativeWindowClientView : public views::ClientView {
   }
   virtual ~NativeWindowClientView() {}
 
-  virtual bool CanClose() OVERRIDE {
+  bool CanClose() override {
     static_cast<NativeWindowViews*>(contents_view())->CloseWebContents();
     return false;
   }

atom/browser/net/adapter_request_job.h

@@ -28,16 +28,16 @@ class AdapterRequestJob : public net::URLRequestJob {
 
  public:
   // net::URLRequestJob:
-  virtual void Start() OVERRIDE;
-  virtual void Kill() OVERRIDE;
-  virtual bool ReadRawData(net::IOBuffer* buf,
-                           int buf_size,
-                           int *bytes_read) OVERRIDE;
-  virtual bool IsRedirectResponse(GURL* location,
-                                  int* http_status_code) OVERRIDE;
-  virtual net::Filter* SetupFilter() const OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual bool GetCharset(std::string* charset) OVERRIDE;
+  void Start() override;
+  void Kill() override;
+  bool ReadRawData(net::IOBuffer* buf,
+                   int buf_size,
+                   int *bytes_read) override;
+  bool IsRedirectResponse(GURL* location,
+                          int* http_status_code) override;
+  net::Filter* SetupFilter() const override;
+  bool GetMimeType(std::string* mime_type) const override;
+  bool GetCharset(std::string* charset) override;
 
   base::WeakPtr<AdapterRequestJob> GetWeakPtr();
 

atom/browser/net/asar/asar_protocol_handler.h

@@ -27,10 +27,10 @@ class AsarProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler {
   Archive* GetOrCreateAsarArchive(const base::FilePath& path) const;
 
   // net::URLRequestJobFactory::ProtocolHandler:
-  virtual net::URLRequestJob* MaybeCreateJob(
+  net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+      net::NetworkDelegate* network_delegate) const override;
+  bool IsSafeRedirectTarget(const GURL& location) const override;
 
  private:
   const scoped_refptr<base::TaskRunner> file_task_runner_;

atom/browser/net/asar/url_request_asar_job.h

@@ -32,12 +32,12 @@ class URLRequestAsarJob : public net::URLRequestJob {
                     const scoped_refptr<base::TaskRunner>& file_task_runner);
 
   // net::URLRequestJob:
-  virtual void Start() OVERRIDE;
-  virtual void Kill() OVERRIDE;
-  virtual bool ReadRawData(net::IOBuffer* buf,
-                           int buf_size,
-                           int* bytes_read) OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  void Start() override;
+  void Kill() override;
+  bool ReadRawData(net::IOBuffer* buf,
+                   int buf_size,
+                   int* bytes_read) override;
+  bool GetMimeType(std::string* mime_type) const override;
 
  protected:
   virtual ~URLRequestAsarJob();

atom/browser/net/atom_url_request_job_factory.cc

@@ -50,7 +50,7 @@ ProtocolHandler* AtomURLRequestJobFactory::ReplaceProtocol(
 
   base::AutoLock locked(lock_);
   if (!ContainsKey(protocol_handler_map_, scheme))
-    return NULL;
+    return nullptr;
   ProtocolHandler* original_protocol_handler = protocol_handler_map_[scheme];
   protocol_handler_map_[scheme] = protocol_handler;
   return original_protocol_handler;
@@ -63,7 +63,7 @@ ProtocolHandler* AtomURLRequestJobFactory::GetProtocolHandler(
   base::AutoLock locked(lock_);
   ProtocolHandlerMap::const_iterator it = protocol_handler_map_.find(scheme);
   if (it == protocol_handler_map_.end())
-    return NULL;
+    return nullptr;
   return it->second;
 }
 
@@ -82,10 +82,23 @@ net::URLRequestJob* AtomURLRequestJobFactory::MaybeCreateJobWithProtocolHandler(
   base::AutoLock locked(lock_);
   ProtocolHandlerMap::const_iterator it = protocol_handler_map_.find(scheme);
   if (it == protocol_handler_map_.end())
-    return NULL;
+    return nullptr;
   return it->second->MaybeCreateJob(request, network_delegate);
 }
 
+net::URLRequestJob* AtomURLRequestJobFactory::MaybeInterceptRedirect(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate,
+    const GURL& location) const {
+  return nullptr;
+}
+
+net::URLRequestJob* AtomURLRequestJobFactory::MaybeInterceptResponse(
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  return nullptr;
+}
+
 bool AtomURLRequestJobFactory::IsHandledProtocol(
     const std::string& scheme) const {
   DCHECK(CalledOnValidThread());

atom/browser/net/atom_url_request_job_factory.h

@@ -40,13 +40,20 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
   bool HasProtocolHandler(const std::string& scheme) const;
 
   // URLRequestJobFactory implementation
-  virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+  net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE;
-  virtual bool IsHandledURL(const GURL& url) const OVERRIDE;
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+      net::NetworkDelegate* network_delegate) const override;
+  net::URLRequestJob* MaybeInterceptRedirect(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      const GURL& location) const override;
+  net::URLRequestJob* MaybeInterceptResponse(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override;
+  bool IsHandledProtocol(const std::string& scheme) const override;
+  bool IsHandledURL(const GURL& url) const override;
+  bool IsSafeRedirectTarget(const GURL& location) const override;
 
  private:
   typedef std::map<std::string, ProtocolHandler*> ProtocolHandlerMap;

atom/browser/net/url_request_string_job.h

@@ -20,10 +20,10 @@ class URLRequestStringJob : public net::URLRequestSimpleJob {
                       const std::string& data);
 
   // URLRequestSimpleJob:
-  virtual int GetData(std::string* mime_type,
-                      std::string* charset,
-                      std::string* data,
-                      const net::CompletionCallback& callback) const OVERRIDE;
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* data,
+              const net::CompletionCallback& callback) const override;
 
  private:
   std::string mime_type_;

atom/browser/node_debugger.h

@@ -33,12 +33,12 @@ class NodeDebugger : public net::StreamListenSocket::Delegate {
   static void DebugMessageHandler(const v8::Debug::Message& message);
 
   // net::StreamListenSocket::Delegate:
-  virtual void DidAccept(net::StreamListenSocket* server,
-                         scoped_ptr<net::StreamListenSocket> socket) OVERRIDE;
-  virtual void DidRead(net::StreamListenSocket* socket,
-                       const char* data,
-                       int len) OVERRIDE;
-  virtual void DidClose(net::StreamListenSocket* socket) OVERRIDE;
+  void DidAccept(net::StreamListenSocket* server,
+                 scoped_ptr<net::StreamListenSocket> socket) override;
+  void DidRead(net::StreamListenSocket* socket,
+               const char* data,
+               int len) override;
+  void DidClose(net::StreamListenSocket* socket) override;
 
   v8::Isolate* isolate_;
 

atom/browser/resources/mac/Info.plist

@@ -17,7 +17,7 @@
   <key>CFBundleIconFile</key>
   <string>atom.icns</string>
   <key>CFBundleVersion</key>
-  <string>0.20.6</string>
+  <string>0.21.0</string>
   <key>LSMinimumSystemVersion</key>
   <string>10.8.0</string>
   <key>NSMainNibFile</key>

atom/browser/resources/win/atom.rc

@@ -50,8 +50,8 @@ END
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 0,20,6,0
- PRODUCTVERSION 0,20,6,0
+ FILEVERSION 0,21,0,0
+ PRODUCTVERSION 0,21,0,0
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
  FILEFLAGS 0x1L
@@ -68,12 +68,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "GitHub, Inc."
             VALUE "FileDescription", "Atom-Shell"
-            VALUE "FileVersion", "0.20.6"
+            VALUE "FileVersion", "0.21.0"
             VALUE "InternalName", "atom.exe"
             VALUE "LegalCopyright", "Copyright (C) 2013 GitHub, Inc. All rights reserved."
             VALUE "OriginalFilename", "atom.exe"
             VALUE "ProductName", "Atom-Shell"
-            VALUE "ProductVersion", "0.20.6"
+            VALUE "ProductVersion", "0.21.0"
             VALUE "SquirrelAwareVersion", "1"
         END
     END

atom/browser/ui/accelerator_util.cc

@@ -121,6 +121,9 @@ bool StringToAccelerator(const std::string& description,
       modifiers |= ui::EF_ALT_DOWN;
     } else if (tokens[i] == "shift") {
       modifiers |= ui::EF_SHIFT_DOWN;
+    } else if (tokens[i] == "plus") {
+      modifiers |= ui::EF_SHIFT_DOWN;
+      key = ui::VKEY_OEM_PLUS;
     } else if (tokens[i] == "tab") {
       key = ui::VKEY_TAB;
     } else if (tokens[i] == "space") {

atom/browser/ui/file_dialog_gtk.cc

@@ -16,7 +16,7 @@
 
 #include "atom/browser/native_window.h"
 #include "base/callback.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/ui/libgtk2ui/gtk2_signal.h"
 #include "ui/aura/window.h"

atom/browser/ui/file_dialog_mac.mm

@@ -8,7 +8,7 @@
 #import <CoreServices/CoreServices.h>
 
 #include "atom/browser/native_window.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/strings/sys_string_conversions.h"

atom/browser/ui/file_dialog_win.cc

@@ -10,7 +10,7 @@
 #include <shlobj.h>
 
 #include "atom/browser/native_window_views.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/strings/string_util.h"
 #include "base/strings/string_split.h"

atom/browser/ui/tray_icon_cocoa.h

@@ -22,12 +22,12 @@ class TrayIconCocoa : public TrayIcon {
   TrayIconCocoa();
   virtual ~TrayIconCocoa();
 
-  virtual void SetImage(const gfx::Image& image) OVERRIDE;
-  virtual void SetPressedImage(const gfx::Image& image) OVERRIDE;
-  virtual void SetToolTip(const std::string& tool_tip) OVERRIDE;
-  virtual void SetTitle(const std::string& title) OVERRIDE;
-  virtual void SetHighlightMode(bool highlight) OVERRIDE;
-  virtual void SetContextMenu(ui::SimpleMenuModel* menu_model) OVERRIDE;
+  void SetImage(const gfx::Image& image) override;
+  void SetPressedImage(const gfx::Image& image) override;
+  void SetToolTip(const std::string& tool_tip) override;
+  void SetTitle(const std::string& title) override;
+  void SetHighlightMode(bool highlight) override;
+  void SetContextMenu(ui::SimpleMenuModel* menu_model) override;
 
  private:
   base::scoped_nsobject<NSStatusItem> item_;

atom/browser/ui/tray_icon_gtk.h

@@ -23,14 +23,14 @@ class TrayIconGtk : public TrayIcon,
   virtual ~TrayIconGtk();
 
   // TrayIcon:
-  virtual void SetImage(const gfx::Image& image) OVERRIDE;
-  virtual void SetToolTip(const std::string& tool_tip) OVERRIDE;
-  virtual void SetContextMenu(ui::SimpleMenuModel* menu_model) OVERRIDE;
+  void SetImage(const gfx::Image& image) override;
+  void SetToolTip(const std::string& tool_tip) override;
+  void SetContextMenu(ui::SimpleMenuModel* menu_model) override;
 
  private:
   // views::StatusIconLinux::Delegate:
-  virtual void OnClick() OVERRIDE;
-  virtual bool HasClickAction() OVERRIDE;
+  void OnClick() override;
+  bool HasClickAction() override;
 
   scoped_ptr<views::StatusIconLinux> icon_;
 

atom/browser/ui/views/submenu_button.cc

@@ -37,7 +37,7 @@ SubmenuButton::SubmenuButton(views::ButtonListener* listener,
       underline_color_(SK_ColorBLACK) {
 #if defined(OS_LINUX)
   // Dont' use native style border.
-  SetBorder(CreateDefaultBorder().PassAs<views::Border>());
+  SetBorder(CreateDefaultBorder().Pass());
 #endif
 
   if (GetUnderlinePosition(title, &accelerator_, &underline_start_,

atom/browser/web_dialog_helper.cc

@@ -12,6 +12,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/file_chooser_file_info.h"
 #include "ui/shell_dialogs/selected_file_info.h"
 
 namespace atom {
@@ -26,15 +27,19 @@ WebDialogHelper::~WebDialogHelper() {
 
 void WebDialogHelper::RunFileChooser(content::WebContents* web_contents,
                                      const content::FileChooserParams& params) {
-  std::vector<ui::SelectedFileInfo> result;
+  std::vector<content::FileChooserFileInfo> result;
   if (params.mode == content::FileChooserParams::Save) {
     base::FilePath path;
     if (file_dialog::ShowSaveDialog(window_,
                                     base::UTF16ToUTF8(params.title),
                                     params.default_file_name,
                                     file_dialog::Filters(),
-                                    &path))
-      result.push_back(ui::SelectedFileInfo(path, path));
+                                    &path)) {
+      content::FileChooserFileInfo info;
+      info.file_path = path;
+      info.display_name = path.BaseName().value();
+      result.push_back(info);
+    }
   } else {
     int flags = file_dialog::FILE_DIALOG_CREATE_DIRECTORY;
     switch (params.mode) {
@@ -56,9 +61,14 @@ void WebDialogHelper::RunFileChooser(content::WebContents* web_contents,
                                     params.default_file_name,
                                     file_dialog::Filters(),
                                     flags,
-                                    &paths))
-      for (auto& path : paths)
-        result.push_back(ui::SelectedFileInfo(path, path));
+                                    &paths)) {
+      for (auto& path : paths) {
+        content::FileChooserFileInfo info;
+        info.file_path = path;
+        info.display_name = path.BaseName().value();
+        result.push_back(info);
+      }
+    }
   }
 
   web_contents->GetRenderViewHost()->FilesSelectedInChooser(

atom/common/api/atom_api_screen.cc

@@ -1,24 +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/common/native_mate_converters/gfx_converter.h"
-#include "atom/common/node_includes.h"
-
-namespace {
-
-void Initialize(v8::Handle<v8::Object> exports, v8::Handle<v8::Value> unused,
-                v8::Handle<v8::Context> context, void* priv) {
-  gfx::Screen* screen = gfx::Screen::GetNativeScreen();
-  mate::Dictionary dict(context->GetIsolate(), exports);
-  dict.SetMethod("getCursorScreenPoint",
-                 base::Bind(&gfx::Screen::GetCursorScreenPoint,
-                            base::Unretained(screen)));
-  dict.SetMethod("getPrimaryDisplay",
-                 base::Bind(&gfx::Screen::GetPrimaryDisplay,
-                            base::Unretained(screen)));
-}
-
-}  // namespace
-
-NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_screen, Initialize)

atom/common/api/atom_bindings.cc

@@ -11,7 +11,6 @@
 #include "atom/common/chrome_version.h"
 #include "atom/common/native_mate_converters/string16_converter.h"
 #include "base/logging.h"
-#include "native_mate/callback.h"
 #include "native_mate/dictionary.h"
 
 #include "atom/common/node_includes.h"
@@ -20,20 +19,9 @@ namespace atom {
 
 namespace {
 
-// Async handle to execute the stored v8 callback.
-uv_async_t g_callback_uv_handle;
-
-// Stored v8 callback, to be called by the async handler.
-base::Closure g_v8_callback;
-
 // Dummy class type that used for crashing the program.
 struct DummyClass { bool crash; };
 
-// Async handler to execute the stored v8 callback.
-void UvOnCallback(uv_async_t* handle) {
-  g_v8_callback.Run();
-}
-
 void Crash() {
   static_cast<DummyClass*>(NULL)->crash = true;
 }
@@ -49,19 +37,12 @@ void Log(const base::string16& message) {
   logging::LogMessage("CONSOLE", 0, 0).stream() << message;
 }
 
-void ScheduleCallback(const base::Closure& callback) {
-  g_v8_callback = callback;
-  uv_async_send(&g_callback_uv_handle);
-}
-
 }  // namespace
 
 
 AtomBindings::AtomBindings() {
   uv_async_init(uv_default_loop(), &call_next_tick_async_, OnCallNextTick);
   call_next_tick_async_.data = this;
-
-  uv_async_init(uv_default_loop(), &g_callback_uv_handle, UvOnCallback);
 }
 
 AtomBindings::~AtomBindings() {
@@ -74,20 +55,17 @@ void AtomBindings::BindTo(v8::Isolate* isolate,
   mate::Dictionary dict(isolate, process);
   dict.SetMethod("crash", &Crash);
   dict.SetMethod("log", &Log);
-  dict.SetMethod("scheduleCallback", &ScheduleCallback);
   dict.SetMethod("activateUvLoop",
       base::Bind(&AtomBindings::ActivateUVLoop, base::Unretained(this)));
 
-  v8::Handle<v8::Object> versions;
-  if (dict.Get("versions", &versions)) {
-    versions->Set(mate::StringToV8(isolate, "atom-shell"),
-                  mate::StringToV8(isolate, ATOM_VERSION_STRING));
-    versions->Set(mate::StringToV8(isolate, "chrome"),
-                  mate::StringToV8(isolate, CHROME_VERSION_STRING));
-  }
+  // Do not warn about deprecated APIs.
+  dict.Set("noDeprecation", true);
 
-  v8::Handle<v8::Value> event = mate::StringToV8(isolate, "BIND_DONE");
-  node::MakeCallback(isolate, process, "emit", 1, &event);
+  mate::Dictionary versions;
+  if (dict.Get("versions", &versions)) {
+    versions.Set("atom-shell", ATOM_VERSION_STRING);
+    versions.Set("chrome", CHROME_VERSION_STRING);
+  }
 }
 
 void AtomBindings::ActivateUVLoop(v8::Isolate* isolate) {

atom/common/api/atom_bindings.h

@@ -24,7 +24,7 @@ class AtomBindings {
 
   // Add process.atomBinding function, which behaves like process.binding but
   // load native code from atom-shell instead.
-  virtual void BindTo(v8::Isolate* isolate, v8::Handle<v8::Object> process);
+  void BindTo(v8::Isolate* isolate, v8::Handle<v8::Object> process);
 
  private:
   void ActivateUVLoop(v8::Isolate* isolate);

atom/common/api/lib/original-fs.coffee

@@ -1,6 +1,8 @@
-fs = require 'fs'
+vm = require 'vm'
 
-copied = {}
-copied[k] = v for k, v of fs
-
-module.exports = copied
+# Execute the 'fs.js' and pass the 'exports' to it.
+source = '(function (exports, require, module, __filename, __dirname) { ' +
+         process.binding('natives').fs +
+         '\n});'
+fn = vm.runInThisContext source, { filename: 'fs.js' }
+fn exports, require, module

atom/common/api/lib/screen.coffee

@@ -1,17 +0,0 @@
-binding = process.atomBinding 'screen'
-
-checkAppIsReady = ->
-  unless process.type is 'renderer' or require('app').isReady()
-    throw new Error('Can not use screen module before the "ready" event of app module gets emitted')
-
-module.exports =
-  if process.platform in ['linux', 'win32'] and process.type is 'renderer'
-    # On Linux we could not access screen in renderer process.
-    require('remote').require 'screen'
-  else
-    getCursorScreenPoint: ->
-      checkAppIsReady()
-      binding.getCursorScreenPoint()
-    getPrimaryDisplay: ->
-      checkAppIsReady()
-      binding.getPrimaryDisplay()

atom/common/asar/scoped_temporary_file.cc

@@ -6,7 +6,7 @@
 
 #include <vector>
 
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace asar {

atom/common/atom_version.h

@@ -6,8 +6,8 @@
 #define ATOM_VERSION_H
 
 #define ATOM_MAJOR_VERSION 0
-#define ATOM_MINOR_VERSION 20
-#define ATOM_PATCH_VERSION 6
+#define ATOM_MINOR_VERSION 21
+#define ATOM_PATCH_VERSION 0
 
 #define ATOM_VERSION_IS_RELEASE 1
 

atom/common/chrome_version.h

@@ -8,7 +8,7 @@
 #ifndef ATOM_COMMON_CHROME_VERSION_H_
 #define ATOM_COMMON_CHROME_VERSION_H_
 
-#define CHROME_VERSION_STRING "39.0.2171.65"
+#define CHROME_VERSION_STRING "40.0.2214.91"
 #define CHROME_VERSION "v" CHROME_VERSION_STRING
 
 #endif  // ATOM_COMMON_CHROME_VERSION_H_

atom/common/crash_reporter/crash_reporter_linux.h

@@ -25,13 +25,13 @@ class CrashReporterLinux : public CrashReporter {
  public:
   static CrashReporterLinux* GetInstance();
 
-  virtual void InitBreakpad(const std::string& product_name,
-                            const std::string& version,
-                            const std::string& company_name,
-                            const std::string& submit_url,
-                            bool auto_submit,
-                            bool skip_system_crash_handler) OVERRIDE;
-  virtual void SetUploadParameters() OVERRIDE;
+  void InitBreakpad(const std::string& product_name,
+                    const std::string& version,
+                    const std::string& company_name,
+                    const std::string& submit_url,
+                    bool auto_submit,
+                    bool skip_system_crash_handler) override;
+  void SetUploadParameters() override;
 
  private:
   friend struct DefaultSingletonTraits<CrashReporterLinux>;

atom/common/crash_reporter/crash_reporter_mac.h

@@ -19,13 +19,13 @@ class CrashReporterMac : public CrashReporter {
  public:
   static CrashReporterMac* GetInstance();
 
-  virtual void InitBreakpad(const std::string& product_name,
-                            const std::string& version,
-                            const std::string& company_name,
-                            const std::string& submit_url,
-                            bool auto_submit,
-                            bool skip_system_crash_handler) OVERRIDE;
-  virtual void SetUploadParameters() OVERRIDE;
+  void InitBreakpad(const std::string& product_name,
+                    const std::string& version,
+                    const std::string& company_name,
+                    const std::string& submit_url,
+                    bool auto_submit,
+                    bool skip_system_crash_handler) override;
+  void SetUploadParameters() override;
 
  private:
   friend struct DefaultSingletonTraits<CrashReporterMac>;

atom/common/crash_reporter/crash_reporter_win.cc

@@ -6,7 +6,7 @@
 
 #include <string>
 
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_util.h"

atom/common/crash_reporter/crash_reporter_win.h

@@ -21,13 +21,13 @@ class CrashReporterWin : public CrashReporter {
  public:
   static CrashReporterWin* GetInstance();
 
-  virtual void InitBreakpad(const std::string& product_name,
-                            const std::string& version,
-                            const std::string& company_name,
-                            const std::string& submit_url,
-                            bool auto_submit,
-                            bool skip_system_crash_handler) OVERRIDE;
-  virtual void SetUploadParameters() OVERRIDE;
+  void InitBreakpad(const std::string& product_name,
+                    const std::string& version,
+                    const std::string& company_name,
+                    const std::string& submit_url,
+                    bool auto_submit,
+                    bool skip_system_crash_handler) override;
+  void SetUploadParameters() override;
 
  private:
   friend struct DefaultSingletonTraits<CrashReporterWin>;

atom/common/crash_reporter/win/crash_service.cc

@@ -11,7 +11,7 @@
 #include <map>
 
 #include "base/command_line.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"

atom/common/crash_reporter/win/crash_service_main.cc

@@ -7,7 +7,7 @@
 #include "atom/common/crash_reporter/win/crash_service.h"
 #include "base/at_exit.h"
 #include "base/command_line.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 

atom/common/lib/init.coffee

@@ -35,8 +35,5 @@ if process.type is 'browser'
   global.setTimeout = wrapWithActivateUvLoop timers.setTimeout
   global.setInterval = wrapWithActivateUvLoop timers.setInterval
 
-# Initialize the "original-fs" module before asar support is loaded.
-require 'original-fs'
-
 # Add support for asar packages.
 require './asar'

atom/common/native_mate_converters/gfx_converter.cc

@@ -0,0 +1,110 @@
+// 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/common/native_mate_converters/gfx_converter.h"
+
+#include "native_mate/dictionary.h"
+#include "ui/gfx/point.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/screen.h"
+#include "ui/gfx/size.h"
+
+namespace mate {
+
+v8::Handle<v8::Value> Converter<gfx::Point>::ToV8(v8::Isolate* isolate,
+                                                  const gfx::Point& val) {
+  mate::Dictionary dict(isolate, v8::Object::New(isolate));
+  dict.Set("x", val.x());
+  dict.Set("y", val.y());
+  return dict.GetHandle();
+}
+
+bool Converter<gfx::Point>::FromV8(v8::Isolate* isolate,
+                                   v8::Handle<v8::Value> val,
+                                   gfx::Point* out) {
+  mate::Dictionary dict;
+  if (!ConvertFromV8(isolate, val, &dict))
+    return false;
+  int x, y;
+  if (!dict.Get("x", &x) || !dict.Get("y", &y))
+    return false;
+  *out = gfx::Point(x, y);
+  return true;
+}
+
+v8::Handle<v8::Value> Converter<gfx::Size>::ToV8(v8::Isolate* isolate,
+                                                  const gfx::Size& val) {
+  mate::Dictionary dict(isolate, v8::Object::New(isolate));
+  dict.Set("width", val.width());
+  dict.Set("height", val.height());
+  return dict.GetHandle();
+}
+
+bool Converter<gfx::Size>::FromV8(v8::Isolate* isolate,
+                                  v8::Handle<v8::Value> val,
+                                  gfx::Size* out) {
+  mate::Dictionary dict;
+  if (!ConvertFromV8(isolate, val, &dict))
+    return false;
+  int width, height;
+  if (!dict.Get("width", &width) || !dict.Get("height", &height))
+    return false;
+  *out = gfx::Size(width, height);
+  return true;
+}
+
+v8::Handle<v8::Value> Converter<gfx::Rect>::ToV8(v8::Isolate* isolate,
+                                                 const gfx::Rect& val) {
+  mate::Dictionary dict(isolate, v8::Object::New(isolate));
+  dict.Set("x", val.x());
+  dict.Set("y", val.y());
+  dict.Set("width", val.width());
+  dict.Set("height", val.height());
+  return dict.GetHandle();
+}
+
+bool Converter<gfx::Rect>::FromV8(v8::Isolate* isolate,
+                                  v8::Handle<v8::Value> val,
+                                  gfx::Rect* out) {
+  mate::Dictionary dict;
+  if (!ConvertFromV8(isolate, val, &dict))
+    return false;
+  int x, y, width, height;
+  if (!dict.Get("x", &x) || !dict.Get("y", &y) ||
+      !dict.Get("width", &width) || !dict.Get("height", &height))
+    return false;
+  *out = gfx::Rect(x, y, width, height);
+  return true;
+}
+
+template<>
+struct Converter<gfx::Display::TouchSupport> {
+  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+                                    const gfx::Display::TouchSupport& val) {
+    switch (val) {
+      case gfx::Display::TOUCH_SUPPORT_AVAILABLE:
+        return StringToV8(isolate, "available");
+      case gfx::Display::TOUCH_SUPPORT_UNAVAILABLE:
+        return StringToV8(isolate, "unavailable");
+      default:
+        return StringToV8(isolate, "unknown");
+    }
+  }
+};
+
+v8::Handle<v8::Value> Converter<gfx::Display>::ToV8(v8::Isolate* isolate,
+                                                    const gfx::Display& val) {
+  mate::Dictionary dict(isolate, v8::Object::New(isolate));
+  dict.Set("id", val.id());
+  dict.Set("bounds", val.bounds());
+  dict.Set("workArea", val.work_area());
+  dict.Set("size", val.size());
+  dict.Set("workAreaSize", val.work_area_size());
+  dict.Set("scaleFactor", val.device_scale_factor());
+  dict.Set("rotation", val.RotationAsDegree());
+  dict.Set("touchSupport", val.touch_support());
+  return dict.GetHandle();
+}
+
+}  // namespace mate

atom/common/native_mate_converters/gfx_converter.h

@@ -5,95 +5,51 @@
 #ifndef ATOM_COMMON_NATIVE_MATE_CONVERTERS_GFX_CONVERTER_H_
 #define ATOM_COMMON_NATIVE_MATE_CONVERTERS_GFX_CONVERTER_H_
 
-#include "native_mate/dictionary.h"
-#include "ui/gfx/point.h"
-#include "ui/gfx/rect.h"
-#include "ui/gfx/screen.h"
-#include "ui/gfx/size.h"
+#include "native_mate/converter.h"
+
+namespace gfx {
+class Point;
+class Size;
+class Rect;
+class Display;
+}
 
 namespace mate {
 
 template<>
 struct Converter<gfx::Point> {
   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    const gfx::Point& val) {
-    mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    dict.Set("x", val.x());
-    dict.Set("y", val.y());
-    return dict.GetHandle();
-  }
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
-                     gfx::Point* out) {
-    mate::Dictionary dict;
-    if (!ConvertFromV8(isolate, val, &dict))
-      return false;
-    int x, y;
-    if (!dict.Get("x", &x) || !dict.Get("y", &y))
-      return false;
-    *out = gfx::Point(x, y);
-    return true;
-  }
+                                    const gfx::Point& val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     gfx::Point* out);
 };
 
 template<>
 struct Converter<gfx::Size> {
   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    const gfx::Size& val) {
-    mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    dict.Set("width", val.width());
-    dict.Set("height", val.height());
-    return dict.GetHandle();
-  }
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
-                     gfx::Size* out) {
-    mate::Dictionary dict;
-    if (!ConvertFromV8(isolate, val, &dict))
-      return false;
-    int width, height;
-    if (!dict.Get("width", &width) || !dict.Get("height", &height))
-      return false;
-    *out = gfx::Size(width, height);
-    return true;
-  }
+                                    const gfx::Size& val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     gfx::Size* out);
 };
 
 template<>
 struct Converter<gfx::Rect> {
   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    const gfx::Rect& val) {
-    mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    dict.Set("x", val.x());
-    dict.Set("y", val.y());
-    dict.Set("width", val.width());
-    dict.Set("height", val.height());
-    return dict.GetHandle();
-  }
-  static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val,
-                     gfx::Rect* out) {
-    mate::Dictionary dict;
-    if (!ConvertFromV8(isolate, val, &dict))
-      return false;
-    int x, y, width, height;
-    if (!dict.Get("x", &x) || !dict.Get("y", &y) ||
-        !dict.Get("width", &width) || !dict.Get("height", &height))
-      return false;
-    *out = gfx::Rect(x, y, width, height);
-    return true;
-  }
+                                    const gfx::Rect& val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     gfx::Rect* out);
 };
 
 template<>
 struct Converter<gfx::Display> {
   static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
-                                    const gfx::Display& display) {
-    mate::Dictionary dict(isolate, v8::Object::New(isolate));
-    dict.Set("bounds", display.bounds());
-    dict.Set("workArea", display.work_area());
-    dict.Set("size", display.size());
-    dict.Set("workAreaSize", display.work_area_size());
-    dict.Set("scaleFactor", display.device_scale_factor());
-    return dict.GetHandle();
-  }
+                                    const gfx::Display& val);
+  static bool FromV8(v8::Isolate* isolate,
+                     v8::Handle<v8::Value> val,
+                     gfx::Display* out);
 };
 
 }  // namespace mate

atom/common/native_mate_converters/image_converter.cc

@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "atom/common/native_mate_converters/file_path_converter.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/strings/string_util.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"

atom/common/native_mate_converters/value_converter.cc

@@ -37,4 +37,11 @@ bool Converter<base::ListValue>::FromV8(v8::Isolate* isolate,
   }
 }
 
+v8::Handle<v8::Value> Converter<base::ListValue>::ToV8(
+    v8::Isolate* isolate,
+    const base::ListValue& val) {
+  scoped_ptr<atom::V8ValueConverter> converter(new atom::V8ValueConverter);
+  return converter->ToV8Value(&val, isolate->GetCurrentContext());
+}
+
 }  // namespace mate

atom/common/native_mate_converters/value_converter.h

@@ -26,6 +26,8 @@ struct Converter<base::ListValue> {
   static bool FromV8(v8::Isolate* isolate,
                      v8::Handle<v8::Value> val,
                      base::ListValue* out);
+  static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate,
+                                    const base::ListValue& val);
 };
 
 }  // namespace mate

atom/common/node_bindings.cc

@@ -26,9 +26,6 @@ using content::BrowserThread;
 // Forward declaration of internal node functions.
 namespace node {
 void Init(int*, const char**, int*, const char***);
-void Load(Environment* env);
-void SetupProcessObject(Environment*, int, const char* const*, int,
-                        const char* const*);
 }
 
 // Force all builtin modules to be referenced so they can actually run their
@@ -89,19 +86,6 @@ namespace {
 void UvNoOp(uv_async_t* handle) {
 }
 
-// Moved from node.cc.
-void HandleCloseCb(uv_handle_t* handle) {
-  node::Environment* env = reinterpret_cast<node::Environment*>(handle->data);
-  env->FinishHandleCleanup(handle);
-}
-
-void HandleCleanup(node::Environment* env,
-                   uv_handle_t* handle,
-                   void* arg) {
-  handle->data = env;
-  uv_close(handle, HandleCloseCb);
-}
-
 // Convert the given vector to an array of C-strings. The strings in the
 // returned vector are only guaranteed valid so long as the vector of strings
 // is not modified.
@@ -126,14 +110,14 @@ std::vector<std::string> String16VectorToStringVector(
 
 }  // namespace
 
-node::Environment* global_env = NULL;
+node::Environment* global_env = nullptr;
 
 NodeBindings::NodeBindings(bool is_browser)
     : is_browser_(is_browser),
-      message_loop_(NULL),
+      message_loop_(nullptr),
       uv_loop_(uv_default_loop()),
       embed_closed_(false),
-      uv_env_(NULL),
+      uv_env_(nullptr),
       weak_factory_(this) {
 }
 
@@ -158,20 +142,21 @@ void NodeBindings::Initialize() {
   // Init node.
   // (we assume it would not node::Init would not modify the parameters under
   // embedded mode).
-  node::Init(NULL, NULL, NULL, NULL);
+  node::Init(nullptr, nullptr, nullptr, nullptr);
 }
 
 node::Environment* NodeBindings::CreateEnvironment(
     v8::Handle<v8::Context> context) {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
   std::vector<std::string> args =
 #if defined(OS_WIN)
-      String16VectorToStringVector(CommandLine::ForCurrentProcess()->argv());
+      String16VectorToStringVector(command_line->argv());
 #else
-      CommandLine::ForCurrentProcess()->argv();
+      command_line->argv();
 #endif
 
   // Feed node the path to initialization script.
-  base::FilePath exec_path(CommandLine::ForCurrentProcess()->argv()[0]);
+  base::FilePath exec_path(command_line->argv()[0]);
   PathService::Get(base::FILE_EXE, &exec_path);
   base::FilePath resources_path =
 #if defined(OS_MACOSX)
@@ -179,77 +164,27 @@ node::Environment* NodeBindings::CreateEnvironment(
                     exec_path.DirName().DirName().DirName().DirName().DirName()
                              .Append("Resources");
 #else
-      exec_path.DirName().AppendASCII("resources");
+      exec_path.DirName().Append(FILE_PATH_LITERAL("resources"));
 #endif
   base::FilePath script_path =
-      resources_path.AppendASCII("atom")
-                    .AppendASCII(is_browser_ ? "browser" : "renderer")
-                    .AppendASCII("lib")
-                    .AppendASCII("init.js");
+      resources_path.Append(FILE_PATH_LITERAL("atom"))
+                    .Append(is_browser_ ? FILE_PATH_LITERAL("browser") :
+                                          FILE_PATH_LITERAL("renderer"))
+                    .Append(FILE_PATH_LITERAL("lib"))
+                    .Append(FILE_PATH_LITERAL("init.js"));
   std::string script_path_str = script_path.AsUTF8Unsafe();
   args.insert(args.begin() + 1, script_path_str.c_str());
 
-  // Convert string vector to const char* array.
   scoped_ptr<const char*[]> c_argv = StringVectorToArgArray(args);
+  return node::CreateEnvironment(context->GetIsolate(),
+                                 uv_default_loop(),
+                                 context,
+                                 args.size(), c_argv.get(),
+                                 0, nullptr);
+}
 
-  // Construct the parameters that passed to node::CreateEnvironment:
-  v8::Isolate* isolate = context->GetIsolate();
-  uv_loop_t* loop = uv_default_loop();
-  int argc = args.size();
-  const char** argv = c_argv.get();
-  int exec_argc = 0;
-  const char** exec_argv = NULL;
-
-  using namespace v8;  // NOLINT
-  using namespace node;  // NOLINT
-
-  // Following code are stripped from node::CreateEnvironment in node.cc:
-  HandleScope handle_scope(isolate);
-
-  Context::Scope context_scope(context);
-  Environment* env = Environment::New(context, loop);
-
-  isolate->SetAutorunMicrotasks(false);
-
-  uv_check_init(env->event_loop(), env->immediate_check_handle());
-  uv_unref(
-      reinterpret_cast<uv_handle_t*>(env->immediate_check_handle()));
-
-  uv_idle_init(env->event_loop(), env->immediate_idle_handle());
-
-  uv_prepare_init(env->event_loop(), env->idle_prepare_handle());
-  uv_check_init(env->event_loop(), env->idle_check_handle());
-  uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_prepare_handle()));
-  uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_check_handle()));
-
-  // Register handle cleanups
-  env->RegisterHandleCleanup(
-      reinterpret_cast<uv_handle_t*>(env->immediate_check_handle()),
-      HandleCleanup,
-      nullptr);
-  env->RegisterHandleCleanup(
-      reinterpret_cast<uv_handle_t*>(env->immediate_idle_handle()),
-      HandleCleanup,
-      nullptr);
-  env->RegisterHandleCleanup(
-      reinterpret_cast<uv_handle_t*>(env->idle_prepare_handle()),
-      HandleCleanup,
-      nullptr);
-  env->RegisterHandleCleanup(
-      reinterpret_cast<uv_handle_t*>(env->idle_check_handle()),
-      HandleCleanup,
-      nullptr);
-
-  Local<FunctionTemplate> process_template = FunctionTemplate::New(isolate);
-  process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "process"));
-
-  Local<Object> process_object = process_template->GetFunction()->NewInstance();
-  env->set_process_object(process_object);
-
-  SetupProcessObject(env, argc, argv, exec_argc, exec_argv);
-  LoadEnvironment(env);
-
-  return env;
+void NodeBindings::LoadEnvironment(node::Environment* env) {
+  node::LoadEnvironment(env);
 }
 
 void NodeBindings::PrepareMessageLoop() {
@@ -290,7 +225,7 @@ void NodeBindings::UvRunOnce() {
   v8::Context::Scope context_scope(env->context());
 
   // Deal with uv events.
-  int r = uv_run(uv_loop_, (uv_run_mode)(UV_RUN_ONCE | UV_RUN_NOWAIT));
+  int r = uv_run(uv_loop_, UV_RUN_NOWAIT);
   if (r == 0 || uv_loop_->stop_flag != 0)
     message_loop_->QuitWhenIdle();  // Quit from uv.
 

atom/common/node_bindings.h

@@ -27,13 +27,16 @@ class NodeBindings {
   virtual ~NodeBindings();
 
   // Setup V8, libuv.
-  virtual void Initialize();
+  void Initialize();
 
   // Create the environment and load node.js.
-  virtual node::Environment* CreateEnvironment(v8::Handle<v8::Context> context);
+  node::Environment* CreateEnvironment(v8::Handle<v8::Context> context);
+
+  // Load node.js in the environment.
+  void LoadEnvironment(node::Environment* env);
 
   // Prepare for message loop integration.
-  virtual void PrepareMessageLoop();
+  void PrepareMessageLoop();
 
   // Do message loop integration.
   virtual void RunMessageLoop();

atom/common/node_bindings_linux.h

@@ -15,13 +15,13 @@ class NodeBindingsLinux : public NodeBindings {
   explicit NodeBindingsLinux(bool is_browser);
   virtual ~NodeBindingsLinux();
 
-  virtual void RunMessageLoop() OVERRIDE;
+  void RunMessageLoop() override;
 
  private:
   // Called when uv's watcher queue changes.
   static void OnWatcherQueueChanged(uv_loop_t* loop);
 
-  virtual void PollEvents() OVERRIDE;
+  void PollEvents() override;
 
   // Epoll to poll for uv's backend fd.
   int epoll_;

atom/common/node_bindings_mac.h

@@ -15,13 +15,13 @@ class NodeBindingsMac : public NodeBindings {
   explicit NodeBindingsMac(bool is_browser);
   virtual ~NodeBindingsMac();
 
-  virtual void RunMessageLoop() OVERRIDE;
+  void RunMessageLoop() override;
 
  private:
   // Called when uv's watcher queue changes.
   static void OnWatcherQueueChanged(uv_loop_t* loop);
 
-  virtual void PollEvents() OVERRIDE;
+  void PollEvents() override;
 
   // Kqueue to poll for uv's backend fd.
   int kqueue_;

atom/common/node_bindings_win.h

@@ -16,7 +16,7 @@ class NodeBindingsWin : public NodeBindings {
   virtual ~NodeBindingsWin();
 
  private:
-  virtual void PollEvents() OVERRIDE;
+  void PollEvents() override;
 
   DISALLOW_COPY_AND_ASSIGN(NodeBindingsWin);
 };

atom/common/platform_util_linux.cc

@@ -6,7 +6,7 @@
 
 #include <stdio.h>
 
-#include "base/file_util.h"
+#include "base/files/file_util.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "url/gurl.h"

atom/renderer/api/atom_renderer_bindings.cc

@@ -1,84 +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/renderer/api/atom_renderer_bindings.h"
-
-#include <vector>
-
-#include "atom/common/native_mate_converters/string16_converter.h"
-#include "atom/common/native_mate_converters/v8_value_converter.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/values.h"
-#include "content/public/renderer/render_view.h"
-#include "native_mate/converter.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
-#include "third_party/WebKit/public/web/WebView.h"
-
-#include "atom/common/node_includes.h"
-
-namespace atom {
-
-namespace {
-
-v8::Handle<v8::Object> GetProcessObject(v8::Handle<v8::Context> context) {
-  v8::Handle<v8::Object> process = context->Global()->Get(
-      mate::StringToV8(context->GetIsolate(), "process"))->ToObject();
-  DCHECK(!process.IsEmpty());
-
-  return process;
-}
-
-}  // namespace
-
-AtomRendererBindings::AtomRendererBindings() {
-}
-
-AtomRendererBindings::~AtomRendererBindings() {
-}
-
-void AtomRendererBindings::BindToFrame(blink::WebFrame* frame) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  v8::HandleScope handle_scope(isolate);
-
-  v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
-  if (context.IsEmpty())
-    return;
-
-  v8::Context::Scope scope(context);
-  AtomBindings::BindTo(isolate, GetProcessObject(context));
-}
-
-void AtomRendererBindings::OnBrowserMessage(content::RenderView* render_view,
-                                            const base::string16& channel,
-                                            const base::ListValue& args) {
-  if (!render_view->GetWebView())
-    return;
-
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  v8::HandleScope handle_scope(isolate);
-
-  v8::Local<v8::Context> context =
-      render_view->GetWebView()->mainFrame()->mainWorldScriptContext();
-  if (context.IsEmpty())
-    return;
-
-  v8::Context::Scope context_scope(context);
-
-  v8::Handle<v8::Object> process = GetProcessObject(context);
-  scoped_ptr<V8ValueConverter> converter(new V8ValueConverter);
-
-  std::vector<v8::Handle<v8::Value>> arguments;
-  arguments.reserve(1 + args.GetSize());
-  arguments.push_back(mate::ConvertToV8(isolate, channel));
-
-  for (size_t i = 0; i < args.GetSize(); i++) {
-    const base::Value* value;
-    if (args.Get(i, &value))
-      arguments.push_back(converter->ToV8Value(value, context));
-  }
-
-  node::MakeCallback(isolate, process, "emit", arguments.size(), &arguments[0]);
-}
-
-}  // namespace atom

atom/renderer/api/atom_renderer_bindings.h

@@ -1,45 +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_RENDERER_API_ATOM_RENDERER_BINDINGS_H_
-#define ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_H_
-
-#include "atom/common/api/atom_bindings.h"
-
-#include "base/strings/string16.h"
-
-namespace base {
-class ListValue;
-}
-
-namespace content {
-class RenderView;
-}
-
-namespace blink {
-class WebFrame;
-}
-
-namespace atom {
-
-class AtomRendererBindings : public AtomBindings {
- public:
-  AtomRendererBindings();
-  virtual ~AtomRendererBindings();
-
-  // Call BindTo for process object of the frame.
-  void BindToFrame(blink::WebFrame* frame);
-
-  // Dispatch messages from browser.
-  void OnBrowserMessage(content::RenderView* render_view,
-                        const base::string16& channel,
-                        const base::ListValue& args);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AtomRendererBindings);
-};
-
-}  // namespace atom
-
-#endif  // ATOM_RENDERER_API_ATOM_RENDERER_BINDINGS_H_

atom/renderer/api/lib/ipc.coffee

@@ -1,26 +1,20 @@
-EventEmitter = require('events').EventEmitter
-process = global.process
-ipc = process.atomBinding('ipc')
+binding = process.atomBinding 'ipc'
+v8Util  = process.atomBinding 'v8_util'
 
-class Ipc extends EventEmitter
-  constructor: ->
-    process.on 'ATOM_INTERNAL_MESSAGE', (args...) =>
-      @emit args...
+# Created by init.coffee.
+ipc = v8Util.getHiddenValue global, 'ipc'
 
-    window.addEventListener 'unload', (event) ->
-      process.removeAllListeners 'ATOM_INTERNAL_MESSAGE'
+ipc.send = (args...) ->
+  binding.send 'ipc-message', [args...]
 
-  send: (args...) ->
-    ipc.send 'ipc-message', [args...]
+ipc.sendSync = (args...) ->
+  JSON.parse binding.sendSync('ipc-message-sync', [args...])
 
-  sendSync: (args...) ->
-    JSON.parse ipc.sendSync('ipc-message-sync', [args...])
+ipc.sendToHost = (args...) ->
+  binding.send 'ipc-message-host', [args...]
 
-  sendToHost: (args...) ->
-    ipc.send 'ipc-message-host', [args...]
+# Deprecated.
+ipc.sendChannel = ipc.send
+ipc.sendChannelSync = ipc.sendSync
 
-  # Discarded
-  sendChannel: -> @send.apply this, arguments
-  sendChannelSync: -> @sendSync.apply this, arguments
-
-module.exports = new Ipc
+module.exports = ipc

atom/renderer/api/lib/screen.coffee

@@ -0,0 +1 @@
+module.exports = require('remote').require('screen')

atom/renderer/atom_render_view_observer.cc

@@ -8,8 +8,9 @@
 #include <vector>
 
 #include "atom/common/api/api_messages.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/native_mate_converters/value_converter.h"
 #include "atom/common/options_switches.h"
-#include "atom/renderer/api/atom_renderer_bindings.h"
 #include "atom/renderer/atom_renderer_client.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
@@ -19,19 +20,43 @@
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
+#include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 #include "atom/common/node_includes.h"
 
-using blink::WebFrame;
-
 namespace atom {
 
+namespace {
+
+bool GetIPCObject(v8::Isolate* isolate,
+                  v8::Handle<v8::Context> context,
+                  v8::Handle<v8::Object>* ipc) {
+  v8::Handle<v8::String> key = mate::StringToV8(isolate, "ipc");
+  v8::Handle<v8::Value> value = context->Global()->GetHiddenValue(key);
+  if (value.IsEmpty() || !value->IsObject())
+    return false;
+  *ipc = value->ToObject();
+  return true;
+}
+
+std::vector<v8::Handle<v8::Value>> ListValueToVector(
+    v8::Isolate* isolate,
+    const base::ListValue& list) {
+  v8::Handle<v8::Value> array = mate::ConvertToV8(isolate, list);
+  std::vector<v8::Handle<v8::Value>> result;
+  mate::ConvertFromV8(isolate, array, &result);
+  return result;
+}
+
+}  // namespace
+
 AtomRenderViewObserver::AtomRenderViewObserver(
     content::RenderView* render_view,
     AtomRendererClient* renderer_client)
     : content::RenderViewObserver(render_view),
-      renderer_client_(renderer_client) {
+      renderer_client_(renderer_client),
+      document_created_(false) {
 }
 
 AtomRenderViewObserver::~AtomRenderViewObserver() {
@@ -39,6 +64,8 @@ AtomRenderViewObserver::~AtomRenderViewObserver() {
 
 void AtomRenderViewObserver::DidCreateDocumentElement(
     blink::WebLocalFrame* frame) {
+  document_created_ = true;
+
   // Read --zoom-factor from command line.
   std::string zoom_factor_str = CommandLine::ForCurrentProcess()->
       GetSwitchValueASCII(switches::kZoomFactor);;
@@ -76,8 +103,29 @@ bool AtomRenderViewObserver::OnMessageReceived(const IPC::Message& message) {
 
 void AtomRenderViewObserver::OnBrowserMessage(const base::string16& channel,
                                               const base::ListValue& args) {
-  renderer_client_->atom_bindings()->OnBrowserMessage(
-      render_view(), channel, args);
+  if (!document_created_)
+    return;
+
+  if (!render_view()->GetWebView())
+    return;
+
+  blink::WebFrame* frame = render_view()->GetWebView()->mainFrame();
+  if (!frame || frame->isWebRemoteFrame())
+    return;
+
+  v8::Isolate* isolate = blink::mainThreadIsolate();
+  v8::HandleScope handle_scope(isolate);
+
+  v8::Local<v8::Context> context = frame->mainWorldScriptContext();
+  v8::Context::Scope context_scope(context);
+
+  std::vector<v8::Handle<v8::Value>> arguments = ListValueToVector(
+      isolate, args);
+  arguments.insert(arguments.begin(), mate::ConvertToV8(isolate, channel));
+
+  v8::Handle<v8::Object> ipc;
+  if (GetIPCObject(isolate, context, &ipc))
+    node::MakeCallback(isolate, ipc, "emit", arguments.size(), &arguments[0]);
 }
 
 }  // namespace atom

atom/renderer/atom_render_view_observer.h

@@ -26,9 +26,9 @@ class AtomRenderViewObserver : public content::RenderViewObserver {
 
  private:
   // content::RenderViewObserver implementation.
-  virtual void DidCreateDocumentElement(blink::WebLocalFrame* frame) OVERRIDE;
-  virtual void DraggableRegionsChanged(blink::WebFrame* frame) OVERRIDE;
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  void DidCreateDocumentElement(blink::WebLocalFrame* frame) override;
+  void DraggableRegionsChanged(blink::WebFrame* frame) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
 
   void OnBrowserMessage(const base::string16& channel,
                         const base::ListValue& args);
@@ -36,6 +36,9 @@ class AtomRenderViewObserver : public content::RenderViewObserver {
   // Weak reference to renderer client.
   AtomRendererClient* renderer_client_;
 
+  // Whether the document object has been created.
+  bool document_created_;
+
   DISALLOW_COPY_AND_ASSIGN(AtomRenderViewObserver);
 };
 

atom/renderer/atom_renderer_client.cc

@@ -4,21 +4,17 @@
 
 #include "atom/renderer/atom_renderer_client.h"
 
-#include <algorithm>
 #include <string>
 
+#include "atom/common/api/atom_bindings.h"
 #include "atom/common/node_bindings.h"
 #include "atom/common/options_switches.h"
-#include "atom/renderer/api/atom_renderer_bindings.h"
 #include "atom/renderer/atom_render_view_observer.h"
 #include "chrome/renderer/printing/print_web_view_helper.h"
 #include "chrome/renderer/tts_dispatcher.h"
 #include "content/public/common/content_constants.h"
-#include "content/public/renderer/render_frame.h"
-#include "content/public/renderer/render_frame_observer.h"
 #include "content/public/renderer/render_thread.h"
 #include "base/command_line.h"
-#include "native_mate/converter.h"
 #include "third_party/WebKit/public/web/WebCustomElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebPluginParams.h"
@@ -44,33 +40,12 @@ bool IsSwitchEnabled(base::CommandLine* command_line,
   return true;
 }
 
-// Helper class to forward the WillReleaseScriptContext message to the client.
-class AtomRenderFrameObserver : public content::RenderFrameObserver {
- public:
-  AtomRenderFrameObserver(content::RenderFrame* frame,
-                          AtomRendererClient* renderer_client)
-      : content::RenderFrameObserver(frame),
-        renderer_client_(renderer_client) {}
-
-  // content::RenderFrameObserver:
-  virtual void WillReleaseScriptContext(v8::Handle<v8::Context> context,
-                                        int world_id) OVERRIDE {
-    renderer_client_->WillReleaseScriptContext(
-        render_frame()->GetWebFrame(), context, world_id);
-  }
-
- private:
-  AtomRendererClient* renderer_client_;
-
-  DISALLOW_COPY_AND_ASSIGN(AtomRenderFrameObserver);
-};
-
 }  // namespace
 
 AtomRendererClient::AtomRendererClient()
     : node_bindings_(NodeBindings::Create(false)),
-      atom_bindings_(new AtomRendererBindings),
-      main_frame_(NULL) {
+      atom_bindings_(new AtomBindings),
+      main_frame_(nullptr) {
 }
 
 AtomRendererClient::~AtomRendererClient() {
@@ -99,11 +74,6 @@ void AtomRendererClient::RenderThreadStarted() {
   content::RenderThread::Get()->AddObserver(this);
 }
 
-void AtomRendererClient::RenderFrameCreated(
-    content::RenderFrame* render_frame) {
-  new AtomRenderFrameObserver(render_frame, this);
-}
-
 void AtomRendererClient::RenderViewCreated(content::RenderView* render_view) {
   new printing::PrintWebViewHelper(render_view);
   new AtomRenderViewObserver(render_view, this);
@@ -132,17 +102,13 @@ void AtomRendererClient::DidCreateScriptContext(blink::WebFrame* frame,
                                                 v8::Handle<v8::Context> context,
                                                 int extension_group,
                                                 int world_id) {
-  // The first web frame is the main frame.
-  if (main_frame_ == NULL)
-    main_frame_ = frame;
-
-  v8::Context::Scope scope(context);
-
-  // Check the existance of process object to prevent duplicate initialization.
-  if (context->Global()->Has(
-        mate::StringToV8(context->GetIsolate(), "process")))
+  // Only attach node bindings in main frame.
+  if (main_frame_)
     return;
 
+  // The first web frame is the main frame.
+  main_frame_ = frame;
+
   // Give the node loop a run to make sure everything is ready.
   node_bindings_->RunMessageLoop();
 
@@ -150,46 +116,14 @@ void AtomRendererClient::DidCreateScriptContext(blink::WebFrame* frame,
   node::Environment* env = node_bindings_->CreateEnvironment(context);
 
   // Add atom-shell extended APIs.
-  atom_bindings_->BindToFrame(frame);
-
-  // Store the created environment.
-  web_page_envs_.push_back(env);
+  atom_bindings_->BindTo(env->isolate(), env->process_object());
 
   // Make uv loop being wrapped by window context.
-  if (node_bindings_->uv_env() == NULL)
+  if (node_bindings_->uv_env() == nullptr)
     node_bindings_->set_uv_env(env);
-}
 
-void AtomRendererClient::WillReleaseScriptContext(
-    blink::WebLocalFrame* frame,
-    v8::Handle<v8::Context> context,
-    int world_id) {
-  node::Environment* env = node::Environment::GetCurrent(context);
-  if (env == NULL) {
-    LOG(ERROR) << "Encounter a non-node context when releasing script context";
-    return;
-  }
-
-  // Clear the environment.
-  web_page_envs_.erase(
-      std::remove(web_page_envs_.begin(), web_page_envs_.end(), env),
-      web_page_envs_.end());
-
-  // Notice that we are not disposing the environment object here, because there
-  // may still be pending uv operations in the uv loop, and when they got done
-  // they would be needing the original environment.
-  // So we are leaking the environment object here, just like Chrome leaking the
-  // memory :) . Since it's only leaked when refreshing or unloading, so as long
-  // as we make sure renderer process is restared then the memory would not be
-  // leaked.
-  // env->Dispose();
-
-  // Wrap the uv loop with another environment.
-  if (env == node_bindings_->uv_env()) {
-    node::Environment* env = web_page_envs_.size() > 0 ? web_page_envs_[0] :
-                                                         NULL;
-    node_bindings_->set_uv_env(env);
-  }
+  // Load everything.
+  node_bindings_->LoadEnvironment(env);
 }
 
 bool AtomRendererClient::ShouldFork(blink::WebFrame* frame,

atom/renderer/atom_renderer_client.h

@@ -6,18 +6,13 @@
 #define ATOM_RENDERER_ATOM_RENDERER_CLIENT_H_
 
 #include <string>
-#include <vector>
 
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_process_observer.h"
 
-namespace node {
-class Environment;
-}
-
 namespace atom {
 
-class AtomRendererBindings;
+class AtomBindings;
 class NodeBindings;
 
 class AtomRendererClient : public content::ContentRendererClient,
@@ -26,13 +21,6 @@ class AtomRendererClient : public content::ContentRendererClient,
   AtomRendererClient();
   virtual ~AtomRendererClient();
 
-  // Forwarded by RenderFrameObserver.
-  void WillReleaseScriptContext(blink::WebLocalFrame* frame,
-                                v8::Handle<v8::Context> context,
-                                int world_id);
-
-  AtomRendererBindings* atom_bindings() const { return atom_bindings_.get(); }
-
  private:
   enum NodeIntegration {
     ALL,
@@ -42,11 +30,10 @@ class AtomRendererClient : public content::ContentRendererClient,
   };
 
   // content::RenderProcessObserver:
-  virtual void WebKitInitialized() OVERRIDE;
+  void WebKitInitialized() override;
 
   // content::ContentRendererClient:
   void RenderThreadStarted() override;
-  void RenderFrameCreated(content::RenderFrame* render_frame) override;
   void RenderViewCreated(content::RenderView*) override;
   blink::WebSpeechSynthesizer* OverrideSpeechSynthesizer(
       blink::WebSpeechSynthesizerClient* client) override;
@@ -67,10 +54,8 @@ class AtomRendererClient : public content::ContentRendererClient,
 
   void EnableWebRuntimeFeatures();
 
-  std::vector<node::Environment*> web_page_envs_;
-
   scoped_ptr<NodeBindings> node_bindings_;
-  scoped_ptr<AtomRendererBindings> atom_bindings_;
+  scoped_ptr<AtomBindings> atom_bindings_;
 
   // The main frame.
   blink::WebFrame* main_frame_;

atom/renderer/lib/init.coffee

@@ -1,4 +1,5 @@
 process = global.process
+events  = require 'events'
 path    = require 'path'
 url     = require 'url'
 Module  = require 'module'
@@ -19,7 +20,11 @@ globalPaths.push path.join(process.resourcesPath, 'atom', 'renderer', 'api', 'li
 globalPaths.push path.join(process.resourcesPath, 'app')
 
 # Import common settings.
-require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init.js')
+require path.resolve(__dirname, '..', '..', 'common', 'lib', 'init')
+
+# The global variable will be used by ipc for event dispatching
+v8Util = process.atomBinding 'v8_util'
+v8Util.setHiddenValue global, 'ipc', new events.EventEmitter
 
 # Process command line arguments.
 nodeIntegration = 'false'
@@ -86,9 +91,12 @@ if nodeIntegration in ['true', 'all', 'except-iframe', 'manual-enable-iframe']
   window.addEventListener 'unload', ->
     process.emit 'exit'
 else
-  # There still some native initialization codes needs "process", delete the
-  # global reference after they are done.
-  process.once 'BIND_DONE', ->
+  # The Module.runMain will run process._tickCallck() immediately, so we are
+  # able to delete the symbols in this tick even though we used process.nextTick
+  # to schedule it.
+  # It is important that we put this in process.nextTick, if we delete them now
+  # some code in node.js will complain about "process not defined".
+  process.nextTick ->
     delete global.process
     delete global.setImmediate
     delete global.clearImmediate

atom/renderer/lib/web-view/web-view.coffee

@@ -254,6 +254,16 @@ registerWebViewElement = ->
     "openDevTools"
     "closeDevTools"
     "isDevToolsOpened"
+    "undo"
+    "redo"
+    "cut"
+    "copy"
+    "paste"
+    "delete"
+    "selectAll"
+    "unselect"
+    "replace"
+    "replaceMisspelling"
     "send"
     "getId"
   ]

chromium_src/chrome/browser/extensions/global_shortcut_listener_mac.h

@@ -41,12 +41,12 @@ class GlobalShortcutListenerMac : public GlobalShortcutListener {
   bool OnMediaOrVolumeKeyEvent(int key_code);
 
   // GlobalShortcutListener implementation.
-  virtual void StartListening() OVERRIDE;
-  virtual void StopListening() OVERRIDE;
+  virtual void StartListening() override;
+  virtual void StopListening() override;
   virtual bool RegisterAcceleratorImpl(
-      const ui::Accelerator& accelerator) OVERRIDE;
+      const ui::Accelerator& accelerator) override;
   virtual void UnregisterAcceleratorImpl(
-      const ui::Accelerator& accelerator) OVERRIDE;
+      const ui::Accelerator& accelerator) override;
 
   // Mac-specific functions for registering hot keys with modifiers.
   bool RegisterHotKey(const ui::Accelerator& accelerator, KeyId hot_key_id);

chromium_src/chrome/browser/extensions/global_shortcut_listener_win.h

@@ -26,15 +26,15 @@ class GlobalShortcutListenerWin : public GlobalShortcutListener,
   virtual void OnWndProc(HWND hwnd,
                          UINT message,
                          WPARAM wparam,
-                         LPARAM lparam) OVERRIDE;
+                         LPARAM lparam) override;
 
   // GlobalShortcutListener implementation.
-  virtual void StartListening() OVERRIDE;
-  virtual void StopListening() OVERRIDE;
+  virtual void StartListening() override;
+  virtual void StopListening() override;
   virtual bool RegisterAcceleratorImpl(
-      const ui::Accelerator& accelerator) OVERRIDE;
+      const ui::Accelerator& accelerator) override;
   virtual void UnregisterAcceleratorImpl(
-      const ui::Accelerator& accelerator) OVERRIDE;
+      const ui::Accelerator& accelerator) override;
 
   // Whether this object is listening for global shortcuts.
   bool is_listening_;

chromium_src/chrome/browser/extensions/global_shortcut_listener_x11.h

@@ -23,17 +23,17 @@ class GlobalShortcutListenerX11 : public GlobalShortcutListener,
   virtual ~GlobalShortcutListenerX11();
 
   // ui::PlatformEventDispatcher implementation.
-  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) OVERRIDE;
-  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) OVERRIDE;
+  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) override;
+  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) override;
 
  private:
   // GlobalShortcutListener implementation.
-  virtual void StartListening() OVERRIDE;
-  virtual void StopListening() OVERRIDE;
+  virtual void StartListening() override;
+  virtual void StopListening() override;
   virtual bool RegisterAcceleratorImpl(
-      const ui::Accelerator& accelerator) OVERRIDE;
+      const ui::Accelerator& accelerator) override;
   virtual void UnregisterAcceleratorImpl(
-      const ui::Accelerator& accelerator) OVERRIDE;
+      const ui::Accelerator& accelerator) override;
 
   // Invoked when a global shortcut is pressed.
   void OnXKeyPressEvent(::XEvent* x_event);

chromium_src/chrome/browser/printing/print_job.h

@@ -51,14 +51,14 @@ class PrintJob : public PrintJobWorkerOwner,
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
+                       const content::NotificationDetails& details) override;
 
   // PrintJobWorkerOwner implementation.
   virtual void GetSettingsDone(const PrintSettings& new_settings,
-                               PrintingContext::Result result) OVERRIDE;
-  virtual PrintJobWorker* DetachWorker(PrintJobWorkerOwner* new_owner) OVERRIDE;
-  virtual const PrintSettings& settings() const OVERRIDE;
-  virtual int cookie() const OVERRIDE;
+                               PrintingContext::Result result) override;
+  virtual PrintJobWorker* DetachWorker(PrintJobWorkerOwner* new_owner) override;
+  virtual const PrintSettings& settings() const override;
+  virtual int cookie() const override;
 
   // Starts the actual printing. Signals the worker that it should begin to
   // spool as soon as data is available.

chromium_src/chrome/browser/printing/print_job_manager.h

@@ -66,7 +66,7 @@ class PrintJobManager : public content::NotificationObserver {
   // content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
+                       const content::NotificationDetails& details) override;
 
   // Returns queries queue. Never returns NULL. Must be called on Browser UI
   // Thread. Reference could be stored and used from any thread.

chromium_src/chrome/browser/printing/print_job_worker.cc

@@ -40,8 +40,8 @@ class PrintingContextDelegate : public PrintingContext::Delegate {
   PrintingContextDelegate(int render_process_id, int render_view_id);
   virtual ~PrintingContextDelegate();
 
-  virtual gfx::NativeView GetParentView() OVERRIDE;
-  virtual std::string GetAppLocale() OVERRIDE;
+  virtual gfx::NativeView GetParentView() override;
+  virtual std::string GetAppLocale() override;
 
  private:
   int render_process_id_;

chromium_src/chrome/browser/printing/print_view_manager_base.cc

@@ -144,7 +144,7 @@ void PrintViewManagerBase::OnDidPrintPage(
 #if !defined(OS_WIN)
   // Update the rendered document. It will send notifications to the listener.
   document->SetPage(params.page_number,
-                    metafile.PassAs<MetafilePlayer>(),
+                    metafile.Pass(),
                     params.page_size,
                     params.content_area);
 

chromium_src/chrome/browser/printing/print_view_manager_base.h

@@ -43,7 +43,7 @@ class PrintViewManagerBase : public content::NotificationObserver,
 #endif  // !DISABLE_BASIC_PRINTING
 
   // PrintedPagesSource implementation.
-  virtual base::string16 RenderSourceName() OVERRIDE;
+  virtual base::string16 RenderSourceName() override;
 
  protected:
   explicit PrintViewManagerBase(content::WebContents* web_contents);
@@ -52,10 +52,10 @@ class PrintViewManagerBase : public content::NotificationObserver,
   bool PrintNowInternal(IPC::Message* message);
 
   // Terminates or cancels the print job if one was pending.
-  virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
+  virtual void RenderProcessGone(base::TerminationStatus status) override;
 
   // content::WebContentsObserver implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
 
   // IPC Message handlers.
   virtual void OnPrintingFailed(int cookie);
@@ -64,10 +64,10 @@ class PrintViewManagerBase : public content::NotificationObserver,
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
+                       const content::NotificationDetails& details) override;
 
   // Cancels the print job.
-  virtual void NavigationStopped() OVERRIDE;
+  virtual void NavigationStopped() override;
 
   // IPC Message handlers.
   void OnDidGetPrintedPagesCount(int cookie, int number_pages);

chromium_src/chrome/browser/printing/print_view_manager_basic.h

@@ -32,10 +32,10 @@ class PrintViewManagerBasic
 
   // content::WebContentsObserver implementation.
   // Terminates or cancels the print job if one was pending.
-  virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
+  virtual void RenderProcessGone(base::TerminationStatus status) override;
 
   // content::WebContentsObserver implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) override;
 #endif
 
  private:
@@ -43,7 +43,7 @@ class PrintViewManagerBasic
   friend class content::WebContentsUserData<PrintViewManagerBasic>;
 
 #if defined(OS_ANDROID)
-  virtual void OnPrintingFailed(int cookie) OVERRIDE;
+  virtual void OnPrintingFailed(int cookie) override;
 
   // The file descriptor into which the PDF of the page will be written.
   base::FileDescriptor file_descriptor_;

chromium_src/chrome/browser/printing/printer_query.h

@@ -33,10 +33,10 @@ class PrinterQuery : public PrintJobWorkerOwner {
 
   // PrintJobWorkerOwner implementation.
   virtual void GetSettingsDone(const PrintSettings& new_settings,
-                               PrintingContext::Result result) OVERRIDE;
-  virtual PrintJobWorker* DetachWorker(PrintJobWorkerOwner* new_owner) OVERRIDE;
-  virtual const PrintSettings& settings() const OVERRIDE;
-  virtual int cookie() const OVERRIDE;
+                               PrintingContext::Result result) override;
+  virtual PrintJobWorker* DetachWorker(PrintJobWorkerOwner* new_owner) override;
+  virtual const PrintSettings& settings() const override;
+  virtual int cookie() const override;
 
   // Initializes the printing context. It is fine to call this function multiple
   // times to reinitialize the settings. |web_contents_observer| can be queried