[Extensions] Remove ExtensionFunction::SetError()

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 <stddef.h>
 #include <algorithm>
 #include <limits>
 #include <memory>
@@ skipping 123 matching lines @@
     if (params_->get_info.get() && params_->get_info->window_types.get())
       return WindowController::GetFilterFromWindowTypes(
           *params_->get_info->window_types);
     return WindowController::kNoWindowFilter;
   }
 
  private:
   T* params_;
 };
 
-bool GetBrowserFromWindowID(ChromeUIThreadExtensionFunction* function,
+bool GetBrowserFromWindowID(const ChromeExtensionFunctionDetails& details,
                             int window_id,
-                            Browser** browser) {
-  std::string error;
-  Browser* result;
-  result =
-      ExtensionTabUtil::GetBrowserFromWindowID(function, window_id, &error);
-  if (!result) {
-    function->SetError(error);
+                            Browser** browser,
+                            std::string* error) {
+  Browser* result = nullptr;
+  result = ExtensionTabUtil::GetBrowserFromWindowID(details, window_id, error);
+  if (!result)
     return false;
-  }
 
   *browser = result;
   return true;
 }
 
-bool GetBrowserFromWindowID(ChromeExtensionFunctionDetails* details,
+bool GetBrowserFromWindowID(ChromeUIThreadExtensionFunction* function,
                             int window_id,
-                            Browser** browser) {
-  std::string error;
-  Browser* result;
-  result =
-      ExtensionTabUtil::GetBrowserFromWindowID(*details, window_id, &error);
-  if (!result) {
-    details->function()->SetError(error);
-    return false;
-  }
-
-  *browser = result;
-  return true;
+                            Browser** browser,
+                            std::string* error) {
+  return GetBrowserFromWindowID(ChromeExtensionFunctionDetails(function),
+                                window_id, browser, error);
 }
 
 // |error_message| can optionally be passed in and will be set with an
 // appropriate message if the tab cannot be found by id.
 bool GetTabById(int tab_id,
                 Profile* profile,
                 bool include_incognito,
                 Browser** browser,
                 TabStripModel** tab_strip,
                 content::WebContents** contents,
@@ skipping 102 matching lines @@
 
 // Windows ---------------------------------------------------------------------
 
 bool WindowsGetFunction::RunSync() {
   std::unique_ptr<windows::Get::Params> params(
       windows::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::Get::Params> extractor(params.get());
   WindowController* controller;
-  if (!windows_util::GetWindowFromWindowID(
-          this, params->window_id, extractor.type_filters(), &controller)) {
+  if (!windows_util::GetWindowFromWindowID(this, params->window_id,
+                                           extractor.type_filters(),
+                                           &controller, &error_)) {
     return false;
   }
 
   if (extractor.populate_tabs())
     SetResult(controller->CreateWindowValueWithTabs(extension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool WindowsGetCurrentFunction::RunSync() {
   std::unique_ptr<windows::GetCurrent::Params> params(
       windows::GetCurrent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::GetCurrent::Params> extractor(params.get());
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(
           this, extension_misc::kCurrentWindowId, extractor.type_filters(),
-          &controller)) {
+          &controller, &error_)) {
     return false;
   }
   if (extractor.populate_tabs())
     SetResult(controller->CreateWindowValueWithTabs(extension()));
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool WindowsGetLastFocusedFunction::RunSync() {
@@ skipping 355 matching lines @@
 }
 
 bool WindowsUpdateFunction::RunSync() {
   std::unique_ptr<windows::Update::Params> params(
       windows::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(
           this, params->window_id, WindowController::GetAllWindowFilter(),
-          &controller)) {
+          &controller, &error_)) {
     return false;
   }
 
   ui::WindowShowState show_state =
       ConvertToWindowShowState(params->update_info.state);
 
   if (show_state != ui::SHOW_STATE_FULLSCREEN &&
       show_state != ui::SHOW_STATE_DEFAULT)
     controller->SetFullscreenMode(false, extension()->url());
 
@@ skipping 83 matching lines @@
 }
 
 bool WindowsRemoveFunction::RunSync() {
   std::unique_ptr<windows::Remove::Params> params(
       windows::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
                                            WindowController::kNoWindowFilter,
-                                           &controller)) {
+                                           &controller, &error_)) {
     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::RunSync() {
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   std::unique_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))
+  if (!GetBrowserFromWindowID(this, window_id, &browser, &error_))
     return false;
 
   TabStripModel* tab_strip = browser->tab_strip_model();
   WebContents* contents = tab_strip->GetActiveWebContents();
   if (!contents) {
     error_ = keys::kNoSelectedTabError;
     return false;
   }
   results_ = tabs::Get::Results::Create(*ExtensionTabUtil::CreateTabObject(
       contents, tab_strip, tab_strip->active_index(), extension()));
   return true;
 }
 
 bool TabsGetAllInWindowFunction::RunSync() {
   std::unique_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))
+  if (!GetBrowserFromWindowID(this, window_id, &browser, &error_))
     return false;
 
   SetResult(ExtensionTabUtil::CreateTabList(browser, extension()));
 
   return true;
 }
 
 bool TabsQueryFunction::RunSync() {
   std::unique_ptr<tabs::Query::Params> params(
       tabs::Query::Params::Create(*args_));
@@ skipping 271 matching lines @@
   std::unique_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;
-  if (!GetBrowserFromWindowID(this, window_id, &browser))
+  if (!GetBrowserFromWindowID(this, window_id, &browser, &error_))
     return false;
 
   TabStripModel* tabstrip = browser->tab_strip_model();
   ui::ListSelectionModel selection;
   int active_index = -1;
 
   if (params->highlight_info.tabs.as_integers) {
     std::vector<int>& tab_indices = *params->highlight_info.tabs.as_integers;
     // Create a new selection model as we read the list of tab indices.
     for (size_t i = 0; i < tab_indices.size(); ++i) {
@@ skipping 325 matching lines @@
     error_ = keys::kTabStripNotEditableError;
     return false;
   }
 
   // Insert the tabs one after another.
   *new_index += iteration;
 
   if (window_id) {
     Browser* target_browser = NULL;
 
-    if (!GetBrowserFromWindowID(this, *window_id, &target_browser))
+    if (!GetBrowserFromWindowID(this, *window_id, &target_browser, &error_))
       return false;
 
     if (!target_browser->window()->IsTabStripEditable()) {
       error_ = keys::kTabStripNotEditableError;
       return false;
     }
 
     if (!target_browser->is_type_tabbed()) {
       error_ = keys::kCanOnlyMoveTabsWithinNormalWindowsError;
       return false;
@@ skipping 174 matching lines @@
   }
   return true;
 }
 
 bool TabsCaptureVisibleTabFunction::ClientAllowsTransparency() {
   return false;
 }
 
 WebContents* TabsCaptureVisibleTabFunction::GetWebContentsForID(int window_id) {
   Browser* browser = NULL;
-  if (!GetBrowserFromWindowID(&chrome_details_, window_id, &browser))
+  if (!GetBrowserFromWindowID(chrome_details_, window_id, &browser, &error_))
     return NULL;
 
   WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
   if (!contents) {
     error_ = "No active web contents to capture";
     return NULL;
   }
 
   if (!extension()->permissions_data()->CanCaptureVisiblePage(
           SessionTabHelper::IdForTab(contents), &error_)) {
@@ skipping 492 matching lines @@
       params->tab_id
           ? ErrorUtils::FormatErrorMessage(keys::kCannotDiscardTab,
                                            base::IntToString(*params->tab_id))
           : keys::kCannotFindTabToDiscard));
 }
 
 TabsDiscardFunction::TabsDiscardFunction() {}
 TabsDiscardFunction::~TabsDiscardFunction() {}
 
 }  // namespace extensions