Run the JSON Schema Compiler's bundle compilation on JSON files. Previously it

chrome/browser/extensions/api/tabs/tabs_api.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/api/tabs/tabs.h"
+#include "chrome/browser/extensions/api/tabs/tabs_api.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.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/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_function_util.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/extensions/file_reader.h"
 #include "chrome/browser/extensions/script_executor.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/extensions/window_controller.h"
 #include "chrome/browser/extensions/window_controller_list.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/snapshot_tab_helper.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/window_sizer/window_sizer.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/api/tabs.h"
 #include "chrome/common/extensions/api/windows.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/extension_file_util.h"
+#include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
+#include "chrome/common/extensions/message_bundle.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 13 matching lines @@
 #include "win8/util/win8_util.h"
 #endif  // OS_WIN
 
 namespace Get = extensions::api::windows::Get;
 namespace GetAll = extensions::api::windows::GetAll;
 namespace GetCurrent = extensions::api::windows::GetCurrent;
 namespace GetLastFocused = extensions::api::windows::GetLastFocused;
 namespace errors = extension_manifest_errors;
 namespace keys = extensions::tabs_constants;
 
+using content::BrowserThread;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderViewHost;
 using content::WebContents;
 using extensions::ErrorUtils;
 using extensions::ScriptExecutor;
+using extensions::UserScript;
 using extensions::WindowController;
 using extensions::WindowControllerList;
+using extensions::api::tabs::InjectDetails;
 
-const int CaptureVisibleTabFunction::kDefaultQuality = 90;
+const int TabsCaptureVisibleTabFunction::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,
                                    std::string* error_message) {
   Profile* incognito_profile =
@@ skipping 130 matching lines @@
 
   if (!new_window)
     new_window = new Browser(params);
   return new_window;
 }
 
 }  // namespace
 
 // Windows ---------------------------------------------------------------------
 
