Rename (Chrome)SyncExtensionFunction::RunImpl to RunSync so that the RunImpl

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_api.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 171 matching lines @@
 // |value| are equal. This function is used to check if a tab's parameters match
 // those of the browser.
 bool MatchesBool(bool* boolean, bool value) {
   return !boolean || *boolean == value;
 }
 
 }  // namespace
 
 // Windows ---------------------------------------------------------------------
 
-bool WindowsGetFunction::RunImpl() {
+bool WindowsGetFunction::RunSync() {
   scoped_ptr<windows::Get::Params> params(windows::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 (!windows_util::GetWindowFromWindowID(this,
                                            params->window_id,
                                            &controller)) {
     return false;
   }
 
   if (populate_tabs)
     SetResult(controller->CreateWindowValueWithTabs(GetExtension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
-bool WindowsGetCurrentFunction::RunImpl() {
+bool WindowsGetCurrentFunction::RunSync() {
   scoped_ptr<windows::GetCurrent::Params> params(
       windows::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 (!windows_util::GetWindowFromWindowID(this,
                                            extension_misc::kCurrentWindowId,
                                            &controller)) {
     return false;
   }
   if (populate_tabs)
     SetResult(controller->CreateWindowValueWithTabs(GetExtension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
-bool WindowsGetLastFocusedFunction::RunImpl() {
+bool WindowsGetLastFocusedFunction::RunSync() {
   scoped_ptr<windows::GetLastFocused::Params> params(
       windows::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(
       GetProfile(), 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 WindowsGetAllFunction::RunImpl() {
+bool WindowsGetAllFunction::RunSync() {
   scoped_ptr<windows::GetAll::Params> params(
       windows::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;
 
   base::ListValue* window_list = new base::ListValue();
   const WindowControllerList::ControllerList& windows =
@@ skipping 53 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 WindowsCreateFunction::RunImpl() {
+bool WindowsCreateFunction::RunSync() {
   scoped_ptr<windows::Create::Params> params(
       windows::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   std::vector<GURL> urls;
   TabStripModel* source_tab_strip = NULL;
   int tab_index = -1;
 
   windows::Create::Params::CreateData* create_data = params->create_data.get();
 
   // Look for optional url.
@@ skipping 243 matching lines @@
     SetResult(base::Value::CreateNullValue());
   } else {
     SetResult(
         new_window->extension_window_controller()->CreateWindowValueWithTabs(
             GetExtension()));
   }
 
   return true;
 }
 
-bool WindowsUpdateFunction::RunImpl() {
+bool WindowsUpdateFunction::RunSync() {
   scoped_ptr<windows::Update::Params> params(
       windows::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
                                             &controller))
     return false;
 
   ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;  // No change.
@@ skipping 99 matching lines @@
   }
 
   if (params->update_info.draw_attention)
     controller->window()->FlashFrame(*params->update_info.draw_attention);
 
   SetResult(controller->CreateWindowValue());
 
   return true;
 }
 
-bool WindowsRemoveFunction::RunImpl() {
+bool WindowsRemoveFunction::RunSync() {
   scoped_ptr<windows::Remove::Params> params(
       windows::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
                                            &controller))
     return false;
 
   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 TabsGetSelectedFunction::RunImpl() {
+bool TabsGetSelectedFunction::RunSync() {
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   scoped_ptr<tabs::GetSelected::Params> params(
       tabs::GetSelected::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   if (params->window_id.get())
     window_id = *params->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 TabsGetAllInWindowFunction::RunImpl() {
+bool TabsGetAllInWindowFunction::RunSync() {
   scoped_ptr<tabs::GetAllInWindow::Params> params(
       tabs::GetAllInWindow::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
   if (params->window_id.get())
     window_id = *params->window_id;
 
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   SetResult(ExtensionTabUtil::CreateTabList(browser, GetExtension()));
 
   return true;
 }
 
-bool TabsQueryFunction::RunImpl() {
+bool TabsQueryFunction::RunSync() {
   scoped_ptr<tabs::Query::Params> params(tabs::Query::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool loading_status_set = params->query_info.status !=
       tabs::Query::Params::QueryInfo::STATUS_NONE;
   bool loading = params->query_info.status ==
       tabs::Query::Params::QueryInfo::STATUS_LOADING;
 
   // It is o.k. to use URLPattern::SCHEME_ALL here because this function does
   // not grant access to the content of the tabs, only to seeing their URLs and
@@ skipping 94 matching lines @@
 
       result->Append(ExtensionTabUtil::CreateTabValue(
           web_contents, tab_strip, i, GetExtension()));
     }
   }
 
   SetResult(result);
   return true;
 }
 
-bool TabsCreateFunction::RunImpl() {
+bool TabsCreateFunction::RunSync() {
   scoped_ptr<tabs::Create::Params> params(tabs::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
   if (params->create_properties.window_id.get())
     window_id = *params->create_properties.window_id;
 
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
@@ skipping 117 matching lines @@
   // Return data about the newly created tab.
   if (has_callback()) {
     SetResult(ExtensionTabUtil::CreateTabValue(
         navigate_params.target_contents,
         tab_strip, new_index, GetExtension()));
   }
 
   return true;
 }
 
-bool TabsDuplicateFunction::RunImpl() {
+bool TabsDuplicateFunction::RunSync() {
   scoped_ptr<tabs::Duplicate::Params> params(
       tabs::Duplicate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   int tab_id = params->tab_id;
 
   Browser* browser = NULL;
   TabStripModel* tab_strip = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id,
                   GetProfile(),
@@ skipping 22 matching lines @@
   }
 
   // Return data about the newly created tab.
   SetResult(ExtensionTabUtil::CreateTabValue(
       new_contents,
       new_tab_strip, new_tab_index, GetExtension()));
 
   return true;
 }
 
-bool TabsGetFunction::RunImpl() {
+bool TabsGetFunction::RunSync() {
   scoped_ptr<tabs::Get::Params> params(tabs::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   int tab_id = params->tab_id;
 
   TabStripModel* tab_strip = NULL;
   WebContents* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id,
                   GetProfile(),
                   include_incognito(),
                   NULL,
                   &tab_strip,
                   &contents,
                   &tab_index,
                   &error_))
     return false;
 
   SetResult(ExtensionTabUtil::CreateTabValue(contents,
                                              tab_strip,
                                              tab_index,
                                              GetExtension()));
   return true;
 }
 
-bool TabsGetCurrentFunction::RunImpl() {
+bool TabsGetCurrentFunction::RunSync() {
   DCHECK(dispatcher());
 
   WebContents* contents = dispatcher()->delegate()->GetAssociatedWebContents();
   if (contents)
     SetResult(ExtensionTabUtil::CreateTabValue(contents, GetExtension()));
 
   return true;
 }
 
-bool TabsHighlightFunction::RunImpl() {
+bool TabsHighlightFunction::RunSync() {
   scoped_ptr<tabs::Highlight::Params> params(
       tabs::Highlight::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Get the window id from the params; default to current window if omitted.
   int window_id = extension_misc::kCurrentWindowId;
   if (params->highlight_info.window_id.get())
     window_id = *params->highlight_info.window_id;
 
   Browser* browser = NULL;
@@ skipping 233 matching lines @@
     int32 on_page_id,
     const GURL& url,
     const base::ListValue& script_result) {
   if (error.empty())
     PopulateResult();
   else
     error_ = error;
   SendResponse(error.empty());
 }
 
-bool TabsMoveFunction::RunImpl() {
+bool TabsMoveFunction::RunSync() {
   scoped_ptr<tabs::Move::Params> params(tabs::Move::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int new_index = params->move_properties.index;
   int* window_id = params->move_properties.window_id.get();
   scoped_ptr<base::ListValue> tab_values(new base::ListValue());
 
   size_t num_tabs = 0;
   if (params->tab_ids.as_integers) {
     std::vector<int>& tab_ids = *params->tab_ids.as_integers;
@@ skipping 126 matching lines @@
     source_tab_strip->MoveWebContentsAt(tab_index, *new_index, false);
 
   if (has_callback()) {
     tab_values->Append(ExtensionTabUtil::CreateTabValue(
         contents, source_tab_strip, *new_index, GetExtension()));
   }
 
   return true;
 }
 
-bool TabsReloadFunction::RunImpl() {
+bool TabsReloadFunction::RunSync() {
   scoped_ptr<tabs::Reload::Params> params(
       tabs::Reload::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool bypass_cache = false;
   if (params->reload_properties.get() &&
       params->reload_properties->bypass_cache.get()) {
     bypass_cache = *params->reload_properties->bypass_cache;
   }
 
@@ skipping 33 matching lines @@
     GetCurrentBrowser()->OpenURL(params);
   } else if (bypass_cache) {
     web_contents->GetController().ReloadIgnoringCache(true);
   } else {
     web_contents->GetController().Reload(true);
   }
 
   return true;
 }
 
-bool TabsRemoveFunction::RunImpl() {
+bool TabsRemoveFunction::RunSync() {
   scoped_ptr<tabs::Remove::Params> params(tabs::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (params->tab_ids.as_integers) {
     std::vector<int>& tab_ids = *params->tab_ids.as_integers;
     for (size_t i = 0; i < tab_ids.size(); ++i) {
       if (!RemoveTab(tab_ids[i]))
         return false;
     }
   } else {
@@ skipping 286 matching lines @@
   execute_tab_id_ = tab_id;
   details_ = details.Pass();
   return true;
 }
 
 bool TabsInsertCSSFunction::ShouldInsertCSS() const {
   return true;
 }
 
 }  // namespace extensions