Implement a module system for the extension bindings JS.

chrome/renderer/extensions/schema_generated_bindings.cc

 // Copyright (c) 2012 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 "chrome/renderer/extensions/schema_generated_bindings.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 33 matching lines @@
 #include "v8/include/v8.h"
 #include "webkit/glue/webkit_glue.h"
 
 using content::V8ValueConverter;
 using extensions::ExtensionAPI;
 using WebKit::WebFrame;
 using WebKit::WebSecurityOrigin;
 
 namespace {
 
-const char* kExtensionDeps[] = {
-  "extensions/event.js",
-  "extensions/json_schema.js",
-  "extensions/miscellaneous_bindings.js",
-  "extensions/apitest.js"
-};
-
 // Contains info relevant to a pending API request.
 struct PendingRequest {
  public :
   PendingRequest(v8::Persistent<v8::Context> context, const std::string& name,
                  const std::string& extension_id)
       : context(context), name(name), extension_id(extension_id) {
   }
   v8::Persistent<v8::Context> context;
   std::string name;
   std::string extension_id;
 };
 typedef std::map<int, linked_ptr<PendingRequest> > PendingRequestMap;
 
 base::LazyInstance<PendingRequestMap> g_pending_requests =
     LAZY_INSTANCE_INITIALIZER;
 
 class ExtensionImpl : public ChromeV8Extension {
  public:
   explicit ExtensionImpl(ExtensionDispatcher* extension_dispatcher)
-      : ChromeV8Extension("extensions/schema_generated_bindings.js",
-                          IDR_SCHEMA_GENERATED_BINDINGS_JS,
-                          arraysize(kExtensionDeps),
-                          kExtensionDeps,
-                          extension_dispatcher) {
+      : ChromeV8Extension(extension_dispatcher) {
+    RouteStaticFunction("GetExtensionAPIDefinition",
+                        &GetExtensionAPIDefinition);
+    RouteStaticFunction("GetNextRequestId", &GetNextRequestId);
+    RouteStaticFunction("StartRequest", &StartRequest);
+    RouteStaticFunction("SetIconCommon", &SetIconCommon);
   }
 
   ~ExtensionImpl() {
     // TODO(aa): It seems that v8 never deletes us, so this doesn't get called.
     // Leaving this in here in case v8's implementation ever changes.
     for (CachedSchemaMap::iterator it = schemas_.begin(); it != schemas_.end();
         ++it) {
       if (!it->second.IsEmpty())
         it->second.Dispose();
     }
   }
 
-  virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
-      v8::Handle<v8::String> name) OVERRIDE {
-    if (name->Equals(v8::String::New("GetExtensionAPIDefinition"))) {
-      return v8::FunctionTemplate::New(GetExtensionAPIDefinition,
-                                       v8::External::New(this));
-    } else if (name->Equals(v8::String::New("GetNextRequestId"))) {
-      return v8::FunctionTemplate::New(GetNextRequestId);
-    } else if (name->Equals(v8::String::New("StartRequest"))) {
-      return v8::FunctionTemplate::New(StartRequest,
-                                       v8::External::New(this));
-    } else if (name->Equals(v8::String::New("SetIconCommon"))) {
-      return v8::FunctionTemplate::New(SetIconCommon,
-                                       v8::External::New(this));
-    }
-
-    return ChromeV8Extension::GetNativeFunction(name);
-  }
-
  private:
   static v8::Handle<v8::Value> GetV8SchemaForAPI(
       ExtensionImpl* self,
       v8::Handle<v8::Context> context,
       const std::string& api_name) {
     CachedSchemaMap::iterator maybe_api = self->schemas_.find(api_name);
     if (maybe_api != self->schemas_.end())
       return maybe_api->second;
 
     scoped_ptr<V8ValueConverter> v8_value_converter(V8ValueConverter::create());
@@ skipping 215 matching lines @@
   // We store this so that we don't have to parse it over and over again for
   // every context that uses it.
   typedef std::map<std::string, v8::Persistent<v8::Object> > CachedSchemaMap;
   CachedSchemaMap schemas_;
 };
 
 }  // namespace
 
 namespace extensions {
 
-v8::Extension* SchemaGeneratedBindings::Get(
+ChromeV8Extension* SchemaGeneratedBindings::Get(
     ExtensionDispatcher* extension_dispatcher) {
-  static v8::Extension* extension = new ExtensionImpl(extension_dispatcher);
-  CHECK_EQ(extension_dispatcher,
-           static_cast<ExtensionImpl*>(extension)->extension_dispatcher());
-  return extension;
+  return new ExtensionImpl(extension_dispatcher);
 }
 
 // static
 void SchemaGeneratedBindings::HandleResponse(const ChromeV8ContextSet& contexts,
                                              int request_id,
                                              bool success,
                                              const std::string& response,
                                              const std::string& error,
                                              std::string* extension_id) {
   PendingRequestMap::iterator request =
@@ skipping 45 matching lines @@
     const std::string& extension_id) {
   for (PendingRequestMap::const_iterator it = g_pending_requests.Get().begin();
        it != g_pending_requests.Get().end(); ++it) {
     if (it->second->extension_id == extension_id)
       return true;
   }
   return false;
 }
 
 }  // namespace