extensions/renderer: Use v8::Local instead of v8::Handle.

extensions/renderer/module_system.cc

 // Copyright 2014 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.
 
 #include "extensions/renderer/module_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 77 matching lines @@
   }
 
  private:
   ScriptContext* context_;
 };
 
 }  // namespace
 
 std::string ModuleSystem::ExceptionHandler::CreateExceptionString(
     const v8::TryCatch& try_catch) {
-  v8::Handle<v8::Message> message(try_catch.Message());
+  v8::Local<v8::Message> message(try_catch.Message());
   if (message.IsEmpty()) {
     return "try_catch has no message";
   }
 
   std::string resource_name = "<unknown resource>";
   if (!message->GetScriptOrigin().ResourceName().IsEmpty()) {
     v8::String::Utf8Value resource_name_v8(
         message->GetScriptOrigin().ResourceName());
     resource_name.assign(*resource_name_v8, resource_name_v8.length());
   }
@@ skipping 22 matching lines @@
       base::Bind(&ModuleSystem::RequireForJs, base::Unretained(this)));
   RouteFunction(
       "requireNative",
       base::Bind(&ModuleSystem::RequireNative, base::Unretained(this)));
   RouteFunction(
       "requireAsync",
       base::Bind(&ModuleSystem::RequireAsync, base::Unretained(this)));
   RouteFunction("privates",
                 base::Bind(&ModuleSystem::Private, base::Unretained(this)));
 
