Add support for using AMD modules from extensions modules.

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"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/renderer/console.h"
 #include "extensions/renderer/safe_builtins.h"
 #include "extensions/renderer/script_context.h"
+#include "gin/modules/module_registry.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
 
 namespace extensions {
 
 namespace {
 
 const char* kModuleSystem = "module_system";
 const char* kModuleName = "module_name";
 const char* kModuleField = "module_field";
@@ skipping 85 matching lines @@
                             resource_name.c_str(),
                             message->GetLineNumber(),
                             error_message.c_str());
 }
 
 ModuleSystem::ModuleSystem(ScriptContext* context, SourceMap* source_map)
     : ObjectBackedNativeHandler(context),
       context_(context),
       source_map_(source_map),
       natives_enabled_(0),
-      exception_handler_(new DefaultExceptionHandler(context)) {
+      exception_handler_(new DefaultExceptionHandler(context)),
+      weak_factory_(this) {
   RouteFunction(
       "require",
       base::Bind(&ModuleSystem::RequireForJs, base::Unretained(this)));
   RouteFunction(
       "requireNative",
       base::Bind(&ModuleSystem::RequireNative, base::Unretained(this)));
+  RouteFunction(
+      "requireAsync",
+      base::Bind(&ModuleSystem::RequireAsync, base::Unretained(this)));
   RouteFunction("privates",
                 base::Bind(&ModuleSystem::Private, base::Unretained(this)));
 
   v8::Handle<v8::Object> global(context->v8_context()->Global());
   v8::Isolate* isolate = context->isolate();
   global->SetHiddenValue(v8::String::NewFromUtf8(isolate, kModulesField),
                          v8::Object::New(isolate));
   global->SetHiddenValue(v8::String::NewFromUtf8(isolate, kModuleSystem),
                          v8::External::New(isolate, this));
+
+  gin::ModuleRegistry::From(context->v8_context())->AddObserver(this);
 }
 
 ModuleSystem::~ModuleSystem() { Invalidate(); }
 
 void ModuleSystem::Invalidate() {
   if (!is_valid())
     return;
 
   // Clear the module system properties from the global context. It's polite,
   // and we use this as a signal in lazy handlers that we no longer exist.
@@ skipping 86 matching lines @@
   v8::Handle<v8::Object> natives(NewInstance());
   CHECK(!natives.IsEmpty());  // this can happen if v8 has issues
 
   // These must match the argument order in WrapSource.
   v8::Handle<v8::Value> args[] = {
       // CommonJS.
       natives->Get(v8::String::NewFromUtf8(
           GetIsolate(), "require", v8::String::kInternalizedString)),
       natives->Get(v8::String::NewFromUtf8(
           GetIsolate(), "requireNative", v8::String::kInternalizedString)),
+      natives->Get(v8::String::NewFromUtf8(
+          GetIsolate(), "requireAsync", v8::String::kInternalizedString)),
       exports,
       // Libraries that we magically expose to every module.
       console::AsV8Object(),
       natives->Get(v8::String::NewFromUtf8(
           GetIsolate(), "privates", v8::String::kInternalizedString)),
       // Each safe builtin. Keep in order with the arguments in WrapSource.
       context_->safe_builtins()->GetArray(),
       context_->safe_builtins()->GetFunction(),
       context_->safe_builtins()->GetJSON(),
       context_->safe_builtins()->GetObjekt(),
       context_->safe_builtins()->GetRegExp(),
-      context_->safe_builtins()->GetString(), };
+      context_->safe_builtins()->GetString(),

[not at google - send to devlin, 2014/07/01 18:13:05]

btw this was git cl format being a pain, which is presumably unaware of
object-like syntax. it will probably do it again.

[Sam McNally, 2014/07/02 03:26:35]

I think clang format prefers this formatting now.

+  };
   {
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
     context_->CallFunction(func, arraysize(args), args);
     if (try_catch.HasCaught()) {
       HandleException(try_catch);
       return v8::Undefined(GetIsolate());
     }
   }
   modules->Set(module_name, exports);
@@ skipping 283 matching lines @@
 
   NativeHandlerMap::iterator i = native_handler_map_.find(native_name);
   if (i == native_handler_map_.end()) {
     Fatal(context_,
           "Couldn't find native for requireNative(" + native_name + ")");
     return v8::Undefined(GetIsolate());
   }
   return i->second->NewInstance();
 }
 
