[Mojo] Remove static "bootstrap" state in mojo_js

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 117 matching lines @@
                                       v8::Handle<ObjectTemplate> templ) {
   DCHECK(!id.empty());
   RegisterModule(isolate, id, templ->NewInstance());
 }
 
 void ModuleRegistry::AddPendingModule(Isolate* isolate,
                                       scoped_ptr<PendingModule> pending) {
   AttemptToLoad(isolate, pending.Pass());
 }
 
+void ModuleRegistry::LoadModule(Isolate* isolate,
+                                const std::string& id,
+                                ModuleLoadCallback callback) {
+  if (available_modules_.count(id)) {

[Aaron Boodman, 2013/11/27 19:02:41]

I think that the implicit int->bool conversion will generate a warning under
msvc. It is more common in Chrome to do this check like:

if (available_modules_.find(id) != available_modules.end())

[abarth-chromium, 2013/11/27 19:18:09]

Done.

+    // Should we call the callback asynchronously?

[Aaron Boodman, 2013/11/27 19:02:41]

I think so, but slightlyoff would be able to answer definitively.

[abarth-chromium, 2013/11/27 19:18:09]

This is just used by C++, so we can change out minds in the future.  If we make
the callback async, we'll need to have a trampoline to set up a HandleScope and
all that.

+    callback.Run(GetModule(isolate, id));
+    return;
+  }
+  // Should we support multiple callers waiting on the same module?

[Aaron Boodman, 2013/11/27 19:02:41]

Couldn't you easily write JavaScript programs that require this?

[abarth-chromium, 2013/11/27 19:18:09]

This API is just for C++.  The JavaScript API is already asynchronous.  For
JavaScript, we execute a JavaScript function rather than a base::Callback when
the module is ready.

+  DCHECK(waiting_callbacks_.find(id) == waiting_callbacks_.end());
+  waiting_callbacks_[id] = callback;
+  unsatisfied_dependencies_.insert(id);
+}
+
 void ModuleRegistry::RegisterModule(Isolate* isolate,
                                     const std::string& id,
                                     v8::Handle<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_);
   modules->Set(StringToSymbol(isolate, id), module);
+
+  ModuleLoadCallbackMap::iterator it = waiting_callbacks_.find(id);
+  if (it == waiting_callbacks_.end())
+    return;
+  // Should we call the callback asynchronously?
+  it->second.Run(module);
 }
 
 void ModuleRegistry::Detach(v8::Handle<Context> context) {
   context->Global()->SetHiddenValue(GetHiddenValueKey(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;
     unsatisfied_dependencies_.insert(dependency);
     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.
 
-  v8::Handle<Object> modules = Local<Object>::New(isolate, modules_);
   uint32_t argc = static_cast<uint32_t>(pending->dependencies.size());
   std::vector<v8::Handle<Value> > argv(argc);
-  for (uint32_t i = 0; i < argc; ++i) {
-    v8::Handle<String> key = StringToSymbol(isolate, pending->dependencies[i]);
-    DCHECK(modules->HasOwnProperty(key));
-    argv[i] = modules->Get(key);
-  }
+  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::Handle<Function> factory;
   if (ConvertFromV8(module, &factory)) {
     PerContextData* data = PerContextData::From(isolate->GetCurrentContext());
     Runner* runner = data->runner();
     module = runner->Call(factory, runner->global(), argc, argv.data());
     if (pending->id.empty())
       ConvertFromV8(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,
+                                                const std::string& id) {
+  v8::Handle<Object> modules = Local<Object>::New(isolate, modules_);
+  v8::Handle<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