Re-land: gin: Use V8 Maybe APIs

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 95 matching lines @@
   modules_.Reset();
 }
 
 // static
 void ModuleRegistry::RegisterGlobals(Isolate* isolate,
                                      v8::Local<ObjectTemplate> templ) {
   templ->Set(StringToSymbol(isolate, "define"), GetDefineTemplate(isolate));
 }
 
 // static
-void ModuleRegistry::InstallGlobals(v8::Isolate* isolate,
+bool ModuleRegistry::InstallGlobals(v8::Isolate* isolate,
                                     v8::Local<v8::Object> obj) {
-  obj->Set(StringToSymbol(isolate, "define"),
-           GetDefineTemplate(isolate)->GetFunction());
+  v8::Local<v8::Function> function;
+  auto maybe_function =
+      GetDefineTemplate(isolate)->GetFunction(isolate->GetCurrentContext());
+  if (!maybe_function.ToLocal(&function))
+    return false;
+  return SetProperty(isolate, obj, StringToSymbol(isolate, "define"), function);
 }
 
 // static
 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));
@@ skipping 40 matching lines @@
   waiting_callbacks_.insert(std::make_pair(id, callback));
 
   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,
+bool ModuleRegistry::RegisterModule(Isolate* isolate,
                                     const std::string& id,
                                     v8::Local<Value> module) {
   if (id.empty() || module.IsEmpty())
-    return;
+    return false;
 
+  v8::Local<Object> modules = Local<Object>::New(isolate, modules_);
+  if (!SetProperty(isolate, modules, StringToSymbol(isolate, id), module))
+    return false;
   unsatisfied_dependencies_.erase(id);
   available_modules_.insert(id);
-  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);
   }
   waiting_callbacks_.erase(range.first, range.second);
   for (std::vector<LoadModuleCallback>::iterator it = callbacks.begin();
        it != callbacks.end();
        ++it) {
     // Should we call the callback asynchronously?
     it->Run(module);
   }
+  return true;
 }
 
 bool ModuleRegistry::CheckDependencies(PendingModule* pending) {
   size_t num_missing_dependencies = 0;
   size_t len = pending->dependencies.size();
   for (size_t i = 0; i < len; ++i) {
     const std::string& dependency = pending->dependencies[i];
     if (available_modules_.count(dependency))
       continue;
     unsatisfied_dependencies_.insert(dependency);
     num_missing_dependencies++;
   }
   return num_missing_dependencies == 0;
 }
 
-void ModuleRegistry::Load(Isolate* isolate, scoped_ptr<PendingModule> pending) {
+bool ModuleRegistry::Load(Isolate* isolate, scoped_ptr<PendingModule> pending) {
   if (!pending->id.empty() && available_modules_.count(pending->id))
-    return;  // We've already loaded this module.
+    return true;  // We've already loaded this module.
 
   uint32_t argc = static_cast<uint32_t>(pending->dependencies.size());
   std::vector<v8::Local<Value> > argv(argc);
   for (uint32_t i = 0; i < argc; ++i)
     argv[i] = GetModule(isolate, pending->dependencies[i]);
 
   v8::Local<Value> module = Local<Value>::New(isolate, pending->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);
+  return 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;
+  return Load(isolate, pending.Pass());
 }
 
 v8::Local<v8::Value> ModuleRegistry::GetModule(v8::Isolate* isolate,
                                                 const std::string& 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);
+  DCHECK(modules->HasOwnProperty(isolate->GetCurrentContext(), key).FromJust());
+  return modules->Get(isolate->GetCurrentContext(), key).ToLocalChecked();
 }
 
 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