Revert 125801 - Implement a module system for the extension bindings JS.

chrome/renderer/extensions/app_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/app_bindings.h"
 
 #include "base/command_line.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 35 matching lines @@
     return false;
   }
 
   return true;
 }
 
 const char* kMissingClientIdError = "Missing clientId parameter";
 const char* kInvalidClientIdError = "Invalid clientId";
 const char* kInvalidCallbackIdError = "Invalid callbackId";
 
+
+class AppBindingsHandler : public ChromeV8ExtensionHandler {
+ public:
+  AppBindingsHandler(ExtensionDispatcher* dispatcher, ChromeV8Context* context);
+
+  // ChromeV8ExtensionHandler
+  virtual v8::Handle<v8::Value> HandleNativeFunction(
+      const std::string& name,
+      const v8::Arguments& arguments) OVERRIDE;
+
+  // IPC::Channel::Listener
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+ private:
+  v8::Handle<v8::Value> GetIsInstalled(const v8::Arguments& args);
+  v8::Handle<v8::Value> Install(const v8::Arguments& args);
+  v8::Handle<v8::Value> GetDetails(const v8::Arguments& args);
+  v8::Handle<v8::Value> GetDetailsForFrame(const v8::Arguments& args);
+  v8::Handle<v8::Value> GetAppNotifyChannel(const v8::Arguments& args);
+
+  v8::Handle<v8::Value> GetDetailsForFrameImpl(WebKit::WebFrame* frame);
+
+  void OnGetAppNotifyChannelResponse(const std::string& channel_id,
+                                     const std::string& error,
+                                     int callback_id);
+
+  ExtensionDispatcher* dispatcher_;
+  DISALLOW_COPY_AND_ASSIGN(AppBindingsHandler);
+};
+
 }  // namespace
 
 