+void ModuleSystem::RequireAsync(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  CHECK_EQ(1, args.Length());
+  std::string module_name = *v8::String::Utf8Value(args[0]->ToString());
+  v8::Handle<v8::Promise::Resolver> resolver(
+      v8::Promise::Resolver::New(GetIsolate()));
+  v8::Handle<v8::Promise> promise(resolver->GetPromise());
+  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());
+  module_registry->LoadModule(GetIsolate(),
+                              module_name,
+                              base::Bind(&ModuleSystem::OnModuleLoaded,
+                                         weak_factory_.GetWeakPtr(),
+                                         base::Passed(&persistent_resolver)));
+  args.GetReturnValue().Set(promise);
+  if (module_registry->available_modules().count(module_name) == 0)
+    LoadAmdModule(module_name);
+}
+
 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(require, requireNative, exports, "
+      "(function(require, requireNative, requireAsync, exports, "
       "console, privates,"
       "$Array, $Function, $JSON, $Object, $RegExp, $String) {"
       "'use strict';");
   v8::Handle<v8::String> right = v8::String::NewFromUtf8(GetIsolate(), "\n})");
   return handle_scope.Escape(v8::Local<v8::String>(
       v8::String::Concat(left, v8::String::Concat(source, right))));
 }
 
+v8::Handle<v8::String> ModuleSystem::WrapAmdSource(
+    v8::Handle<v8::String> source) {
+  v8::EscapableHandleScope handle_scope(GetIsolate());
+  // Keep in order with the arguments in LoadAmdModule.
+  v8::Handle<v8::String> left =
+      v8::String::NewFromUtf8(GetIsolate(), "(function(define) {");
+  v8::Handle<v8::String> right = v8::String::NewFromUtf8(GetIsolate(), "\n})");
+  return handle_scope.Escape(v8::Local<v8::String>(
+      v8::String::Concat(left, v8::String::Concat(source, right))));
+}
+
 void ModuleSystem::Private(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsObject());
   v8::Local<v8::Object> obj = args[0].As<v8::Object>();
   v8::Local<v8::String> privates_key =
       v8::String::NewFromUtf8(GetIsolate(), "privates");
   v8::Local<v8::Value> privates = obj->GetHiddenValue(privates_key);
   if (privates.IsEmpty()) {
     privates = v8::Object::New(args.GetIsolate());
     obj->SetHiddenValue(privates_key, privates);
   }
   args.GetReturnValue().Set(privates);
 }
 
+void ModuleSystem::LoadAmdModule(const std::string& module_name) {
+  v8::HandleScope 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 requireAsync(" + module_name + ")");
+    return;
+  }
+  v8::Handle<v8::String> wrapped_source(
+      WrapAmdSource(v8::Handle<v8::String>::Cast(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 requireAsync(" + module_name + ")");
+    return;
+  }

[not at google - send to devlin, 2014/07/01 18:13:05]

surely there is some code we can share with the sync require code around here

[Sam McNally, 2014/07/02 03:26:35]

Done.

+
+  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(func_as_value);
+
+  v8::Handle<v8::Object> define_object = v8::Object::New(GetIsolate());
+  gin::ModuleRegistry::InstallGlobals(GetIsolate(), define_object);
+
+  // These must match the argument order in WrapAmdSource.
+  v8::Handle<v8::Value> args[] = {
+      define_object->Get(v8::String::NewFromUtf8(GetIsolate(), "define")),
+  };
+  {
+    v8::TryCatch try_catch;
+    try_catch.SetCaptureMessage(true);
+    context_->CallFunction(func, arraysize(args), args);
+    if (try_catch.HasCaught()) {
+      HandleException(try_catch);
+      return;
+    }
+  }
+}
+
+void ModuleSystem::OnDidAddPendingModule(
+    const std::string& id,
+    const std::vector<std::string>& dependencies) {
+  if (!source_map_->Contains(id))
+    return;
+
+  gin::ModuleRegistry* registry =
+      gin::ModuleRegistry::From(context_->v8_context());
+  for (std::vector<std::string>::const_iterator it = dependencies.begin();
+       it != dependencies.end();
+       ++it) {
+    if (registry->available_modules().count(*it) == 0)
+      LoadAmdModule(*it);
+  }
+  registry->AttemptToLoadMoreModules(GetIsolate());
+}
+
+void ModuleSystem::OnModuleLoaded(
+    scoped_ptr<v8::UniquePersistent<v8::Promise::Resolver> > resolver,
+    v8::Handle<v8::Value> value) {
+  v8::HandleScope handle_scope(GetIsolate());
+  v8::Handle<v8::Promise::Resolver> resolver_local(
+      v8::Local<v8::Promise::Resolver>::New(GetIsolate(), *resolver));

[not at google - send to devlin, 2014/07/01 18:13:05]

you should also check is_valid(). the C++ lifetime != v8 lifetime.

[Sam McNally, 2014/07/02 03:26:35]

Done.

+  resolver_local->Resolve(value);
+}
+
 }  // namespace extensions