-  v8::Handle<v8::Object> global(context->v8_context()->Global());
+  v8::Local<v8::Object> global(context->v8_context()->Global());
   v8::Isolate* isolate = context->isolate();
   global->SetHiddenValue(v8::String::NewFromUtf8(isolate, kModulesField),
                          v8::Object::New(isolate));
   global->SetHiddenValue(v8::String::NewFromUtf8(isolate, kModuleSystem),
                          v8::External::New(isolate, this));
 
   gin::ModuleRegistry::From(context->v8_context())->AddObserver(this);
   if (context_->GetRenderFrame()) {
     context_->GetRenderFrame()->EnsureMojoBuiltinsAreAvailable(
         context->isolate(), context->v8_context());
   }
 }
 
 ModuleSystem::~ModuleSystem() {
 }
 
 void ModuleSystem::Invalidate() {
   // Clear the module system properties from the global context. It's polite,
   // and we use this as a signal in lazy handlers that we no longer exist.
   {
     v8::HandleScope scope(GetIsolate());
-    v8::Handle<v8::Object> global = context()->v8_context()->Global();
+    v8::Local<v8::Object> global = context()->v8_context()->Global();
     global->DeleteHiddenValue(
         v8::String::NewFromUtf8(GetIsolate(), kModulesField));
     global->DeleteHiddenValue(
         v8::String::NewFromUtf8(GetIsolate(), kModuleSystem));
   }
 
   // Invalidate all active and clobbered NativeHandlers we own.
   for (const auto& handler : native_handler_map_)
     handler.second->Invalidate();
   for (const auto& clobbered_handler : clobbered_native_handlers_)
@@ skipping 10 matching lines @@
 
 ModuleSystem::NativesEnabledScope::~NativesEnabledScope() {
   module_system_->natives_enabled_--;
   CHECK_GE(module_system_->natives_enabled_, 0);
 }
 
 void ModuleSystem::HandleException(const v8::TryCatch& try_catch) {
   exception_handler_->HandleUncaughtException(try_catch);
 }
 
-v8::Handle<v8::Value> ModuleSystem::Require(const std::string& module_name) {
+v8::Local<v8::Value> ModuleSystem::Require(const std::string& module_name) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   return handle_scope.Escape(RequireForJsInner(
       v8::String::NewFromUtf8(GetIsolate(), module_name.c_str())));
 }
 
 void ModuleSystem::RequireForJs(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::Handle<v8::String> module_name = args[0]->ToString(args.GetIsolate());
+  v8::Local<v8::String> module_name = args[0]->ToString(args.GetIsolate());
   args.GetReturnValue().Set(RequireForJsInner(module_name));
 }
 
 v8::Local<v8::Value> ModuleSystem::RequireForJsInner(
-    v8::Handle<v8::String> module_name) {
+    v8::Local<v8::String> module_name) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
-  v8::Handle<v8::Object> global(context()->v8_context()->Global());
+  v8::Local<v8::Object> global(context()->v8_context()->Global());
 
   // The module system might have been deleted. This can happen if a different
   // context keeps a reference to us, but our frame is destroyed (e.g.
   // background page keeps reference to chrome object in a closed popup).
-  v8::Handle<v8::Value> modules_value = global->GetHiddenValue(
+  v8::Local<v8::Value> modules_value = global->GetHiddenValue(
       v8::String::NewFromUtf8(GetIsolate(), kModulesField));
   if (modules_value.IsEmpty() || modules_value->IsUndefined()) {
     Warn(GetIsolate(), "Extension view no longer exists");
     return v8::Undefined(GetIsolate());
   }
 
-  v8::Handle<v8::Object> modules(v8::Handle<v8::Object>::Cast(modules_value));
+  v8::Local<v8::Object> modules(v8::Local<v8::Object>::Cast(modules_value));
   v8::Local<v8::Value> exports(modules->Get(module_name));
   if (!exports->IsUndefined())
     return handle_scope.Escape(exports);
 
   exports = LoadModule(*v8::String::Utf8Value(module_name));
   modules->Set(module_name, exports);
   return handle_scope.Escape(exports);
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
-  v8::Handle<v8::Value> no_args;
+  v8::Local<v8::Value> no_args;
   return handle_scope.Escape(
       CallModuleMethod(module_name, method_name, 0, &no_args));
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name,
-    std::vector<v8::Handle<v8::Value> >* args) {
+    std::vector<v8::Local<v8::Value>>* args) {
   return CallModuleMethod(
       module_name, method_name, args->size(), vector_as_array(args));
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name,
     int argc,
-    v8::Handle<v8::Value> argv[]) {
+    v8::Local<v8::Value> argv[]) {
   TRACE_EVENT2("v8",
                "v8.callModuleMethod",
                "module_name",
                module_name,
                "method_name",
                method_name);
 
   v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   v8::Local<v8::Value> module;
   {
     NativesEnabledScope natives_enabled(this);
     module = RequireForJsInner(
         v8::String::NewFromUtf8(GetIsolate(), module_name.c_str()));
   }
 
   if (module.IsEmpty() || !module->IsObject()) {
     Fatal(context_,
           "Failed to get module " + module_name + " to call " + method_name);
     return handle_scope.Escape(
         v8::Local<v8::Primitive>(v8::Undefined(GetIsolate())));
   }
 
-  v8::Local<v8::Value> value = v8::Handle<v8::Object>::Cast(module)->Get(
+  v8::Local<v8::Value> value = v8::Local<v8::Object>::Cast(module)->Get(
       v8::String::NewFromUtf8(GetIsolate(), method_name.c_str()));
   if (value.IsEmpty() || !value->IsFunction()) {
     Fatal(context_, module_name + "." + method_name + " is not a function");
     return handle_scope.Escape(
         v8::Local<v8::Primitive>(v8::Undefined(GetIsolate())));
   }
 
-  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value);
+  v8::Local<v8::Function> func = v8::Local<v8::Function>::Cast(value);
   v8::Local<v8::Value> result;
   {
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
     result = context_->CallFunction(func, argc, argv);
     if (try_catch.HasCaught())
       HandleException(try_catch);
   }
   return handle_scope.Escape(result);
 }
@@ skipping 32 matching lines @@
 }
 
 // static
 void ModuleSystem::LazyFieldGetterInner(
     v8::Local<v8::String> property,
     const v8::PropertyCallbackInfo<v8::Value>& info,
     RequireFunction require_function) {
   CHECK(!info.Data().IsEmpty());
   CHECK(info.Data()->IsObject());
   v8::HandleScope handle_scope(info.GetIsolate());
-  v8::Handle<v8::Object> parameters = v8::Handle<v8::Object>::Cast(info.Data());
+  v8::Local<v8::Object> parameters = v8::Local<v8::Object>::Cast(info.Data());
   // This context should be the same as context()->v8_context().
-  v8::Handle<v8::Context> context = parameters->CreationContext();
-  v8::Handle<v8::Object> global(context->Global());
-  v8::Handle<v8::Value> module_system_value = global->GetHiddenValue(
+  v8::Local<v8::Context> context = parameters->CreationContext();
+  v8::Local<v8::Object> global(context->Global());
+  v8::Local<v8::Value> module_system_value = global->GetHiddenValue(
       v8::String::NewFromUtf8(info.GetIsolate(), kModuleSystem));
   if (module_system_value.IsEmpty() || !module_system_value->IsExternal()) {
     // ModuleSystem has been deleted.
     // TODO(kalman): See comment in header file.
     Warn(info.GetIsolate(),
          "Module system has been deleted, does extension view exist?");
     return;
   }
 
   ModuleSystem* module_system = static_cast<ModuleSystem*>(
-      v8::Handle<v8::External>::Cast(module_system_value)->Value());
+      v8::Local<v8::External>::Cast(module_system_value)->Value());
 
   std::string name = *v8::String::Utf8Value(parameters->Get(
       v8::String::NewFromUtf8(info.GetIsolate(), kModuleName)));
 
   // Switch to our v8 context because we need functions created while running
   // the require()d module to belong to our context, not the current one.
   v8::Context::Scope context_scope(context);
   NativesEnabledScope natives_enabled_scope(module_system);
 
   v8::TryCatch try_catch;
-  v8::Handle<v8::Value> module_value = (module_system->*require_function)(name);
+  v8::Local<v8::Value> module_value = (module_system->*require_function)(name);
   if (try_catch.HasCaught()) {
     module_system->HandleException(try_catch);
     return;
   }
   if (module_value.IsEmpty() || !module_value->IsObject()) {
     // require_function will have already logged this, we don't need to.
     return;
   }
 
-  v8::Handle<v8::Object> module = v8::Handle<v8::Object>::Cast(module_value);
-  v8::Handle<v8::String> field =
+  v8::Local<v8::Object> module = v8::Local<v8::Object>::Cast(module_value);
+  v8::Local<v8::String> field =
       parameters->Get(v8::String::NewFromUtf8(info.GetIsolate(), kModuleField))
           ->ToString(info.GetIsolate());
 
   if (!module->Has(field)) {
     std::string field_str = *v8::String::Utf8Value(field);
     Fatal(module_system->context_,
           "Lazy require of " + name + "." + field_str + " did not set the " +
               field_str + " field");
     return;
   }
 
   v8::Local<v8::Value> new_field = module->Get(field);
   if (try_catch.HasCaught()) {
     module_system->HandleException(try_catch);
     return;
   }
 
   // Ok for it to be undefined, among other things it's how bindings signify
   // that the extension doesn't have permission to use them.
   CHECK(!new_field.IsEmpty());
 
   // Delete the getter and set this field to |new_field| so the same object is
   // returned every time a certain API is accessed.
-  v8::Handle<v8::Value> val = info.This();
+  v8::Local<v8::Value> val = info.This();
   if (val->IsObject()) {
-    v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(val);
+    v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(val);
     object->Delete(property);
     object->Set(property, new_field);
   } else {
     NOTREACHED();
   }
   info.GetReturnValue().Set(new_field);
 }
 
