Extract executeScript-like functionality into a single ExtensionScriptExecutor class.

chrome/browser/extensions/extension_tabs_module.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/browser/extensions/extension_tabs_module.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
 #include "chrome/browser/extensions/extension_window_controller.h"
 #include "chrome/browser/extensions/extension_window_list.h"
+#include "chrome/browser/extensions/script_executor.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
@@ skipping 41 matching lines @@
 namespace GetLastFocused = extensions::api::windows::GetLastFocused;
 namespace errors = extension_manifest_errors;
 namespace keys = extension_tabs_module_constants;
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderViewHost;
 using content::WebContents;
+using extensions::ScriptExecutor;
 
 const int CaptureVisibleTabFunction::kDefaultQuality = 90;
 
 namespace {
 
 // |error_message| can optionally be passed in a will be set with an appropriate
 // message if the window cannot be found by id.
 Browser* GetBrowserInProfileWithId(Profile* profile,
                                    const int window_id,
                                    bool include_incognito,
@@ skipping 1070 matching lines @@
     return false;
   }
 
   selection.set_active(active_index);
   browser->tab_strip_model()->SetSelectionFromModel(selection);
   result_.reset(
       browser->extension_window_controller()->CreateWindowValueWithTabs());
   return true;
 }
 
-UpdateTabFunction::UpdateTabFunction() : web_contents_(NULL) {
+UpdateTabFunction::UpdateTabFunction() : tab_contents_(NULL) {
 }
 
 bool UpdateTabFunction::RunImpl() {
   DictionaryValue* update_props = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   Value* tab_value = NULL;
   if (HasOptionalArgument(0)) {
     EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
   }
@@ skipping 16 matching lines @@
     EXTENSION_FUNCTION_VALIDATE(tab_value->GetAsInteger(&tab_id));
   }
 
   int tab_index = -1;
   TabStripModel* tab_strip = NULL;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_)) {
     return false;
   }
 
-  web_contents_ = contents->web_contents();
+  tab_contents_ = contents;
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
   // -favIconUrl
 
   // Navigate the tab to a new location if the url is different.
   bool is_async = false;
   if (!UpdateURLIfPresent(update_props, &is_async))
     return false;
 
   bool active = false;
   // TODO(rafaelw): Setting |active| from js doesn't make much sense.
   // Move tab selection management up to window.
   if (update_props->HasKey(keys::kSelectedKey))
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kSelectedKey, &active));
 
   // The 'active' property has replaced 'selected'.
   if (update_props->HasKey(keys::kActiveKey))
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kActiveKey, &active));
 
   if (active) {
     if (tab_strip->active_index() != tab_index) {
       tab_strip->ActivateTabAt(tab_index, false);
       DCHECK_EQ(contents, tab_strip->GetActiveTabContents());
     }
-    web_contents_->Focus();
+    tab_contents_->web_contents()->Focus();
   }
 
   if (update_props->HasKey(keys::kHighlightedKey)) {
     bool highlighted = false;
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kHighlightedKey, &highlighted));
     if (highlighted != tab_strip->IsTabSelected(tab_index))
       tab_strip->ToggleSelectionAt(tab_index);
   }
 
@@ skipping 49 matching lines @@
   // Don't let the extension crash the browser or renderers.
   if (ExtensionTabUtil::IsCrashURL(url)) {
     error_ = keys::kNoCrashBrowserError;
     return false;
   }
 
   // JavaScript URLs can do the same kinds of things as cross-origin XHR, so
   // we need to check host permissions before allowing them.
   if (url.SchemeIs(chrome::kJavaScriptScheme)) {
     if (!GetExtension()->CanExecuteScriptOnPage(
-            web_contents_->GetURL(), NULL, &error_)) {
+            tab_contents_->web_contents()->GetURL(), NULL, &error_)) {
       return false;
     }
 
