Replace v8::Handle with v8::Local in gin/modules/*

gin/modules/module_registry.cc

 // 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.
 
 #include "gin/modules/module_registry.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 46 matching lines @@
 };
 
 void Define(const v8::FunctionCallbackInfo<Value>& info) {
   Arguments args(info);
 
   if (!info.Length())
     return args.ThrowTypeError("At least one argument is required.");
 
   std::string id;
   std::vector<std::string> dependencies;
-  v8::Handle<Value> factory;
+  v8::Local<Value> factory;
 
   if (args.PeekNext()->IsString())
     args.GetNext(&id);
   if (args.PeekNext()->IsArray())
     args.GetNext(&dependencies);
   if (!args.GetNext(&factory))
     return args.ThrowError();
 
   scoped_ptr<PendingModule> pending(new PendingModule);
   pending->id = id;
@@ skipping 23 matching lines @@
 ModuleRegistry::ModuleRegistry(Isolate* isolate)
     : modules_(isolate, Object::New(isolate)) {
 }
 
 ModuleRegistry::~ModuleRegistry() {
   modules_.Reset();
 }
 
 // static
 void ModuleRegistry::RegisterGlobals(Isolate* isolate,
-                                     v8::Handle<ObjectTemplate> templ) {
+                                     v8::Local<ObjectTemplate> templ) {
   templ->Set(StringToSymbol(isolate, "define"), GetDefineTemplate(isolate));
 }
 
 // static
 void ModuleRegistry::InstallGlobals(v8::Isolate* isolate,
-                                    v8::Handle<v8::Object> obj) {
+                                    v8::Local<v8::Object> obj) {
   obj->Set(StringToSymbol(isolate, "define"),
            GetDefineTemplate(isolate)->GetFunction());
 }
 
 // static
-ModuleRegistry* ModuleRegistry::From(v8::Handle<Context> context) {
+ModuleRegistry* ModuleRegistry::From(v8::Local<Context> context) {
   PerContextData* data = PerContextData::From(context);
   if (!data)
     return NULL;
 
   ModuleRegistryData* registry_data = static_cast<ModuleRegistryData*>(
       data->GetUserData(kModuleRegistryKey));
   if (!registry_data) {
     // PerContextData takes ownership of ModuleRegistryData.
     registry_data = new ModuleRegistryData;
     registry_data->registry.reset(new ModuleRegistry(context->GetIsolate()));
     data->SetUserData(kModuleRegistryKey, registry_data);
   }
   return registry_data->registry.get();
 }
 
 void ModuleRegistry::AddObserver(ModuleRegistryObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void ModuleRegistry::RemoveObserver(ModuleRegistryObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void ModuleRegistry::AddBuiltinModule(Isolate* isolate, const std::string& id,
-                                      v8::Handle<Value> module) {
+                                      v8::Local<Value> module) {
   DCHECK(!id.empty());
   RegisterModule(isolate, id, module);
 }
 
 void ModuleRegistry::AddPendingModule(Isolate* isolate,
                                       scoped_ptr<PendingModule> pending) {
   const std::string pending_id = pending->id;
   const std::vector<std::string> pending_dependencies = pending->dependencies;
   AttemptToLoad(isolate, pending.Pass());
   FOR_EACH_OBSERVER(ModuleRegistryObserver, observer_list_,
@@ skipping 13 matching lines @@
   for (size_t i = 0; i < pending_modules_.size(); ++i) {
     if (pending_modules_[i]->id == id)
       return;
   }
 
   unsatisfied_dependencies_.insert(id);
 }
 
 void ModuleRegistry::RegisterModule(Isolate* isolate,
                                     const std::string& id,
-                                    v8::Handle<Value> module) {
+                                    v8::Local<Value> module) {
   if (id.empty() || module.IsEmpty())
     return;
 
   unsatisfied_dependencies_.erase(id);
   available_modules_.insert(id);
-  v8::Handle<Object> modules = Local<Object>::New(isolate, modules_);
+  v8::Local<Object> modules = Local<Object>::New(isolate, modules_);
   modules->Set(StringToSymbol(isolate, id), module);
 
   std::pair<LoadModuleCallbackMap::iterator, LoadModuleCallbackMap::iterator>
       range = waiting_callbacks_.equal_range(id);
   std::vector<LoadModuleCallback> callbacks;
   callbacks.reserve(waiting_callbacks_.count(id));
   for (LoadModuleCallbackMap::iterator it = range.first; it != range.second;
        ++it) {
     callbacks.push_back(it->second);
   }
@@ skipping 17 matching lines @@
     num_missing_dependencies++;
   }
   return num_missing_dependencies == 0;
 }
 
 void ModuleRegistry::Load(Isolate* isolate, scoped_ptr<PendingModule> pending) {
   if (!pending->id.empty() && available_modules_.count(pending->id))
     return;  // We've already loaded this module.
 
   uint32_t argc = static_cast<uint32_t>(pending->dependencies.size());
-  std::vector<v8::Handle<Value> > argv(argc);
+  std::vector<v8::Local<Value> > argv(argc);
   for (uint32_t i = 0; i < argc; ++i)
     argv[i] = GetModule(isolate, pending->dependencies[i]);
 
-  v8::Handle<Value> module = Local<Value>::New(isolate, pending->factory);
+  v8::Local<Value> module = Local<Value>::New(isolate, pending->factory);
 
-  v8::Handle<Function> factory;
+  v8::Local<Function> factory;
   if (ConvertFromV8(isolate, module, &factory)) {
     PerContextData* data = PerContextData::From(isolate->GetCurrentContext());
     Runner* runner = data->runner();
     module = runner->Call(factory, runner->global(), argc,
                           argv.empty() ? NULL : &argv.front());
     if (pending->id.empty())
       ConvertFromV8(isolate, factory->GetScriptOrigin().ResourceName(),
                     &pending->id);
   }
 
   RegisterModule(isolate, pending->id, module);
 }
 
 bool ModuleRegistry::AttemptToLoad(Isolate* isolate,
                                    scoped_ptr<PendingModule> pending) {
   if (!CheckDependencies(pending.get())) {
     pending_modules_.push_back(pending.release());
     return false;
   }
   Load(isolate, pending.Pass());
   return true;
 }
 
-v8::Handle<v8::Value> ModuleRegistry::GetModule(v8::Isolate* isolate,
+v8::Local<v8::Value> ModuleRegistry::GetModule(v8::Isolate* isolate,
                                                 const std::string& id) {
-  v8::Handle<Object> modules = Local<Object>::New(isolate, modules_);
-  v8::Handle<String> key = StringToSymbol(isolate, id);
+  v8::Local<Object> modules = Local<Object>::New(isolate, modules_);
+  v8::Local<String> key = StringToSymbol(isolate, id);
   DCHECK(modules->HasOwnProperty(key));
   return modules->Get(key);
 }
 
 void ModuleRegistry::AttemptToLoadMoreModules(Isolate* isolate) {
   bool keep_trying = true;
   while (keep_trying) {
     keep_trying = false;
     PendingModuleVector pending_modules;
     pending_modules.swap(pending_modules_);
     for (size_t i = 0; i < pending_modules.size(); ++i) {
       scoped_ptr<PendingModule> pending(pending_modules[i]);
       pending_modules[i] = NULL;
       if (AttemptToLoad(isolate, pending.Pass()))
         keep_trying = true;
     }
   }
 }
 
 }  // namespace gin