Add support for using AMD modules from extensions modules.

extensions/renderer/module_system.h

 // 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.
 
 #ifndef EXTENSIONS_RENDERER_MODULE_SYSTEM_H_
 #define EXTENSIONS_RENDERER_MODULE_SYSTEM_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "extensions/renderer/native_handler.h"
 #include "extensions/renderer/object_backed_native_handler.h"
+#include "gin/modules/module_registry_observer.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 class ScriptContext;
 
 // A module system for JS similar to node.js' require() function.
 // Each module has three variables in the global scope:
 //   - exports, an object returned to dependencies who require() this
 //     module.
 //   - require, a function that takes a module name as an argument and returns
 //     that module's exports object.
 //   - requireNative, a function that takes the name of a registered
 //     NativeHandler and returns an object that contains the functions the
 //     NativeHandler defines.
 //
 // Each module in a ModuleSystem is executed at most once and its exports
 // object cached.
 //
 // Note that a ModuleSystem must be used only in conjunction with a single
 // v8::Context.
 // TODO(koz): Rename this to JavaScriptModuleSystem.
-class ModuleSystem : public ObjectBackedNativeHandler {
+class ModuleSystem : public ObjectBackedNativeHandler,
+                     public gin::ModuleRegistryObserver {
  public:
   class SourceMap {
    public:
     virtual ~SourceMap() {}
     virtual v8::Handle<v8::Value> GetSource(v8::Isolate* isolate,
                                             const std::string& name) = 0;
     virtual bool Contains(const std::string& name) = 0;
   };
 
   class ExceptionHandler {
@@ skipping 100 matching lines @@
                               const v8::PropertyCallbackInfo<v8::Value>& info);
   // Retrieves the lazily defined field specified by |property| on a native
   // object.
   static void NativeLazyFieldGetter(
       v8::Local<v8::String> property,
       const v8::PropertyCallbackInfo<v8::Value>& info);
 
   // Called when an exception is thrown but not caught.
   void HandleException(const v8::TryCatch& try_catch);
 
-  // Ensure that require_ has been evaluated from require.js.
-  void EnsureRequireLoaded();
-
   void RequireForJs(const v8::FunctionCallbackInfo<v8::Value>& args);
   v8::Local<v8::Value> RequireForJsInner(v8::Handle<v8::String> module_name);
 
   typedef v8::Handle<v8::Value>(ModuleSystem::*RequireFunction)(
       const std::string&);
   // Base implementation of a LazyFieldGetter which uses |require_fn| to require
   // modules.
   static void LazyFieldGetterInner(
       v8::Local<v8::String> property,
       const v8::PropertyCallbackInfo<v8::Value>& info,
       RequireFunction require_function);
 
   // Return the named source file stored in the source map.
   // |args[0]| - the name of a source file in source_map_.
   v8::Handle<v8::Value> GetSource(const std::string& module_name);
 
   // Return an object that contains the native methods defined by the named
   // NativeHandler.
   // |args[0]| - the name of a native handler object.
   v8::Handle<v8::Value> RequireNativeFromString(const std::string& native_name);
   void RequireNative(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  // Wraps |source| in a (function(require, requireNative, exports) {...}).
+  // Return a promise for a requested module.
+  // |args[0]| - the name of a module.
+  void RequireAsync(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  // Wraps |source| in a (function(define, require, requireNative, ...) {...}).
   v8::Handle<v8::String> WrapSource(v8::Handle<v8::String> source);
 
   // NativeHandler implementation which returns the private area of an Object.
   void Private(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  // NativeHandler implementation which returns a function wrapper for a
-  // provided function.
-  void CreateFunctionWrapper(const v8::FunctionCallbackInfo<v8::Value>& args);
+  // Loads and runs a Javascript module.
+  v8::Handle<v8::Value> LoadModule(const std::string& module_name);
+
+  // Invoked when a module is loaded in response to a requireAsync call.
+  // Resolves |resolver| with |value|.
+  void OnModuleLoaded(
+      scoped_ptr<v8::UniquePersistent<v8::Promise::Resolver> > resolver,
+      v8::Handle<v8::Value> value);
+
+  // gin::ModuleRegistryObserver overrides.
+  virtual void OnDidAddPendingModule(
+      const std::string& id,
+      const std::vector<std::string>& dependencies) OVERRIDE;
 
   ScriptContext* context_;
 
   // A map from module names to the JS source for that module. GetSource()
   // performs a lookup on this map.
   SourceMap* source_map_;
 
   // A map from native handler names to native handlers.
   NativeHandlerMap native_handler_map_;
 
   // When 0, natives are disabled, otherwise indicates how many callers have
   // pinned natives as enabled.
   int natives_enabled_;
 
   // Called when an exception is thrown but not caught in JS. Overridable by
   // tests.
   scoped_ptr<ExceptionHandler> exception_handler_;
 
   std::set<std::string> overridden_native_handlers_;
 
+  base::WeakPtrFactory<ModuleSystem> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(ModuleSystem);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_RENDERER_MODULE_SYSTEM_H_