-    ExtensionMsg_ExecuteCode_Params params;
-    params.request_id = request_id();
-    params.extension_id = extension_id();
-    params.is_javascript = true;
-    params.code = url.path();
-    params.run_at = UserScript::DOCUMENT_IDLE;
-    params.all_frames = false;
-    params.in_main_world = true;
-
-    RenderViewHost* render_view_host = web_contents_->GetRenderViewHost();
-    render_view_host->Send(
-        new ExtensionMsg_ExecuteCode(render_view_host->GetRoutingID(), params));
-
-    Observe(web_contents_);
-    AddRef();  // Balanced in OnExecuteCodeFinished().
+    tab_contents_->extension_script_executor()->ExecuteScript(
+        extension_id(),
+        ScriptExecutor::JAVASCRIPT,
+        url.path(),
+        ScriptExecutor::TOP_FRAME,
+        UserScript::DOCUMENT_IDLE,
+        ScriptExecutor::MAIN_WORLD,
+        base::Bind(&UpdateTabFunction::OnExecuteCodeFinished, this));
 
     *is_async = true;
     return true;
   }
 
-  web_contents_->GetController().LoadURL(
+  tab_contents_->web_contents()->GetController().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_LINK, std::string());
 
   // The URL of a tab contents never actually changes to a JavaScript URL, so
   // this check only makes sense in other cases.
   if (!url.SchemeIs(chrome::kJavaScriptScheme))
-    DCHECK_EQ(url.spec(), web_contents_->GetURL().spec());
+    DCHECK_EQ(url.spec(), tab_contents_->web_contents()->GetURL().spec());
 
   return true;
 }
 
 void UpdateTabFunction::PopulateResult() {
   if (!has_callback())
     return;
 
-  if (GetExtension()->HasAPIPermission(ExtensionAPIPermission::kTab) &&
-      web_contents_ != NULL) {
-    result_.reset(ExtensionTabUtil::CreateTabValue(web_contents_));
+  if (GetExtension()->HasAPIPermission(ExtensionAPIPermission::kTab)) {
+    result_.reset(
+        ExtensionTabUtil::CreateTabValue(tab_contents_->web_contents()));
   } else {
     result_.reset(Value::CreateNullValue());
   }
 }
 
-void UpdateTabFunction::WebContentsDestroyed(WebContents* tab) {
-  CHECK_EQ(tab, web_contents_);
-  web_contents_ = NULL;
-}
-
-bool UpdateTabFunction::OnMessageReceived(const IPC::Message& message) {
-  if (message.type() != ExtensionHostMsg_ExecuteCodeFinished::ID)
-    return false;
-
-  int message_request_id = -1;
-  PickleIterator iter(message);
-  if (!message.ReadInt(&iter, &message_request_id)) {
-    NOTREACHED() << "malformed extension message";
-    return true;
-  }
-
-  if (message_request_id != request_id())
-    return false;
-
-  IPC_BEGIN_MESSAGE_MAP(UpdateTabFunction, message)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_ExecuteCodeFinished,
-                        OnExecuteCodeFinished)
-  IPC_END_MESSAGE_MAP()
-  return true;
-}
-
-void UpdateTabFunction::OnExecuteCodeFinished(int request_id,
-                                              bool success,
+void UpdateTabFunction::OnExecuteCodeFinished(bool success,
                                               const std::string& error) {
   if (!error.empty()) {
     CHECK(!success);
     error_ = error;
   }
 
   if (success)
     PopulateResult();
   SendResponse(success);
-
-  Observe(NULL);
-  Release();  // Balanced in UpdateURLIfPresent().
 }
 
 bool MoveTabsFunction::RunImpl() {
   Value* tab_value = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
 
   std::vector<int> tab_ids;
   EXTENSION_FUNCTION_VALIDATE(ReadOneOrMoreIntegers(tab_value, &tab_ids));
 
   DictionaryValue* update_props = NULL;
@@ skipping 437 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }