Implement a module system for the extension bindings JS.

chrome/renderer/extensions/miscellaneous_bindings.cc

 // Copyright (c) 2011 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/miscellaneous_bindings.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 56 matching lines @@
 class ExtensionImpl : public ChromeV8Extension {
  public:
   explicit ExtensionImpl(ExtensionDispatcher* dispatcher)
       : ChromeV8Extension("extensions/miscellaneous_bindings.js",
                           IDR_MISCELLANEOUS_BINDINGS_JS,
                           arraysize(kExtensionDeps), kExtensionDeps,
                           dispatcher) {
   }
   ~ExtensionImpl() {}
 
-  virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
-      v8::Handle<v8::String> name) {
-    if (name->Equals(v8::String::New("OpenChannelToExtension"))) {
-      return v8::FunctionTemplate::New(OpenChannelToExtension);
-    } else if (name->Equals(v8::String::New("PostMessage"))) {
-      return v8::FunctionTemplate::New(PostMessage);
-    } else if (name->Equals(v8::String::New("CloseChannel"))) {
-      return v8::FunctionTemplate::New(CloseChannel);
-    } else if (name->Equals(v8::String::New("PortAddRef"))) {
-      return v8::FunctionTemplate::New(PortAddRef);
-    } else if (name->Equals(v8::String::New("PortRelease"))) {
-      return v8::FunctionTemplate::New(PortRelease);
-    } else if (name->Equals(v8::String::New("GetL10nMessage"))) {
-      return v8::FunctionTemplate::New(GetL10nMessage);
-    }
-    return ChromeV8Extension::GetNativeFunction(name);
+  void SetNativeFunctions(v8::Handle<v8::Object> object) {
+    RouteFunctionToStatic("OpenChannelToExtension", OpenChannelToExtension,
+        object);
+    RouteFunctionToStatic("PostMessage", PostMessage, object);
+    RouteFunctionToStatic("CloseChannel", CloseChannel, object);
+    RouteFunctionToStatic("PortAddRef", PortAddRef, object);
+    RouteFunctionToStatic("PortRelease", PortRelease, object);
+    RouteFunctionToStatic("GetL10nMessage", GetL10nMessage, object);
   }
 
   // Creates a new messaging channel to the given extension.
   static v8::Handle<v8::Value> OpenChannelToExtension(
       const v8::Arguments& args) {
     // Get the current RenderView so that we can send a routed IPC message from
     // the correct source.
     content::RenderView* renderview = GetCurrentRenderView();
     if (!renderview)
       return v8::Undefined();
@@ skipping 142 matching lines @@
 
     return v8::String::New(ReplaceStringPlaceholders(
         message, substitutions, NULL).c_str());
   }
 };
 
 }  // namespace
 
 namespace extensions {
 
-v8::Extension* MiscellaneousBindings::Get(ExtensionDispatcher* dispatcher) {
-  static v8::Extension* extension = new ExtensionImpl(dispatcher);
-  return extension;
+ChromeV8Extension* MiscellaneousBindings::Get(ExtensionDispatcher* dispatcher) {
+  return new ExtensionImpl(dispatcher);
 }
 
 void MiscellaneousBindings::DeliverMessage(
     const ChromeV8ContextSet::ContextSet& contexts,
     int target_port_id,
     const std::string& message,
     content::RenderView* restrict_to_render_view) {
   v8::HandleScope handle_scope;
 
   for (ChromeV8ContextSet::ContextSet::const_iterator it = contexts.begin();
@@ skipping 21 matching lines @@
     arguments.push_back(v8::String::New(message.c_str(), message.size()));
     arguments.push_back(port_id_handle);
     CHECK((*it)->CallChromeHiddenMethod("Port.dispatchOnMessage",
                                         arguments.size(),
                                         &arguments[0],
                                         NULL));
   }
 }
 
 }  // namespace extension