Add API: getBackgroundPageView and getToolstripViews

chrome/renderer/extensions/extension_process_bindings.cc

 // Copyright (c) 2009 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/extension_process_bindings.h"
 
 #include "base/singleton.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
+#include "chrome/renderer/extension_groups.h"
 #include "chrome/renderer/extensions/bindings_utils.h"
 #include "chrome/renderer/extensions/event_bindings.h"
 #include "chrome/renderer/extensions/js_only_v8_extensions.h"
 #include "chrome/renderer/extensions/renderer_extension_bindings.h"
 #include "chrome/renderer/render_view.h"
 #include "grit/common_resources.h"
 #include "grit/renderer_resources.h"
 #include "webkit/api/public/WebFrame.h"
+#include "webkit/api/public/WebScriptSource.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebKit.h"
 
 using bindings_utils::GetStringResource;
 using bindings_utils::ContextInfo;
 using bindings_utils::ContextList;
 using bindings_utils::GetContexts;
 using bindings_utils::GetPendingRequestMap;
 using bindings_utils::PendingRequest;
 using bindings_utils::PendingRequestMap;
 using bindings_utils::ExtensionBase;
+using WebKit::WebScriptSource;
+using WebKit::WebString;
 
 namespace {
 
 // A map of extension ID to vector of page action ids.
 typedef std::map< std::string, std::vector<std::string> > PageActionIdMap;
 
 // A map of permission name to whether its enabled for this extension.
 typedef std::map<std::string, bool> PermissionsMap;
 
 // A map of extension ID to permissions map.
@@ skipping 57 matching lines @@
     } else if (name->Equals(v8::String::New("GetExtensionViews"))) {
       return v8::FunctionTemplate::New(GetExtensionViews);
     } else if (name->Equals(v8::String::New("GetNextRequestId"))) {
       return v8::FunctionTemplate::New(GetNextRequestId);
     } else if (name->Equals(v8::String::New("OpenChannelToTab"))) {
       return v8::FunctionTemplate::New(OpenChannelToTab);
     } else if (name->Equals(v8::String::New("GetCurrentPageActions"))) {
       return v8::FunctionTemplate::New(GetCurrentPageActions);
     } else if (name->Equals(v8::String::New("StartRequest"))) {
       return v8::FunctionTemplate::New(StartRequest);
+    } else if (name->Equals(v8::String::New("ExecuteScript"))) {
+      return v8::FunctionTemplate::New(ExecuteScript);
+    } else if (name->Equals(v8::String::New("ExecuteScriptWithUrl"))) {
+      return v8::FunctionTemplate::New(ExecuteScriptWithUrl);
     }
 
     return ExtensionBase::GetNativeFunction(name);
   }
 
  private:
+  static v8::Handle<v8::Value> ExecuteScript(const v8::Arguments& args) {
+    if (args.Length() != 1 || !args[0]->IsString())
+      return v8::Boolean::New(false);
+
+    std::string script_source = *v8::String::Utf8Value(args[0]->ToString());
+    WebScriptSource web_script = WebScriptSource(
+        WebString::fromUTF8(script_source));
+    RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
+    if (!renderview)
+      return v8::Boolean::New(false);
+
+    renderview->webview()->GetMainFrame()->executeScriptInNewWorld(
+        &web_script, 1, EXTENSION_GROUP_CONTENT_SCRIPTS);
+    return v8::Boolean::New(true);
+  }
+
+  static v8::Handle<v8::Value> ExecuteScriptWithUrl(const v8::Arguments& args) {
+    if (args.Length() != 2)
+      return v8::Undefined();
+
+    if (!args[0]->IsInt32() || !args[1]->IsString())
+      return v8::Undefined();
+
+    int request_id = args[0]->Int32Value();
+    std::string script_url = *v8::String::Utf8Value(args[1]->ToString());
+    SendExtensionRequest("extension.executeScriptWithUrl", script_url,
+                         request_id, true);
+    return v8::Boolean::New(true);
+  }
+
   static v8::Handle<v8::Value> GetExtensionAPIDefinition(
       const v8::Arguments& args) {
     return v8::String::New(GetStringResource<IDR_EXTENSION_API_JSON>());
   }
 
   static v8::Handle<v8::Value> GetExtensionViews(const v8::Arguments& args) {
     if (args.Length() != 2)
       return v8::Undefined();
 
     if (!args[0]->IsInt32() || !args[1]->IsString())
@@ skipping 102 matching lines @@
       page_action_vector->Set(v8::Integer::New(i),
                               v8::String::New(page_action_id.c_str()));
     }
 
     return page_action_vector;
   }
 
   // Starts an API request to the browser, with an optional callback.  The
   // callback will be dispatched to EventBindings::HandleResponse.
   static v8::Handle<v8::Value> StartRequest(const v8::Arguments& args) {
-    // Get the current RenderView so that we can send a routed IPC message from
-    // the correct source.
-    RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
-    if (!renderview)
-      return v8::Undefined();
-
     if (args.Length() != 4 || !args[0]->IsString() || !args[1]->IsString() ||
         !args[2]->IsInt32() || !args[3]->IsBoolean())
       return v8::Undefined();
 
     std::string name = *v8::String::AsciiValue(args[0]);
     if (GetFunctionNameSet()->find(name) == GetFunctionNameSet()->end()) {
       NOTREACHED() << "Unexpected function " << name;
       return v8::Undefined();
     }
 
     if (!ExtensionProcessBindings::CurrentContextHasPermission(name)) {
 #if EXTENSION_TIME_TO_BREAK_API
       return ExtensionProcessBindings::ThrowPermissionDeniedException(name);
 #else
       ExtensionProcessBindings::ThrowPermissionDeniedException(name);
 #endif
     }
 
     std::string json_args = *v8::String::Utf8Value(args[1]);
     int request_id = args[2]->Int32Value();
     bool has_callback = args[3]->BooleanValue();
+    SendExtensionRequest(name, json_args, request_id, has_callback);
 
+    return v8::Undefined();
+  }
+
+  static bool SendExtensionRequest(std::string name,
+                                   std::string json_args,
+                                   int request_id,
+                                   bool has_callback) {
+    // Get the current RenderView so that we can send a routed IPC message from
+    // the correct source.
+    RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
+    if (!renderview)
+      return false;
     v8::Persistent<v8::Context> current_context =
         v8::Persistent<v8::Context>::New(v8::Context::GetCurrent());
     DCHECK(!current_context.IsEmpty());
     GetPendingRequestMap()[request_id].reset(new PendingRequest(
         current_context, name));
 
     renderview->SendExtensionRequest(name, json_args, request_id, has_callback);
-
-    return v8::Undefined();
+    return true;
   }
 };
 
 }  // namespace
 
 v8::Extension* ExtensionProcessBindings::Get() {
   static v8::Extension* extension = new ExtensionImpl();
   return extension;
 }
 
@@ skipping 122 matching lines @@
 
   v8::Local<v8::Function> function =
       v8::Local<v8::Function>::Cast(console_error);
   v8::Local<v8::Value> argv[] = { v8::String::New(error_msg.c_str()) };
   if (!function.IsEmpty())
     function->Call(console->ToObject(), arraysize(argv), argv);
 
   return v8::Undefined();
 #endif
 }