Revert 125801 - 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(extension_dispatcher) {
-    RouteStaticFunction("GetExtensionAPIDefinition",
-                        &GetExtensionAPIDefinition);
-    RouteStaticFunction("GetNextRequestId", &GetNextRequestId);
-    RouteStaticFunction("StartRequest", &StartRequest);
-    RouteStaticFunction("SetIconCommon", &SetIconCommon);
+      : ChromeV8Extension("extensions/schema_generated_bindings.js",
+                          IDR_SCHEMA_GENERATED_BINDINGS_JS,
+                          arraysize(kExtensionDeps),
+                          kExtensionDeps,
+                          extension_dispatcher) {
   }
 
   ~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 {
 
-ChromeV8Extension* SchemaGeneratedBindings::Get(
+v8::Extension* SchemaGeneratedBindings::Get(
     ExtensionDispatcher* extension_dispatcher) {
-  return new ExtensionImpl(extension_dispatcher);
+  static v8::Extension* extension = new ExtensionImpl(extension_dispatcher);
+  CHECK_EQ(extension_dispatcher,
+           static_cast<ExtensionImpl*>(extension)->extension_dispatcher());
+  return extension;
 }
 
 // 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