-bool GetWindowFunction::RunImpl() {
+bool WindowsGetFunction::RunImpl() {
   scoped_ptr<Get::Params> params(Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   WindowController* controller;
   if (!GetWindowFromWindowID(this, params->window_id, &controller))
     return false;
 
   if (populate_tabs)
     SetResult(controller->CreateWindowValueWithTabs(GetExtension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
-bool GetCurrentWindowFunction::RunImpl() {
+bool WindowsGetCurrentFunction::RunImpl() {
   scoped_ptr<GetCurrent::Params> params(GetCurrent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   WindowController* controller;
   if (!GetWindowFromWindowID(this,
                              extension_misc::kCurrentWindowId,
                              &controller)) {
     return false;
   }
   if (populate_tabs)
     SetResult(controller->CreateWindowValueWithTabs(GetExtension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
-bool GetLastFocusedWindowFunction::RunImpl() {
+bool WindowsGetLastFocusedFunction::RunImpl() {
   scoped_ptr<GetLastFocused::Params> params(
       GetLastFocused::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   // Note: currently this returns the last active browser. If we decide to
   // include other window types (e.g. panels), we will need to add logic to
   // WindowControllerList that mirrors the active behavior of BrowserList.
   Browser* browser = chrome::FindAnyBrowser(
       profile(), include_incognito(), chrome::GetActiveDesktop());
   if (!browser || !browser->window()) {
     error_ = keys::kNoLastFocusedWindowError;
     return false;
   }
   WindowController* controller =
       browser->extension_window_controller();
   if (populate_tabs)
     SetResult(controller->CreateWindowValueWithTabs(GetExtension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
-bool GetAllWindowsFunction::RunImpl() {
+bool WindowsGetAllFunction::RunImpl() {
   scoped_ptr<GetAll::Params> params(GetAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   ListValue* window_list = new ListValue();
   const WindowControllerList::ControllerList& windows =
       WindowControllerList::GetInstance()->windows();
   for (WindowControllerList::ControllerList::const_iterator iter =
            windows.begin();
        iter != windows.end(); ++iter) {
     if (!this->CanOperateOnWindow(*iter))
       continue;
     if (populate_tabs)
       window_list->Append((*iter)->CreateWindowValueWithTabs(GetExtension()));
     else
       window_list->Append((*iter)->CreateWindowValue());
   }
   SetResult(window_list);
   return true;
 }
 
-bool CreateWindowFunction::ShouldOpenIncognitoWindow(
+bool WindowsCreateFunction::ShouldOpenIncognitoWindow(
     const base::DictionaryValue* args,
     std::vector<GURL>* urls,
     bool* is_error) {
   *is_error = false;
   const IncognitoModePrefs::Availability incognito_availability =
       IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
   bool incognito = false;
   if (args && args->HasKey(keys::kIncognitoKey)) {
     EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kIncognitoKey,
                                                  &incognito));
@@ skipping 29 matching lines @@
     if (urls->empty() && !first_url_erased.empty()) {
       error_ = ErrorUtils::FormatErrorMessage(
           keys::kURLsNotAllowedInIncognitoError, first_url_erased);
       *is_error = true;
       return false;
     }
   }
   return incognito;
 }
 
-bool CreateWindowFunction::RunImpl() {
+bool WindowsCreateFunction::RunImpl() {
   DictionaryValue* args = NULL;
   std::vector<GURL> urls;
   WebContents* contents = NULL;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   // Look for optional url.
   if (args) {
     if (args->HasKey(keys::kUrlKey)) {
@@ skipping 248 matching lines @@
     SetResult(Value::CreateNullValue());
   } else {
     SetResult(
         new_window->extension_window_controller()->CreateWindowValueWithTabs(
             GetExtension()));
   }
 
   return true;
 }
 
-bool UpdateWindowFunction::RunImpl() {
+bool WindowsUpdateFunction::RunImpl() {
   int window_id = extension_misc::kUnknownWindowId;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
   DictionaryValue* update_props;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   WindowController* controller;
   if (!GetWindowFromWindowID(this, window_id, &controller))
     return false;
 
 #if defined(OS_WIN)
@@ skipping 123 matching lines @@
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kDrawAttentionKey, &draw_attention));
     controller->window()->FlashFrame(draw_attention);
   }
 
   SetResult(controller->CreateWindowValue());
 
   return true;
 }
 
-bool RemoveWindowFunction::RunImpl() {
+bool WindowsRemoveFunction::RunImpl() {
   int window_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   WindowController* controller;
   if (!GetWindowFromWindowID(this, window_id, &controller))
     return false;
 
 #if defined(OS_WIN)
   // In Windows 8 metro mode, an existing Browser instance is reused for
   // hosting the extension tab. We should not be closing it as we don't own it.
   if (win8::IsSingleWindowMetroMode())
     return false;
 #endif
 
   WindowController::Reason reason;
   if (!controller->CanClose(&reason)) {
     if (reason == WindowController::REASON_NOT_EDITABLE)
       error_ = keys::kTabStripNotEditableError;
     return false;
   }
   controller->window()->Close();
   return true;
 }
 
 // Tabs ------------------------------------------------------------------------
 
-bool GetSelectedTabFunction::RunImpl() {
+bool TabsGetSelectedFunction::RunImpl() {
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   TabStripModel* tab_strip = browser->tab_strip_model();
   WebContents* contents = tab_strip->GetActiveWebContents();
   if (!contents) {
     error_ = keys::kNoSelectedTabError;
     return false;
   }
   SetResult(ExtensionTabUtil::CreateTabValue(contents,
                                              tab_strip,
                                              tab_strip->active_index(),
                                              GetExtension()));
   return true;
 }
 
-bool GetAllTabsInWindowFunction::RunImpl() {
+bool TabsGetAllInWindowFunction::RunImpl() {
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   SetResult(ExtensionTabUtil::CreateTabList(browser, GetExtension()));
 
   return true;
 }
 
-bool QueryTabsFunction::RunImpl() {
+bool TabsQueryFunction::RunImpl() {
   DictionaryValue* query = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &query));
 
   QueryArg active = ParseBoolQueryArg(query, keys::kActiveKey);
   QueryArg pinned = ParseBoolQueryArg(query, keys::kPinnedKey);
   QueryArg selected = ParseBoolQueryArg(query, keys::kHighlightedKey);
   QueryArg current_window = ParseBoolQueryArg(query, keys::kCurrentWindowKey);
   QueryArg focused_window =
       ParseBoolQueryArg(query, keys::kLastFocusedWindowKey);
 
@@ skipping 92 matching lines @@
 
       result->Append(ExtensionTabUtil::CreateTabValue(
           web_contents, tab_strip, i, GetExtension()));
     }
   }
 
   SetResult(result);
   return true;
 }
 
-bool CreateTabFunction::RunImpl() {
+bool TabsCreateFunction::RunImpl() {
   DictionaryValue* args = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
   if (args->HasKey(keys::kWindowIdKey))
     EXTENSION_FUNCTION_VALIDATE(args->GetInteger(
         keys::kWindowIdKey, &window_id));
 
   Browser* browser = NULL;
@@ skipping 113 matching lines @@
   // Return data about the newly created tab.
   if (has_callback()) {
     SetResult(ExtensionTabUtil::CreateTabValue(
         params.target_contents,
         tab_strip, new_index, GetExtension()));
   }
 
   return true;
 }
 
-bool DuplicateTabFunction::RunImpl() {
+bool TabsDuplicateFunction::RunImpl() {
   int tab_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   Browser* browser = NULL;
   TabStripModel* tab_strip = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   &browser, &tab_strip, NULL, &tab_index, &error_)) {
     return false;
   }
 
   WebContents* new_contents = chrome::DuplicateTabAt(browser, tab_index);
   if (!has_callback())
     return true;
 
   int new_index = tab_strip->GetIndexOfWebContents(new_contents);
 
   // Return data about the newly created tab.
   SetResult(ExtensionTabUtil::CreateTabValue(
       new_contents,
       tab_strip, new_index, GetExtension()));
 
   return true;
 }
 
-bool GetTabFunction::RunImpl() {
+bool TabsGetFunction::RunImpl() {
   int tab_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   TabStripModel* tab_strip = NULL;
   WebContents* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_))
     return false;
 
   SetResult(ExtensionTabUtil::CreateTabValue(contents,
                                              tab_strip,
                                              tab_index,
                                              GetExtension()));
   return true;
 }
 
-bool GetCurrentTabFunction::RunImpl() {
+bool TabsGetCurrentFunction::RunImpl() {
   DCHECK(dispatcher());
 
   WebContents* contents = dispatcher()->delegate()->GetAssociatedWebContents();
   if (contents)
     SetResult(ExtensionTabUtil::CreateTabValue(contents, GetExtension()));
 
   return true;
 }
 
-bool HighlightTabsFunction::RunImpl() {
+bool TabsHighlightFunction::RunImpl() {
   DictionaryValue* info = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &info));
 
   // Get the window id from the params; default to current window if omitted.
   int window_id = extension_misc::kCurrentWindowId;
   if (info->HasKey(keys::kWindowIdKey))
     EXTENSION_FUNCTION_VALIDATE(
         info->GetInteger(keys::kWindowIdKey, &window_id));
 
   Browser* browser = NULL;
@@ skipping 36 matching lines @@
   }
 
   selection.set_active(active_index);
   browser->tab_strip_model()->SetSelectionFromModel(selection);
   SetResult(
       browser->extension_window_controller()->CreateWindowValueWithTabs(
           GetExtension()));
   return true;
 }
 
-UpdateTabFunction::UpdateTabFunction() : web_contents_(NULL) {
+TabsUpdateFunction::TabsUpdateFunction() : web_contents_(NULL) {
 }
 
-bool UpdateTabFunction::RunImpl() {
+bool TabsUpdateFunction::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));
   }
 
   int tab_id = -1;
   WebContents* contents = NULL;
@@ skipping 83 matching lines @@
     tab_strip->SetOpenerOfWebContentsAt(tab_index, opener_contents);
   }
 
   if (!is_async) {
     PopulateResult();
     SendResponse(true);
   }
   return true;
 }
 
-bool UpdateTabFunction::UpdateURLIfPresent(DictionaryValue* update_props,
+bool TabsUpdateFunction::UpdateURLIfPresent(DictionaryValue* update_props,
                                            int tab_id,
                                            bool* is_async) {
   if (!update_props->HasKey(keys::kUrlKey))
     return true;
 
   std::string url_string;
   EXTENSION_FUNCTION_VALIDATE(update_props->GetString(
       keys::kUrlKey, &url_string));
   GURL url = ExtensionTabUtil::ResolvePossiblyRelativeURL(
       url_string, GetExtension());
@@ skipping 23 matching lines @@
     }
 
     extensions::TabHelper::FromWebContents(web_contents_)->
         script_executor()->ExecuteScript(
             extension_id(),
             ScriptExecutor::JAVASCRIPT,
             url.path(),
             ScriptExecutor::TOP_FRAME,
             extensions::UserScript::DOCUMENT_IDLE,
             ScriptExecutor::MAIN_WORLD,
-            base::Bind(&UpdateTabFunction::OnExecuteCodeFinished, this));
+            base::Bind(&TabsUpdateFunction::OnExecuteCodeFinished, this));
 
     *is_async = true;
     return true;
   }
 
   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());
 
   return true;
 }
 
-void UpdateTabFunction::PopulateResult() {
+void TabsUpdateFunction::PopulateResult() {
   if (!has_callback())
     return;
 
   SetResult(ExtensionTabUtil::CreateTabValue(web_contents_, GetExtension()));
 }
 
-void UpdateTabFunction::OnExecuteCodeFinished(const std::string& error,
+void TabsUpdateFunction::OnExecuteCodeFinished(const std::string& error,
                                               int32 on_page_id,
                                               const GURL& url,
                                               const ListValue& script_result) {
   if (error.empty())
     PopulateResult();
   else
     error_ = error;
   SendResponse(error.empty());
 }
 
-bool MoveTabsFunction::RunImpl() {
+bool TabsMoveFunction::RunImpl() {
   Value* tab_value = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
 
   std::vector<int> tab_ids;
   EXTENSION_FUNCTION_VALIDATE(extensions::ReadOneOrMoreIntegers(
       tab_value, &tab_ids));
 
   DictionaryValue* update_props = NULL;
   int new_index;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
@@ skipping 100 matching lines @@
   if (tab_ids.size() > 1) {
     SetResult(tab_values.DeepCopy());
   } else if (tab_ids.size() == 1) {
     Value* value = NULL;
     CHECK(tab_values.Get(0, &value));
     SetResult(value->DeepCopy());
   }
   return true;
 }
 
-bool ReloadTabFunction::RunImpl() {
+bool TabsReloadFunction::RunImpl() {
   bool bypass_cache = false;
   if (HasOptionalArgument(1)) {
       DictionaryValue* reload_props = NULL;
       EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &reload_props));
 
       if (reload_props->HasKey(keys::kBypassCache)) {
         EXTENSION_FUNCTION_VALIDATE(reload_props->GetBoolean(
             keys::kBypassCache,
             &bypass_cache));
       }
@@ skipping 34 matching lines @@
     GetCurrentBrowser()->OpenURL(params);
   } else if (bypass_cache) {
     web_contents->GetController().ReloadIgnoringCache(true);
   } else {
     web_contents->GetController().Reload(true);
   }
 
   return true;
 }
 
-bool RemoveTabsFunction::RunImpl() {
+bool TabsRemoveFunction::RunImpl() {
   Value* tab_value = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
 
   std::vector<int> tab_ids;
   EXTENSION_FUNCTION_VALIDATE(extensions::ReadOneOrMoreIntegers(
       tab_value, &tab_ids));
 
   for (size_t i = 0; i < tab_ids.size(); ++i) {
     Browser* browser = NULL;
     WebContents* contents = NULL;
     if (!GetTabById(tab_ids[i], profile(), include_incognito(),
                     &browser, NULL, &contents, NULL, &error_))
       return false;
 
     // Don't let the extension remove a tab if the user is dragging tabs around.
     if (!browser->window()->IsTabStripEditable()) {
       error_ = keys::kTabStripNotEditableError;
       return false;
     }
 
     // There's a chance that the tab is being dragged, or we're in some other
     // nested event loop. This code path ensures that the tab is safely closed
     // under such circumstances, whereas |TabStripModel::CloseWebContentsAt()|
     // does not.
     contents->Close();
   }
   return true;
 }
 
-bool CaptureVisibleTabFunction::GetTabToCapture(WebContents** web_contents) {
+bool TabsCaptureVisibleTabFunction::GetTabToCapture(
+    WebContents** web_contents) {
   Browser* browser = NULL;
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   *web_contents = chrome::GetActiveWebContents(browser);
   if (*web_contents == NULL) {
     error_ = keys::kInternalVisibleTabCaptureError;
     return false;
   }
 
   return true;
 };
 
-bool CaptureVisibleTabFunction::RunImpl() {
+bool TabsCaptureVisibleTabFunction::RunImpl() {
   PrefServiceBase* service = profile()->GetPrefs();
   if (service->GetBoolean(prefs::kDisableScreenshots)) {
     error_ = keys::kScreenshotsDisabled;
     return false;
   }
 
   WebContents* web_contents = NULL;
   if (!GetTabToCapture(&web_contents))
     return false;
 
@@ skipping 38 matching lines @@
   RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
   content::RenderWidgetHostView* view = render_view_host->GetView();
   if (!view) {
     error_ = keys::kInternalVisibleTabCaptureError;
     return false;
   }
   skia::PlatformBitmap* temp_bitmap = new skia::PlatformBitmap;
   render_view_host->CopyFromBackingStore(
       gfx::Rect(),
       view->GetViewBounds().size(),
-      base::Bind(&CaptureVisibleTabFunction::CopyFromBackingStoreComplete,
+      base::Bind(&TabsCaptureVisibleTabFunction::CopyFromBackingStoreComplete,
                  this,
                  base::Owned(temp_bitmap)),
       temp_bitmap);
   return true;
 }
 
-void CaptureVisibleTabFunction::CopyFromBackingStoreComplete(
+void TabsCaptureVisibleTabFunction::CopyFromBackingStoreComplete(
     skia::PlatformBitmap* bitmap,
     bool succeeded) {
   if (succeeded) {
     VLOG(1) << "captureVisibleTab() got image from backing store.";
     SendResultFromBitmap(bitmap->GetBitmap());
     return;
   }
 
   WebContents* web_contents = NULL;
   if (!GetTabToCapture(&web_contents)) {
     error_ = keys::kInternalVisibleTabCaptureError;
     SendResponse(false);
     return;
   }
 
   // Ask the renderer for a snapshot of the tab.
   registrar_.Add(this,
                  chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN,
                  content::Source<WebContents>(web_contents));
-  AddRef();  // Balanced in CaptureVisibleTabFunction::Observe().
+  AddRef();  // Balanced in TabsCaptureVisibleTabFunction::Observe().
   SnapshotTabHelper::FromWebContents(web_contents)->CaptureSnapshot();
 }
 
-// If a backing store was not available in CaptureVisibleTabFunction::RunImpl,
-// than the renderer was asked for a snapshot.  Listen for a notification
-// that the snapshot is available.
-void CaptureVisibleTabFunction::Observe(
+// If a backing store was not available in
+// TabsCaptureVisibleTabFunction::RunImpl, than the renderer was asked for a
+// snapshot.  Listen for a notification that the snapshot is available.
+void TabsCaptureVisibleTabFunction::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN);
 
   const SkBitmap *screen_capture =
       content::Details<const SkBitmap>(details).ptr();
   const bool error = screen_capture->empty();
 
   if (error) {
     error_ = keys::kInternalVisibleTabCaptureError;
     SendResponse(false);
   } else {
     VLOG(1) << "captureVisibleTab() got image from renderer.";
     SendResultFromBitmap(*screen_capture);
   }
 
-  Release();  // Balanced in CaptureVisibleTabFunction::RunImpl().
+  Release();  // Balanced in TabsCaptureVisibleTabFunction::RunImpl().
 }
 
 // Turn a bitmap of the screen into an image, set that image as the result,
 // and call SendResponse().
-void CaptureVisibleTabFunction::SendResultFromBitmap(
+void TabsCaptureVisibleTabFunction::SendResultFromBitmap(
     const SkBitmap& screen_capture) {
   std::vector<unsigned char> data;
   SkAutoLockPixels screen_capture_lock(screen_capture);
   bool encoded = false;
   std::string mime_type;
   switch (image_format_) {
     case FORMAT_JPEG:
       encoded = gfx::JPEGCodec::Encode(
           reinterpret_cast<unsigned char*>(screen_capture.getAddr32(0, 0)),
           gfx::JPEGCodec::FORMAT_SkBitmap,
@@ skipping 25 matching lines @@
   base::StringPiece stream_as_string(
       reinterpret_cast<const char*>(vector_as_array(&data)), data.size());
 
   base::Base64Encode(stream_as_string, &base64_result);
   base64_result.insert(0, base::StringPrintf("data:%s;base64,",
                                              mime_type.c_str()));
   SetResult(new StringValue(base64_result));
   SendResponse(true);
 }
 
-void CaptureVisibleTabFunction::RegisterUserPrefs(
+void TabsCaptureVisibleTabFunction::RegisterUserPrefs(
     PrefServiceSyncable* service) {
   service->RegisterBooleanPref(prefs::kDisableScreenshots, false,
                                PrefServiceSyncable::UNSYNCABLE_PREF);
 }
 
-bool DetectTabLanguageFunction::RunImpl() {
+bool TabsDetectLanguageFunction::RunImpl() {
   int tab_id = 0;
   Browser* browser = NULL;
   WebContents* contents = NULL;
 
   // If |tab_id| is specified, look for it. Otherwise default to selected tab
   // in the current window.
   if (HasOptionalArgument(0)) {
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
     if (!GetTabById(tab_id, profile(), include_incognito(),
                     &browser, NULL, &contents, NULL, &error_)) {
@@ skipping 17 matching lines @@
   }
 
   AddRef();  // Balanced in GotLanguage().
 
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(contents);
   if (!translate_tab_helper->language_state().original_language().empty()) {
     // Delay the callback invocation until after the current JS call has
     // returned.
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &DetectTabLanguageFunction::GotLanguage, this,
+        &TabsDetectLanguageFunction::GotLanguage, this,
         translate_tab_helper->language_state().original_language()));
     return true;
   }
   // The tab contents does not know its language yet.  Let's wait until it
   // receives it, or until the tab is closed/navigates to some other page.
   registrar_.Add(this, chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
                  content::Source<WebContents>(contents));
   registrar_.Add(
       this, chrome::NOTIFICATION_TAB_CLOSING,
       content::Source<NavigationController>(&(contents->GetController())));
   registrar_.Add(
       this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(&(contents->GetController())));
   return true;
 }
 
-void DetectTabLanguageFunction::Observe(
+void TabsDetectLanguageFunction::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   std::string language;
   if (type == chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED)
     language = *content::Details<std::string>(details).ptr();
 
   registrar_.RemoveAll();
 
   // Call GotLanguage in all cases as we want to guarantee the callback is
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
-void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
+void TabsDetectLanguageFunction::GotLanguage(const std::string& language) {
   SetResult(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }
+
+ExecuteCodeInTabFunction::ExecuteCodeInTabFunction()
+    : execute_tab_id_(-1) {
+}
+
+ExecuteCodeInTabFunction::~ExecuteCodeInTabFunction() {}
+
+bool ExecuteCodeInTabFunction::HasPermission() {
+  if (Init() &&
+      extension_->HasAPIPermissionForTab(execute_tab_id_,
+                                         extensions::APIPermission::kTab)) {
+    return true;
+  }
+  return ExtensionFunction::HasPermission();
+}
+
+bool ExecuteCodeInTabFunction::RunImpl() {
+  EXTENSION_FUNCTION_VALIDATE(Init());
+
+  if (!details_->code.get() && !details_->file.get()) {
+    error_ = keys::kNoCodeOrFileToExecuteError;
+    return false;
+  }
+  if (details_->code.get() && details_->file.get()) {
+    error_ = keys::kMoreThanOneValuesError;
+    return false;
+  }
+
+  content::WebContents* contents = NULL;
+
+  // If |tab_id| is specified, look for the tab. Otherwise default to selected
+  // tab in the current window.
+  CHECK_GE(execute_tab_id_, 0);
+  if (!ExtensionTabUtil::GetTabById(execute_tab_id_, profile(),
+                                    include_incognito(),
+                                    NULL, NULL, &contents, NULL)) {
+    return false;
+  }
+
+  // NOTE: This can give the wrong answer due to race conditions, but it is OK,
+  // we check again in the renderer.
+  CHECK(contents);
+  if (!GetExtension()->CanExecuteScriptOnPage(contents->GetURL(),
+                                              contents->GetURL(),
+                                              execute_tab_id_,
+                                              NULL,
+                                              &error_)) {
+    return false;
+  }
+
+  if (details_->code.get())
+    return Execute(*details_->code);
+
+  CHECK(details_->file.get());
+  resource_ = GetExtension()->GetResource(*details_->file);
+
+  if (resource_.extension_root().empty() || resource_.relative_path().empty()) {
+    error_ = keys::kNoCodeOrFileToExecuteError;
+    return false;
+  }
+
+  scoped_refptr<FileReader> file_reader(new FileReader(
+      resource_, base::Bind(&ExecuteCodeInTabFunction::DidLoadFile, this)));
+  file_reader->Start();
+
+  return true;
+}
+
+void ExecuteCodeInTabFunction::OnExecuteCodeFinished(const std::string& error,
+                                                     int32 on_page_id,
+                                                     const GURL& on_url,
+                                                     const ListValue& result) {
+  if (!error.empty())
+    SetError(error);
+
+  SendResponse(error.empty());
+}
+
+void TabsExecuteScriptFunction::OnExecuteCodeFinished(const std::string& error,
+                                                      int32 on_page_id,
+                                                      const GURL& on_url,
+                                                      const ListValue& result) {
+  if (error.empty())
+    SetResult(result.DeepCopy());
+  ExecuteCodeInTabFunction::OnExecuteCodeFinished(error, on_page_id, on_url,
+                                                  result);
+}
+
+bool ExecuteCodeInTabFunction::Init() {
+  if (details_.get())
+    return true;
+
+  // |tab_id| is optional so it's ok if it's not there.
+  int tab_id = -1;
+  args_->GetInteger(0, &tab_id);
+
+  // |details| are not optional.
+  DictionaryValue* details_value = NULL;
+  if (!args_->GetDictionary(1, &details_value))
+    return false;
+  scoped_ptr<InjectDetails> details(new InjectDetails());
+  if (!InjectDetails::Populate(*details_value, details.get()))
+    return false;
+
+  // If the tab ID is -1 then it needs to be converted to the currently active
+  // tab's ID.
+  if (tab_id == -1) {
+    Browser* browser = GetCurrentBrowser();
+    if (!browser)
+      return false;
+    content::WebContents* web_contents = NULL;
+    if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, &tab_id))
+      return false;
+  }
+
+  execute_tab_id_ = tab_id;
+  details_ = details.Pass();
+  return true;
+}
+
+void ExecuteCodeInTabFunction::DidLoadFile(bool success,
+                                           const std::string& data) {
+  std::string function_name = name();
+  const extensions::Extension* extension = GetExtension();
+
+  // Check if the file is CSS and needs localization.
+  if (success &&
+      function_name == TabsInsertCSSFunction::function_name() &&
+      extension != NULL &&
+      data.find(
+          extensions::MessageBundle::kMessageBegin) != std::string::npos) {
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&ExecuteCodeInTabFunction::LocalizeCSS, this,
+                   data,
+                   extension->id(),
+                   extension->path(),
+                   extension->default_locale()));
+  } else {
+    DidLoadAndLocalizeFile(success, data);
+  }
+}
+
+void ExecuteCodeInTabFunction::LocalizeCSS(
+    const std::string& data,
+    const std::string& extension_id,
+    const FilePath& extension_path,
+    const std::string& extension_default_locale) {
+  scoped_ptr<SubstitutionMap> localization_messages(
+      extension_file_util::LoadMessageBundleSubstitutionMap(
+          extension_path, extension_id, extension_default_locale));
+
+  // We need to do message replacement on the data, so it has to be mutable.
+  std::string css_data = data;
+  std::string error;
+  extensions::MessageBundle::ReplaceMessagesWithExternalDictionary(
+      *localization_messages, &css_data, &error);
+
+  // Call back DidLoadAndLocalizeFile on the UI thread. The success parameter
+  // is always true, because if loading had failed, we wouldn't have had
+  // anything to localize.
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&ExecuteCodeInTabFunction::DidLoadAndLocalizeFile, this,
+                 true, css_data));
+}
+
+void ExecuteCodeInTabFunction::DidLoadAndLocalizeFile(bool success,
+                                                      const std::string& data) {
+  if (success) {
+    if (!Execute(data))
+      SendResponse(false);
+  } else {
+#if defined(OS_POSIX)
+    // TODO(viettrungluu): bug: there's no particular reason the path should be
+    // UTF-8, in which case this may fail.
+    error_ = ErrorUtils::FormatErrorMessage(keys::kLoadFileError,
+        resource_.relative_path().value());
+#elif defined(OS_WIN)
+    error_ = ErrorUtils::FormatErrorMessage(keys::kLoadFileError,
+        WideToUTF8(resource_.relative_path().value()));
+#endif  // OS_WIN
+    SendResponse(false);
+  }
+}
+
+bool ExecuteCodeInTabFunction::Execute(const std::string& code_string) {
+  content::WebContents* contents = NULL;
+  Browser* browser = NULL;
+
+  bool success = ExtensionTabUtil::GetTabById(
+      execute_tab_id_, profile(), include_incognito(), &browser, NULL,
+      &contents, NULL) && contents && browser;
+
+  if (!success)
+    return false;
+
+  const extensions::Extension* extension = GetExtension();
+  if (!extension)
+    return false;
+
+  ScriptExecutor::ScriptType script_type = ScriptExecutor::JAVASCRIPT;
+  std::string function_name = name();
+  if (function_name == TabsInsertCSSFunction::function_name()) {
+    script_type = ScriptExecutor::CSS;
+  } else if (function_name != TabsExecuteScriptFunction::function_name()) {
+    NOTREACHED();
+  }
+
+  ScriptExecutor::FrameScope frame_scope =
+      details_->all_frames.get() && *details_->all_frames ?
+          ScriptExecutor::ALL_FRAMES :
+          ScriptExecutor::TOP_FRAME;
+
+  UserScript::RunLocation run_at = UserScript::UNDEFINED;
+  switch (details_->run_at) {
+    case InjectDetails::RUN_AT_NONE:
+    case InjectDetails::RUN_AT_DOCUMENT_IDLE:
+      run_at = UserScript::DOCUMENT_IDLE;
+      break;
+    case InjectDetails::RUN_AT_DOCUMENT_START:
+      run_at = UserScript::DOCUMENT_START;
+      break;
+    case InjectDetails::RUN_AT_DOCUMENT_END:
+      run_at = UserScript::DOCUMENT_END;
+      break;
+  }
+  CHECK_NE(UserScript::UNDEFINED, run_at);
+
+  extensions::TabHelper::FromWebContents(contents)->
+      script_executor()->ExecuteScript(
+          extension->id(),
+          script_type,
+          code_string,
+          frame_scope,
+          run_at,
+          ScriptExecutor::ISOLATED_WORLD,
+          base::Bind(&ExecuteCodeInTabFunction::OnExecuteCodeFinished, this));
+  return true;
+}