-AppBindings::AppBindings(ExtensionDispatcher* dispatcher,
-                         ChromeV8Context* context)
-    : ChromeV8Extension(dispatcher),
-      ChromeV8ExtensionHandler(context) {
-  RouteFunction("GetIsInstalled",
-      base::Bind(&AppBindings::GetIsInstalled, base::Unretained(this)));
-  RouteFunction("Install",
-      base::Bind(&AppBindings::Install, base::Unretained(this)));
-  RouteFunction("GetDetails",
-      base::Bind(&AppBindings::GetDetails, base::Unretained(this)));
-  RouteFunction("GetDetailsForFrame",
-      base::Bind(&AppBindings::GetDetailsForFrame, base::Unretained(this)));
-  RouteFunction("GetAppNotifyChannel",
-      base::Bind(&AppBindings::GetAppNotifyChannel, base::Unretained(this)));
+AppBindings::AppBindings(ExtensionDispatcher* dispatcher)
+    : ChromeV8Extension("extensions/app.js", IDR_APP_BINDINGS_JS,
+                        dispatcher) {
+}
+
+ChromeV8ExtensionHandler* AppBindings::CreateHandler(
+    ChromeV8Context* context) {
+  return new AppBindingsHandler(extension_dispatcher(), context);
 }
 
 
-v8::Handle<v8::Value> AppBindings::GetIsInstalled(
+
+AppBindingsHandler::AppBindingsHandler(ExtensionDispatcher* dispatcher,
+                                       ChromeV8Context* context)
+    : ChromeV8ExtensionHandler(context),
+      dispatcher_(dispatcher) {
+}
+
+v8::Handle<v8::Value> AppBindingsHandler::HandleNativeFunction(
+    const std::string& name, const v8::Arguments& args) {
+  // TODO(aa): Create a helper map of callback that can be used in either
+  // extensions or handlers.
+  if (name == "GetIsInstalled") {
+    return GetIsInstalled(args);
+  } else if (name == "Install") {
+    return Install(args);
+  } else if (name == "GetDetails") {
+    return GetDetails(args);
+  } else if (name == "GetDetailsForFrame") {
+    return GetDetailsForFrame(args);
+  } else if (name == "GetAppNotifyChannel") {
+    return GetAppNotifyChannel(args);
+  } else {
+    CHECK(false) << "Unknown native function: " << name;
+  }
+
+  return v8::Undefined();
+}
+
+v8::Handle<v8::Value> AppBindingsHandler::GetIsInstalled(
     const v8::Arguments& args) {
   // TODO(aa): Hm, maybe ExtensionBindingsContext should have GetExtension()
   // afterall?
   const ::Extension* extension =
-      extension_dispatcher_->extensions()->GetByID(context_->extension_id());
+      dispatcher_->extensions()->GetByID(context_->extension_id());
 
   // TODO(aa): Why only hosted app?
   // TODO(aa): GARRR - why is there IsExtensionActive and IsApplicationActive!?
   bool result = extension && extension->is_hosted_app() &&
-      extension_dispatcher_->IsApplicationActive(extension->id());
+      dispatcher_->IsApplicationActive(extension->id());
   return v8::Boolean::New(result);
 }
 
-v8::Handle<v8::Value> AppBindings::Install(const v8::Arguments& args) {
+v8::Handle<v8::Value> AppBindingsHandler::Install(const v8::Arguments& args) {
   content::RenderView* render_view = context_->GetRenderView();
   CHECK(render_view);
 
   string16 error;
   ExtensionHelper* helper = ExtensionHelper::Get(render_view);
   if (!helper->InstallWebApplicationUsingDefinitionFile(
           context_->web_frame(), &error)) {
     v8::ThrowException(v8::String::New(UTF16ToUTF8(error).c_str()));
   }
 
   return v8::Undefined();
 }
 
-v8::Handle<v8::Value> AppBindings::GetDetails(
+v8::Handle<v8::Value> AppBindingsHandler::GetDetails(
     const v8::Arguments& args) {
   CHECK(context_->web_frame());
   return GetDetailsForFrameImpl(context_->web_frame());
 }
 
-v8::Handle<v8::Value> AppBindings::GetDetailsForFrame(
+v8::Handle<v8::Value> AppBindingsHandler::GetDetailsForFrame(
     const v8::Arguments& args) {
   CHECK(context_->web_frame());
   if (!CheckAccessToAppDetails(context_->web_frame()))
     return v8::Undefined();
 
   if (args.Length() < 0)
     return v8::ThrowException(v8::String::New("Not enough arguments."));
 
   if (!args[0]->IsObject()) {
     return v8::ThrowException(
         v8::String::New("Argument 0 must be an object."));
   }
 
   v8::Local<v8::Context> context =
       v8::Local<v8::Object>::Cast(args[0])->CreationContext();
   CHECK(!context.IsEmpty());
 
   WebFrame* target_frame = WebFrame::frameForContext(context);
   if (!target_frame) {
     return v8::ThrowException(
         v8::String::New("Could not find frame for specified object."));
   }
 
   return GetDetailsForFrameImpl(target_frame);
 }
 
-v8::Handle<v8::Value> AppBindings::GetDetailsForFrameImpl(
+v8::Handle<v8::Value> AppBindingsHandler::GetDetailsForFrameImpl(
     WebFrame* frame) {
   const ::Extension* extension =
-      extension_dispatcher_->extensions()->GetExtensionOrAppByURL(
-          ExtensionURLInfo(frame->document().securityOrigin(),
-                           frame->document().url()));
+      dispatcher_->extensions()->GetExtensionOrAppByURL(ExtensionURLInfo(
+          frame->document().securityOrigin(),
+          frame->document().url()));
   if (!extension)
     return v8::Null();
 
   scoped_ptr<DictionaryValue> manifest_copy(
       extension->manifest()->value()->DeepCopy());
   manifest_copy->SetString("id", extension->id());
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   return converter->ToV8Value(manifest_copy.get(),
                               frame->mainWorldScriptContext());
 }
 
-v8::Handle<v8::Value> AppBindings::GetAppNotifyChannel(
+v8::Handle<v8::Value> AppBindingsHandler::GetAppNotifyChannel(
     const v8::Arguments& args) {
   // Read the required 'clientId' value out of the object at args[0].
   std::string client_id;
   if (args.Length() < 1 || !args[0]->IsObject()) {
     v8::ThrowException(v8::String::New(kMissingClientIdError));
     return v8::Undefined();
   }
   v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(args[0]);
   v8::Local<v8::String> client_id_key = v8::String::New("clientId");
   if (obj->Has(client_id_key)) {
@@ skipping 18 matching lines @@
 
   content::RenderView* render_view = context_->GetRenderView();
   CHECK(render_view);
 
   Send(new ExtensionHostMsg_GetAppNotifyChannel(
       render_view->GetRoutingID(), context_->web_frame()->document().url(),
       client_id, GetRoutingID(), callback_id));
   return v8::Undefined();
 }
 
-bool AppBindings::OnMessageReceived(const IPC::Message& message) {
-  IPC_BEGIN_MESSAGE_MAP(AppBindings, message)
+bool AppBindingsHandler::OnMessageReceived(const IPC::Message& message) {
+  IPC_BEGIN_MESSAGE_MAP(AppBindingsHandler, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_GetAppNotifyChannelResponse,
                         OnGetAppNotifyChannelResponse)
     IPC_MESSAGE_UNHANDLED(CHECK(false) << "Unhandled IPC message")
   IPC_END_MESSAGE_MAP()
   return true;
 }
 
-void AppBindings::OnGetAppNotifyChannelResponse(
+void AppBindingsHandler::OnGetAppNotifyChannelResponse(
     const std::string& channel_id, const std::string& error, int callback_id) {
   v8::HandleScope handle_scope;
   v8::Context::Scope context_scope(context_->v8_context());
   v8::Handle<v8::Value> argv[3];
   argv[0] = v8::String::New(channel_id.c_str());
   argv[1] = v8::String::New(error.c_str());
   argv[2] = v8::Integer::New(callback_id);
   CHECK(context_->CallChromeHiddenMethod("app.onGetAppNotifyChannelResponse",
                                          arraysize(argv), argv, NULL));
 }