Implement a module system for the extension bindings JS.

chrome/renderer/extensions/chrome_v8_extension.cc

Index: chrome/renderer/extensions/chrome_v8_extension.cc
diff --git a/chrome/renderer/extensions/chrome_v8_extension.cc b/chrome/renderer/extensions/chrome_v8_extension.cc
index 35b5153c45d024bbbeac10fc3736dbb19901502e..3274dc62b41d4d2dfb0bbebeb0a145fac58c7280 100644
--- a/chrome/renderer/extensions/chrome_v8_extension.cc
+++ b/chrome/renderer/extensions/chrome_v8_extension.cc
@@ -18,6 +18,10 @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "grit/renderer_resources.h"
+
+#include <iostream>

[Aaron Boodman, 2012/02/16 01:54:42]

These seem unneeded.

[koz (OOO until 15th September), 2012/02/27 01:06:14]

Done.

+using namespace std;
 
 using extensions::ExtensionAPI;
 using WebKit::WebDocument;
@@ -87,16 +91,6 @@ const ChromeV8Extension::InstanceSet& ChromeV8Extension::GetAll() {
 }
 
 void ChromeV8Extension::ContextWillBeReleased(ChromeV8Context* context) {
-  handlers_.erase(context);
-}
-
-ChromeV8ExtensionHandler* ChromeV8Extension::GetHandler(
-    ChromeV8Context* context) const {
-  HandlerMap::const_iterator iter = handlers_.find(context);
-  if (iter == handlers_.end())
-    return NULL;
-  else
-    return iter->second.get();
 }
 
 const Extension* ChromeV8Extension::GetExtensionForCurrentRenderView() const {
@@ -153,60 +147,29 @@ bool ChromeV8Extension::CheckCurrentContextAccessToExtensionAPI(
   return true;
 }
 
-v8::Handle<v8::FunctionTemplate>
-    ChromeV8Extension::GetNativeFunction(v8::Handle<v8::String> name) {
-  if (name->Equals(v8::String::New("GetChromeHidden"))) {
-    return v8::FunctionTemplate::New(GetChromeHidden);
-  }
-
-  if (name->Equals(v8::String::New("Print"))) {
-    return v8::FunctionTemplate::New(Print);
-  }
-
-  return v8::FunctionTemplate::New(HandleNativeFunction,
-                                   v8::External::New(this));
-}
-
-// static
 v8::Handle<v8::Value> ChromeV8Extension::HandleNativeFunction(
-    const v8::Arguments& arguments) {
-  ChromeV8Extension* self = GetFromArguments<ChromeV8Extension>(arguments);
-  ChromeV8Context* context =
-      self->extension_dispatcher()->v8_context_set().GetCurrent();
-  CHECK(context) << "Unknown V8 context. Maybe a native function is getting "
-                 << "called during parse of a v8 extension, before the context "
-                 << "has been registered.";
-
-  ChromeV8ExtensionHandler* handler = self->GetHandler(context);
-  if (!handler) {
-    handler = self->CreateHandler(context);
-    if (handler)
-      self->handlers_[context] = linked_ptr<ChromeV8ExtensionHandler>(handler);
-  }
-  CHECK(handler) << "No handler for v8 extension: " << self->name();
-
-  std::string name = *v8::String::AsciiValue(arguments.Callee()->GetName());
-  return handler->HandleNativeFunction(name, arguments);
+    const std::string& function_name, const v8::Arguments& args) {
+  CHECK(false) << "Failed to handle native call to " << function_name;
+  return v8::Undefined();
 }
 
-ChromeV8ExtensionHandler* ChromeV8Extension::CreateHandler(
-    ChromeV8Context* context) {
-  return NULL;
+// static
+v8::Handle<v8::Value> ChromeV8Extension::Router(const v8::Arguments& args) {
+  std::string callee_name = *v8::String::AsciiValue(args.Callee()->GetName());
+  ChromeV8Extension* extension = static_cast<ChromeV8Extension*>(
+      args.Data().As<v8::External>()->Value());
+  return extension->HandleNativeFunction(callee_name, args);
 }
 
-v8::Handle<v8::Value> ChromeV8Extension::GetChromeHidden(
-    const v8::Arguments& args) {
-  return ChromeV8Context::GetOrCreateChromeHidden(v8::Context::GetCurrent());
+void ChromeV8Extension::RouteFunctionHere(const char* name,
+    v8::Handle<v8::Object> object) {
+  RouteFunctionToStatic(name, Router, object);
 }
 
-v8::Handle<v8::Value> ChromeV8Extension::Print(const v8::Arguments& args) {
-  if (args.Length() < 1)
-    return v8::Undefined();
-
-  std::vector<std::string> components;
-  for (int i = 0; i < args.Length(); ++i)
-    components.push_back(*v8::String::Utf8Value(args[i]->ToString()));
-
-  LOG(ERROR) << JoinString(components, ',');
-  return v8::Undefined();
+void ChromeV8Extension::RouteFunctionToStatic(const char* name,
+    HandlerFunction function, v8::Handle<v8::Object> object) {
+  v8::Handle<v8::Function> v8_function = v8::FunctionTemplate::New(
+      function, v8::External::New(this))->GetFunction();
+  v8_function->SetName(v8::String::New(name));
+  object->Set(v8::String::NewSymbol(name), v8_function);
 }