Refactors parts of gin:

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"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/per_isolate_data.h"
+#include "gin/public/context_holder.h"
 #include "gin/public/wrapper_info.h"
 #include "gin/runner.h"
 
 using v8::Context;
 using v8::External;
 using v8::Function;
 using v8::FunctionTemplate;
 using v8::Isolate;
 using v8::Local;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::Persistent;
 using v8::StackTrace;
 using v8::String;
 using v8::Value;
 
 namespace gin {
 
-struct PendingModule {
-  PendingModule();
-  ~PendingModule();
-
-  std::string id;
-  std::vector<std::string> dependencies;
-  Persistent<Value> factory;
-};
-
 PendingModule::PendingModule() {
 }
 
 PendingModule::~PendingModule() {
   factory.Reset();
 }
 
 namespace {
 
 void Define(const v8::FunctionCallbackInfo<Value>& info) {
@@ skipping 11 matching lines @@
   if (args.PeekNext()->IsArray())
     args.GetNext(&dependencies);
   if (!args.GetNext(&factory))
     return args.ThrowError();
 
   scoped_ptr<PendingModule> pending(new PendingModule);
   pending->id = id;
   pending->dependencies = dependencies;
   pending->factory.Reset(args.isolate(), factory);
 
-  ModuleRegistry* registry =
-      ModuleRegistry::From(args.isolate()->GetCurrentContext());
-  registry->AddPendingModule(args.isolate(), pending.Pass());
+  ModuleLoader* loader =
+      ModuleLoader::From(args.isolate()->GetCurrentContext());
+  loader->Load(args.isolate()->GetCurrentContext(), pending.Pass());
 }
 
 WrapperInfo g_wrapper_info = { kEmbedderNativeGin };
 
 Local<FunctionTemplate> GetDefineTemplate(Isolate* isolate) {
   PerIsolateData* data = PerIsolateData::From(isolate);
   Local<FunctionTemplate> templ = data->GetFunctionTemplate(
       &g_wrapper_info);
   if (templ.IsEmpty()) {
     templ = FunctionTemplate::New(isolate, Define);
     data->SetFunctionTemplate(&g_wrapper_info, templ);
   }
   return templ;
 }
 
-v8::Handle<String> GetHiddenValueKey(Isolate* isolate) {
+v8::Handle<String> GetModuleRegistryHiddenValueKey(Isolate* isolate) {
   return StringToSymbol(isolate, "::gin::ModuleRegistry");
 }
 
+v8::Handle<String> GetModuleLoaderHiddenValueKey(Isolate* isolate) {
+  return StringToSymbol(isolate, "::gin::ModuleLoader");
+}
+
 }  // namespace
 
+ModuleLoader* ModuleLoader::From(v8::Handle<Context> context) {
+  Isolate* isolate = context->GetIsolate();
+  v8::Handle<String> key = GetModuleLoaderHiddenValueKey(isolate);
+  v8::Handle<Value> value = context->Global()->GetHiddenValue(key);
+  v8::Handle<External> external;
+  return (value.IsEmpty() || !ConvertFromV8(isolate, value, &external)) ?
+      NULL : static_cast<ModuleLoader*>(external->Value());
+}
+
+ModuleLoader::ModuleLoader(v8::Handle<Context> context) {
+  Isolate* isolate = context->GetIsolate();
+  v8::Handle<String> key = GetModuleLoaderHiddenValueKey(isolate);
+  v8::Handle<Value> value = context->Global()->GetHiddenValue(key);
+  v8::Handle<External> external;
+  DCHECK(value.IsEmpty() || !ConvertFromV8(isolate, value, &external));
+  PerContextData* data = PerContextData::From(context);
+  DCHECK(data);
+  context->Global()->SetHiddenValue(key, External::New(isolate, this));
+  data->AddSupplement(scoped_ptr<ContextSupplement>(this));
+}
+
+ModuleLoader::~ModuleLoader() {
+}
+
+// static
+void ModuleLoader::RegisterGlobals(Isolate* isolate,
+                                   v8::Handle<ObjectTemplate> templ) {
+  templ->Set(StringToSymbol(isolate, "define"), GetDefineTemplate(isolate));
+}
+
+// static
+void ModuleLoader::RegisterGlobalsObject(v8::Isolate* isolate,
+                                         v8::Handle<v8::Object> obj) {
+  obj->Set(StringToSymbol(isolate, "define"),
+           GetDefineTemplate(isolate)->GetFunction());
+}
+
+void ModuleLoader::Detach(v8::Handle<Context> context) {
+  context->Global()->SetHiddenValue(GetModuleLoaderHiddenValueKey(
+                                        context->GetIsolate()),
+                                    v8::Handle<Value>());
+}
+
 ModuleRegistry::ModuleRegistry(Isolate* isolate)
     : modules_(isolate, Object::New(isolate)) {
 }
 
 ModuleRegistry::~ModuleRegistry() {
   modules_.Reset();
 }
 
-void ModuleRegistry::RegisterGlobals(Isolate* isolate,
-                                     v8::Handle<ObjectTemplate> templ) {
-  templ->Set(StringToSymbol(isolate, "define"), GetDefineTemplate(isolate));
-}
-
+// static
 ModuleRegistry* ModuleRegistry::From(v8::Handle<Context> context) {
   Isolate* isolate = context->GetIsolate();
-  v8::Handle<String> key = GetHiddenValueKey(isolate);
+  v8::Handle<String> key = GetModuleRegistryHiddenValueKey(isolate);
   v8::Handle<Value> value = context->Global()->GetHiddenValue(key);
   v8::Handle<External> external;
   if (value.IsEmpty() || !ConvertFromV8(isolate, value, &external)) {
     PerContextData* data = PerContextData::From(context);
     if (!data)
       return NULL;
     ModuleRegistry* registry = new ModuleRegistry(isolate);
     context->Global()->SetHiddenValue(key, External::New(isolate, registry));
     data->AddSupplement(scoped_ptr<ContextSupplement>(registry));
     return registry;
@@ skipping 40 matching lines @@
   LoadModuleCallbackMap::iterator it = waiting_callbacks_.find(id);
   if (it == waiting_callbacks_.end())
     return;
   LoadModuleCallback callback = it->second;
   waiting_callbacks_.erase(it);
   // Should we call the callback asynchronously?
   callback.Run(module);
 }
 
 void ModuleRegistry::Detach(v8::Handle<Context> context) {
-  context->Global()->SetHiddenValue(GetHiddenValueKey(context->GetIsolate()),
+  context->Global()->SetHiddenValue(GetModuleRegistryHiddenValueKey(
+                                        context->GetIsolate()),
                                     v8::Handle<Value>());
 }
 
 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;
@@ skipping 55 matching lines @@
     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