-void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
+void ModuleSystem::SetLazyField(v8::Local<v8::Object> object,
                                 const std::string& field,
                                 const std::string& module_name,
                                 const std::string& module_field) {
   SetLazyField(
       object, field, module_name, module_field, &ModuleSystem::LazyFieldGetter);
 }
 
-void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
+void ModuleSystem::SetLazyField(v8::Local<v8::Object> object,
                                 const std::string& field,
                                 const std::string& module_name,
                                 const std::string& module_field,
                                 v8::AccessorGetterCallback getter) {
   v8::HandleScope handle_scope(GetIsolate());
-  v8::Handle<v8::Object> parameters = v8::Object::New(GetIsolate());
+  v8::Local<v8::Object> parameters = v8::Object::New(GetIsolate());
   parameters->Set(v8::String::NewFromUtf8(GetIsolate(), kModuleName),
                   v8::String::NewFromUtf8(GetIsolate(), module_name.c_str()));
   parameters->Set(v8::String::NewFromUtf8(GetIsolate(), kModuleField),
                   v8::String::NewFromUtf8(GetIsolate(), module_field.c_str()));
   object->SetAccessor(v8::String::NewFromUtf8(GetIsolate(), field.c_str()),
                       getter,
                       NULL,
                       parameters);
 }
 
