Huge commit to use new V8 and Content APIs.

Still got a lots of linking errors!

app/atom_main_delegate.cc

@@ -43,7 +43,6 @@ void AtomMainDelegate::PreSandboxStartup() {
 #if defined(OS_MACOSX)
   OverrideChildProcessPath();
   OverrideFrameworkBundlePath();
-  SetProcessName();
 #endif
   InitializeResourceBundle();
 

app/atom_main_delegate.h

@@ -23,7 +23,6 @@ class AtomMainDelegate : public brightray::MainDelegate {
   virtual base::FilePath GetResourcesPakFilePath();
   virtual void OverrideChildProcessPath();
   virtual void OverrideFrameworkBundlePath();
-  virtual void SetProcessName();
 #endif
 
  private:

app/atom_main_delegate_mac.mm

@@ -45,22 +45,4 @@ void AtomMainDelegate::OverrideChildProcessPath() {
   PathService::Override(content::CHILD_PROCESS_EXE, helper_path);
 }
 
-void AtomMainDelegate::SetProcessName() {
-  const auto& command_line = *CommandLine::ForCurrentProcess();
-  auto process_type = command_line.GetSwitchValueASCII(switches::kProcessType);
-  std::string suffix;
-  if (process_type == switches::kRendererProcess)
-    suffix = "Renderer";
-  else if (process_type == switches::kPluginProcess ||
-           process_type == switches::kPpapiPluginProcess)
-    suffix = "Plug-In Host";
-  else if (process_type == switches::kUtilityProcess)
-    suffix = "Utility";
-  else
-    return;
-
-  base::mac::SetProcessName(base::mac::NSToCFCast(base::SysUTF8ToNSString(
-      brightray::GetApplicationName() + " " + suffix)));
-}
-
 }  // namespace atom

atom.gyp

@@ -165,7 +165,9 @@
       'common/platform_util_mac.mm',
       'common/platform_util_win.cc',
       'common/swap_or_assign.h',
-      'common/v8_conversions.h',
+      'common/v8/node_common.h',
+      'common/v8/scoped_persistent.h',
+      'common/v8/native_type_conversions.h',
       'common/v8_value_converter_impl.cc',
       'common/v8_value_converter_impl.h',
       'renderer/api/atom_api_renderer_ipc.cc',
@@ -328,6 +330,8 @@
         'vendor',
         # The `node.h` is using `#include"v8.h"`.
         'vendor/brightray/vendor/download/libchromiumcontent/src/v8/include',
+        # The `node.h` is using `#include"ares.h"`.
+        'vendor/node/deps/cares/include',
       ],
       'direct_dependent_settings': {
         'include_dirs': [

browser/api/atom_api_app.cc

@@ -7,8 +7,9 @@
 #include "base/values.h"
 #include "base/command_line.h"
 #include "browser/browser.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
-#include "vendor/node/src/node.h"
+
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -52,93 +53,65 @@ void App::OnFinishLaunching() {
 }
 
 // static
-v8::Handle<v8::Value> App::New(const v8::Arguments& args) {
+void App::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope scope(args.GetIsolate());
 
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
 
   new App(args.This());
-
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> App::Quit(const v8::Arguments& args) {
+void App::Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   Browser::Get()->Quit();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::Exit(const v8::Arguments& args) {
+void App::Exit(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   exit(args[0]->IntegerValue());
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::Terminate(const v8::Arguments& args) {
+void App::Terminate(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   Browser::Get()->Terminate();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::Focus(const v8::Arguments& args) {
+void App::Focus(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   Browser::Get()->Focus();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::GetVersion(const v8::Arguments& args) {
+void App::GetVersion(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  return ToV8Value(Browser::Get()->GetVersion());
+  args.GetReturnValue().Set(ToV8Value(Browser::Get()->GetVersion()));
 }
 
 // static
-v8::Handle<v8::Value> App::SetVersion(const v8::Arguments& args) {
+void App::SetVersion(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   std::string version;
   if (!FromV8Arguments(args, &version))
     return node::ThrowError("Bad argument");
 
   Browser::Get()->SetVersion(version);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::GetName(const v8::Arguments& args) {
+void App::GetName(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  return ToV8Value(Browser::Get()->GetName());
+  return args.GetReturnValue().Set(ToV8Value(Browser::Get()->GetName()));
 }
 
 // static
-v8::Handle<v8::Value> App::SetName(const v8::Arguments& args) {
+void App::SetName(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   std::string name;
   if (!FromV8Arguments(args, &name))
     return node::ThrowError("Bad argument");
 
   Browser::Get()->SetName(name);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::AppendSwitch(const v8::Arguments& args) {
+void App::AppendSwitch(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   std::string switch_string;
   if (!FromV8Arguments(args, &switch_string))
     return node::ThrowError("Bad argument");
@@ -150,27 +123,21 @@ v8::Handle<v8::Value> App::AppendSwitch(const v8::Arguments& args) {
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switch_string, value);
   }
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::AppendArgument(const v8::Arguments& args) {
+void App::AppendArgument(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   std::string value;
   if (!FromV8Arguments(args, &value))
     return node::ThrowError("Bad argument");
 
   CommandLine::ForCurrentProcess()->AppendArg(value);
-
-  return v8::Undefined();
 }
 
 #if defined(OS_MACOSX)
 
 // static
-v8::Handle<v8::Value> App::DockBounce(const v8::Arguments& args) {
+void App::DockBounce(const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string type;
   if (!FromV8Arguments(args, &type))
     return node::ThrowError("Bad argument");
@@ -184,34 +151,32 @@ v8::Handle<v8::Value> App::DockBounce(const v8::Arguments& args) {
   else
     return node::ThrowTypeError("Invalid bounce type");
 
-  return ToV8Value(request_id);
+  args.GetReturnValue().Set(request_id);
 }
 
 // static
-v8::Handle<v8::Value> App::DockCancelBounce(const v8::Arguments& args) {
+void App::DockCancelBounce(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Browser::Get()->DockCancelBounce(FromV8Value(args[0]));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::DockSetBadgeText(const v8::Arguments& args) {
+void App::DockSetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Browser::Get()->DockSetBadgeText(FromV8Value(args[0]));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> App::DockGetBadgeText(const v8::Arguments& args) {
+void App::DockGetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string text(Browser::Get()->DockGetBadgeText());
-  return ToV8Value(text);
+  args.GetReturnValue().Set(ToV8Value(text));
 }
 
 #endif  // defined(OS_MACOSX)
 
 // static
 void App::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
-  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(App::New);
+  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(v8::String::NewSymbol("Application"));
 

browser/api/atom_api_app.h

@@ -33,24 +33,24 @@ class App : public EventEmitter,
   virtual void OnFinishLaunching() OVERRIDE;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> Quit(const v8::Arguments& args);
+  static void Quit(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Exit(const v8::Arguments& args);
+  static void Exit(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Terminate(const v8::Arguments& args);
+  static void Terminate(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Focus(const v8::Arguments& args);
+  static void Focus(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetVersion(const v8::Arguments& args);
+  static void GetVersion(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetVersion(const v8::Arguments& args);
+  static void SetVersion(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetName(const v8::Arguments& args);
+  static void GetName(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetName(const v8::Arguments& args);
+  static void SetName(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> AppendSwitch(const v8::Arguments& args);
+  static void AppendSwitch(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> AppendArgument(const v8::Arguments& args);
+  static void AppendArgument(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 #if defined(OS_MACOSX)
-  static v8::Handle<v8::Value> DockBounce(const v8::Arguments& args);
+  static void DockBounce(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> DockCancelBounce(const v8::Arguments& args);
+  static void DockCancelBounce(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> DockSetBadgeText(const v8::Arguments& args);
+  static void DockSetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> DockGetBadgeText(const v8::Arguments& args);
+  static void DockGetBadgeText(const v8::FunctionCallbackInfo<v8::Value>& args);
 #endif  // defined(OS_MACOSX)
 
   DISALLOW_COPY_AND_ASSIGN(App);

browser/api/atom_api_auto_updater.cc

@@ -6,7 +6,12 @@
 
 #include "base/values.h"
 #include "browser/auto_updater.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
+
+#undef CHECK
+#undef DISALLOW_COPY_AND_ASSIGN
+#include "vendor/node/src/node.h"
+#include "vendor/node/src/node_internals.h"
 
 namespace atom {
 
@@ -44,69 +49,63 @@ void AutoUpdater::ReadyForUpdateOnQuit(const std::string& version,
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::New(const v8::Arguments& args) {
+void AutoUpdater::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(args.GetIsolate());
 
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
 
   new AutoUpdater(args.This());
-
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::SetFeedURL(const v8::Arguments& args) {
+void AutoUpdater::SetFeedURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
   auto_updater::AutoUpdater::SetFeedURL(FromV8Value(args[0]));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::SetAutomaticallyChecksForUpdates(
+void AutoUpdater::SetAutomaticallyChecksForUpdates(
-      const v8::Arguments& args) {
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   auto_updater::AutoUpdater::SetAutomaticallyChecksForUpdates(
-      args[0]->BooleanValue());
+      FromV8Value(args[0]));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::SetAutomaticallyDownloadsUpdates(
+void AutoUpdater::SetAutomaticallyDownloadsUpdates(
-      const v8::Arguments& args) {
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   auto_updater::AutoUpdater::SetAutomaticallyDownloadsUpdates(
-      args[0]->BooleanValue());
+      FromV8Value(args[0]));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::CheckForUpdates(const v8::Arguments& args) {
+void AutoUpdater::CheckForUpdates(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   auto_updater::AutoUpdater::CheckForUpdates();
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::CheckForUpdatesInBackground(
+void AutoUpdater::CheckForUpdatesInBackground(
-      const v8::Arguments& args) {
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   auto_updater::AutoUpdater::CheckForUpdatesInBackground();
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::ContinueUpdate(const v8::Arguments& args) {
+void AutoUpdater::ContinueUpdate(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   AutoUpdater* self = AutoUpdater::Unwrap<AutoUpdater>(args.This());
   self->continue_update_.Run();
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AutoUpdater::QuitAndInstall(const v8::Arguments& args) {
+void AutoUpdater::QuitAndInstall(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   AutoUpdater* self = AutoUpdater::Unwrap<AutoUpdater>(args.This());
   self->quit_and_install_.Run();
-  return v8::Undefined();
 }
 
 // static
 void AutoUpdater::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   v8::Local<v8::FunctionTemplate> t(
       v8::FunctionTemplate::New(AutoUpdater::New));

browser/api/atom_api_auto_updater.h

@@ -31,19 +31,19 @@ class AutoUpdater : public EventEmitter,
       const base::Closure& quit_and_install) OVERRIDE;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> SetFeedURL(const v8::Arguments& args);
+  static void SetFeedURL(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetAutomaticallyChecksForUpdates(
+  static void SetAutomaticallyChecksForUpdates(
-      const v8::Arguments& args);
+      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetAutomaticallyDownloadsUpdates(
+  static void SetAutomaticallyDownloadsUpdates(
-      const v8::Arguments& args);
+      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> CheckForUpdates(const v8::Arguments& args);
+  static void CheckForUpdates(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> CheckForUpdatesInBackground(
+  static void CheckForUpdatesInBackground(
-      const v8::Arguments& args);
+      const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> ContinueUpdate(const v8::Arguments& args);
+  static void ContinueUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> QuitAndInstall(const v8::Arguments& args);
+  static void QuitAndInstall(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   base::Closure continue_update_;
   base::Closure quit_and_install_;

browser/api/atom_api_browser_ipc.cc

@@ -5,10 +5,9 @@
 #include "browser/api/atom_api_browser_ipc.h"
 
 #include "common/api/api_messages.h"
-#include "common/v8_conversions.h"
+#include "common/v8/node_common.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/render_view_host.h"
-#include "vendor/node/src/node.h"
-#include "vendor/node/src/node_internals.h"
 
 using content::RenderViewHost;
 using content::V8ValueConverter;
@@ -18,9 +17,7 @@ namespace atom {
 namespace api {
 
 // static
-v8::Handle<v8::Value> BrowserIPC::Send(const v8::Arguments& args) {
+void BrowserIPC::Send(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   string16 channel;
   int process_id, routing_id;
   scoped_ptr<base::Value> arguments;
@@ -34,17 +31,15 @@ v8::Handle<v8::Value> BrowserIPC::Send(const v8::Arguments& args) {
   if (!render_view_host)
     return node::ThrowError("Invalid render view host");
 
-  render_view_host->Send(new AtomViewMsg_Message(
+  args.GetReturnValue().Set(render_view_host->Send(new AtomViewMsg_Message(
       routing_id,
       channel,
-      *static_cast<base::ListValue*>(arguments.get())));
+      *static_cast<base::ListValue*>(arguments.get()))));
-
-  return v8::Undefined();
 }
 
 // static
 void BrowserIPC::Initialize(v8::Handle<v8::Object> target) {
-  node::SetMethod(target, "send", Send);
+  NODE_SET_METHOD(target, "send", Send);
 }
 
 }  // namespace api

browser/api/atom_api_browser_ipc.h

@@ -17,7 +17,7 @@ class BrowserIPC {
   static void Initialize(v8::Handle<v8::Object> target);
 
  private:
-  static v8::Handle<v8::Value> Send(const v8::Arguments& args);
+  static void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BrowserIPC);
 };

browser/api/atom_api_dialog.cc

@@ -8,10 +8,8 @@
 #include "browser/native_window.h"
 #include "browser/ui/file_dialog.h"
 #include "browser/ui/message_box.h"
-#include "common/v8_conversions.h"
+#include "common/v8/node_common.h"
-#include "vendor/node/src/node_internals.h"
+#include "common/v8/native_type_conversions.h"
-
-using node::node_isolate;
 
 namespace atom {
 
@@ -20,19 +18,14 @@ namespace api {
 namespace {
 
 template<typename T>
-void CallV8Function(v8::Persistent<v8::Function> callback, T arg) {
+void CallV8Function(const RefCountedV8Function& callback, T arg) {
-  DCHECK(!callback.IsEmpty());
-
-  v8::HandleScope scope;
   v8::Handle<v8::Value> value = ToV8Value(arg);
-  callback->Call(callback, 1, &value);
+  callback->NewHandle(node_isolate)->Call(
-  callback.Dispose(node_isolate);
+      v8::Context::GetCurrent()->Global(), 1, &value);
 }
 
 template<typename T>
-void CallV8Function2(v8::Persistent<v8::Function> callback,
+void CallV8Function2(const RefCountedV8Function& callback, bool result, T arg) {
-                     bool result,
-                     T arg) {
   if (result)
     return CallV8Function<T>(callback, arg);
   else
@@ -40,7 +33,7 @@ void CallV8Function2(v8::Persistent<v8::Function> callback,
 }
 
 void Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   NODE_SET_METHOD(target, "showMessageBox", ShowMessageBox);
   NODE_SET_METHOD(target, "showOpenDialog", ShowOpenDialog);
@@ -49,9 +42,7 @@ void Initialize(v8::Handle<v8::Object> target) {
 
 }  // namespace
 
-v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments& args) {
+void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   int type;
   std::vector<std::string> buttons;
   std::string title, message, detail;
@@ -68,9 +59,9 @@ v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments& args) {
         title,
         message,
         detail);
-    return scope.Close(v8::Integer::New(chosen));
+    args.GetReturnValue().Set(chosen);
   } else {
-    v8::Persistent<v8::Function> callback = FromV8Value(args[6]);
+    RefCountedV8Function callback = FromV8Value(args[6]);
     atom::ShowMessageBox(
         native_window,
         (MessageBoxType)type,
@@ -79,13 +70,10 @@ v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments& args) {
         message,
         detail,
         base::Bind(&CallV8Function<int>, callback));
-    return v8::Undefined();
   }
 }
 
-v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments& args) {
+void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   std::string title;
   base::FilePath default_path;
   int properties;
@@ -101,15 +89,15 @@ v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments& args) {
                                      default_path,
                                      properties,
                                      &paths))
-      return v8::Undefined();
+      return;
 
     v8::Handle<v8::Array> result = v8::Array::New(paths.size());
     for (size_t i = 0; i < paths.size(); ++i)
       result->Set(i, ToV8Value(paths[i]));
 
-    return scope.Close(result);
+    args.GetReturnValue().Set(result);
   } else {
-    v8::Persistent<v8::Function> callback = FromV8Value(args[4]);
+    RefCountedV8Function callback = FromV8Value(args[4]);
     file_dialog::ShowOpenDialog(
         native_window,
         title,
@@ -117,13 +105,10 @@ v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments& args) {
         properties,
         base::Bind(&CallV8Function2<const std::vector<base::FilePath>&>,
                    callback));
-    return v8::Undefined();
   }
 }
 
-v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments& args) {
+void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   std::string title;
   base::FilePath default_path;
   if (!FromV8Arguments(args, &title, &default_path))
@@ -133,21 +118,18 @@ v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments& args) {
 
   if (!args[3]->IsFunction()) {
     base::FilePath path;
-    if (!file_dialog::ShowSaveDialog(native_window,
+    if (file_dialog::ShowSaveDialog(native_window,
-                                     title,
+                                    title,
-                                     default_path,
+                                    default_path,
-                                     &path))
+                                    &path))
-      return v8::Undefined();
+      args.GetReturnValue().Set(ToV8Value(path));
-
-    return scope.Close(ToV8Value(path));
   } else {
-    v8::Persistent<v8::Function> callback = FromV8Value(args[3]);
+    RefCountedV8Function callback = FromV8Value(args[3]);
     file_dialog::ShowSaveDialog(
         native_window,
         title,
         default_path,
         base::Bind(&CallV8Function2<const base::FilePath&>, callback));
-    return v8::Undefined();
   }
 }
 

browser/api/atom_api_dialog.h

@@ -11,9 +11,9 @@ namespace atom {
 
 namespace api {
 
-v8::Handle<v8::Value> ShowMessageBox(const v8::Arguments& args);
+void ShowMessageBox(const v8::FunctionCallbackInfo<v8::Value>& args);
-v8::Handle<v8::Value> ShowOpenDialog(const v8::Arguments& args);
+void ShowOpenDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
-v8::Handle<v8::Value> ShowSaveDialog(const v8::Arguments& args);
+void ShowSaveDialog(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 }  // namespace api
 

browser/api/atom_api_event.cc

@@ -6,15 +6,14 @@
 
 #include "browser/native_window.h"
 #include "common/api/api_messages.h"
-#include "common/v8_conversions.h"
+#include "common/v8/node_common.h"
-
+#include "common/v8/native_type_conversions.h"
-using node::node_isolate;
 
 namespace atom {
 
 namespace api {
 
-v8::Persistent<v8::FunctionTemplate> Event::constructor_template_;
+ScopedPersistent<v8::Function> Event::constructor_template_;
 
 Event::Event()
     : sender_(NULL),
@@ -29,24 +28,20 @@ Event::~Event() {
 
 // static
 v8::Handle<v8::Object> Event::CreateV8Object() {
-  v8::HandleScope scope;
-
   if (constructor_template_.IsEmpty()) {
     v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
-    constructor_template_ = v8::Persistent<v8::FunctionTemplate>::New(
+    t->InstanceTemplate()->SetInternalFieldCount(1);
-        node_isolate, t);
+    t->SetClassName(v8::String::NewSymbol("Event"));
-    constructor_template_->InstanceTemplate()->SetInternalFieldCount(1);
-    constructor_template_->SetClassName(v8::String::NewSymbol("Event"));
 
     NODE_SET_PROTOTYPE_METHOD(t, "preventDefault", PreventDefault);
     NODE_SET_PROTOTYPE_METHOD(t, "sendReply", SendReply);
     NODE_SET_PROTOTYPE_METHOD(t, "destroy", Destroy);
+
+    constructor_template_.reset(t->GetFunction());
   }
 
-  v8::Handle<v8::Object> v8_event =
+  v8::Handle<v8::Function> t = constructor_template_.NewHandle(node_isolate);
-      constructor_template_->GetFunction()->NewInstance(0, NULL);
+  return t->NewInstance(0, NULL);
-
-  return scope.Close(v8_event);
 }
 
 void Event::SetSenderAndMessage(NativeWindow* sender, IPC::Message* message) {
@@ -64,26 +59,22 @@ void Event::OnWindowClosed() {
 }
 
 // static
-v8::Handle<v8::Value> Event::New(const v8::Arguments& args) {
+void Event::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Event* event = new Event;
   event->Wrap(args.This());
-
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> Event::PreventDefault(const v8::Arguments& args) {
+void Event::PreventDefault(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Event* event = Unwrap<Event>(args.This());
   if (event == NULL)
     return node::ThrowError("Event is already destroyed");
 
   event->prevent_default_ = true;
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Event::SendReply(const v8::Arguments& args) {
+void Event::SendReply(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Event* event = Unwrap<Event>(args.This());
   if (event == NULL)
     return node::ThrowError("Event is already destroyed");
@@ -97,14 +88,11 @@ v8::Handle<v8::Value> Event::SendReply(const v8::Arguments& args) {
   event->sender_->Send(event->message_);
 
   delete event;
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Event::Destroy(const v8::Arguments& args) {
+void Event::Destroy(const v8::FunctionCallbackInfo<v8::Value>& args) {
   delete Unwrap<Event>(args.This());
-  return v8::Undefined();
 }
 
 }  // namespace api

browser/api/atom_api_event.h

@@ -9,6 +9,7 @@
 #include "base/compiler_specific.h"
 #include "base/strings/string16.h"
 #include "browser/native_window_observer.h"
+#include "common/v8/scoped_persistent.h"
 #include "vendor/node/src/node_object_wrap.h"
 
 namespace IPC {
@@ -32,9 +33,6 @@ class Event : public node::ObjectWrap,
   // Pass the sender and message to be replied.
   void SetSenderAndMessage(NativeWindow* sender, IPC::Message* message);
 
-  // Accessor to return handle_, this follows Google C++ Style.
-  v8::Persistent<v8::Object>& handle() { return handle_; }
-
   // Whether event.preventDefault() is called.
   bool prevent_default() const { return prevent_default_; }
 
@@ -45,13 +43,13 @@ class Event : public node::ObjectWrap,
   virtual void OnWindowClosed() OVERRIDE;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> PreventDefault(const v8::Arguments& args);
+  static void PreventDefault(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SendReply(const v8::Arguments& args);
+  static void SendReply(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Destroy(const v8::Arguments& args);
+  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Persistent<v8::FunctionTemplate> constructor_template_;
+  static ScopedPersistent<v8::Function> constructor_template_;
 
   // Replyer for the synchronous messages.
   NativeWindow* sender_;

browser/api/atom_api_event_emitter.cc

@@ -8,9 +8,8 @@
 
 #include "base/logging.h"
 #include "browser/api/atom_api_event.h"
-#include "common/v8_conversions.h"
+#include "common/v8/node_common.h"
-#include "vendor/node/src/node.h"
+#include "common/v8/native_type_conversions.h"
-#include "vendor/node/src/node_internals.h"
 
 namespace atom {
 
@@ -24,7 +23,8 @@ EventEmitter::EventEmitter(v8::Handle<v8::Object> wrapper) {
       v8::String::New("ATOM_BROWSER_INTERNAL_NEW"),
       wrapper,
   };
-  node::MakeCallback(node::process, "emit", 2, args);
+  node::Environment* env = node::Environment::GetCurrent(node_isolate);
+  node::MakeCallback(env->process_object(), "emit", 2, args);
 }
 
 EventEmitter::~EventEmitter() {
@@ -36,7 +36,7 @@ bool EventEmitter::Emit(const std::string& name) {
 }
 
 bool EventEmitter::Emit(const std::string& name, base::ListValue* args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Handle<v8::Context> context = v8::Context::GetCurrent();
   scoped_ptr<content::V8ValueConverter> converter(new V8ValueConverterImpl);

browser/api/atom_api_event_emitter.h

@@ -29,6 +29,11 @@ class EventEmitter : public node::ObjectWrap {
   bool Emit(const std::string& name);
   bool Emit(const std::string& name, base::ListValue* args);
 
+  // The handle() of ObjectWrap doesn't provide the const version.
+  inline v8::Local<v8::Object> handle() const {
+    return const_cast<EventEmitter*>(this)->handle();
+  }
+
  protected:
   explicit EventEmitter(v8::Handle<v8::Object> wrapper);
 

browser/api/atom_api_menu.cc

@@ -5,7 +5,8 @@
 #include "browser/api/atom_api_menu.h"
 
 #include "browser/ui/accelerator_util.h"
-#include "common/v8_conversions.h"
+#include "common/v8/node_common.h"
+#include "common/v8/native_type_conversions.h"
 
 #define UNWRAP_MEMNU_AND_CHECK \
   Menu* self = ObjectWrap::Unwrap<Menu>(args.This()); \
@@ -23,7 +24,7 @@ v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
                                    v8::Handle<v8::Object> menu,
                                    const char* method,
                                    int command_id) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Handle<v8::Value> delegate = menu->Get(v8::String::New("delegate"));
   if (!delegate->IsObject())
@@ -36,7 +37,7 @@ v8::Handle<v8::Value> CallDelegate(v8::Handle<v8::Value> default_value,
 
   v8::Handle<v8::Value> argv = v8::Integer::New(command_id);
 
-  return scope.Close(
+  return handle_scope.Close(
       function->Call(v8::Context::GetCurrent()->Global(), 1, &argv));
 }
 
@@ -51,7 +52,7 @@ Menu::~Menu() {
 }
 
 bool Menu::IsCommandIdChecked(int command_id) const {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::False(),
                       handle(),
                       "isCommandIdChecked",
@@ -59,7 +60,7 @@ bool Menu::IsCommandIdChecked(int command_id) const {
 }
 
 bool Menu::IsCommandIdEnabled(int command_id) const {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::True(),
                       handle(),
                       "isCommandIdEnabled",
@@ -67,7 +68,7 @@ bool Menu::IsCommandIdEnabled(int command_id) const {
 }
 
 bool Menu::IsCommandIdVisible(int command_id) const {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::True(),
                       handle(),
                       "isCommandIdVisible",
@@ -76,7 +77,7 @@ bool Menu::IsCommandIdVisible(int command_id) const {
 
 bool Menu::GetAcceleratorForCommandId(int command_id,
                                       ui::Accelerator* accelerator) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
   v8::Handle<v8::Value> shortcut = CallDelegate(v8::Undefined(),
                                                 handle(),
                                                 "getAcceleratorForCommandId",
@@ -90,7 +91,7 @@ bool Menu::GetAcceleratorForCommandId(int command_id,
 }
 
 bool Menu::IsItemForCommandIdDynamic(int command_id) const {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
   return CallDelegate(v8::False(),
                       handle(),
                       "isItemForCommandIdDynamic",
@@ -98,7 +99,7 @@ bool Menu::IsItemForCommandIdDynamic(int command_id) const {
 }
 
 string16 Menu::GetLabelForCommandId(int command_id) const {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
   return FromV8Value(CallDelegate(v8::False(),
                                   handle(),
                                   "getLabelForCommandId",
@@ -106,7 +107,7 @@ string16 Menu::GetLabelForCommandId(int command_id) const {
 }
 
 string16 Menu::GetSublabelForCommandId(int command_id) const {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
   return FromV8Value(CallDelegate(v8::False(),
                                   handle(),
                                   "getSubLabelForCommandId",
@@ -114,24 +115,22 @@ string16 Menu::GetSublabelForCommandId(int command_id) const {
 }
 
 void Menu::ExecuteCommand(int command_id, int event_flags) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
   CallDelegate(v8::False(), handle(), "executeCommand", command_id);
 }
 
 // static
-v8::Handle<v8::Value> Menu::New(const v8::Arguments& args) {
+void Menu::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(args.GetIsolate());
 
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
 
   Menu::Create(args.This());
-
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertItem(const v8::Arguments& args) {
+void Menu::InsertItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
   int index, command_id;
@@ -143,12 +142,10 @@ v8::Handle<v8::Value> Menu::InsertItem(const v8::Arguments& args) {
     self->model_->AddItem(command_id, label);
   else
     self->model_->InsertItemAt(index, command_id, label);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertCheckItem(const v8::Arguments& args) {
+void Menu::InsertCheckItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
   int index, command_id;
@@ -160,12 +157,10 @@ v8::Handle<v8::Value> Menu::InsertCheckItem(const v8::Arguments& args) {
     self->model_->AddCheckItem(command_id, label);
   else
     self->model_->InsertCheckItemAt(index, command_id, label);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertRadioItem(const v8::Arguments& args) {
+void Menu::InsertRadioItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
   int index, command_id, group_id;
@@ -177,12 +172,10 @@ v8::Handle<v8::Value> Menu::InsertRadioItem(const v8::Arguments& args) {
     self->model_->AddRadioItem(command_id, label, group_id);
   else
     self->model_->InsertRadioItemAt(index, command_id, label, group_id);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertSeparator(const v8::Arguments& args) {
+void Menu::InsertSeparator(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
   int index;
@@ -193,12 +186,10 @@ v8::Handle<v8::Value> Menu::InsertSeparator(const v8::Arguments& args) {
     self->model_->AddSeparator(ui::NORMAL_SEPARATOR);
   else
     self->model_->InsertSeparatorAt(index, ui::NORMAL_SEPARATOR);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::InsertSubMenu(const v8::Arguments& args) {
+void Menu::InsertSubMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
   int index, command_id;
@@ -215,12 +206,10 @@ v8::Handle<v8::Value> Menu::InsertSubMenu(const v8::Arguments& args) {
   else
     self->model_->InsertSubMenuAt(
         index, command_id, label, submenu->model_.get());
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::SetIcon(const v8::Arguments& args) {
+void Menu::SetIcon(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
   int index;
@@ -229,12 +218,10 @@ v8::Handle<v8::Value> Menu::SetIcon(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   // FIXME use webkit_glue's image decoder here.
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::SetSublabel(const v8::Arguments& args) {
+void Menu::SetSublabel(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
   int index;
@@ -243,74 +230,71 @@ v8::Handle<v8::Value> Menu::SetSublabel(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->model_->SetSublabel(index, label);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::Clear(const v8::Arguments& args) {
+void Menu::Clear(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-
   self->model_->Clear();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetIndexOfCommandId(const v8::Arguments& args) {
+void Menu::GetIndexOfCommandId(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
+  int index = FromV8Value(args[0]);
-  return v8::Integer::New(self->model_->GetIndexOfCommandId(index));
+  args.GetReturnValue().Set(self->model_->GetIndexOfCommandId(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetItemCount(const v8::Arguments& args) {
+void Menu::GetItemCount(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  return v8::Integer::New(self->model_->GetItemCount());
+  args.GetReturnValue().Set(self->model_->GetItemCount());
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetCommandIdAt(const v8::Arguments& args) {
+void Menu::GetCommandIdAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
+  int index = FromV8Value(args[0]);
-  return v8::Integer::New(self->model_->GetCommandIdAt(index));
+  args.GetReturnValue().Set(self->model_->GetCommandIdAt(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetLabelAt(const v8::Arguments& args) {
+void Menu::GetLabelAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
+  int index = FromV8Value(args[0]);
-  return ToV8Value(self->model_->GetLabelAt(index));
+  args.GetReturnValue().Set(ToV8Value(self->model_->GetLabelAt(index)));
 }
 
 // static
-v8::Handle<v8::Value> Menu::GetSublabelAt(const v8::Arguments& args) {
+void Menu::GetSublabelAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
+  int index = FromV8Value(args[0]);
-  return ToV8Value(self->model_->GetSublabelAt(index));
+  args.GetReturnValue().Set(ToV8Value(self->model_->GetSublabelAt(index)));
 }
 
 // static
-v8::Handle<v8::Value> Menu::IsItemCheckedAt(const v8::Arguments& args) {
+void Menu::IsItemCheckedAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  int index = args[0]->IntegerValue();
+  int index = FromV8Value(args[0]);
-  return v8::Boolean::New(self->model_->IsItemCheckedAt(index));
+  args.GetReturnValue().Set(self->model_->IsItemCheckedAt(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::IsEnabledAt(const v8::Arguments& args) {
+void Menu::IsEnabledAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  return v8::Boolean::New(self->model_->IsEnabledAt(args[0]->IntegerValue()));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(self->model_->IsEnabledAt(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::IsVisibleAt(const v8::Arguments& args) {
+void Menu::IsVisibleAt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
-  return v8::Boolean::New(self->model_->IsVisibleAt(args[0]->IntegerValue()));
+  int index = FromV8Value(args[0]);
+  args.GetReturnValue().Set(self->model_->IsVisibleAt(index));
 }
 
 // static
-v8::Handle<v8::Value> Menu::Popup(const v8::Arguments& args) {
+void Menu::Popup(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_MEMNU_AND_CHECK;
 
   atom::NativeWindow* window;
@@ -318,12 +302,11 @@ v8::Handle<v8::Value> Menu::Popup(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->Popup(window);
-  return v8::Undefined();
 }
 
 // static
 void Menu::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Local<v8::FunctionTemplate> t(v8::FunctionTemplate::New(Menu::New));
   t->InstanceTemplate()->SetInternalFieldCount(1);

browser/api/atom_api_menu.h

@@ -44,36 +44,37 @@ class Menu : public EventEmitter,
   scoped_ptr<ui::SimpleMenuModel> model_;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> InsertItem(const v8::Arguments& args);
+  static void InsertItem(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> InsertCheckItem(const v8::Arguments& args);
+  static void InsertCheckItem(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> InsertRadioItem(const v8::Arguments& args);
+  static void InsertRadioItem(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> InsertSeparator(const v8::Arguments& args);
+  static void InsertSeparator(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> InsertSubMenu(const v8::Arguments& args);
+  static void InsertSubMenu(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> SetIcon(const v8::Arguments& args);
+  static void SetIcon(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetSublabel(const v8::Arguments& args);
+  static void SetSublabel(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> Clear(const v8::Arguments& args);
+  static void Clear(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> GetIndexOfCommandId(const v8::Arguments& args);
+  static void GetIndexOfCommandId(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetItemCount(const v8::Arguments& args);
+  static void GetItemCount(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetCommandIdAt(const v8::Arguments& args);
+  static void GetCommandIdAt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetLabelAt(const v8::Arguments& args);
+  static void GetLabelAt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetSublabelAt(const v8::Arguments& args);
+  static void GetSublabelAt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsItemCheckedAt(const v8::Arguments& args);
+  static void IsItemCheckedAt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsEnabledAt(const v8::Arguments& args);
+  static void IsEnabledAt(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsVisibleAt(const v8::Arguments& args);
+  static void IsVisibleAt(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> Popup(const v8::Arguments& args);
+  static void Popup(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 #if defined(OS_WIN)
-  static v8::Handle<v8::Value> AttachToWindow(const v8::Arguments& args);
+  static void AttachToWindow(const v8::FunctionCallbackInfo<v8::Value>& args);
 #elif defined(OS_MACOSX)
-  static v8::Handle<v8::Value> SetApplicationMenu(const v8::Arguments& args);
+  static void SetApplicationMenu(
-  static v8::Handle<v8::Value> SendActionToFirstResponder(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
-      const v8::Arguments& args);
+  static void SendActionToFirstResponder(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(Menu);

browser/api/atom_api_menu_mac.h

@@ -21,7 +21,7 @@ class MenuMac : public Menu {
  protected:
   virtual void Popup(NativeWindow* window) OVERRIDE;
 
-  scoped_nsobject<AtomMenuController> menu_controller_;
+  base::scoped_nsobject<AtomMenuController> menu_controller_;
 
  private:
   friend class Menu;

browser/api/atom_api_menu_mac.mm

@@ -4,11 +4,12 @@
 
 #import "browser/api/atom_api_menu_mac.h"
 
-#include "base/message_loop.h"
 #include "base/mac/scoped_sending_event.h"
+#include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "browser/native_window.h"
-#include "common/v8_conversions.h"
+#include "common/v8/node_common.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 
@@ -24,7 +25,7 @@ MenuMac::~MenuMac() {
 }
 
 void MenuMac::Popup(NativeWindow* native_window) {
-  scoped_nsobject<AtomMenuController> menu_controller(
+  base::scoped_nsobject<AtomMenuController> menu_controller(
       [[AtomMenuController alloc] initWithModel:model_.get()]);
 
   NSWindow* window = native_window->GetNativeWindow();
@@ -46,7 +47,8 @@ void MenuMac::Popup(NativeWindow* native_window) {
 
   {
     // Make sure events can be pumped while the menu is up.
-    MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
+    base::MessageLoop::ScopedNestableTaskAllower allow(
+        base::MessageLoop::current());
 
     // One of the events that could be pumped is |window.close()|.
     // User-initiated event-tracking loops protect against this by
@@ -71,8 +73,8 @@ void MenuMac::SendActionToFirstResponder(const std::string& action) {
 }
 
 // static
-v8::Handle<v8::Value> Menu::SetApplicationMenu(const v8::Arguments& args) {
+void Menu::SetApplicationMenu(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(args.GetIsolate());
 
   if (!args[0]->IsObject())
     return node::ThrowTypeError("Bad argument");
@@ -81,28 +83,24 @@ v8::Handle<v8::Value> Menu::SetApplicationMenu(const v8::Arguments& args) {
   if (!menu)
     return node::ThrowError("Menu is destroyed");
 
-  scoped_nsobject<AtomMenuController> menu_controller(
+  base::scoped_nsobject<AtomMenuController> menu_controller(
       [[AtomMenuController alloc] initWithModel:menu->model_.get()]);
   [NSApp setMainMenu:[menu_controller menu]];
 
   // Ensure the menu_controller_ is destroyed after main menu is set.
   menu_controller.swap(menu->menu_controller_);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Menu::SendActionToFirstResponder(
+void Menu::SendActionToFirstResponder(
-    const v8::Arguments& args) {
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(args.GetIsolate());
 
   std::string action;
   if (!FromV8Arguments(args, &action))
     return node::ThrowTypeError("Bad argument");
 
   MenuMac::SendActionToFirstResponder(action);
-
-  return v8::Undefined();
 }
 
 // static

browser/api/atom_api_menu_win.cc

@@ -6,7 +6,7 @@
 
 #include "browser/native_window_win.h"
 #include "browser/ui/win/menu_2.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/screen.h"
 
@@ -28,8 +28,8 @@ void MenuWin::Popup(NativeWindow* native_window) {
 }
 
 // static
-v8::Handle<v8::Value> Menu::AttachToWindow(const v8::Arguments& args) {
+void Menu::AttachToWindow(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(args.GetIsolate());
 
   Menu* self = ObjectWrap::Unwrap<Menu>(args.This());
   if (self == NULL)

browser/api/atom_api_power_monitor.cc

@@ -5,6 +5,9 @@
 #include "browser/api/atom_api_power_monitor.h"
 
 #include "base/power_monitor/power_monitor.h"
+#include "base/power_monitor/power_monitor_device_source.h"
+
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -35,20 +38,22 @@ void PowerMonitor::OnResume() {
 }
 
 // static
-v8::Handle<v8::Value> PowerMonitor::New(const v8::Arguments& args) {
+void PowerMonitor::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(args.GetIsolate());
 
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
 
   new PowerMonitor(args.This());
-
-  return args.This();
 }
 
 // static
 void PowerMonitor::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
+
+#if defined(OS_MACOSX)
+  base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
+#endif
 
   v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(
       PowerMonitor::New);

browser/api/atom_api_power_monitor.h

@@ -29,7 +29,7 @@ class PowerMonitor : public EventEmitter,
   virtual void OnResume() OVERRIDE;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   DISALLOW_COPY_AND_ASSIGN(PowerMonitor);
 };

browser/api/atom_api_protocol.cc

@@ -9,11 +9,11 @@
 #include "browser/net/adapter_request_job.h"
 #include "browser/net/atom_url_request_context_getter.h"
 #include "browser/net/atom_url_request_job_factory.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/url_request/url_request_context.h"
-#include "vendor/node/src/node.h"
+
-#include "vendor/node/src/node_internals.h"
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -24,10 +24,10 @@ typedef net::URLRequestJobFactory::ProtocolHandler ProtocolHandler;
 namespace {
 
 // The protocol module object.
-v8::Persistent<v8::Object> g_protocol_object;
+ScopedPersistent<v8::Object> g_protocol_object;
 
 // Registered protocol handlers.
-typedef std::map<std::string, v8::Persistent<v8::Function>> HandlersMap;
+typedef std::map<std::string, RefCountedV8Function> HandlersMap;
 static HandlersMap g_handlers;
 
 static const char* kEarlyUseProtocolError = "This method can only be used"
@@ -35,25 +35,23 @@ static const char* kEarlyUseProtocolError = "This method can only be used"
 
 // Emit an event for the protocol module.
 void EmitEventInUI(const std::string& event, const std::string& parameter) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Handle<v8::Value> argv[] = {
-    ToV8Value(event),
+      ToV8Value(event),
-    ToV8Value(parameter),
+      ToV8Value(parameter),
   };
-  node::MakeCallback(g_protocol_object, "emit", arraysize(argv), argv);
+  node::MakeCallback(g_protocol_object.NewHandle(node_isolate),
+                     "emit", 2, argv);
 }
 
 // Convert the URLRequest object to V8 object.
 v8::Handle<v8::Object> ConvertURLRequestToV8Object(
     const net::URLRequest* request) {
   v8::Local<v8::Object> obj = v8::Object::New();
-  obj->Set(v8::String::New("method"),
+  obj->Set(ToV8Value("method"), ToV8Value(request->method()));
-           v8::String::New(request->method().c_str()));
+  obj->Set(ToV8Value("url"), ToV8Value(request->url().spec()));
-  obj->Set(v8::String::New("url"),
+  obj->Set(ToV8Value("referrer"), ToV8Value(request->referrer()));
-           v8::String::New(request->url().spec().c_str()));
-  obj->Set(v8::String::New("referrer"),
-           v8::String::New(request->referrer().c_str()));
   return obj;
 }
 
@@ -74,13 +72,15 @@ class CustomProtocolRequestJob : public AdapterRequestJob {
   virtual void GetJobTypeInUI() OVERRIDE {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
+    v8::HandleScope handle_scope(node_isolate);
+
     // Call the JS handler.
-    v8::HandleScope scope;
     v8::Handle<v8::Value> argv[] = {
       ConvertURLRequestToV8Object(request()),
     };
-    v8::Handle<v8::Value> result = g_handlers[request()->url().scheme()]->Call(
+    RefCountedV8Function callback = g_handlers[request()->url().scheme()];
-        v8::Context::GetCurrent()->Global(), arraysize(argv), argv);
+    v8::Handle<v8::Value> result = callback->NewHandle(node_isolate)->Call(
+        v8::Context::GetCurrent()->Global(), 1, argv);
 
     // Determine the type of the job we are going to create.
     if (result->IsString()) {
@@ -180,9 +180,10 @@ class CustomProtocolHandler : public ProtocolHandler {
 }  // namespace
 
 // static
-v8::Handle<v8::Value> Protocol::RegisterProtocol(const v8::Arguments& args) {
+void Protocol::RegisterProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string scheme;
-  v8::Persistent<v8::Function> callback;
+  RefCountedV8Function callback;
   if (!FromV8Arguments(args, &scheme, &callback))
     return node::ThrowTypeError("Bad argument");
 
@@ -199,12 +200,11 @@ v8::Handle<v8::Value> Protocol::RegisterProtocol(const v8::Arguments& args) {
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(&RegisterProtocolInIO, scheme));
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Protocol::UnregisterProtocol(const v8::Arguments& args) {
+void Protocol::UnregisterProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string scheme;
   if (!FromV8Arguments(args, &scheme))
     return node::ThrowTypeError("Bad argument");
@@ -221,19 +221,20 @@ v8::Handle<v8::Value> Protocol::UnregisterProtocol(const v8::Arguments& args) {
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(&UnregisterProtocolInIO, scheme));
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Protocol::IsHandledProtocol(const v8::Arguments& args) {
+void Protocol::IsHandledProtocol(
-  return ToV8Value(net::URLRequest::IsHandledProtocol(FromV8Value(args[0])));
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  std::string scheme = FromV8Value(args[0]);
+  args.GetReturnValue().Set(net::URLRequest::IsHandledProtocol(scheme));
 }
 
 // static
-v8::Handle<v8::Value> Protocol::InterceptProtocol(const v8::Arguments& args) {
+void Protocol::InterceptProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string scheme;
-  v8::Persistent<v8::Function> callback;
+  RefCountedV8Function callback;
   if (!FromV8Arguments(args, &scheme, &callback))
     return node::ThrowTypeError("Bad argument");
 
@@ -252,11 +253,11 @@ v8::Handle<v8::Value> Protocol::InterceptProtocol(const v8::Arguments& args) {
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(&InterceptProtocolInIO, scheme));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Protocol::UninterceptProtocol(const v8::Arguments& args) {
+void Protocol::UninterceptProtocol(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string scheme;
   if (!FromV8Arguments(args, &scheme))
     return node::ThrowTypeError("Bad argument");
@@ -274,7 +275,6 @@ v8::Handle<v8::Value> Protocol::UninterceptProtocol(const v8::Arguments& args) {
                                    FROM_HERE,
                                    base::Bind(&UninterceptProtocolInIO,
                                               scheme));
-  return v8::Undefined();
 }
 
 // static
@@ -361,14 +361,13 @@ void Protocol::UninterceptProtocolInIO(const std::string& scheme) {
 // static
 void Protocol::Initialize(v8::Handle<v8::Object> target) {
   // Remember the protocol object, used for emitting event later.
-  g_protocol_object = v8::Persistent<v8::Object>::New(
+  g_protocol_object.reset(v8::Object::New());
-      node::node_isolate, target);
 
-  node::SetMethod(target, "registerProtocol", RegisterProtocol);
+  NODE_SET_METHOD(target, "registerProtocol", RegisterProtocol);
-  node::SetMethod(target, "unregisterProtocol", UnregisterProtocol);
+  NODE_SET_METHOD(target, "unregisterProtocol", UnregisterProtocol);
-  node::SetMethod(target, "isHandledProtocol", IsHandledProtocol);
+  NODE_SET_METHOD(target, "isHandledProtocol", IsHandledProtocol);
-  node::SetMethod(target, "interceptProtocol", InterceptProtocol);
+  NODE_SET_METHOD(target, "interceptProtocol", InterceptProtocol);
-  node::SetMethod(target, "uninterceptProtocol", UninterceptProtocol);
+  NODE_SET_METHOD(target, "uninterceptProtocol", UninterceptProtocol);
 }
 
 }  // namespace api

browser/api/atom_api_protocol.h

@@ -20,12 +20,12 @@ class Protocol {
   static void Initialize(v8::Handle<v8::Object> target);
 
  private:
-  static v8::Handle<v8::Value> RegisterProtocol(const v8::Arguments& args);
+  static void RegisterProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> UnregisterProtocol(const v8::Arguments& args);
+  static void UnregisterProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsHandledProtocol(const v8::Arguments& args);
+  static void IsHandledProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::Handle<v8::Value> InterceptProtocol(const v8::Arguments& args);
+  static void InterceptProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> UninterceptProtocol(const v8::Arguments& args);
+  static void UninterceptProtocol(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void RegisterProtocolInIO(const std::string& scheme);
   static void UnregisterProtocolInIO(const std::string& scheme);

browser/api/atom_api_window.cc

@@ -4,9 +4,9 @@
 
 #include "browser/api/atom_api_window.h"
 
-#include "base/process_util.h"
+#include "base/process/kill.h"
 #include "browser/native_window.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/render_process_host.h"
@@ -14,6 +14,8 @@
 #include "ui/gfx/size.h"
 #include "vendor/node/src/node_buffer.h"
 
+#include "common/v8/node_common.h"
+
 using content::NavigationController;
 using node::ObjectWrap;
 
@@ -87,23 +89,20 @@ void Window::OnRendererCrashed() {
   Emit("crashed");
 }
 
-void Window::OnCapturePageDone(v8::Persistent<v8::Function> callback,
+void Window::OnCapturePageDone(const RefCountedV8Function& callback,
                                const std::vector<unsigned char>& data) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
-  // TODO(zcbenz): Use new Buffer API when we updated to node v0.12.x.
+  v8::Local<v8::Value> buffer = node::Buffer::New(
-  node::Buffer* buffer = node::Buffer::New(
       reinterpret_cast<const char*>(data.data()),
       data.size());
-
+  callback->NewHandle(node_isolate)->Call(
-  v8::Handle<v8::Value> arg = buffer->handle_;
+      v8::Context::GetCurrent()->Global(), 1, &buffer);
-  callback->Call(v8::Context::GetCurrent()->Global(), 1, &arg);
-  callback.Dispose(v8::Isolate::GetCurrent());
 }
 
 // static
-v8::Handle<v8::Value> Window::New(const v8::Arguments& args) {
+void Window::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(args.GetIsolate());
 
   if (!args.IsConstructCall())
     return node::ThrowError("Require constructor call");
@@ -119,12 +118,10 @@ v8::Handle<v8::Value> Window::New(const v8::Arguments& args) {
 
   // Give js code a chance to do initialization.
   node::MakeCallback(args.This(), "_init", 0, NULL);
-
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> Window::Destroy(const v8::Arguments& args) {
+void Window::Destroy(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   base::ProcessHandle handle = self->window_->GetRenderProcessHandle();
@@ -135,96 +132,70 @@ v8::Handle<v8::Value> Window::Destroy(const v8::Arguments& args) {
   if (!base::WaitForSingleProcess(handle,
                                   base::TimeDelta::FromMilliseconds(500)))
     base::KillProcess(handle, 0, true);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Close(const v8::Arguments& args) {
+void Window::Close(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Close();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Focus(const v8::Arguments& args) {
+void Window::Focus(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Focus(args[0]->IsBoolean() ? args[0]->BooleanValue(): true);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsFocused(const v8::Arguments& args) {
+void Window::IsFocused(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-  return ToV8Value(self->window_->IsFocused());
+  args.GetReturnValue().Set(self->window_->IsFocused());
 }
 
 // static
-v8::Handle<v8::Value> Window::Show(const v8::Arguments& args) {
+void Window::Show(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Show();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Hide(const v8::Arguments& args) {
+void Window::Hide(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Hide();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsVisible(const v8::Arguments& args) {
+void Window::IsVisible(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-  return ToV8Value(self->window_->IsVisible());
+  return args.GetReturnValue().Set(self->window_->IsVisible());
 }
 
 // static
-v8::Handle<v8::Value> Window::Maximize(const v8::Arguments& args) {
+void Window::Maximize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Maximize();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Unmaximize(const v8::Arguments& args) {
+void Window::Unmaximize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Unmaximize();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Minimize(const v8::Arguments& args) {
+void Window::Minimize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Minimize();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Restore(const v8::Arguments& args) {
+void Window::Restore(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Restore();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::SetFullscreen(const v8::Arguments& args) {
+void Window::SetFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   bool fs;
@@ -232,18 +203,16 @@ v8::Handle<v8::Value> Window::SetFullscreen(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetFullscreen(fs);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsFullscreen(const v8::Arguments& args) {
+void Window::IsFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(self->window_->IsFullscreen());
-  return ToV8Value(self->window_->IsFullscreen());
 }
 
 // static
-v8::Handle<v8::Value> Window::SetSize(const v8::Arguments& args) {
+void Window::SetSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   int width, height;
@@ -251,11 +220,10 @@ v8::Handle<v8::Value> Window::SetSize(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetSize(gfx::Size(width, height));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetSize(const v8::Arguments& args) {
+void Window::GetSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Size size = self->window_->GetSize();
@@ -263,11 +231,11 @@ v8::Handle<v8::Value> Window::GetSize(const v8::Arguments& args) {
   ret->Set(0, ToV8Value(size.width()));
   ret->Set(1, ToV8Value(size.height()));
 
-  return ret;
+  args.GetReturnValue().Set(ret);
 }
 
 // static
-v8::Handle<v8::Value> Window::SetMinimumSize(const v8::Arguments& args) {
+void Window::SetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   int width, height;
@@ -275,11 +243,10 @@ v8::Handle<v8::Value> Window::SetMinimumSize(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetMinimumSize(gfx::Size(width, height));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetMinimumSize(const v8::Arguments& args) {
+void Window::GetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Size size = self->window_->GetMinimumSize();
@@ -287,24 +254,22 @@ v8::Handle<v8::Value> Window::GetMinimumSize(const v8::Arguments& args) {
   ret->Set(0, ToV8Value(size.width()));
   ret->Set(1, ToV8Value(size.height()));
 
-  return ret;
+  args.GetReturnValue().Set(ret);
 }
 
 // static
-v8::Handle<v8::Value> Window::SetMaximumSize(const v8::Arguments& args) {
+void Window::SetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-
   int width, height;
   if (!FromV8Arguments(args, &width, &height))
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetMaximumSize(gfx::Size(width, height));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetMaximumSize(const v8::Arguments& args) {
+void Window::GetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Size size = self->window_->GetMaximumSize();
@@ -312,11 +277,11 @@ v8::Handle<v8::Value> Window::GetMaximumSize(const v8::Arguments& args) {
   ret->Set(0, ToV8Value(size.width()));
   ret->Set(1, ToV8Value(size.height()));
 
-  return ret;
+  args.GetReturnValue().Set(ret);
 }
 
 // static
-v8::Handle<v8::Value> Window::SetResizable(const v8::Arguments& args) {
+void Window::SetResizable(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   bool resizable;
@@ -324,18 +289,16 @@ v8::Handle<v8::Value> Window::SetResizable(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetResizable(resizable);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsResizable(const v8::Arguments& args) {
+void Window::IsResizable(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(self->window_->IsResizable());
-  return ToV8Value(self->window_->IsResizable());
 }
 
 // static
-v8::Handle<v8::Value> Window::SetAlwaysOnTop(const v8::Arguments& args) {
+void Window::SetAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   bool top;
@@ -343,27 +306,22 @@ v8::Handle<v8::Value> Window::SetAlwaysOnTop(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetAlwaysOnTop(top);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsAlwaysOnTop(const v8::Arguments& args) {
+void Window::IsAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(self->window_->IsAlwaysOnTop());
-  return ToV8Value(self->window_->IsAlwaysOnTop());
 }
 
 // static
-v8::Handle<v8::Value> Window::Center(const v8::Arguments& args) {
+void Window::Center(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->Center();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::SetPosition(const v8::Arguments& args) {
+void Window::SetPosition(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   int x, y;
@@ -371,11 +329,10 @@ v8::Handle<v8::Value> Window::SetPosition(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetPosition(gfx::Point(x, y));
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetPosition(const v8::Arguments& args) {
+void Window::GetPosition(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Point pos = self->window_->GetPosition();
@@ -383,11 +340,11 @@ v8::Handle<v8::Value> Window::GetPosition(const v8::Arguments& args) {
   ret->Set(0, ToV8Value(pos.x()));
   ret->Set(1, ToV8Value(pos.y()));
 
-  return ret;
+  args.GetReturnValue().Set(ret);
 }
 
 // static
-v8::Handle<v8::Value> Window::SetTitle(const v8::Arguments& args) {
+void Window::SetTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   std::string title;
@@ -395,27 +352,23 @@ v8::Handle<v8::Value> Window::SetTitle(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetTitle(title);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetTitle(const v8::Arguments& args) {
+void Window::GetTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-  return ToV8Value(self->window_->GetTitle());
+  args.GetReturnValue().Set(ToV8Value(self->window_->GetTitle()));
 }
 
 // static
-v8::Handle<v8::Value> Window::FlashFrame(const v8::Arguments& args) {
+void Window::FlashFrame(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->FlashFrame(
       args[0]->IsBoolean() ? args[0]->BooleanValue(): true);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::SetKiosk(const v8::Arguments& args) {
+void Window::SetKiosk(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   bool kiosk;
@@ -423,42 +376,34 @@ v8::Handle<v8::Value> Window::SetKiosk(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->SetKiosk(kiosk);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsKiosk(const v8::Arguments& args) {
+void Window::IsKiosk(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(self->window_->IsKiosk());
-  return ToV8Value(self->window_->IsKiosk());
 }
 
 // static
-v8::Handle<v8::Value> Window::OpenDevTools(const v8::Arguments& args) {
+void Window::OpenDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->OpenDevTools();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::CloseDevTools(const v8::Arguments& args) {
+void Window::CloseDevTools(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->CloseDevTools();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsDevToolsOpened(const v8::Arguments& args) {
+void Window::IsDevToolsOpened(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-  return ToV8Value(self->window_->IsDevToolsOpened());
+  args.GetReturnValue().Set(self->window_->IsDevToolsOpened());
 }
 
 // static
-v8::Handle<v8::Value> Window::InspectElement(const v8::Arguments& args) {
+void Window::InspectElement(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   int x, y;
@@ -466,39 +411,32 @@ v8::Handle<v8::Value> Window::InspectElement(const v8::Arguments& args) {
     return node::ThrowTypeError("Bad argument");
 
   self->window_->InspectElement(x, y);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::FocusOnWebView(const v8::Arguments& args) {
+void Window::FocusOnWebView(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->FocusOnWebView();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::BlurWebView(const v8::Arguments& args) {
+void Window::BlurWebView(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->BlurWebView();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::IsWebViewFocused(const v8::Arguments& args) {
+void Window::IsWebViewFocused(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-  return ToV8Value(self->window_->IsWebViewFocused());
+  args.GetReturnValue().Set(self->window_->IsWebViewFocused());
 }
 
 // static
-v8::Handle<v8::Value> Window::CapturePage(const v8::Arguments& args) {
+void Window::CapturePage(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   gfx::Rect rect;
-  v8::Persistent<v8::Function> callback;
+  RefCountedV8Function callback;
   if (!FromV8Arguments(args, &rect, &callback) &&
       !FromV8Arguments(args, &callback))
     return node::ThrowTypeError("Bad argument");
@@ -506,64 +444,56 @@ v8::Handle<v8::Value> Window::CapturePage(const v8::Arguments& args) {
   self->window_->CapturePage(rect, base::Bind(&Window::OnCapturePageDone,
                                               base::Unretained(self),
                                               callback));
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetPageTitle(const v8::Arguments& args) {
+void Window::GetPageTitle(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(ToV8Value(
-  return ToV8Value(self->window_->GetWebContents()->GetTitle());
+      self->window_->GetWebContents()->GetTitle()));
 }
 
 // static
-v8::Handle<v8::Value> Window::IsLoading(const v8::Arguments& args) {
+void Window::IsLoading(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(self->window_->GetWebContents()->IsLoading());
-  return ToV8Value(self->window_->GetWebContents()->IsLoading());
 }
 
 // static
-v8::Handle<v8::Value> Window::IsWaitingForResponse(const v8::Arguments& args) {
+void Window::IsWaitingForResponse(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(
-  return ToV8Value(self->window_->GetWebContents()->IsWaitingForResponse());
+      self->window_->GetWebContents()->IsWaitingForResponse());
 }
 
 // static
-v8::Handle<v8::Value> Window::Stop(const v8::Arguments& args) {
+void Window::Stop(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
   self->window_->GetWebContents()->Stop();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetRoutingID(const v8::Arguments& args) {
+void Window::GetRoutingID(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(self->window_->GetWebContents()->GetRoutingID());
-  return ToV8Value(self->window_->GetWebContents()->GetRoutingID());
 }
 
 // static
-v8::Handle<v8::Value> Window::GetProcessID(const v8::Arguments& args) {
+void Window::GetProcessID(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
-  return ToV8Value(
+  args.GetReturnValue().Set(
       self->window_->GetWebContents()->GetRenderProcessHost()->GetID());
 }
 
 // static
-v8::Handle<v8::Value> Window::IsCrashed(const v8::Arguments& args) {
+void Window::IsCrashed(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
-
+  args.GetReturnValue().Set(self->window_->GetWebContents()->IsCrashed());
-  return ToV8Value(self->window_->GetWebContents()->IsCrashed());
 }
 
 // static
-v8::Handle<v8::Value> Window::LoadURL(const v8::Arguments& args) {
+void Window::LoadURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   GURL url;
@@ -577,12 +507,10 @@ v8::Handle<v8::Value> Window::LoadURL(const v8::Arguments& args) {
   params.transition_type = content::PAGE_TRANSITION_TYPED;
   params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
   controller.LoadURLWithParams(params);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GetURL(const v8::Arguments& args) {
+void Window::GetURL(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
@@ -591,31 +519,31 @@ v8::Handle<v8::Value> Window::GetURL(const v8::Arguments& args) {
   if (controller.GetActiveEntry())
     url = controller.GetActiveEntry()->GetVirtualURL();
 
-  return ToV8Value(url);
+  args.GetReturnValue().Set(ToV8Value(url));
 }
 
 // static
-v8::Handle<v8::Value> Window::CanGoBack(const v8::Arguments& args) {
+void Window::CanGoBack(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
 
-  return ToV8Value(controller.CanGoBack());
+  args.GetReturnValue().Set(controller.CanGoBack());
 }
 
 // static
-v8::Handle<v8::Value> Window::CanGoForward(const v8::Arguments& args) {
+void Window::CanGoForward(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
 
-  return ToV8Value(controller.CanGoForward());
+  args.GetReturnValue().Set(controller.CanGoForward());
 }
 
 // static
-v8::Handle<v8::Value> Window::CanGoToOffset(const v8::Arguments& args) {
+void Window::CanGoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   int offset;
@@ -625,33 +553,29 @@ v8::Handle<v8::Value> Window::CanGoToOffset(const v8::Arguments& args) {
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
 
-  return ToV8Value(controller.CanGoToOffset(offset));
+  args.GetReturnValue().Set(controller.CanGoToOffset(offset));
 }
 
 // static
-v8::Handle<v8::Value> Window::GoBack(const v8::Arguments& args) {
+void Window::GoBack(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.GoBack();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GoForward(const v8::Arguments& args) {
+void Window::GoForward(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.GoForward();
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GoToIndex(const v8::Arguments& args) {
+void Window::GoToIndex(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   int index;
@@ -661,12 +585,10 @@ v8::Handle<v8::Value> Window::GoToIndex(const v8::Arguments& args) {
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.GoToIndex(index);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::GoToOffset(const v8::Arguments& args) {
+void Window::GoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   int offset;
@@ -676,36 +598,30 @@ v8::Handle<v8::Value> Window::GoToOffset(const v8::Arguments& args) {
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.GoToOffset(offset);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::Reload(const v8::Arguments& args) {
+void Window::Reload(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.Reload(args[0]->IsBoolean() ? args[0]->BooleanValue(): false);
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Window::ReloadIgnoringCache(const v8::Arguments& args) {
+void Window::ReloadIgnoringCache(const v8::FunctionCallbackInfo<v8::Value>& args) {
   UNWRAP_WINDOW_AND_CHECK;
 
   NavigationController& controller =
       self->window_->GetWebContents()->GetController();
   controller.ReloadIgnoringCache(
       args[0]->IsBoolean() ? args[0]->BooleanValue(): false);
-
-  return v8::Undefined();
 }
 
 // static
 void Window::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(Window::New);
   t->InstanceTemplate()->SetInternalFieldCount(1);

browser/api/atom_api_window.h

@@ -10,6 +10,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "browser/api/atom_api_event_emitter.h"
 #include "browser/native_window_observer.h"
+#include "common/v8/scoped_persistent.h"
 
 namespace base {
 class DictionaryValue;
@@ -47,73 +48,73 @@ class Window : public EventEmitter,
   virtual void OnRendererCrashed() OVERRIDE;
 
  private:
-  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Destroy(const v8::Arguments& args);
+  static void Destroy(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // APIs for NativeWindow.
-  static v8::Handle<v8::Value> Close(const v8::Arguments& args);
+  static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Focus(const v8::Arguments& args);
+  static void Focus(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsFocused(const v8::Arguments& args);
+  static void IsFocused(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Show(const v8::Arguments& args);
+  static void Show(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Hide(const v8::Arguments& args);
+  static void Hide(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsVisible(const v8::Arguments& args);
+  static void IsVisible(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Maximize(const v8::Arguments& args);
+  static void Maximize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Unmaximize(const v8::Arguments& args);
+  static void Unmaximize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Minimize(const v8::Arguments& args);
+  static void Minimize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Restore(const v8::Arguments& args);
+  static void Restore(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetFullscreen(const v8::Arguments& args);
+  static void SetFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsFullscreen(const v8::Arguments& args);
+  static void IsFullscreen(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetSize(const v8::Arguments& args);
+  static void SetSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetSize(const v8::Arguments& args);
+  static void GetSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetMinimumSize(const v8::Arguments& args);
+  static void SetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetMinimumSize(const v8::Arguments& args);
+  static void GetMinimumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetMaximumSize(const v8::Arguments& args);
+  static void SetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetMaximumSize(const v8::Arguments& args);
+  static void GetMaximumSize(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetResizable(const v8::Arguments& args);
+  static void SetResizable(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsResizable(const v8::Arguments& args);
+  static void IsResizable(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetAlwaysOnTop(const v8::Arguments& args);
+  static void SetAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsAlwaysOnTop(const v8::Arguments& args);
+  static void IsAlwaysOnTop(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Center(const v8::Arguments& args);
+  static void Center(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetPosition(const v8::Arguments& args);
+  static void SetPosition(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetPosition(const v8::Arguments& args);
+  static void GetPosition(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetTitle(const v8::Arguments& args);
+  static void SetTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetTitle(const v8::Arguments& args);
+  static void GetTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> FlashFrame(const v8::Arguments& args);
+  static void FlashFrame(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SetKiosk(const v8::Arguments& args);
+  static void SetKiosk(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsKiosk(const v8::Arguments& args);
+  static void IsKiosk(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> OpenDevTools(const v8::Arguments& args);
+  static void OpenDevTools(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> CloseDevTools(const v8::Arguments& args);
+  static void CloseDevTools(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsDevToolsOpened(const v8::Arguments& args);
+  static void IsDevToolsOpened(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> InspectElement(const v8::Arguments& args);
+  static void InspectElement(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> FocusOnWebView(const v8::Arguments& args);
+  static void FocusOnWebView(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> BlurWebView(const v8::Arguments& args);
+  static void BlurWebView(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsWebViewFocused(const v8::Arguments& args);
+  static void IsWebViewFocused(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> CapturePage(const v8::Arguments& args);
+  static void CapturePage(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // APIs for WebContents.
-  static v8::Handle<v8::Value> GetPageTitle(const v8::Arguments& args);
+  static void GetPageTitle(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsLoading(const v8::Arguments& args);
+  static void IsLoading(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsWaitingForResponse(const v8::Arguments& args);
+  static void IsWaitingForResponse(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Stop(const v8::Arguments& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetRoutingID(const v8::Arguments& args);
+  static void GetRoutingID(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetProcessID(const v8::Arguments& args);
+  static void GetProcessID(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> IsCrashed(const v8::Arguments& args);
+  static void IsCrashed(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // APIs for NavigationController.
-  static v8::Handle<v8::Value> LoadURL(const v8::Arguments& args);
+  static void LoadURL(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetURL(const v8::Arguments& args);
+  static void GetURL(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> CanGoBack(const v8::Arguments& args);
+  static void CanGoBack(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> CanGoForward(const v8::Arguments& args);
+  static void CanGoForward(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> CanGoToOffset(const v8::Arguments& args);
+  static void CanGoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GoBack(const v8::Arguments& args);
+  static void GoBack(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GoForward(const v8::Arguments& args);
+  static void GoForward(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GoToIndex(const v8::Arguments& args);
+  static void GoToIndex(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GoToOffset(const v8::Arguments& args);
+  static void GoToOffset(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Reload(const v8::Arguments& args);
+  static void Reload(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> ReloadIgnoringCache(const v8::Arguments& args);
+  static void ReloadIgnoringCache(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // Called when capturePage is done.
-  void OnCapturePageDone(v8::Persistent<v8::Function> callback,
+  void OnCapturePageDone(const RefCountedV8Function& callback,
                          const std::vector<unsigned char>& data);
 
   scoped_ptr<NativeWindow> window_;

browser/api/atom_browser_bindings.cc

@@ -8,13 +8,12 @@
 
 #include "base/logging.h"
 #include "browser/api/atom_api_event.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/browser_thread.h"
-#include "vendor/node/src/node.h"
+
-#include "vendor/node/src/node_internals.h"
+#include "common/v8/node_common.h"
 
 using content::V8ValueConverter;
-using node::node_isolate;
 
 namespace atom {
 
@@ -27,16 +26,14 @@ AtomBrowserBindings::~AtomBrowserBindings() {
 void AtomBrowserBindings::AfterLoad() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
-  v8::Handle<v8::Object> global = node::g_context->Global();
+  v8::Handle<v8::Object> global = global_env->context()->Global();
-  v8::Handle<v8::Object> atom =
+  v8::Handle<v8::Object> atom = global->Get(ToV8Value("__atom"))->ToObject();
-      global->Get(v8::String::New("__atom"))->ToObject();
   DCHECK(!atom.IsEmpty());
 
-  browser_main_parts_ = v8::Persistent<v8::Object>::New(
+  browser_main_parts_.reset(
-      node_isolate,
+      atom->Get(ToV8Value("browserMainParts"))->ToObject());
-      atom->Get(v8::String::New("browserMainParts"))->ToObject());
   DCHECK(!browser_main_parts_.IsEmpty());
 }
 
@@ -44,9 +41,7 @@ void AtomBrowserBindings::OnRendererMessage(int process_id,
                                             int routing_id,
                                             const string16& channel,
                                             const base::ListValue& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
-
-  v8::Handle<v8::Context> context = v8::Context::GetCurrent();
 
   scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
 
@@ -56,17 +51,20 @@ void AtomBrowserBindings::OnRendererMessage(int process_id,
   arguments.push_back(ToV8Value(channel));
   const base::Value* value;
   if (args.Get(0, &value))
-    arguments.push_back(converter->ToV8Value(value, context));
+    arguments.push_back(converter->ToV8Value(value, global_env->context()));
   arguments.push_back(v8::Integer::New(process_id));
   arguments.push_back(v8::Integer::New(routing_id));
 
   for (size_t i = 1; i < args.GetSize(); i++) {
     const base::Value* value;
     if (args.Get(i, &value))
-      arguments.push_back(converter->ToV8Value(value, context));
+      arguments.push_back(converter->ToV8Value(value, global_env->context()));
   }
 
-  node::MakeCallback(node::process, "emit", arguments.size(), &arguments[0]);
+  node::MakeCallback(global_env->process_object(),
+                     "emit",
+                     arguments.size(),
+                     &arguments[0]);
 }
 
 void AtomBrowserBindings::OnRendererMessageSync(
@@ -76,9 +74,7 @@ void AtomBrowserBindings::OnRendererMessageSync(
     const base::ListValue& args,
     NativeWindow* sender,
     IPC::Message* message) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
-
-  v8::Handle<v8::Context> context = v8::Context::GetCurrent();
 
   scoped_ptr<V8ValueConverter> converter(new V8ValueConverterImpl());
 
@@ -92,7 +88,7 @@ void AtomBrowserBindings::OnRendererMessageSync(
   arguments.push_back(ToV8Value(channel));
   const base::Value* value;
   if (args.Get(0, &value))
-    arguments.push_back(converter->ToV8Value(value, context));
+    arguments.push_back(converter->ToV8Value(value, global_env->context()));
   arguments.push_back(event);
   arguments.push_back(v8::Integer::New(process_id));
   arguments.push_back(v8::Integer::New(routing_id));
@@ -100,10 +96,13 @@ void AtomBrowserBindings::OnRendererMessageSync(
   for (size_t i = 1; i < args.GetSize(); i++) {
     const base::Value* value;
     if (args.Get(i, &value))
-      arguments.push_back(converter->ToV8Value(value, context));
+      arguments.push_back(converter->ToV8Value(value, global_env->context()));
   }
 
-  node::MakeCallback(node::process, "emit", arguments.size(), &arguments[0]);
+  node::MakeCallback(global_env->process_object(),
+                     "emit",
+                     arguments.size(),
+                     &arguments[0]);
 }
 
 }  // namespace atom

browser/api/atom_browser_bindings.h

@@ -7,6 +7,7 @@
 
 #include "base/strings/string16.h"
 #include "common/api/atom_bindings.h"
+#include "common/v8/scoped_persistent.h"
 
 namespace base {
 class ListValue;
@@ -44,11 +45,11 @@ class AtomBrowserBindings : public AtomBindings {
 
   // The require('atom').browserMainParts object.
   v8::Handle<v8::Object> browser_main_parts() {
-    return browser_main_parts_;
+    return browser_main_parts_.NewHandle();
   }
 
  private:
-  v8::Persistent<v8::Object> browser_main_parts_;
+  ScopedPersistent<v8::Object> browser_main_parts_;
 
   DISALLOW_COPY_AND_ASSIGN(AtomBrowserBindings);
 };

browser/atom_browser_client.cc

@@ -7,7 +7,7 @@
 #include "browser/atom_browser_context.h"
 #include "browser/atom_browser_main_parts.h"
 #include "browser/net/atom_url_request_context_getter.h"
-#include "webkit/glue/webpreferences.h"
+#include "webkit/common/webpreferences.h"
 
 namespace atom {
 

browser/atom_browser_context.cc

@@ -33,6 +33,14 @@ class AtomResourceContext : public content::ResourceContext {
     return getter_->GetURLRequestContext();
   }
 
+  virtual bool AllowMicAccess(const GURL& origin) OVERRIDE {
+    return true;
+  }
+
+  virtual bool AllowCameraAccess(const GURL& origin) OVERRIDE {
+    return true;
+  }
+
  private:
   AtomURLRequestContextGetter* getter_;
 

browser/atom_browser_main_parts.cc

@@ -4,15 +4,13 @@
 
 #include "browser/atom_browser_main_parts.h"
 
-#include "base/power_monitor/power_monitor.h"
 #include "browser/api/atom_browser_bindings.h"
 #include "browser/atom_browser_client.h"
 #include "browser/atom_browser_context.h"
 #include "browser/browser.h"
 #include "common/node_bindings.h"
-#include "net/proxy/proxy_resolver_v8.h"
+
-#include "vendor/node/src/node.h"
+#include "common/v8/node_common.h"
-#include "vendor/node/src/node_internals.h"
 
 namespace atom {
 
@@ -43,19 +41,14 @@ brightray::BrowserContext* AtomBrowserMainParts::CreateBrowserContext() {
 void AtomBrowserMainParts::PostEarlyInitialization() {
   brightray::BrowserMainParts::PostEarlyInitialization();
 
-#if defined(OS_MACOSX)
+  v8::HandleScope handle_scope(node_isolate);
-  base::PowerMonitor::AllocateSystemIOPorts();
-#endif
 
   node_bindings_->Initialize();
 
   // Wrap whole process in one global context.
-  node::g_context->Enter();
+  global_env->context()->Enter();
-
-  atom_bindings_->BindTo(node::process);
-
-  node_bindings_->Load();
 
+  atom_bindings_->BindTo(global_env->process_object());
   atom_bindings_->AfterLoad();
 }
 
@@ -65,8 +58,8 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
   brightray::BrowserMainParts::PreMainMessageLoopRun();
 
   {
-    v8::HandleScope scope;
+    v8::HandleScope handle_scope(node_isolate);
-    v8::Context::Scope context_scope(node::g_context);
+    v8::Context::Scope context_scope(global_env->context());
 
     v8::Handle<v8::Value> args;
     node::MakeCallback(atom_bindings_->browser_main_parts(),
@@ -88,10 +81,4 @@ void AtomBrowserMainParts::PreMainMessageLoopRun() {
 #endif
 }
 
-int AtomBrowserMainParts::PreCreateThreads() {
-  // TODO(zcbenz): Calling CreateIsolate() on Windows when updated to Chrome30.
-  net::ProxyResolverV8::RememberDefaultIsolate();
-  return 0;
-}
-
 }  // namespace atom

browser/atom_browser_main_parts.h

@@ -30,7 +30,6 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   // Implementations of content::BrowserMainParts.
   virtual void PostEarlyInitialization() OVERRIDE;
   virtual void PreMainMessageLoopRun() OVERRIDE;
-  virtual int PreCreateThreads() OVERRIDE;
 #if defined(OS_MACOSX)
   virtual void PreMainMessageLoopStart() OVERRIDE;
   virtual void PostDestroyThreads() OVERRIDE;

browser/atom_javascript_dialog_manager.cc

@@ -4,7 +4,7 @@
 
 #include "browser/atom_javascript_dialog_manager.h"
 
-#include "base/utf_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
 
 namespace atom {
 

browser/atom_javascript_dialog_manager.h

@@ -26,7 +26,9 @@ class AtomJavaScriptDialogManager : public content::JavaScriptDialogManager {
       const string16& message_text,
       bool is_reload,
       const DialogClosedCallback& callback) OVERRIDE;
-  virtual void ResetJavaScriptState(
+  virtual void CancelActiveAndPendingDialogs(
+      content::WebContents* web_contents) OVERRIDE {}
+  virtual void WebContentsDestroyed(
       content::WebContents* web_contents) OVERRIDE {}
 };
 

browser/native_window.cc

@@ -7,9 +7,9 @@
 #include <string>
 
 #include "base/file_util.h"
-#include "base/message_loop.h"
+#include "base/message_loop/message_loop.h"
-#include "base/stringprintf.h"
+#include "base/strings/stringprintf.h"
-#include "base/utf_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "brightray/browser/inspectable_web_contents.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
@@ -37,8 +37,7 @@
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
-#include "webkit/glue/image_decoder.h"
+#include "webkit/common/user_agent/user_agent_util.h"
-#include "webkit/user_agent/user_agent_util.h"
 
 using content::NavigationEntry;
 
@@ -165,7 +164,7 @@ void NativeWindow::CloseDevTools() {
 }
 
 bool NativeWindow::IsDevToolsOpened() {
-  return inspectable_web_contents()->IsDevToolsOpened();
+  return inspectable_web_contents()->IsDevToolsViewShowing();
 }
 
 void NativeWindow::InspectElement(int x, int y) {
@@ -193,15 +192,14 @@ bool NativeWindow::SetIcon(const std::string& str_path) {
 
   // Read the file from disk.
   std::string file_contents;
-  if (path.empty() || !file_util::ReadFileToString(path, &file_contents))
+  if (path.empty() || !base::ReadFileToString(path, &file_contents))
     return false;
 
   // Decode the bitmap using WebKit's image decoder.
   const unsigned char* data =
       reinterpret_cast<const unsigned char*>(file_contents.data());
-  webkit_glue::ImageDecoder decoder;
   scoped_ptr<SkBitmap> decoded(new SkBitmap());
-  *decoded = decoder.Decode(data, file_contents.length());
+  gfx::PNGCodec::Decode(data, file_contents.length(), decoded.get());
   if (decoded->empty())
     return false;  // Unable to decode.
 
@@ -383,6 +381,21 @@ void NativeWindow::RendererResponsive(content::WebContents* source) {
   FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererResponsive());
 }
 
+void NativeWindow::RenderViewDeleted(content::RenderViewHost* rvh) {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
+                    OnRenderViewDeleted(rvh->GetProcess()->GetID(),
+                                        rvh->GetRoutingID()));
+}
+
+void NativeWindow::RenderProcessGone(base::TerminationStatus status) {
+  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererCrashed());
+}
+
+void NativeWindow::BeforeUnloadFired(const base::TimeTicks& proceed_time) {
+  // Do nothing, we override this method just to avoid compilation error since
+  // there are two virtual functions named BeforeUnloadFired.
+}
+
 bool NativeWindow::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NativeWindow, message)
@@ -397,16 +410,6 @@ bool NativeWindow::OnMessageReceived(const IPC::Message& message) {
   return handled;
 }
 
-void NativeWindow::RenderViewDeleted(content::RenderViewHost* rvh) {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_,
-                    OnRenderViewDeleted(rvh->GetProcess()->GetID(),
-                                        rvh->GetRoutingID()));
-}
-
-void NativeWindow::RenderViewGone(base::TerminationStatus status) {
-  FOR_EACH_OBSERVER(NativeWindowObserver, observers_, OnRendererCrashed());
-}
-
 void NativeWindow::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {

browser/native_window.h

@@ -184,7 +184,8 @@ class NativeWindow : public brightray::DefaultWebContentsDelegate,
 
   // Implementations of content::WebContentsObserver.
   virtual void RenderViewDeleted(content::RenderViewHost*) OVERRIDE;
-  virtual void RenderViewGone(base::TerminationStatus status) OVERRIDE;
+  virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE;
+  virtual void BeforeUnloadFired(const base::TimeTicks& proceed_time) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
   // Implementations of content::NotificationObserver

browser/native_window_mac.mm

@@ -11,6 +11,7 @@
 #define BASE_MAC_FOUNDATION_UTIL_H_
 
 #include "base/mac/mac_util.h"
+#include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/values.h"
 #import "browser/ui/atom_event_processing_window.h"
@@ -490,7 +491,7 @@ void NativeWindowMac::InstallDraggableRegionViews() {
   // Note that [webView subviews] returns the view's mutable internal array and
   // it should be copied to avoid mutating the original array while enumerating
   // it.
-  scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
+  base::scoped_nsobject<NSArray> subviews([[webView subviews] copy]);
   for (NSView* subview in subviews.get())
     if ([subview isKindOfClass:[ControlRegionView class]])
       [subview removeFromSuperview];
@@ -501,7 +502,7 @@ void NativeWindowMac::InstallDraggableRegionViews() {
            system_drag_exclude_areas_.begin();
        iter != system_drag_exclude_areas_.end();
        ++iter) {
-    scoped_nsobject<NSView> controlRegion(
+    base::scoped_nsobject<NSView> controlRegion(
         [[ControlRegionView alloc] initWithShellWindow:this]);
     [controlRegion setFrame:NSMakeRect(iter->x(),
                                        webViewHeight - iter->bottom(),

browser/net/adapter_request_job.cc

@@ -4,6 +4,7 @@
 
 #include "browser/net/adapter_request_job.h"
 
+#include "base/threading/sequenced_worker_pool.h"
 #include "browser/net/url_request_string_job.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
@@ -87,7 +88,13 @@ void AdapterRequestJob::CreateStringJobAndStart(const std::string& mime_type,
 void AdapterRequestJob::CreateFileJobAndStart(const base::FilePath& path) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 
-  real_job_ = new net::URLRequestFileJob(request(), network_delegate(), path);
+  real_job_ = new net::URLRequestFileJob(
+      request(),
+      network_delegate(),
+      path,
+      content::BrowserThread::GetBlockingPool()->
+          GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
   real_job_->Start();
 }
 

browser/net/atom_url_request_context_getter.cc

@@ -4,7 +4,8 @@
 
 #include "browser/net/atom_url_request_context_getter.h"
 
-#include "base/string_util.h"
+#include "base/strings/string_util.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
 #include "browser/net/atom_url_request_job_factory.h"
 #include "content/public/browser/browser_thread.h"
@@ -36,8 +37,8 @@ using content::BrowserThread;
 
 AtomURLRequestContextGetter::AtomURLRequestContextGetter(
     const base::FilePath& base_path,
-    MessageLoop* io_loop,
+    base::MessageLoop* io_loop,
-    MessageLoop* file_loop,
+    base::MessageLoop* file_loop,
     scoped_ptr<brightray::NetworkDelegate> network_delegate,
     content::ProtocolHandlerMap* protocol_handlers)
     : base_path_(base_path),
@@ -74,6 +75,7 @@ net::URLRequestContext* AtomURLRequestContextGetter::GetURLRequestContext() {
         base_path_.Append(FILE_PATH_LITERAL("Cookies")),
         false,
         nullptr,
+        nullptr,
         nullptr));
     storage_->set_server_bound_cert_service(new net::ServerBoundCertService(
         new net::DefaultServerBoundCertStore(NULL),
@@ -98,7 +100,9 @@ net::URLRequestContext* AtomURLRequestContextGetter::GetURLRequestContext() {
     storage_->set_ssl_config_service(new net::SSLConfigServiceDefaults);
     storage_->set_http_auth_handler_factory(
         net::HttpAuthHandlerFactory::CreateDefault(host_resolver.get()));
-    storage_->set_http_server_properties(new net::HttpServerPropertiesImpl);
+    scoped_ptr<net::HttpServerProperties> server_properties(
+        new net::HttpServerPropertiesImpl);
+    storage_->set_http_server_properties(server_properties.Pass());
 
     base::FilePath cache_path = base_path_.Append(FILE_PATH_LITERAL("Cache"));
     net::HttpCache::DefaultBackend* main_backend =
@@ -147,10 +151,15 @@ net::URLRequestContext* AtomURLRequestContextGetter::GetURLRequestContext() {
     }
     protocol_handlers_.clear();
 
+    scoped_ptr<net::FileProtocolHandler> file_protocol_handler(
+        new net::FileProtocolHandler(
+            content::BrowserThread::GetBlockingPool()->
+                GetTaskRunnerWithShutdownBehavior(
+                    base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
     job_factory_->SetProtocolHandler(chrome::kDataScheme,
                                      new net::DataProtocolHandler);
     job_factory_->SetProtocolHandler(chrome::kFileScheme,
-                                     new net::FileProtocolHandler);
+                                     file_protocol_handler.release());
     storage_->set_job_factory(job_factory_);
   }
 

browser/net/atom_url_request_job_factory.cc

@@ -6,7 +6,6 @@
 #include "browser/net/atom_url_request_job_factory.h"
 
 #include "base/stl_util.h"
-#include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request.h"
 
@@ -102,4 +101,9 @@ bool AtomURLRequestJobFactory::IsHandledURL(const GURL& url) const {
   return IsHandledProtocol(url.scheme());
 }
 
+bool AtomURLRequestJobFactory::IsSafeRedirectTarget(
+    const GURL& location) const {
+  return IsHandledURL(location);
+}
+
 }  // namespace atom

browser/net/atom_url_request_job_factory.h

@@ -45,6 +45,7 @@ class AtomURLRequestJobFactory : public net::URLRequestJobFactory {
       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;
 
  private:
   typedef std::map<std::string, ProtocolHandler*> ProtocolHandlerMap;

browser/ui/accelerator_util.cc

@@ -8,7 +8,7 @@
 
 #include <string>
 
-#include "base/string_util.h"
+#include "base/strings/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "ui/base/accelerators/accelerator.h"

browser/ui/accelerator_util_mac.mm

@@ -6,7 +6,7 @@
 
 #include "ui/base/accelerators/accelerator.h"
 #import "ui/base/accelerators/platform_accelerator_cocoa.h"
-#import "ui/base/keycodes/keyboard_code_conversion_mac.h"
+#import "ui/events/keycodes/keyboard_code_conversion_mac.h"
 
 namespace accelerator_util {
 

browser/ui/atom_event_processing_window.h

@@ -7,8 +7,6 @@
 
 #import <Cocoa/Cocoa.h>
 
-#include "base/memory/scoped_nsobject.h"
-
 // Override NSWindow to access unhandled keyboard events (for command
 // processing); subclassing NSWindow is the only method to do
 // this.

browser/ui/atom_menu_controller_mac.h

@@ -8,7 +8,7 @@
 
 #import <Cocoa/Cocoa.h>
 
-#include "base/memory/scoped_nsobject.h"
+#include "base/mac/scoped_nsobject.h"
 #include "base/strings/string16.h"
 
 namespace ui {
@@ -24,7 +24,7 @@ class MenuModel;
 @interface AtomMenuController : NSObject<NSMenuDelegate> {
  @protected
   ui::MenuModel* model_;  // weak
-  scoped_nsobject<NSMenu> menu_;
+  base::scoped_nsobject<NSMenu> menu_;
   BOOL isMenuOpen_;
 }
 

browser/ui/atom_menu_controller_mac.mm

@@ -133,7 +133,7 @@ int EventFlagsFromNSEvent(NSEvent* event) {
             fromModel:(ui::MenuModel*)model {
   string16 label16 = model->GetLabelAt(index);
   NSString* label = l10n_util::FixUpWindowsStyleLabel(label16);
-  scoped_nsobject<NSMenuItem> item(
+  base::scoped_nsobject<NSMenuItem> item(
       [[NSMenuItem alloc] initWithTitle:label
                                  action:@selector(itemSelected:)
                           keyEquivalent:@""]);

browser/ui/file_dialog_mac.mm

@@ -24,7 +24,7 @@ void SetupDialog(NSSavePanel* dialog,
   NSString* default_dir = nil;
   NSString* default_filename = nil;
   if (!default_path.empty()) {
-    if (file_util::DirectoryExists(default_path)) {
+    if (base::DirectoryExists(default_path)) {
       default_dir = base::SysUTF8ToNSString(default_path.value());
     } else {
       default_dir = base::SysUTF8ToNSString(default_path.DirName().value());

common/api/atom_api_clipboard.cc

@@ -6,92 +6,81 @@
 
 #include <string>
 
+#include "common/v8/native_type_conversions.h"
 #include "ui/base/clipboard/clipboard.h"
-#include "vendor/node/src/node.h"
+
+#include "common/v8/node_common.h"
 
 namespace atom {
 
 namespace api {
 
 // static
-v8::Handle<v8::Value> Clipboard::Has(const v8::Arguments& args) {
+void Clipboard::Has(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  std::string format_string;
-
+  if (!FromV8Arguments(args, &format_string))
-  if (!args[0]->IsString())
     return node::ThrowTypeError("Bad argument");
 
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
-
-  std::string format_string(*v8::String::Utf8Value(args[0]));
   ui::Clipboard::FormatType format(ui::Clipboard::GetFormatType(format_string));
 
-  return scope.Close(v8::Boolean::New(
+  args.GetReturnValue().Set(
-      clipboard->IsFormatAvailable(format, ui::Clipboard::BUFFER_STANDARD)));
+      clipboard->IsFormatAvailable(format, ui::Clipboard::BUFFER_STANDARD));
 }
 
 // static
-v8::Handle<v8::Value> Clipboard::Read(const v8::Arguments& args) {
+void Clipboard::Read(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  std::string format_string;
-
+  if (!FromV8Arguments(args, &format_string))
-  if (!args[0]->IsString())
     return node::ThrowTypeError("Bad argument");
 
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
-
-  std::string format_string(*v8::String::Utf8Value(args[0]));
   ui::Clipboard::FormatType format(ui::Clipboard::GetFormatType(format_string));
 
   std::string data;
   clipboard->ReadData(format, &data);
 
-  return scope.Close(v8::String::New(data.c_str(), data.size()));
+  args.GetReturnValue().Set(ToV8Value(data));
 }
 
 // static
-v8::Handle<v8::Value> Clipboard::ReadText(const v8::Arguments& args) {
+void Clipboard::ReadText(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
 
   std::string data;
   clipboard->ReadAsciiText(ui::Clipboard::BUFFER_STANDARD, &data);
 
-  return scope.Close(v8::String::New(data.c_str(), data.size()));
+  args.GetReturnValue().Set(ToV8Value(data));
 }
 
 // static
-v8::Handle<v8::Value> Clipboard::WriteText(const v8::Arguments& args) {
+void Clipboard::WriteText(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  std::string text;
-
+  if (!FromV8Arguments(args, &text))
-  if (!args[0]->IsString())
     return node::ThrowTypeError("Bad argument");
 
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
-  std::string text(*v8::String::Utf8Value(args[0]));
-
   ui::Clipboard::ObjectMap object_map;
   object_map[ui::Clipboard::CBF_TEXT].push_back(
       std::vector<char>(text.begin(), text.end()));
-  clipboard->WriteObjects(ui::Clipboard::BUFFER_STANDARD, object_map, NULL);
 
-  return v8::Undefined();
+  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  clipboard->WriteObjects(ui::Clipboard::BUFFER_STANDARD, object_map);
 }
 
 // static
-v8::Handle<v8::Value> Clipboard::Clear(const v8::Arguments& args) {
+void Clipboard::Clear(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+  ui::Clipboard::GetForCurrentThread()->Clear(ui::Clipboard::BUFFER_STANDARD);
-  clipboard->Clear(ui::Clipboard::BUFFER_STANDARD);
-
-  return v8::Undefined();
 }
 
 // static
 void Clipboard::Initialize(v8::Handle<v8::Object> target) {
-  node::SetMethod(target, "has", Has);
+  v8::HandleScope handle_scope(node_isolate);
-  node::SetMethod(target, "read", Read);
+
-  node::SetMethod(target, "readText", ReadText);
+  NODE_SET_METHOD(target, "has", Has);
-  node::SetMethod(target, "writeText", WriteText);
+  NODE_SET_METHOD(target, "read", Read);
-  node::SetMethod(target, "clear", Clear);
+  NODE_SET_METHOD(target, "readText", ReadText);
+  NODE_SET_METHOD(target, "writeText", WriteText);
+  NODE_SET_METHOD(target, "clear", Clear);
 }
 
 }  // namespace api

common/api/atom_api_clipboard.h

@@ -17,11 +17,11 @@ class Clipboard {
   static void Initialize(v8::Handle<v8::Object> target);
 
  private:
-  static v8::Handle<v8::Value> Has(const v8::Arguments& args);
+  static void Has(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Read(const v8::Arguments& args);
+  static void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> ReadText(const v8::Arguments& args);
+  static void ReadText(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> WriteText(const v8::Arguments& args);
+  static void WriteText(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Clear(const v8::Arguments& args);
+  static void Clear(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Clipboard);
 };

common/api/atom_api_crash_reporter.cc

@@ -5,16 +5,16 @@
 #include "common/api/atom_api_crash_reporter.h"
 
 #include "common/crash_reporter/crash_reporter.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
-#include "vendor/node/src/node.h"
+
-#include "vendor/node/src/node_internals.h"
+#include "common/v8/node_common.h"
 
 namespace atom {
 
 namespace api {
 
 // static
-v8::Handle<v8::Value> CrashReporter::Start(const v8::Arguments& args) {
+void CrashReporter::Start(const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string product_name, company_name, submit_url;
   bool auto_submit, skip_system;
   std::map<std::string, std::string> dict;
@@ -24,13 +24,11 @@ v8::Handle<v8::Value> CrashReporter::Start(const v8::Arguments& args) {
 
   crash_reporter::CrashReporter::GetInstance()->Start(
       product_name, company_name, submit_url, auto_submit, skip_system, dict);
-
-  return v8::Undefined();
 }
 
 // static
 void CrashReporter::Initialize(v8::Handle<v8::Object> target) {
-  node::SetMethod(target, "start", Start);
+  NODE_SET_METHOD(target, "start", Start);
 }
 
 }  // namespace api

common/api/atom_api_crash_reporter.h

@@ -17,7 +17,7 @@ class CrashReporter {
   static void Initialize(v8::Handle<v8::Object> target);
 
  private:
-  static v8::Handle<v8::Value> Start(const v8::Arguments& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CrashReporter);
 };

common/api/atom_api_id_weak_map.cc

@@ -5,7 +5,11 @@
 
 #include "common/api/atom_api_id_weak_map.h"
 
+#include <algorithm>
+
 #include "base/logging.h"
+#include "common/v8/native_type_conversions.h"
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -16,29 +20,17 @@ IDWeakMap::IDWeakMap()
 }
 
 IDWeakMap::~IDWeakMap() {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-
-  auto copied_map = map_;
-  for (auto el = copied_map.begin(); el != copied_map.end(); ++el)
-    Erase(isolate, el->first);
 }
 
 bool IDWeakMap::Has(int key) const {
   return map_.find(key) != map_.end();
 }
 
-void IDWeakMap::Erase(v8::Isolate* isolate, int key) {
+void IDWeakMap::Erase(int key) {
-  if (!Has(key)) {
+  if (Has(key))
+    map_.erase(key);
+  else
     LOG(WARNING) << "Object with key " << key << " is being GCed for twice.";
-    return;
-  }
-
-  v8::Persistent<v8::Value> value = map_[key];
-  value.ClearWeak(isolate);
-  value.Dispose(isolate);
-  value.Clear();
-
-  map_.erase(key);
 }
 
 int IDWeakMap::GetNextID() {
@@ -47,104 +39,93 @@ int IDWeakMap::GetNextID() {
 
 // static
 void IDWeakMap::WeakCallback(v8::Isolate* isolate,
-                             v8::Persistent<v8::Value> value,
+                             v8::Persistent<v8::Object>* value,
-                             void *data) {
+                             IDWeakMap* self) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(isolate);
-
+  v8::Local<v8::Object> local = v8::Local<v8::Object>::New(isolate, *value);
-  IDWeakMap* obj = static_cast<IDWeakMap*>(data);
+  self->Erase(
-  int key = value->ToObject()->GetHiddenValue(
+      FromV8Value(local->GetHiddenValue(v8::String::New("IDWeakMapKey"))));
-      v8::String::New("IDWeakMapKey"))->IntegerValue();
-
-  obj->Erase(isolate, key);
 }
 
 // static
-v8::Handle<v8::Value> IDWeakMap::New(const v8::Arguments& args) {
+void IDWeakMap::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  IDWeakMap* obj = new IDWeakMap();
+  (new IDWeakMap)->Wrap(args.This());
-  obj->Wrap(args.This());
-  return args.This();
 }
 
 // static
-v8::Handle<v8::Value> IDWeakMap::Add(const v8::Arguments& args) {
+void IDWeakMap::Add(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (!args[0]->IsObject())
     return node::ThrowTypeError("Bad argument");
 
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
-  IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
-  int key = obj->GetNextID();
 
-  v8::Handle<v8::Value> v8_key = v8::Integer::New(key);
+  int key = self->GetNextID();
-  v8::Persistent<v8::Value> value =
+  v8::Local<v8::Object> v8_value = args[0]->ToObject();
-      v8::Persistent<v8::Value>::New(isolate, args[0]);
+  v8_value->SetHiddenValue(v8::String::New("IDWeakMapKey"), ToV8Value(key));
 
-  value->ToObject()->SetHiddenValue(v8::String::New("IDWeakMapKey"), v8_key);
+  RefCountedV8Object& value = self->map_[key];
-  value.MakeWeak(isolate, obj, WeakCallback);
+  value->reset(v8_value);
-  obj->map_[key] = value;
+  value->MakeWeak(self, WeakCallback);
 
-  return v8_key;
+  args.GetReturnValue().Set(key);
 }
 
 // static
-v8::Handle<v8::Value> IDWeakMap::Get(const v8::Arguments& args) {
+void IDWeakMap::Get(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  if (!args[0]->IsNumber())
+  int key;
+  if (!FromV8Arguments(args, &key))
     return node::ThrowTypeError("Bad argument");
 
-  IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
+  IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
-
+  if (!self->Has(key))
-  int key = args[0]->IntegerValue();
-  if (!obj->Has(key))
     return node::ThrowError("Invalid key");
 
-  return obj->map_[key];
+  args.GetReturnValue().Set(self->map_[key]->NewHandle());
 }
 
 // static
-v8::Handle<v8::Value> IDWeakMap::Has(const v8::Arguments& args) {
+void IDWeakMap::Has(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  if (!args[0]->IsNumber())
+  int key;
+  if (!FromV8Arguments(args, &key))
     return node::ThrowTypeError("Bad argument");
 
-  IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
+  IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
-
+  args.GetReturnValue().Set(self->Has(key));
-  int key = args[0]->IntegerValue();
-  return v8::Boolean::New(obj->Has(key));
 }
 
 // static
-v8::Handle<v8::Value> IDWeakMap::Keys(const v8::Arguments& args) {
+void IDWeakMap::Keys(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
+  IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
 
-  v8::Handle<v8::Array> keys = v8::Array::New(obj->map_.size());
+  v8::Local<v8::Array> keys = v8::Array::New(self->map_.size());
 
   int i = 0;
-  for (auto el = obj->map_.begin(); el != obj->map_.end(); ++el) {
+  for (auto el = self->map_.begin(); el != self->map_.end(); ++el) {
-    keys->Set(i, v8::Integer::New(el->first));
+    keys->Set(i, ToV8Value(el->first));
     ++i;
   }
 
-  return keys;
+  args.GetReturnValue().Set(keys);
 }
 
 // static
-v8::Handle<v8::Value> IDWeakMap::Remove(const v8::Arguments& args) {
+void IDWeakMap::Remove(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  if (!args[0]->IsNumber())
+  int key;
+  if (!FromV8Arguments(args, &key))
     return node::ThrowTypeError("Bad argument");
 
-  IDWeakMap* obj = ObjectWrap::Unwrap<IDWeakMap>(args.This());
+  IDWeakMap* self = Unwrap<IDWeakMap>(args.This());
-
+  if (!self->Has(key))
-  int key = args[0]->IntegerValue();
-  if (!obj->Has(key))
     return node::ThrowError("Invalid key");
 
-  obj->Erase(v8::Isolate::GetCurrent(), key);
+  self->Erase(key);
-  return v8::Undefined();
 }
 
 // static
 void IDWeakMap::Initialize(v8::Handle<v8::Object> target) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
-  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(IDWeakMap::New);
+  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(v8::String::NewSymbol("IDWeakMap"));
 

common/api/atom_api_id_weak_map.h

@@ -9,6 +9,7 @@
 #include <map>
 
 #include "base/basictypes.h"
+#include "common/v8/scoped_persistent.h"
 #include "vendor/node/src/node_object_wrap.h"
 
 namespace atom {
@@ -24,23 +25,22 @@ class IDWeakMap : public node::ObjectWrap {
   virtual ~IDWeakMap();
 
   bool Has(int key) const;
-  void Erase(v8::Isolate* isolate, int key);
+  void Erase(int key);
   int GetNextID();
 
   static void WeakCallback(v8::Isolate* isolate,
-                           v8::Persistent<v8::Value> value,
+                           v8::Persistent<v8::Object>* value,
-                           void *data);
+                           IDWeakMap* self);
 
-  static v8::Handle<v8::Value> New(const v8::Arguments& args);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Add(const v8::Arguments& args);
+  static void Add(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Get(const v8::Arguments& args);
+  static void Get(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Has(const v8::Arguments& args);
+  static void Has(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Keys(const v8::Arguments& args);
+  static void Keys(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Remove(const v8::Arguments& args);
+  static void Remove(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   int next_id_;
-
+  std::map<int, RefCountedV8Object> map_;
-  std::map<int, v8::Persistent<v8::Value>> map_;
 
   DISALLOW_COPY_AND_ASSIGN(IDWeakMap);
 };

common/api/atom_api_shell.cc

@@ -8,91 +8,65 @@
 
 #include "base/files/file_path.h"
 #include "common/platform_util.h"
-#include "googleurl/src/gurl.h"
+#include "common/v8/native_type_conversions.h"
-#include "vendor/node/src/node.h"
+#include "url/gurl.h"
+
+#include "common/v8/node_common.h"
 
 namespace atom {
 
 namespace api {
 
-namespace {
-
-bool V8ValueToFilePath(v8::Handle<v8::Value> value, base::FilePath* path) {
-  if (!value->IsString())
-    return false;
-
-  std::string file_path_string(*v8::String::Utf8Value(value));
-  base::FilePath file_path = base::FilePath::FromUTF8Unsafe(file_path_string);
-
-  if (file_path.empty())
-    return false;
-
-  *path = file_path;
-  return true;
-}
-
-}  // namespace
-
 // static
-v8::Handle<v8::Value> Shell::ShowItemInFolder(const v8::Arguments& args) {
+void Shell::ShowItemInFolder(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   base::FilePath file_path;
-  if (!V8ValueToFilePath(args[0], &file_path))
+  if (!FromV8Arguments(args, &file_path))
     return node::ThrowTypeError("Bad argument");
 
   platform_util::ShowItemInFolder(file_path);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Shell::OpenItem(const v8::Arguments& args) {
+void Shell::OpenItem(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   base::FilePath file_path;
-  if (!V8ValueToFilePath(args[0], &file_path))
+  if (!FromV8Arguments(args, &file_path))
     return node::ThrowTypeError("Bad argument");
 
   platform_util::OpenItem(file_path);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Shell::OpenExternal(const v8::Arguments& args) {
+void Shell::OpenExternal(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  GURL url;
-
+  if (!FromV8Arguments(args, &url))
-  if (!args[0]->IsString())
     return node::ThrowTypeError("Bad argument");
 
-  platform_util::OpenExternal(GURL(*v8::String::Utf8Value(args[0])));
+  platform_util::OpenExternal(url);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Shell::MoveItemToTrash(const v8::Arguments& args) {
+void Shell::MoveItemToTrash(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   base::FilePath file_path;
-  if (!V8ValueToFilePath(args[0], &file_path))
+  if (!FromV8Arguments(args, &file_path))
     return node::ThrowTypeError("Bad argument");
 
   platform_util::MoveItemToTrash(file_path);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> Shell::Beep(const v8::Arguments& args) {
+void Shell::Beep(const v8::FunctionCallbackInfo<v8::Value>& args) {
   platform_util::Beep();
-  return v8::Undefined();
 }
 
 // static
 void Shell::Initialize(v8::Handle<v8::Object> target) {
-  node::SetMethod(target, "showItemInFolder", ShowItemInFolder);
+  v8::HandleScope handle_scope(node_isolate);
-  node::SetMethod(target, "openItem", OpenItem);
+
-  node::SetMethod(target, "openExternal", OpenExternal);
+  NODE_SET_METHOD(target, "showItemInFolder", ShowItemInFolder);
-  node::SetMethod(target, "moveItemToTrash", MoveItemToTrash);
+  NODE_SET_METHOD(target, "openItem", OpenItem);
-  node::SetMethod(target, "beep", Beep);
+  NODE_SET_METHOD(target, "openExternal", OpenExternal);
+  NODE_SET_METHOD(target, "moveItemToTrash", MoveItemToTrash);
+  NODE_SET_METHOD(target, "beep", Beep);
 }
 
 }  // namespace api

common/api/atom_api_shell.h

@@ -17,11 +17,11 @@ class Shell {
   static void Initialize(v8::Handle<v8::Object> target);
 
  private:
-  static v8::Handle<v8::Value> ShowItemInFolder(const v8::Arguments& args);
+  static void ShowItemInFolder(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> OpenItem(const v8::Arguments& args);
+  static void OpenItem(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> OpenExternal(const v8::Arguments& args);
+  static void OpenExternal(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> MoveItemToTrash(const v8::Arguments& args);
+  static void MoveItemToTrash(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Beep(const v8::Arguments& args);
+  static void Beep(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Shell);
 };

common/api/atom_api_v8_util.cc

@@ -3,9 +3,11 @@
 // found in the LICENSE file.
 
 #include "common/api/object_life_monitor.h"
+
+#include "common/v8/native_type_conversions.h"
 #include "v8/include/v8-profiler.h"
-#include "vendor/node/src/node.h"
+
-#include "vendor/node/src/node_internals.h"
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -13,48 +15,39 @@ namespace api {
 
 namespace {
 
-v8::Handle<v8::Value> DummyNew(const v8::Arguments& args) {
+void CreateObjectWithName(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  return args.This();
+  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New();
-}
-
-v8::Handle<v8::Value> CreateObjectWithName(const v8::Arguments& args) {
-  v8::HandleScope scope;
-
-  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(DummyNew);
   t->SetClassName(args[0]->ToString());
-
+  args.GetReturnValue().Set(t->GetFunction()->NewInstance());
-  return scope.Close(t->GetFunction()->NewInstance());
 }
 
-v8::Handle<v8::Value> GetHiddenValue(const v8::Arguments& args) {
+void GetHiddenValue(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  return args[0]->ToObject()->GetHiddenValue(args[1]->ToString());
+  args.GetReturnValue().Set(
+      args[0]->ToObject()->GetHiddenValue(args[1]->ToString()));
 }
 
-v8::Handle<v8::Value> SetHiddenValue(const v8::Arguments& args) {
+void SetHiddenValue(const v8::FunctionCallbackInfo<v8::Value>& args) {
   args[0]->ToObject()->SetHiddenValue(args[1]->ToString(), args[2]);
-  return v8::Undefined();
 }
 
-v8::Handle<v8::Value> GetObjectHash(const v8::Arguments& args) {
+void GetObjectHash(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope handle_scope;
+  args.GetReturnValue().Set(args[0]->ToObject()->GetIdentityHash());
-  return handle_scope.Close(v8::Integer::New(
-      args[0]->ToObject()->GetIdentityHash()));
 }
 
-v8::Handle<v8::Value> SetDestructor(const v8::Arguments& args) {
+void SetDestructor(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ObjectLifeMonitor::BindTo(args[0]->ToObject(), args[1]);
-  return v8::Undefined();
 }
 
-v8::Handle<v8::Value> TakeHeapSnapshot(const v8::Arguments& args) {
+void TakeHeapSnapshot(const v8::FunctionCallbackInfo<v8::Value>& args) {
   node::node_isolate->GetHeapProfiler()->TakeHeapSnapshot(
       v8::String::New("test"));
-  return v8::Undefined();
 }
 
 }  // namespace
 
 void InitializeV8Util(v8::Handle<v8::Object> target) {
+  v8::HandleScope handle_scope(node_isolate);
+
   NODE_SET_METHOD(target, "createObjectWithName", CreateObjectWithName);
   NODE_SET_METHOD(target, "getHiddenValue", GetHiddenValue);
   NODE_SET_METHOD(target, "setHiddenValue", SetHiddenValue);

common/api/atom_bindings.cc

@@ -6,8 +6,9 @@
 
 #include "base/logging.h"
 #include "common/atom_version.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
-#include "vendor/node/src/node.h"
+
+#include "common/v8/node_common.h"
 
 namespace atom {
 
@@ -50,22 +51,20 @@ AtomBindings::~AtomBindings() {
 }
 
 void AtomBindings::BindTo(v8::Handle<v8::Object> process) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
-  node::SetMethod(process, "atomBinding", Binding);
+  NODE_SET_METHOD(process, "atomBinding", Binding);
-  node::SetMethod(process, "crash", Crash);
+  NODE_SET_METHOD(process, "crash", Crash);
-  node::SetMethod(process, "activateUvLoop", ActivateUVLoop);
+  NODE_SET_METHOD(process, "activateUvLoop", ActivateUVLoop);
-  node::SetMethod(process, "log", Log);
+  NODE_SET_METHOD(process, "log", Log);
-  node::SetMethod(process, "getCurrentStackTrace", GetCurrentStackTrace);
+  NODE_SET_METHOD(process, "getCurrentStackTrace", GetCurrentStackTrace);
 
   process->Get(v8::String::New("versions"))->ToObject()->
     Set(v8::String::New("atom-shell"), v8::String::New(ATOM_VERSION_STRING));
 }
 
 // static
-v8::Handle<v8::Value> AtomBindings::Binding(const v8::Arguments& args) {
+void AtomBindings::Binding(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   v8::Local<v8::String> module = args[0]->ToString();
   v8::String::Utf8Value module_v(module);
   node::node_module_struct* modp;
@@ -93,7 +92,7 @@ v8::Handle<v8::Value> AtomBindings::Binding(const v8::Arguments& args) {
 
   if (binding_cache->Has(module)) {
     exports = binding_cache->Get(module)->ToObject();
-    return scope.Close(exports);
+    return args.GetReturnValue().Set(exports);
   }
 
   if ((modp = GetBuiltinModule(*module_v, is_browser)) != NULL) {
@@ -102,39 +101,36 @@ v8::Handle<v8::Value> AtomBindings::Binding(const v8::Arguments& args) {
     // only exports.
     modp->register_func(exports, v8::Undefined());
     binding_cache->Set(module, exports);
-    return scope.Close(exports);
+    return args.GetReturnValue().Set(exports);
   }
 
-  return v8::ThrowException(v8::Exception::Error(
+  return node::ThrowError("No such module");
-      v8::String::New("No such module")));
 }
 
 // static
-v8::Handle<v8::Value> AtomBindings::Crash(const v8::Arguments& args) {
+void AtomBindings::Crash(const v8::FunctionCallbackInfo<v8::Value>& args) {
   static_cast<DummyClass*>(NULL)->crash = true;
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AtomBindings::ActivateUVLoop(const v8::Arguments& args) {
+void AtomBindings::ActivateUVLoop(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   uv_async_send(&dummy_uv_handle);
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AtomBindings::Log(const v8::Arguments& args) {
+void AtomBindings::Log(const v8::FunctionCallbackInfo<v8::Value>& args) {
   std::string message;
   for (int i = 0; i < args.Length(); ++i)
     message += *v8::String::Utf8Value(args[i]);
 
   logging::LogMessage("CONSOLE", 0, 0).stream() << message;
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> AtomBindings::GetCurrentStackTrace(
+void AtomBindings::GetCurrentStackTrace(
-    const v8::Arguments& args) {
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(args.GetIsolate());
 
   int stack_limit = kMaxCallStackSize;
   FromV8Arguments(args, &stack_limit);
@@ -147,7 +143,7 @@ v8::Handle<v8::Value> AtomBindings::GetCurrentStackTrace(
   for (int i = 0; i < frame_count; ++i)
     result->Set(i, DumpStackFrame(stack_trace->GetFrame(i)));
 
-  return scope.Close(result);
+  args.GetReturnValue().Set(result);
 }
 
 }  // namespace atom

common/api/atom_bindings.h

@@ -20,11 +20,12 @@ class AtomBindings {
   virtual void BindTo(v8::Handle<v8::Object> process);
 
  private:
-  static v8::Handle<v8::Value> Binding(const v8::Arguments& args);
+  static void Binding(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Crash(const v8::Arguments& args);
+  static void Crash(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> ActivateUVLoop(const v8::Arguments& args);
+  static void ActivateUVLoop(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> Log(const v8::Arguments& args);
+  static void Log(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> GetCurrentStackTrace(const v8::Arguments& args);
+  static void GetCurrentStackTrace(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
 
   DISALLOW_COPY_AND_ASSIGN(AtomBindings);
 };

common/api/atom_extensions.cc

@@ -5,10 +5,11 @@
 #include <string.h>
 #include <stdio.h>
 
-#include "base/string_util.h"
+#include "base/strings/string_util.h"
-#include "vendor/node/src/node.h"
 #include "vendor/node/src/node_version.h"
 
+#include "common/v8/node_common.h"
+
 namespace atom {
 
 #undef NODE_EXT_LIST_START

common/api/object_life_monitor.cc

@@ -10,42 +10,29 @@ namespace atom {
 // static
 void ObjectLifeMonitor::BindTo(v8::Handle<v8::Object> target,
                                v8::Handle<v8::Value> destructor) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
   target->SetHiddenValue(v8::String::New("destructor"), destructor);
 
   ObjectLifeMonitor* olm = new ObjectLifeMonitor();
-  olm->handle_ = v8::Persistent<v8::Object>::New(isolate, target);
+  olm->handle_.reset(target);
-  olm->handle_.MakeWeak(isolate, olm, WeakCallback);
+  olm->handle_.MakeWeak(olm, WeakCallback);
 }
 
 ObjectLifeMonitor::ObjectLifeMonitor() {
 }
 
-ObjectLifeMonitor::~ObjectLifeMonitor() {
-  if (!handle_.IsEmpty()) {
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    handle_.ClearWeak(isolate);
-    handle_.Dispose(isolate);
-    handle_.Clear();
-  }
-}
-
 // static
 void ObjectLifeMonitor::WeakCallback(v8::Isolate* isolate,
-                                     v8::Persistent<v8::Value> value,
+                                     v8::Persistent<v8::Object>* value,
-                                     void *data) {
+                                     ObjectLifeMonitor* self) {
   // destructor.call(object, object);
   {
-    v8::HandleScope scope;
+    v8::HandleScope handle_scope(isolate);
-
+    v8::Local<v8::Object> obj = self->handle_.NewHandle();
-    v8::Local<v8::Object> obj = value->ToObject();
-    v8::Local<v8::Value> args[] = { obj };
     v8::Local<v8::Function>::Cast(obj->GetHiddenValue(
-        v8::String::New("destructor")))->Call(obj, 1, args);
+        v8::String::New("destructor")))->Call(obj, 0, NULL);
   }
 
-  ObjectLifeMonitor* obj = static_cast<ObjectLifeMonitor*>(data);
+  delete self;
-  delete obj;
 }
 
 }  // namespace atom

common/api/object_life_monitor.h

@@ -7,7 +7,7 @@
 #define ATOM_COMMON_API_OBJECT_LIFE_MONITOR_H_
 
 #include "base/basictypes.h"
-#include "v8/include/v8.h"
+#include "common/v8/scoped_persistent.h"
 
 namespace atom {
 
@@ -18,13 +18,12 @@ class ObjectLifeMonitor {
 
  private:
   ObjectLifeMonitor();
-  virtual ~ObjectLifeMonitor();
 
   static void WeakCallback(v8::Isolate* isolate,
-                           v8::Persistent<v8::Value> value,
+                           v8::Persistent<v8::Object>* value,
-                           void *data);
+                           ObjectLifeMonitor* self);
 
-  v8::Persistent<v8::Object> handle_;
+  ScopedPersistent<v8::Object> handle_;
 
   DISALLOW_COPY_AND_ASSIGN(ObjectLifeMonitor);
 };

common/node_bindings.cc

@@ -6,22 +6,34 @@
 
 #include "base/command_line.h"
 #include "base/logging.h"
-#include "base/message_loop.h"
+#include "base/message_loop/message_loop.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/escape.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
-#include "vendor/node/src/node.h"
-#include "vendor/node/src/node_internals.h"
 #include "vendor/node/src/node_javascript.h"
 
 #if defined(OS_WIN)
 #include "base/strings/utf_string_conversions.h"
 #endif
 
+#include "common/v8/node_common.h"
+
 using content::BrowserThread;
 
+namespace node {
+void Init(int* argc,
+          const char** argv,
+          int* exec_argc,
+          const char*** exec_argv);
+Environment* CreateEnvironment(v8::Isolate* isolate,
+                               int argc,
+                               const char* const* argv,
+                               int exec_argc,
+                               const char* const* exec_argv);
+}
+
 namespace atom {
 
 namespace {
@@ -31,6 +43,8 @@ void UvNoOp(uv_async_t* handle, int status) {
 
 }  // namespace
 
+node::Environment* global_env = NULL;
+
 NodeBindings::NodeBindings(bool is_browser)
     : is_browser_(is_browser),
       message_loop_(NULL),
@@ -61,14 +75,14 @@ void NodeBindings::Initialize() {
   utf8_str_argv.reserve(str_argv.size());
 #endif
 
-  // Convert string vector to char* array.
+  // Convert string vector to const char* array.
-  std::vector<char*> argv(str_argv.size(), NULL);
+  std::vector<const char*> args(str_argv.size(), NULL);
   for (size_t i = 0; i < str_argv.size(); ++i) {
 #if defined(OS_WIN)
     utf8_str_argv.push_back(UTF16ToUTF8(str_argv[i]));
-    argv[i] = const_cast<char*>(utf8_str_argv[i].c_str());
+    args[i] = utf8_str_argv[i].c_str();
 #else
-    argv[i] = const_cast<char*>(str_argv[i].c_str());
+    args[i] = str_argv[i].c_str();
 #endif
   }
 
@@ -81,33 +95,30 @@ void NodeBindings::Initialize() {
   node::g_upstream_node_mode = false;
 
   // Init node.
-  node::Init(argv.size(), &argv[0]);
+  int argc = args.size();
+  const char** argv = &args[0];
+  int exec_argc;
+  const char** exec_argv;
+  node::Init(&argc, argv, &exec_argc, &exec_argv);
   v8::V8::Initialize();
 
-  // Load node.js.
+  // Create environment (setup process object and load node.js).
-  v8::HandleScope scope;
+  global_env = node::CreateEnvironment(node_isolate, argc, argv, argc, argv);
-  node::g_context = v8::Persistent<v8::Context>::New(
+
-      node::node_isolate, v8::Context::New(node::node_isolate));
+  // Set the process.__atom_type.
   {
-    v8::Context::Scope context_scope(node::g_context);
+    v8::Context::Scope context_scope(global_env->context());
-    v8::Handle<v8::Object> process = node::SetupProcessObject(
+    v8::HandleScope handle_scope(global_env->isolate());
-        argv.size(), &argv[0]);
 
     // Tell node.js we are in browser or renderer.
     v8::Handle<v8::String> type =
         is_browser_ ? v8::String::New("browser") : v8::String::New("renderer");
-    process->Set(v8::String::New("__atom_type"), type);
+    global_env->process_object()->Set(v8::String::New("__atom_type"), type);
   }
 }
 
-void NodeBindings::Load() {
-  v8::HandleScope scope;
-  v8::Context::Scope context_scope(node::g_context);
-  node::Load(node::process);
-}
-
 void NodeBindings::BindTo(WebKit::WebFrame* frame) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
@@ -116,7 +127,7 @@ void NodeBindings::BindTo(WebKit::WebFrame* frame) {
   v8::Context::Scope scope(context);
 
   // Erase security token.
-  context->SetSecurityToken(node::g_context->GetSecurityToken());
+  context->SetSecurityToken(global_env->context()->GetSecurityToken());
 
   // Evaluate cefode.js.
   v8::Handle<v8::Script> script = node::CompileCefodeMainSource();
@@ -128,7 +139,7 @@ void NodeBindings::BindTo(WebKit::WebFrame* frame) {
       script_path,
       net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS);
   v8::Handle<v8::Value> args[2] = {
-    v8::Local<v8::Value>::New(node::process),
+    global_env->process_object(),
     ToV8Value(script_path),
   };
   v8::Local<v8::Function>::Cast(result)->Call(context->Global(), 2, args);
@@ -160,8 +171,8 @@ void NodeBindings::UvRunOnce() {
   DCHECK(!is_browser_ || BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Enter node context while dealing with uv events.
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
-  v8::Context::Scope context_scope(node::g_context);
+  v8::Context::Scope context_scope(global_env->context());
 
   // Deal with uv events.
   int r = uv_run(uv_loop_, (uv_run_mode)(UV_RUN_ONCE | UV_RUN_NOWAIT));

common/node_bindings.h

@@ -24,12 +24,9 @@ class NodeBindings {
 
   virtual ~NodeBindings();
 
-  // Setup V8, libuv and the process object.
+  // Setup V8, libuv and the process object, then load the node.js script.
   virtual void Initialize();
 
-  // Load node.js main script.
-  virtual void Load();
-
   // Load cefode.js script under web frame.
   virtual void BindTo(WebKit::WebFrame* frame);
 

common/node_bindings_mac.cc

@@ -9,8 +9,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 
-#include "vendor/node/src/node.h"
+#include "common/v8/node_common.h"
-#include "vendor/node/src/node_internals.h"
 
 namespace atom {
 

common/platform_util_mac.mm

@@ -12,7 +12,7 @@
 #include "base/mac/mac_logging.h"
 #include "base/mac/scoped_aedesc.h"
 #include "base/strings/sys_string_conversions.h"
-#include "googleurl/src/gurl.h"
+#include "url/gurl.h"
 
 namespace platform_util {
 

common/v8/native_type_conversions.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMMON_V8_CONVERSIONS_H_
+#ifndef ATOM_COMMON_V8_NATIVE_TYPE_CONVERSIONS_H_
-#define COMMON_V8_CONVERSIONS_H_
+#define ATOM_COMMON_V8_NATIVE_TYPE_CONVERSIONS_H_
 
 #include <map>
 #include <string>
@@ -15,11 +15,11 @@
 #include "base/values.h"
 #include "browser/api/atom_api_window.h"
 #include "common/swap_or_assign.h"
+#include "common/v8/scoped_persistent.h"
 #include "common/v8_value_converter_impl.h"
 #include "content/public/renderer/v8_value_converter.h"
-#include "googleurl/src/gurl.h"
 #include "ui/gfx/rect.h"
-#include "v8/include/v8.h"
+#include "url/gurl.h"
 
 // Convert V8 value to arbitrary supported types.
 struct FromV8Value {
@@ -104,10 +104,10 @@ struct FromV8Value {
     return NULL;
   }
 
-  operator v8::Persistent<v8::Function>() {
+  operator atom::RefCountedV8Function() {
-    return v8::Persistent<v8::Function>::New(
+    v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value_);
-        node::node_isolate,
+    return atom::RefCountedV8Function(
-        v8::Handle<v8::Function>::Cast(value_));
+        new atom::RefCountedPersistent<v8::Function>(func));
   }
 
   v8::Handle<v8::Value> value_;
@@ -233,7 +233,9 @@ bool V8ValueCanBeConvertedTo<v8::Persistent<v8::Function>>(
 
 // Check and convert V8's Arguments to native types.
 template<typename T1> inline
-bool FromV8Arguments(const v8::Arguments& args, T1* value, int index = 0) {
+bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
+                     T1* value,
+                     int index = 0) {
   if (!V8ValueCanBeConvertedTo<T1>(args[index]))
     return false;
   internal::SwapOrAssign(*value,
@@ -242,18 +244,23 @@ bool FromV8Arguments(const v8::Arguments& args, T1* value, int index = 0) {
 }
 
 template<typename T1, typename T2> inline
-bool FromV8Arguments(const v8::Arguments& args, T1* a1, T2* a2) {
+bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
+                     T1* a1,
+                     T2* a2) {
   return FromV8Arguments<T1>(args, a1) && FromV8Arguments<T2>(args, a2, 1);
 }
 
 template<typename T1, typename T2, typename T3> inline
-bool FromV8Arguments(const v8::Arguments& args, T1* a1, T2* a2, T3* a3) {
+bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
+                     T1* a1,
+                     T2* a2,
+                     T3* a3) {
   return FromV8Arguments<T1, T2>(args, a1, a2) &&
          FromV8Arguments<T3>(args, a3, 2);
 }
 
 template<typename T1, typename T2, typename T3, typename T4> inline
-bool FromV8Arguments(const v8::Arguments& args,
+bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
                      T1* a1,
                      T2* a2,
                      T3* a3,
@@ -263,7 +270,7 @@ bool FromV8Arguments(const v8::Arguments& args,
 }
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5> inline
-bool FromV8Arguments(const v8::Arguments& args,
+bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
                      T1* a1,
                      T2* a2,
                      T3* a3,
@@ -275,7 +282,7 @@ bool FromV8Arguments(const v8::Arguments& args,
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5,
     typename T6> inline
-bool FromV8Arguments(const v8::Arguments& args,
+bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
                      T1* a1,
                      T2* a2,
                      T3* a3,
@@ -288,7 +295,7 @@ bool FromV8Arguments(const v8::Arguments& args,
 
 template<typename T1, typename T2, typename T3, typename T4, typename T5,
     typename T6, typename T7> inline
-bool FromV8Arguments(const v8::Arguments& args,
+bool FromV8Arguments(const v8::FunctionCallbackInfo<v8::Value>& args,
                      T1* a1,
                      T2* a2,
                      T3* a3,
@@ -301,4 +308,4 @@ bool FromV8Arguments(const v8::Arguments& args,
       FromV8Arguments<T7>(args, a7, 6);
 }
 
-#endif  // COMMON_V8_CONVERSIONS_H_
+#endif  // ATOM_COMMON_V8_NATIVE_TYPE_CONVERSIONS_H_

common/v8/node_common.h

@@ -0,0 +1,22 @@
+// Copyright (c) 2013 GitHub, Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_COMMON_V8_NODE_COMMON_H_
+#define ATOM_COMMON_V8_NODE_COMMON_H_
+
+// Common helper for using node APIs.
+
+#undef CHECK
+#undef DISALLOW_COPY_AND_ASSIGN
+#include "vendor/node/src/env.h"
+#include "vendor/node/src/node.h"
+#include "vendor/node/src/node_internals.h"
+using node::node_isolate;
+
+namespace atom {
+// Defined in node_bindings.cc.
+extern node::Environment* global_env;
+}
+
+#endif  // ATOM_COMMON_V8_NODE_COMMON_H_

common/v8/scoped_persistent.h

@@ -0,0 +1,115 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_COMMON_SCOPED_PERSISTENT_H_
+#define ATOM_COMMON_SCOPED_PERSISTENT_H_
+
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "v8/include/v8.h"
+
+namespace atom {
+
+// A v8::Persistent handle to a V8 value which destroys and clears the
+// underlying handle on destruction.
+template <typename T>
+class ScopedPersistent {
+ public:
+  ScopedPersistent() {
+  }
+
+  explicit ScopedPersistent(v8::Handle<T> handle) {
+    reset(handle);
+  }
+
+  ~ScopedPersistent() {
+    reset();
+  }
+
+  void reset(v8::Handle<T> handle) {
+    if (!handle.IsEmpty())
+      handle_.Reset(GetIsolate(handle), handle);
+    else
+      reset();
+  }
+
+  void reset() {
+    handle_.Reset();
+  }
+
+  bool IsEmpty() const {
+    return handle_.IsEmpty();
+  }
+
+  v8::Handle<T> NewHandle() const {
+    if (handle_.IsEmpty())
+      return v8::Local<T>();
+    return v8::Local<T>::New(GetIsolate(handle_), handle_);
+  }
+
+  v8::Handle<T> NewHandle(v8::Isolate* isolate) const {
+    if (handle_.IsEmpty())
+      return v8::Local<T>();
+    return v8::Local<T>::New(isolate, handle_);
+  }
+
+  template <typename P>
+  void MakeWeak(P* parameters,
+                typename v8::WeakReferenceCallbacks<T, P>::Revivable callback) {
+    handle_.MakeWeak(parameters, callback);
+  }
+
+ private:
+  template <typename U>
+  static v8::Isolate* GetIsolate(v8::Handle<U> object_handle) {
+    // Only works for v8::Object and its subclasses. Add specialisations for
+    // anything else.
+    if (!object_handle.IsEmpty())
+      return GetIsolate(object_handle->CreationContext());
+    return v8::Isolate::GetCurrent();
+  }
+  static v8::Isolate* GetIsolate(v8::Handle<v8::Context> context_handle) {
+    if (!context_handle.IsEmpty())
+      return context_handle->GetIsolate();
+    return v8::Isolate::GetCurrent();
+  }
+  static v8::Isolate* GetIsolate(
+      v8::Handle<v8::ObjectTemplate> template_handle) {
+    return v8::Isolate::GetCurrent();
+  }
+  template <typename U>
+  static v8::Isolate* GetIsolate(const U& any_handle) {
+    return v8::Isolate::GetCurrent();
+  }
+
+  v8::Persistent<T> handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedPersistent);
+};
+
+template <typename T>
+class RefCountedPersistent : public ScopedPersistent<T>,
+                             public base::RefCounted<RefCountedPersistent<T>> {
+ public:
+  RefCountedPersistent() {}
+
+  explicit RefCountedPersistent(v8::Handle<T> handle)
+    : ScopedPersistent<T>(handle) {
+  }
+
+ protected:
+  friend class base::RefCounted<RefCountedPersistent<T>>;
+
+  ~RefCountedPersistent() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(RefCountedPersistent);
+};
+
+typedef scoped_refptr<RefCountedPersistent<v8::Function>> RefCountedV8Function;
+typedef scoped_refptr<RefCountedPersistent<v8::Object>> RefCountedV8Object;
+
+}  // namespace atom
+
+#endif  // ATOM_COMMON_SCOPED_PERSISTENT_H_

common/v8_value_converter_impl.cc

@@ -36,10 +36,14 @@ void V8ValueConverterImpl::SetStripNullFromObjects(bool val) {
   strip_null_from_objects_ = val;
 }
 
+void V8ValueConverterImpl::SetStrategy(Strategy* strategy) {
+  // Ignore any strategy.
+}
+
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Value(
     const base::Value* value, v8::Handle<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   return handle_scope.Close(ToV8ValueImpl(value));
 }
 
@@ -47,7 +51,7 @@ Value* V8ValueConverterImpl::FromV8Value(
     v8::Handle<v8::Value> val,
     v8::Handle<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   HashToHandleMap unique_map;
   return FromV8ValueImpl(val, &unique_map);
 }

common/v8_value_converter_impl.h

@@ -31,6 +31,7 @@ class V8ValueConverterImpl : public content::V8ValueConverter {
   virtual void SetRegExpAllowed(bool val) OVERRIDE;
   virtual void SetFunctionAllowed(bool val) OVERRIDE;
   virtual void SetStripNullFromObjects(bool val) OVERRIDE;
+  virtual void SetStrategy(Strategy* strategy) OVERRIDE;
   virtual v8::Handle<v8::Value> ToV8Value(
       const base::Value* value,
       v8::Handle<v8::Context> context) const OVERRIDE;

renderer/api/atom_api_renderer_ipc.cc

@@ -5,11 +5,12 @@
 #include "renderer/api/atom_api_renderer_ipc.h"
 
 #include "common/api/api_messages.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/renderer/render_view.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
+#include "third_party/WebKit/public/web/WebView.h"
-#include "vendor/node/src/node.h"
+
+#include "common/v8/node_common.h"
 
 using content::RenderView;
 using WebKit::WebFrame;
@@ -36,9 +37,7 @@ RenderView* GetCurrentRenderView() {
 }  // namespace
 
 // static
-v8::Handle<v8::Value> RendererIPC::Send(const v8::Arguments& args) {
+void RendererIPC::Send(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   string16 channel;
   scoped_ptr<base::Value> arguments;
   if (!FromV8Arguments(args, &channel, &arguments))
@@ -46,7 +45,7 @@ v8::Handle<v8::Value> RendererIPC::Send(const v8::Arguments& args) {
 
   RenderView* render_view = GetCurrentRenderView();
   if (render_view == NULL)
-    return v8::Undefined();
+    return;
 
   bool success = render_view->Send(new AtomViewHostMsg_Message(
       render_view->GetRoutingID(),
@@ -55,14 +54,10 @@ v8::Handle<v8::Value> RendererIPC::Send(const v8::Arguments& args) {
 
   if (!success)
     return node::ThrowError("Unable to send AtomViewHostMsg_Message");
-
-  return v8::Undefined();
 }
 
 // static
-v8::Handle<v8::Value> RendererIPC::SendSync(const v8::Arguments& args) {
+void RendererIPC::SendSync(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::HandleScope scope;
-
   string16 channel;
   scoped_ptr<base::Value> arguments;
   if (!FromV8Arguments(args, &channel, &arguments))
@@ -70,7 +65,7 @@ v8::Handle<v8::Value> RendererIPC::SendSync(const v8::Arguments& args) {
 
   RenderView* render_view = GetCurrentRenderView();
   if (render_view == NULL)
-    return v8::Undefined();
+    return;
 
   string16 json;
   IPC::SyncMessage* message = new AtomViewHostMsg_Message_Sync(
@@ -85,13 +80,15 @@ v8::Handle<v8::Value> RendererIPC::SendSync(const v8::Arguments& args) {
   if (!success)
     return node::ThrowError("Unable to send AtomViewHostMsg_Message_Sync");
 
-  return scope.Close(ToV8Value(json));
+  args.GetReturnValue().Set(ToV8Value(json));
 }
 
 // static
 void RendererIPC::Initialize(v8::Handle<v8::Object> target) {
-  node::SetMethod(target, "send", Send);
+  v8::HandleScope handle_scope(node_isolate);
-  node::SetMethod(target, "sendSync", SendSync);
+
+  NODE_SET_METHOD(target, "send", Send);
+  NODE_SET_METHOD(target, "sendSync", SendSync);
 }
 
 }  // namespace api

renderer/api/atom_api_renderer_ipc.h

@@ -17,8 +17,8 @@ class RendererIPC {
   static void Initialize(v8::Handle<v8::Object> target);
 
  private:
-  static v8::Handle<v8::Value> Send(const v8::Arguments& args);
+  static void Send(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::Handle<v8::Value> SendSync(const v8::Arguments& args);
+  static void SendSync(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(RendererIPC);
 };

renderer/api/atom_renderer_bindings.cc

@@ -7,11 +7,12 @@
 #include <vector>
 
 #include "base/logging.h"
-#include "common/v8_conversions.h"
+#include "common/v8/native_type_conversions.h"
 #include "content/public/renderer/render_view.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
+#include "third_party/WebKit/public/web/WebView.h"
-#include "vendor/node/src/node.h"
+
+#include "common/v8/node_common.h"
 
 using content::RenderView;
 using content::V8ValueConverter;
@@ -39,7 +40,7 @@ AtomRendererBindings::~AtomRendererBindings() {
 }
 
 void AtomRendererBindings::BindToFrame(WebFrame* frame) {
-  v8::HandleScope handle_scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Handle<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
@@ -55,7 +56,7 @@ void AtomRendererBindings::OnBrowserMessage(const string16& channel,
   if (!render_view_->GetWebView())
     return;
 
-  v8::HandleScope scope;
+  v8::HandleScope handle_scope(node_isolate);
 
   v8::Local<v8::Context> context =
       render_view_->GetWebView()->mainFrame()->mainWorldScriptContext();

renderer/atom_render_view_observer.cc

@@ -12,9 +12,9 @@
 #include "ipc/ipc_message_macros.h"
 #include "renderer/api/atom_renderer_bindings.h"
 #include "renderer/atom_renderer_client.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebDraggableRegion.h"
+#include "third_party/WebKit/public/web/WebDraggableRegion.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
 #include "v8/include/v8.h"
 
 using WebKit::WebFrame;

renderer/atom_renderer_client.cc

@@ -6,7 +6,8 @@
 
 #include "common/node_bindings.h"
 #include "renderer/atom_render_view_observer.h"
-#include "vendor/node/src/node_internals.h"
+
+#include "common/v8/node_common.h"
 
 namespace webkit {
 extern void SetGetNodeContext(v8::Handle<v8::Context> (*)());
@@ -17,7 +18,7 @@ namespace atom {
 namespace {
 
 v8::Handle<v8::Context> GetNodeContext() {
-  return node::g_context;
+  return global_env->context();
 }
 
 }  // namespace
@@ -35,7 +36,6 @@ void AtomRendererClient::RenderThreadStarted() {
   // Interact with dirty workarounds of extra node context in WebKit.
   webkit::SetGetNodeContext(GetNodeContext);
 
-  node_bindings_->Load();
   node_bindings_->PrepareMessageLoop();
   node_bindings_->RunMessageLoop();
 }

vendor/brightray

@@ -1 +1 @@
-Subproject commit 8e453e36fe6ab74cf4e72fe0fa67e30eb048d2b3
+Subproject commit 3f92be3fd3e7d841e0153d32eb8945ed65827225

vendor/node

@@ -1 +1 @@
-Subproject commit 4b6ab23cb972a96bde40c899aab41703f08a1f0d
+Subproject commit 264b0177bc11c4b2e733294c7921fd4c72e5b4e5