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 76 matching lines @@
   ~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);
+  void SetNativeFunctions(v8::Handle<v8::Object> object) {
+    RouteFunctionToStatic("GetExtensionAPIDefinition",
+        GetExtensionAPIDefinition, object);
+    RouteFunctionToStatic("GetNextRequestId", GetNextRequestId, object);
+    RouteFunctionToStatic("StartRequest", StartRequest, object);
+    RouteFunctionToStatic("SetIconCommon", SetIconCommon, object);
   }
 
  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;
@@ skipping 212 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