-void ModuleSystem::SetNativeLazyField(v8::Handle<v8::Object> object,
+void ModuleSystem::SetNativeLazyField(v8::Local<v8::Object> object,
                                       const std::string& field,
                                       const std::string& module_name,
                                       const std::string& module_field) {
   SetLazyField(object,
                field,
                module_name,
                module_field,
                &ModuleSystem::NativeLazyFieldGetter);
 }
 
-v8::Handle<v8::Value> ModuleSystem::RunString(v8::Handle<v8::String> code,
-                                              v8::Handle<v8::String> name) {
+v8::Local<v8::Value> ModuleSystem::RunString(v8::Local<v8::String> code,
+                                             v8::Local<v8::String> name) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   // Prepend extensions:: to |name| so that internal code can be differentiated
   // from external code in stack traces. This has no effect on behaviour.
   std::string internal_name =
       base::StringPrintf("extensions::%s", *v8::String::Utf8Value(name));
 
   blink::WebScopedMicrotaskSuppression suppression;
   v8::TryCatch try_catch;
   try_catch.SetCaptureMessage(true);
-  v8::Handle<v8::Script> script(
-      v8::Script::Compile(code,
-                          v8::String::NewFromUtf8(GetIsolate(),
-                                                  internal_name.c_str(),
-                                                  v8::String::kNormalString,
-                                                  internal_name.size())));
+  v8::Local<v8::Script> script(v8::Script::Compile(
+      code, v8::String::NewFromUtf8(GetIsolate(), internal_name.c_str(),
+                                    v8::String::kNormalString,
+                                    internal_name.size())));
   if (try_catch.HasCaught()) {
     HandleException(try_catch);
     return v8::Undefined(GetIsolate());
   }
 
   v8::Local<v8::Value> result = script->Run();
   if (try_catch.HasCaught()) {
     HandleException(try_catch);
     return v8::Undefined(GetIsolate());
   }
 
   return handle_scope.Escape(result);
 }
 
-v8::Handle<v8::Value> ModuleSystem::GetSource(const std::string& module_name) {
+v8::Local<v8::Value> ModuleSystem::GetSource(const std::string& module_name) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   if (!source_map_->Contains(module_name))
     return v8::Undefined(GetIsolate());
   return handle_scope.Escape(
       v8::Local<v8::Value>(source_map_->GetSource(GetIsolate(), module_name)));
 }
 
 void ModuleSystem::RequireNative(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   std::string native_name = *v8::String::Utf8Value(args[0]);
   args.GetReturnValue().Set(RequireNativeFromString(native_name));
 }
 
-v8::Handle<v8::Value> ModuleSystem::RequireNativeFromString(
+v8::Local<v8::Value> ModuleSystem::RequireNativeFromString(
     const std::string& native_name) {
   if (natives_enabled_ == 0) {
     // HACK: if in test throw exception so that we can test the natives-disabled
     // logic; however, under normal circumstances, this is programmer error so
     // we could crash.
     if (exception_handler_) {
       return GetIsolate()->ThrowException(
           v8::String::NewFromUtf8(GetIsolate(), "Natives disabled"));
     }
     Fatal(context_, "Natives disabled for requireNative(" + native_name + ")");
@@ skipping 11 matching lines @@
           "Couldn't find native for requireNative(" + native_name + ")");
     return v8::Undefined(GetIsolate());
   }
   return i->second->NewInstance();
 }
 
 void ModuleSystem::RequireAsync(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   std::string module_name = *v8::String::Utf8Value(args[0]);
-  v8::Handle<v8::Promise::Resolver> resolver(
+  v8::Local<v8::Promise::Resolver> resolver(
       v8::Promise::Resolver::New(GetIsolate()));
   args.GetReturnValue().Set(resolver->GetPromise());
   scoped_ptr<v8::Global<v8::Promise::Resolver>> global_resolver(
       new v8::Global<v8::Promise::Resolver>(GetIsolate(), resolver));
   gin::ModuleRegistry* module_registry =
       gin::ModuleRegistry::From(context_->v8_context());
   if (!module_registry) {
     Warn(GetIsolate(), "Extension view no longer exists");
     resolver->Reject(v8::Exception::Error(v8::String::NewFromUtf8(
         GetIsolate(), "Extension view no longer exists")));
     return;
   }
   module_registry->LoadModule(
       GetIsolate(), module_name,
       base::Bind(&ModuleSystem::OnModuleLoaded, weak_factory_.GetWeakPtr(),
                  base::Passed(&global_resolver)));
   if (module_registry->available_modules().count(module_name) == 0)
     LoadModule(module_name);
 }
 
-v8::Handle<v8::String> ModuleSystem::WrapSource(v8::Handle<v8::String> source) {
+v8::Local<v8::String> ModuleSystem::WrapSource(v8::Local<v8::String> source) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   // Keep in order with the arguments in RequireForJsInner.
-  v8::Handle<v8::String> left = v8::String::NewFromUtf8(
+  v8::Local<v8::String> left = v8::String::NewFromUtf8(
       GetIsolate(),
       "(function(define, require, requireNative, requireAsync, exports, "
       "console, privates,"
       "$Array, $Function, $JSON, $Object, $RegExp, $String, $Error) {"
       "'use strict';");
-  v8::Handle<v8::String> right = v8::String::NewFromUtf8(GetIsolate(), "\n})");
+  v8::Local<v8::String> right = v8::String::NewFromUtf8(GetIsolate(), "\n})");
   return handle_scope.Escape(v8::Local<v8::String>(
       v8::String::Concat(left, v8::String::Concat(source, right))));
 }
 
 void ModuleSystem::Private(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   if (!args[0]->IsObject() || args[0]->IsNull()) {
     GetIsolate()->ThrowException(
         v8::Exception::TypeError(v8::String::NewFromUtf8(GetIsolate(),
             args[0]->IsUndefined()
@@ skipping 11 matching lines @@
     if (privates.IsEmpty()) {
       GetIsolate()->ThrowException(
           v8::String::NewFromUtf8(GetIsolate(), "Failed to create privates"));
       return;
     }
     obj->SetHiddenValue(privates_key, privates);
   }
   args.GetReturnValue().Set(privates);
 }
 
-v8::Handle<v8::Value> ModuleSystem::LoadModule(const std::string& module_name) {
+v8::Local<v8::Value> ModuleSystem::LoadModule(const std::string& module_name) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
-  v8::Handle<v8::Value> source(GetSource(module_name));
+  v8::Local<v8::Value> source(GetSource(module_name));
   if (source.IsEmpty() || source->IsUndefined()) {
     Fatal(context_, "No source for require(" + module_name + ")");
     return v8::Undefined(GetIsolate());
   }
-  v8::Handle<v8::String> wrapped_source(
-      WrapSource(v8::Handle<v8::String>::Cast(source)));
+  v8::Local<v8::String> wrapped_source(
+      WrapSource(v8::Local<v8::String>::Cast(source)));
   // Modules are wrapped in (function(){...}) so they always return functions.
-  v8::Handle<v8::Value> func_as_value =
+  v8::Local<v8::Value> func_as_value =
       RunString(wrapped_source,
                 v8::String::NewFromUtf8(GetIsolate(), module_name.c_str()));
   if (func_as_value.IsEmpty() || func_as_value->IsUndefined()) {
     Fatal(context_, "Bad source for require(" + module_name + ")");
     return v8::Undefined(GetIsolate());
   }
 
-  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(func_as_value);
+  v8::Local<v8::Function> func = v8::Local<v8::Function>::Cast(func_as_value);
 
-  v8::Handle<v8::Object> define_object = v8::Object::New(GetIsolate());
+  v8::Local<v8::Object> define_object = v8::Object::New(GetIsolate());
   gin::ModuleRegistry::InstallGlobals(GetIsolate(), define_object);
 
   v8::Local<v8::Value> exports = v8::Object::New(GetIsolate());
-  v8::Handle<v8::Object> natives(NewInstance());
+  v8::Local<v8::Object> natives(NewInstance());
   CHECK(!natives.IsEmpty());  // this can happen if v8 has issues
 
   // These must match the argument order in WrapSource.
-  v8::Handle<v8::Value> args[] = {
+  v8::Local<v8::Value> args[] = {
       // AMD.
       define_object->Get(v8::String::NewFromUtf8(GetIsolate(), "define")),
       // CommonJS.
-      natives->Get(v8::String::NewFromUtf8(
-          GetIsolate(), "require", v8::String::kInternalizedString)),
-      natives->Get(v8::String::NewFromUtf8(
-          GetIsolate(), "requireNative", v8::String::kInternalizedString)),
-      natives->Get(v8::String::NewFromUtf8(
-          GetIsolate(), "requireAsync", v8::String::kInternalizedString)),
+      natives->Get(v8::String::NewFromUtf8(GetIsolate(), "require",
+                                           v8::String::kInternalizedString)),
+      natives->Get(v8::String::NewFromUtf8(GetIsolate(), "requireNative",
+                                           v8::String::kInternalizedString)),
+      natives->Get(v8::String::NewFromUtf8(GetIsolate(), "requireAsync",
+                                           v8::String::kInternalizedString)),
       exports,
       // Libraries that we magically expose to every module.
       console::AsV8Object(GetIsolate()),
-      natives->Get(v8::String::NewFromUtf8(
-          GetIsolate(), "privates", v8::String::kInternalizedString)),
+      natives->Get(v8::String::NewFromUtf8(GetIsolate(), "privates",
+                                           v8::String::kInternalizedString)),
       // Each safe builtin. Keep in order with the arguments in WrapSource.
       context_->safe_builtins()->GetArray(),
       context_->safe_builtins()->GetFunction(),
       context_->safe_builtins()->GetJSON(),
       context_->safe_builtins()->GetObjekt(),
       context_->safe_builtins()->GetRegExp(),
       context_->safe_builtins()->GetString(),
       context_->safe_builtins()->GetError(),
   };
   {
@@ skipping 24 matching lines @@
     if (registry->available_modules().count(dependency) == 0 &&
         (module_system_managed || source_map_->Contains(dependency))) {
       LoadModule(dependency);
     }
   }
   registry->AttemptToLoadMoreModules(GetIsolate());
 }
 
 void ModuleSystem::OnModuleLoaded(
     scoped_ptr<v8::Global<v8::Promise::Resolver>> resolver,
-    v8::Handle<v8::Value> value) {
+    v8::Local<v8::Value> value) {
   if (!is_valid())
     return;
   v8::HandleScope handle_scope(GetIsolate());
-  v8::Handle<v8::Promise::Resolver> resolver_local(
+  v8::Local<v8::Promise::Resolver> resolver_local(
       v8::Local<v8::Promise::Resolver>::New(GetIsolate(), *resolver));
   resolver_local->Resolve(value);
 }
 
 void ModuleSystem::ClobberExistingNativeHandler(const std::string& name) {
   NativeHandlerMap::iterator existing_handler = native_handler_map_.find(name);
   if (existing_handler != native_handler_map_.end()) {
     clobbered_native_handlers_.push_back(existing_handler->second);
     native_handler_map_.erase(existing_handler);
   }
 }
 
 }  // namespace extensions