Expose requireAsync method and make it more robust

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/debug/trace_event.h"
 #include "base/stl_util.h"
@@ skipping 209 matching lines @@
   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::Value> exports(modules->Get(module_name));
   if (!exports->IsUndefined())
     return handle_scope.Escape(exports);
 
-  exports = LoadModule(*v8::String::Utf8Value(module_name));
+  std::string module_name_str = *v8::String::Utf8Value(module_name);
+
+  v8::Handle<v8::Value> source(GetSource(module_name_str));
+  if (source.IsEmpty() || source->IsUndefined()) {
+    Fatal(context_, "No source for require(" + module_name_str + ")");
+    return v8::Undefined(GetIsolate());
+  }
+
+  exports = LoadModule(module_name_str, source);
   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;
   return handle_scope.Escape(
@@ skipping 290 matching lines @@
   scoped_ptr<v8::UniquePersistent<v8::Promise::Resolver> > persistent_resolver(
       new v8::UniquePersistent<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;
   }
+
+  v8::Handle<v8::Value> source(GetSource(module_name));
+  if ((source.IsEmpty() || source->IsUndefined()) &&

[Sam McNally, 2015/01/22 07:42:11]

I'm not a fan of this. It introduces ordering dependencies:
define('foo', ...);
requireAsync('foo');
will succeed, but
requireAsync('foo');
define('foo', ...);
will fail.

+      !ContainsKey(module_registry->available_modules(), module_name)) {
+    std::string error_text = "No source for require(" + module_name + ")";
+    Fatal(context_, error_text);
+    resolver->Reject(v8::Exception::Error(
+        v8::String::NewFromUtf8(GetIsolate(), error_text.c_str())));
+    return;
+  }
+
   module_registry->LoadModule(GetIsolate(),
                               module_name,
                               base::Bind(&ModuleSystem::OnModuleLoaded,
                                          weak_factory_.GetWeakPtr(),
                                          base::Passed(&persistent_resolver)));
   if (module_registry->available_modules().count(module_name) == 0)
-    LoadModule(module_name);
+    LoadModule(module_name, source);
 }
 
 v8::Handle<v8::String> ModuleSystem::WrapSource(v8::Handle<v8::String> source) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   // Keep in order with the arguments in RequireForJsInner.
   v8::Handle<v8::String> left = v8::String::NewFromUtf8(
       GetIsolate(),
       "(function(define, require, requireNative, requireAsync, exports, "
       "console, privates,"
       "$Array, $Function, $JSON, $Object, $RegExp, $String, $Error) {"
@@ skipping 23 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::Handle<v8::Value> ModuleSystem::LoadModule(
+    const std::string& module_name,
+    v8::Handle<v8::Value> module_source) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
-  v8::Handle<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)));
+      WrapSource(v8::Handle<v8::String>::Cast(module_source)));
   // Modules are wrapped in (function(){...}) so they always return functions.
   v8::Handle<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);
@@ skipping 50 matching lines @@
   gin::ModuleRegistry* registry =
       gin::ModuleRegistry::From(context_->v8_context());
   DCHECK(registry);
   for (const auto& dependency : dependencies) {
     // If a dependency is not available, and either the module or this
     // dependency is managed by ModuleSystem, attempt to load it. Other
     // gin::ModuleRegistry users (WebUI and users of the mojoPrivate API) are
     // responsible for loading their module dependencies when required.
     if (registry->available_modules().count(dependency) == 0 &&
         (module_system_managed || source_map_->Contains(dependency))) {
-      LoadModule(dependency);
+      LoadModule(dependency, GetSource(dependency));
     }
   }
   registry->AttemptToLoadMoreModules(GetIsolate());
 }
 
 void ModuleSystem::OnModuleLoaded(
     scoped_ptr<v8::UniquePersistent<v8::Promise::Resolver> > resolver,
     v8::Handle<v8::Value> value) {
-  if (!is_valid())
+  if (!is_valid()) {
+    LOG(ERROR) << "!is_valid";
     return;
+  }
   v8::HandleScope handle_scope(GetIsolate());
   v8::Handle<v8::Promise::Resolver> resolver_local(
       v8::Local<v8::Promise::Resolver>::New(GetIsolate(), *resolver));
   resolver_local->Resolve(value);
 }
 
 }  // namespace extensions