[Extensions] Convert some ChromeSyncExtensionFunctions

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 136 matching lines @@
                             std::string* error) {
   Browser* result = nullptr;
   result = ExtensionTabUtil::GetBrowserFromWindowID(details, window_id, error);
   if (!result)
     return false;
 
   *browser = result;
   return true;
 }
 
-bool GetBrowserFromWindowID(ChromeUIThreadExtensionFunction* function,
+bool GetBrowserFromWindowID(UIThreadExtensionFunction* function,
                             int window_id,
                             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,
+                content::BrowserContext* context,
                 bool include_incognito,
                 Browser** browser,
                 TabStripModel** tab_strip,
                 content::WebContents** contents,
                 int* tab_index,
                 std::string* error_message) {
-  if (ExtensionTabUtil::GetTabById(tab_id, profile, include_incognito,
-                                   browser, tab_strip, contents, tab_index)) {
+  if (ExtensionTabUtil::GetTabById(tab_id, context, include_incognito, browser,
+                                   tab_strip, contents, tab_index)) {
     return true;
   }
 
   if (error_message) {
     *error_message = ErrorUtils::FormatErrorMessage(
         keys::kTabNotFoundError, base::IntToString(tab_id));
   }
 
   return false;
 }
@@ skipping 81 matching lines @@
       break;
     case ZoomController::ZOOM_MODE_DISABLED:
       zoom_settings->mode = api::tabs::ZOOM_SETTINGS_MODE_DISABLED;
       zoom_settings->scope = api::tabs::ZOOM_SETTINGS_SCOPE_PER_TAB;
       break;
   }
 }
 
 // Windows ---------------------------------------------------------------------
 
-bool WindowsGetFunction::RunSync() {
+ExtensionFunction::ResponseAction WindowsGetFunction::Run() {
   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;
+  WindowController* controller = nullptr;
+  std::string error;
   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
                                            extractor.type_filters(),
-                                           &controller, &error_)) {
-    return false;
+                                           &controller, &error)) {
+    return RespondNow(Error(error));
   }
 
-  if (extractor.populate_tabs())
-    SetResult(controller->CreateWindowValueWithTabs(extension()));
-  else
-    SetResult(controller->CreateWindowValue());
-  return true;
+  std::unique_ptr<base::DictionaryValue> windows =
+      extractor.populate_tabs()
+          ? controller->CreateWindowValueWithTabs(extension())
+          : controller->CreateWindowValue();
+  return RespondNow(OneArgument(std::move(windows)));
 }
 
-bool WindowsGetCurrentFunction::RunSync() {
+ExtensionFunction::ResponseAction WindowsGetCurrentFunction::Run() {
   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;
+  WindowController* controller = nullptr;
+  std::string error;
   if (!windows_util::GetWindowFromWindowID(
           this, extension_misc::kCurrentWindowId, extractor.type_filters(),
-          &controller, &error_)) {
-    return false;
+          &controller, &error)) {
+    return RespondNow(Error(error));
   }
-  if (extractor.populate_tabs())
-    SetResult(controller->CreateWindowValueWithTabs(extension()));
-  else
-    SetResult(controller->CreateWindowValue());
-  return true;
+
+  std::unique_ptr<base::DictionaryValue> windows =
+      extractor.populate_tabs()
+          ? controller->CreateWindowValueWithTabs(extension())
+          : controller->CreateWindowValue();
+  return RespondNow(OneArgument(std::move(windows)));
 }
 
-bool WindowsGetLastFocusedFunction::RunSync() {
+ExtensionFunction::ResponseAction WindowsGetLastFocusedFunction::Run() {
   std::unique_ptr<windows::GetLastFocused::Params> params(
       windows::GetLastFocused::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::GetLastFocused::Params> extractor(
       params.get());
   // The WindowControllerList should contain a list of application,
   // browser and devtools windows.
   WindowController* controller = nullptr;
   for (auto* iter : WindowControllerList::GetInstance()->windows()) {
     if (windows_util::CanOperateOnWindow(this, iter,
                                          extractor.type_filters())) {
       controller = iter;
       if (controller->window()->IsActive())
         break;  // Use focused window.
     }
   }
-  if (!controller) {
-    error_ = keys::kNoLastFocusedWindowError;
-    return false;
-  }
-  if (extractor.populate_tabs())
-    SetResult(controller->CreateWindowValueWithTabs(extension()));
-  else
-    SetResult(controller->CreateWindowValue());
-  return true;
+  if (!controller)
+    return RespondNow(Error(keys::kNoLastFocusedWindowError));
+
+  std::unique_ptr<base::DictionaryValue> windows =
+      extractor.populate_tabs()
+          ? controller->CreateWindowValueWithTabs(extension())
+          : controller->CreateWindowValue();
+  return RespondNow(OneArgument(std::move(windows)));
 }
 
-bool WindowsGetAllFunction::RunSync() {
+ExtensionFunction::ResponseAction WindowsGetAllFunction::Run() {
   std::unique_ptr<windows::GetAll::Params> params(
       windows::GetAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ApiParameterExtractor<windows::GetAll::Params> extractor(params.get());
   std::unique_ptr<base::ListValue> window_list(new base::ListValue());
   const WindowControllerList::ControllerList& windows =
       WindowControllerList::GetInstance()->windows();
   for (WindowControllerList::ControllerList::const_iterator iter =
            windows.begin();
        iter != windows.end(); ++iter) {
     if (!windows_util::CanOperateOnWindow(this, *iter,
                                           extractor.type_filters()))
       continue;
     if (extractor.populate_tabs())
       window_list->Append((*iter)->CreateWindowValueWithTabs(extension()));
     else
       window_list->Append((*iter)->CreateWindowValue());
   }
-  SetResult(std::move(window_list));
-  return true;
+
+  return RespondNow(OneArgument(std::move(window_list)));
 }
 
 bool WindowsCreateFunction::ShouldOpenIncognitoWindow(
     const windows::Create::Params::CreateData* create_data,
-    std::vector<GURL>* urls, bool* is_error) {
-  *is_error = false;
+    std::vector<GURL>* urls,
+    std::string* error) {
+  Profile* profile = Profile::FromBrowserContext(browser_context());
   const IncognitoModePrefs::Availability incognito_availability =
-      IncognitoModePrefs::GetAvailability(GetProfile()->GetPrefs());
+      IncognitoModePrefs::GetAvailability(profile->GetPrefs());
   bool incognito = false;
   if (create_data && create_data->incognito) {
     incognito = *create_data->incognito;
     if (incognito && incognito_availability == IncognitoModePrefs::DISABLED) {
-      error_ = keys::kIncognitoModeIsDisabled;
-      *is_error = true;
+      *error = keys::kIncognitoModeIsDisabled;
       return false;
     }
     if (!incognito && incognito_availability == IncognitoModePrefs::FORCED) {
-      error_ = keys::kIncognitoModeIsForced;
-      *is_error = true;
+      *error = keys::kIncognitoModeIsForced;
       return false;
     }
   } else if (incognito_availability == IncognitoModePrefs::FORCED) {
     // If incognito argument is not specified explicitly, we default to
     // incognito when forced so by policy.
     incognito = true;
   }
 
   // Remove all URLs that are not allowed in an incognito session. Note that a
   // ChromeOS guest session is not considered incognito in this case.
-  if (incognito && !GetProfile()->IsGuestSession()) {
+  if (incognito && !profile->IsGuestSession()) {
     std::string first_url_erased;
     for (size_t i = 0; i < urls->size();) {
-      if (chrome::IsURLAllowedInIncognito((*urls)[i], GetProfile())) {
+      if (chrome::IsURLAllowedInIncognito((*urls)[i], profile)) {
         i++;
       } else {
         if (first_url_erased.empty())
           first_url_erased = (*urls)[i].spec();
         urls->erase(urls->begin() + i);
       }
     }
     if (urls->empty() && !first_url_erased.empty()) {
-      error_ = ErrorUtils::FormatErrorMessage(
+      *error = ErrorUtils::FormatErrorMessage(
           keys::kURLsNotAllowedInIncognitoError, first_url_erased);
-      *is_error = true;
       return false;
     }
   }
   return incognito;
 }
 
-bool WindowsCreateFunction::RunSync() {
+ExtensionFunction::ResponseAction WindowsCreateFunction::Run() {
   std::unique_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.
   if (create_data && create_data->url) {
     std::vector<std::string> url_strings;
     // First, get all the URLs the client wants to open.
     if (create_data->url->as_string)
       url_strings.push_back(*create_data->url->as_string);
     else if (create_data->url->as_strings)
       url_strings.swap(*create_data->url->as_strings);
 
     // Second, resolve, validate and convert them to GURLs.
     for (std::vector<std::string>::iterator i = url_strings.begin();
          i != url_strings.end(); ++i) {
       GURL url = ExtensionTabUtil::ResolvePossiblyRelativeURL(*i, extension());
-      if (!url.is_valid()) {
-        error_ = ErrorUtils::FormatErrorMessage(keys::kInvalidUrlError, *i);
-        return false;
-      }
+      if (!url.is_valid())
+        return RespondNow(Error(keys::kInvalidUrlError, *i));
       // Don't let the extension crash the browser or renderers.
-      if (ExtensionTabUtil::IsKillURL(url)) {
-        error_ = keys::kNoCrashBrowserError;
-        return false;
-      }
+      if (ExtensionTabUtil::IsKillURL(url))
+        return RespondNow(Error(keys::kNoCrashBrowserError));
       urls.push_back(url);
     }
   }
 
   // Decide whether we are opening a normal window or an incognito window.
-  bool is_error = true;
+  std::string error;
   bool open_incognito_window =
-      ShouldOpenIncognitoWindow(create_data, &urls, &is_error);
-  if (is_error)
-    return false;  // error_ member is set inside of ShouldOpenIncognitoWindow.
+      ShouldOpenIncognitoWindow(create_data, &urls, &error);
+  if (!error.empty())
+    return RespondNow(Error(error));
 
-  Profile* window_profile = GetProfile();
-  if (open_incognito_window)
-    window_profile = window_profile->GetOffTheRecordProfile();
+  Profile* calling_profile = Profile::FromBrowserContext(browser_context());
+  Profile* window_profile = open_incognito_window
+                                ? calling_profile->GetOffTheRecordProfile()
+                                : calling_profile;
 
   // Look for optional tab id.
   if (create_data && create_data->tab_id) {
     // Find the tab. |source_tab_strip| and |tab_index| will later be used to
     // move the tab into the created window.
     Browser* source_browser = nullptr;
-    if (!GetTabById(*create_data->tab_id,
-                    GetProfile(),
-                    include_incognito(),
-                    &source_browser,
-                    &source_tab_strip,
-                    nullptr,
-                    &tab_index,
-                    &error_))
-      return false;
-
-    if (!source_browser->window()->IsTabStripEditable()) {
-      error_ = keys::kTabStripNotEditableError;
-      return false;
+    if (!GetTabById(*create_data->tab_id, calling_profile, include_incognito(),
+                    &source_browser, &source_tab_strip, nullptr, &tab_index,
+                    &error)) {
+      return RespondNow(Error(error));
     }
 
-    if (source_browser->profile() != window_profile) {
-      error_ = keys::kCanOnlyMoveTabsWithinSameProfileError;
-      return false;
-    }
+    if (!source_browser->window()->IsTabStripEditable())
+      return RespondNow(Error(keys::kTabStripNotEditableError));
+
+    if (source_browser->profile() != window_profile)
+      return RespondNow(Error(keys::kCanOnlyMoveTabsWithinSameProfileError));
   }
 
-  if (!IsValidStateForWindowsCreateFunction(create_data)) {
-    error_ = keys::kInvalidWindowStateError;
-    return false;
-  }
+  if (!IsValidStateForWindowsCreateFunction(create_data))
+    return RespondNow(Error(keys::kInvalidWindowStateError));
 
   Browser::Type window_type = Browser::TYPE_TABBED;
 
 #if defined(USE_ASH)
   bool create_ash_panel = false;
   bool saw_focus_key = false;
 #endif  // defined(USE_ASH)
 
   gfx::Rect window_bounds;
   bool focused = true;
@@ skipping 27 matching lines @@
         // window.create parameters. However, this is a more breaking change, so
         // for now simply treat it as a POPUP.
         window_type = Browser::TYPE_POPUP;
         break;
       }
 
       case windows::CREATE_TYPE_NONE:
       case windows::CREATE_TYPE_NORMAL:
         break;
       default:
-        error_ = keys::kInvalidWindowTypeError;
-        return false;
+        return RespondNow(Error(keys::kInvalidWindowTypeError));
     }
 
     // Initialize default window bounds according to window type.
     if (window_type == Browser::TYPE_TABBED ||
         window_type == Browser::TYPE_POPUP) {
       // Try to position the new browser relative to its originating
       // browser window. The call offsets the bounds by kWindowTilePixels
       // (defined in WindowSizer to be 10).
       //
       // NOTE(rafaelw): It's ok if GetCurrentBrowser() returns NULL here.
       // GetBrowserWindowBounds will default to saved "default" values for
       // the app.
       ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;
-      WindowSizer::GetBrowserWindowBoundsAndShowState(std::string(),
-                                                      gfx::Rect(),
-                                                      GetCurrentBrowser(),
-                                                      &window_bounds,
-                                                      &show_state);
+      WindowSizer::GetBrowserWindowBoundsAndShowState(
+          std::string(), gfx::Rect(),
+          ChromeExtensionFunctionDetails(this).GetCurrentBrowser(),
+          &window_bounds, &show_state);
     }
 
     // Any part of the bounds can optionally be set by the caller.
     if (create_data->left)
       window_bounds.set_x(*create_data->left);
 
     if (create_data->top)
       window_bounds.set_y(*create_data->top);
 
     if (create_data->width)
@@ skipping 22 matching lines @@
     create_params.focused = saw_focus_key && focused;
     AppWindow* app_window =
         new AppWindow(window_profile, new ChromeAppDelegate(true), extension());
     AshPanelContents* ash_panel_contents = new AshPanelContents(app_window);
     app_window->Init(urls[0], ash_panel_contents, render_frame_host(),
                      create_params);
     WindowController* window_controller =
         WindowControllerList::GetInstance()->FindWindowById(
             app_window->session_id().id());
     if (!window_controller)
-      return false;
-    SetResult(window_controller->CreateWindowValueWithTabs(extension()));
-    return true;
+      return RespondNow(Error(kUnknownErrorDoNotUse));
+    return RespondNow(
+        OneArgument(window_controller->CreateWindowValueWithTabs(extension())));
   }
 #endif  // defined(USE_ASH)
 
   // Create a new BrowserWindow.
   Browser::CreateParams create_params(window_type, window_profile);
   if (extension_id.empty()) {
     create_params.initial_bounds = window_bounds;
   } else {
     create_params = Browser::CreateParams::CreateForApp(
         web_app::GenerateApplicationNameFromExtensionId(extension_id),
@@ skipping 36 matching lines @@
   }
   chrome::SelectNumberedTab(new_window, 0);
 
   if (focused)
     new_window->window()->Show();
   else
     new_window->window()->ShowInactive();
 
   WindowController* controller = new_window->extension_window_controller();
 
+  std::unique_ptr<base::Value> result;
   if (new_window->profile()->IsOffTheRecord() &&
-      !GetProfile()->IsOffTheRecord() && !include_incognito()) {
+      !browser_context()->IsOffTheRecord() && !include_incognito()) {
     // Don't expose incognito windows if extension itself works in non-incognito
     // profile and CanCrossIncognito isn't allowed.
-    SetResult(base::Value::CreateNullValue());
+    result = base::Value::CreateNullValue();
   } else {
-    SetResult(controller->CreateWindowValueWithTabs(extension()));
+    result = controller->CreateWindowValueWithTabs(extension());
   }
 
-  return true;
+  return RespondNow(OneArgument(std::move(result)));
 }
 
-bool WindowsUpdateFunction::RunSync() {
+ExtensionFunction::ResponseAction WindowsUpdateFunction::Run() {
   std::unique_ptr<windows::Update::Params> params(
       windows::Update::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WindowController* controller;
+  std::string error;
   if (!windows_util::GetWindowFromWindowID(
           this, params->window_id, WindowController::GetAllWindowFilter(),
-          &controller, &error_)) {
-    return false;
+          &controller, &error)) {
+    return RespondNow(Error(error));
   }
 
   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());
 
   switch (show_state) {
@@ skipping 41 matching lines @@
 
   if (params->update_info.height) {
     bounds.set_height(*params->update_info.height);
     set_bounds = true;
   }
 
   if (set_bounds) {
     if (show_state == ui::SHOW_STATE_MINIMIZED ||
         show_state == ui::SHOW_STATE_MAXIMIZED ||
         show_state == ui::SHOW_STATE_FULLSCREEN) {
-      error_ = keys::kInvalidWindowStateError;
-      return false;
+      return RespondNow(Error(keys::kInvalidWindowStateError));
     }
     // TODO(varkha): Updating bounds during a drag can cause problems and a more
     // general solution is needed. See http://crbug.com/251813 .
     controller->window()->SetBounds(bounds);
   }
 
   if (params->update_info.focused) {
     if (*params->update_info.focused) {
-      if (show_state == ui::SHOW_STATE_MINIMIZED) {
-        error_ = keys::kInvalidWindowStateError;
-        return false;
-      }
+      if (show_state == ui::SHOW_STATE_MINIMIZED)
+        return RespondNow(Error(keys::kInvalidWindowStateError));
       controller->window()->Activate();
     } else {
       if (show_state == ui::SHOW_STATE_MAXIMIZED ||
           show_state == ui::SHOW_STATE_FULLSCREEN) {
-        error_ = keys::kInvalidWindowStateError;
-        return false;
+        return RespondNow(Error(keys::kInvalidWindowStateError));
       }
       controller->window()->Deactivate();
     }
   }
 
   if (params->update_info.draw_attention)
     controller->window()->FlashFrame(*params->update_info.draw_attention);
 
-  SetResult(controller->CreateWindowValue());
-
-  return true;
+  return RespondNow(OneArgument(controller->CreateWindowValue()));
 }
 
-bool WindowsRemoveFunction::RunSync() {
+ExtensionFunction::ResponseAction WindowsRemoveFunction::Run() {
   std::unique_ptr<windows::Remove::Params> params(
       windows::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  WindowController* controller;
+  WindowController* controller = nullptr;
+  std::string error;
   if (!windows_util::GetWindowFromWindowID(this, params->window_id,
                                            WindowController::kNoWindowFilter,
-                                           &controller, &error_)) {
-    return false;
+                                           &controller, &error)) {
+    return RespondNow(Error(error));
   }
 
   WindowController::Reason reason;
   if (!controller->CanClose(&reason)) {
-    if (reason == WindowController::REASON_NOT_EDITABLE)
-      error_ = keys::kTabStripNotEditableError;
-    return false;
+    return RespondNow(Error(reason == WindowController::REASON_NOT_EDITABLE
+                                ? keys::kTabStripNotEditableError
+                                : kUnknownErrorDoNotUse));
   }
   controller->window()->Close();
-  return true;
+  return RespondNow(NoArguments());
 }
 
 // Tabs ------------------------------------------------------------------------
 
-bool TabsGetSelectedFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsGetSelectedFunction::Run() {
   // 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, &error_))
-    return false;
+  std::string error;
+  if (!GetBrowserFromWindowID(this, window_id, &browser, &error))
+    return RespondNow(Error(error));
 
   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;
+  if (!contents)
+    return RespondNow(Error(keys::kNoSelectedTabError));
+  return RespondNow(ArgumentList(
+      tabs::Get::Results::Create(*ExtensionTabUtil::CreateTabObject(
+          contents, tab_strip, tab_strip->active_index(), extension()))));
 }
 
-bool TabsGetAllInWindowFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsGetAllInWindowFunction::Run() {
   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, &error_))
-    return false;
+  std::string error;
+  if (!GetBrowserFromWindowID(this, window_id, &browser, &error))
+    return RespondNow(Error(error));
 
-  SetResult(ExtensionTabUtil::CreateTabList(browser, extension()));
-
-  return true;
+  return RespondNow(
+      OneArgument(ExtensionTabUtil::CreateTabList(browser, extension())));
 }
 
-bool TabsQueryFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsQueryFunction::Run() {
   std::unique_ptr<tabs::Query::Params> params(
       tabs::Query::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool loading_status_set = params->query_info.status != tabs::TAB_STATUS_NONE;
   bool loading = params->query_info.status == tabs::TAB_STATUS_LOADING;
 
   URLPatternSet url_patterns;
   if (params->query_info.url.get()) {
     std::vector<std::string> url_pattern_strings;
     if (params->query_info.url->as_string)
       url_pattern_strings.push_back(*params->query_info.url->as_string);
     else if (params->query_info.url->as_strings)
       url_pattern_strings.swap(*params->query_info.url->as_strings);
     // 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 meta data.
+    std::string error;
     if (!url_patterns.Populate(url_pattern_strings, URLPattern::SCHEME_ALL,
-                               true, &error_)) {
-      return false;
+                               true, &error)) {
+      return RespondNow(Error(error));
     }
   }
 
   std::string title;
   if (params->query_info.title.get())
     title = *params->query_info.title;
 
   int window_id = extension_misc::kUnknownWindowId;
   if (params->query_info.window_id.get())
     window_id = *params->query_info.window_id;
 
   int index = -1;
   if (params->query_info.index.get())
     index = *params->query_info.index;
 
   std::string window_type;
   if (params->query_info.window_type != tabs::WINDOW_TYPE_NONE)
     window_type = tabs::ToString(params->query_info.window_type);
 
   std::unique_ptr<base::ListValue> result(new base::ListValue());
+  Profile* profile = Profile::FromBrowserContext(browser_context());
   Browser* last_active_browser =
-      chrome::FindAnyBrowser(GetProfile(), include_incognito());
-  Browser* current_browser = GetCurrentBrowser();
+      chrome::FindAnyBrowser(profile, include_incognito());
+  Browser* current_browser =
+      ChromeExtensionFunctionDetails(this).GetCurrentBrowser();
   for (auto* browser : *BrowserList::GetInstance()) {
-    if (!GetProfile()->IsSameProfile(browser->profile()))
+    if (!profile->IsSameProfile(browser->profile()))
       continue;
 
     if (!browser->window())
       continue;
 
-    if (!include_incognito() && GetProfile() != browser->profile())
+    if (!include_incognito() && profile != browser->profile())
       continue;
 
     if (!browser->extension_window_controller()->IsVisibleToExtension(
             extension())) {
       continue;
     }
 
     if (window_id >= 0 && window_id != ExtensionTabUtil::GetWindowId(browser))
       continue;
 
@@ skipping 88 matching lines @@
 
       if (loading_status_set && loading != web_contents->IsLoading())
         continue;
 
       result->Append(ExtensionTabUtil::CreateTabObject(web_contents, tab_strip,
                                                        i, extension())
                          ->ToValue());
     }
   }
 
-  SetResult(std::move(result));
-  return true;
+  return RespondNow(OneArgument(std::move(result)));
 }
 
-bool TabsCreateFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsCreateFunction::Run() {
   std::unique_ptr<tabs::Create::Params> params(
       tabs::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   ExtensionTabUtil::OpenTabParams options;
   AssignOptionalValue(params->create_properties.window_id, options.window_id);
   AssignOptionalValue(params->create_properties.opener_tab_id,
                       options.opener_tab_id);
   AssignOptionalValue(params->create_properties.selected, options.active);
   // The 'active' property has replaced the 'selected' property.
   AssignOptionalValue(params->create_properties.active, options.active);
   AssignOptionalValue(params->create_properties.pinned, options.pinned);
   AssignOptionalValue(params->create_properties.index, options.index);
   AssignOptionalValue(params->create_properties.url, options.url);
 
   std::string error;
   std::unique_ptr<base::DictionaryValue> result(
       ExtensionTabUtil::OpenTab(this, options, &error));
-  if (!result) {
-    SetError(error);
-    return false;
-  }
+  if (!result)
+    return RespondNow(Error(error));
 
   // Return data about the newly created tab.
-  if (has_callback()) {
-    SetResult(std::move(result));
-  }
-  return true;
+  return RespondNow(has_callback() ? OneArgument(std::move(result))
+                                   : NoArguments());
 }
 
-bool TabsDuplicateFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsDuplicateFunction::Run() {
   std::unique_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(),
-                  include_incognito(),
-                  &browser,
-                  &tab_strip,
-                  NULL,
-                  &tab_index,
-                  &error_)) {
-    return false;
+  std::string error;
+  if (!GetTabById(tab_id, browser_context(), include_incognito(), &browser,
+                  &tab_strip, NULL, &tab_index, &error)) {
+    return RespondNow(Error(error));
   }
 
   WebContents* new_contents = chrome::DuplicateTabAt(browser, tab_index);
   if (!has_callback())
-    return true;
+    return RespondNow(NoArguments());
 
   // Duplicated tab may not be in the same window as the original, so find
   // the window and the tab.
   TabStripModel* new_tab_strip = NULL;
   int new_tab_index = -1;
   ExtensionTabUtil::GetTabStripModel(new_contents,
                                      &new_tab_strip,
                                      &new_tab_index);
   if (!new_tab_strip || new_tab_index == -1) {
-    return false;
+    return RespondNow(Error(kUnknownErrorDoNotUse));
   }
 
-  // Return data about the newly created tab.
-  results_ = tabs::Get::Results::Create(*ExtensionTabUtil::CreateTabObject(
-      new_contents, new_tab_strip, new_tab_index, extension()));
-
-  return true;
+  return RespondNow(ArgumentList(
+      tabs::Get::Results::Create(*ExtensionTabUtil::CreateTabObject(
+          new_contents, new_tab_strip, new_tab_index, extension()))));
 }
 
-bool TabsGetFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsGetFunction::Run() {
   std::unique_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;
+  std::string error;
+  if (!GetTabById(tab_id, browser_context(), include_incognito(), NULL,
+                  &tab_strip, &contents, &tab_index, &error)) {
+    return RespondNow(Error(error));
+  }
 
-  results_ = tabs::Get::Results::Create(*ExtensionTabUtil::CreateTabObject(
-      contents, tab_strip, tab_index, extension()));
-  return true;
+  return RespondNow(ArgumentList(
+      tabs::Get::Results::Create(*ExtensionTabUtil::CreateTabObject(
+          contents, tab_strip, tab_index, extension()))));
 }
 
-bool TabsGetCurrentFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsGetCurrentFunction::Run() {
   DCHECK(dispatcher());
 
   // Return the caller, if it's a tab. If not the result isn't an error but an
   // empty tab (hence returning true).
   WebContents* caller_contents = GetSenderWebContents();
-  if (caller_contents && ExtensionTabUtil::GetTabId(caller_contents) >= 0)
-    results_ = tabs::Get::Results::Create(
+  std::unique_ptr<base::ListValue> results;
+  if (caller_contents && ExtensionTabUtil::GetTabId(caller_contents) >= 0) {
+    results = tabs::Get::Results::Create(
         *ExtensionTabUtil::CreateTabObject(caller_contents, extension()));
-
-  return true;
+  }
+  return RespondNow(results ? ArgumentList(std::move(results)) : NoArguments());
 }
 
-bool TabsHighlightFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsHighlightFunction::Run() {
   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, &error_))
-    return false;
+  std::string error;
+  if (!GetBrowserFromWindowID(this, window_id, &browser, &error))
+    return RespondNow(Error(error));
 
   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) {
-      if (!HighlightTab(tabstrip, &selection, &active_index, tab_indices[i]))
-        return false;
+      if (!HighlightTab(tabstrip, &selection, &active_index, tab_indices[i],
+                        &error)) {
+        return RespondNow(Error(error));
+      }
     }
   } else {
     EXTENSION_FUNCTION_VALIDATE(params->highlight_info.tabs.as_integer);
-    if (!HighlightTab(tabstrip,
-                      &selection,
-                      &active_index,
-                      *params->highlight_info.tabs.as_integer)) {
-      return false;
+    if (!HighlightTab(tabstrip, &selection, &active_index,
+                      *params->highlight_info.tabs.as_integer, &error)) {
+      return RespondNow(Error(error));
     }
   }
 
   // Make sure they actually specified tabs to select.
-  if (selection.empty()) {
-    error_ = keys::kNoHighlightedTabError;
-    return false;
-  }
+  if (selection.empty())
+    return RespondNow(Error(keys::kNoHighlightedTabError));
 
   selection.set_active(active_index);
   browser->tab_strip_model()->SetSelectionFromModel(selection);
-  SetResult(browser->extension_window_controller()->CreateWindowValueWithTabs(
-      extension()));
-  return true;
+  return RespondNow(OneArgument(
+      browser->extension_window_controller()->CreateWindowValueWithTabs(
+          extension())));
 }
 
 bool TabsHighlightFunction::HighlightTab(TabStripModel* tabstrip,
                                          ui::ListSelectionModel* selection,
                                          int* active_index,
-                                         int index) {
+                                         int index,
+                                         std::string* error) {
   // Make sure the index is in range.
   if (!tabstrip->ContainsIndex(index)) {
-    error_ = ErrorUtils::FormatErrorMessage(
-        keys::kTabIndexNotFoundError, base::IntToString(index));
+    *error = ErrorUtils::FormatErrorMessage(keys::kTabIndexNotFoundError,
+                                            base::IntToString(index));
     return false;
   }
 
   // By default, we make the first tab in the list active.
   if (*active_index == -1)
     *active_index = index;
 
   selection->AddIndexToSelection(index);
   return true;
 }
@@ skipping 19 matching lines @@
       error_ = keys::kNoSelectedTabError;
       return false;
     }
     tab_id = SessionTabHelper::IdForTab(contents);
   } else {
     tab_id = *params->tab_id;
   }
 
   int tab_index = -1;
   TabStripModel* tab_strip = NULL;
-  if (!GetTabById(tab_id,
-                  GetProfile(),
-                  include_incognito(),
-                  NULL,
-                  &tab_strip,
-                  &contents,
-                  &tab_index,
-                  &error_)) {
+  if (!GetTabById(tab_id, browser_context(), include_incognito(), NULL,
+                  &tab_strip, &contents, &tab_index, &error_)) {
     return false;
   }
 
   web_contents_ = contents;
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
   // -favIconUrl
 
   // Navigate the tab to a new location if the url is different.
@@ skipping 51 matching lines @@
         error_ = ErrorUtils::FormatErrorMessage(keys::kCannotUpdateMuteCaptured,
                                                 base::IntToString(tab_id));
         return false;
     }
   }
 
   if (params->update_properties.opener_tab_id.get()) {
     int opener_id = *params->update_properties.opener_tab_id;
 
     WebContents* opener_contents = NULL;
-    if (!ExtensionTabUtil::GetTabById(opener_id,
-                                      GetProfile(),
-                                      include_incognito(),
-                                      NULL,
-                                      NULL,
-                                      &opener_contents,
-                                      NULL))
+    if (!ExtensionTabUtil::GetTabById(opener_id, browser_context(),
+                                      include_incognito(), nullptr, nullptr,
+                                      &opener_contents, nullptr))
       return false;
 
     tab_strip->SetOpenerOfWebContentsAt(tab_index, opener_contents);
   }
 
   if (params->update_properties.auto_discardable.get()) {
     bool state = *params->update_properties.auto_discardable;
     g_browser_process->GetTabManager()->SetTabAutoDiscardableState(contents,
                                                                    state);
   }
@@ skipping 77 matching lines @@
     const std::string& error,
     const GURL& url,
     const base::ListValue& script_result) {
   if (error.empty())
     PopulateResult();
   else
     error_ = error;
   SendResponse(error.empty());
 }
 
-bool TabsMoveFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsMoveFunction::Run() {
   std::unique_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();
   std::unique_ptr<base::ListValue> tab_values(new base::ListValue());
 
   size_t num_tabs = 0;
+  std::string error;
   if (params->tab_ids.as_integers) {
     std::vector<int>& tab_ids = *params->tab_ids.as_integers;
     num_tabs = tab_ids.size();
     for (size_t i = 0; i < tab_ids.size(); ++i) {
-      if (!MoveTab(tab_ids[i], &new_index, i, tab_values.get(), window_id))
-        return false;
+      if (!MoveTab(tab_ids[i], &new_index, i, tab_values.get(), window_id,
+                   &error)) {
+        return RespondNow(Error(error));
+      }
     }
   } else {
     EXTENSION_FUNCTION_VALIDATE(params->tab_ids.as_integer);
     num_tabs = 1;
-    if (!MoveTab(*params->tab_ids.as_integer,
-                 &new_index,
-                 0,
-                 tab_values.get(),
-                 window_id)) {
-      return false;
+    if (!MoveTab(*params->tab_ids.as_integer, &new_index, 0, tab_values.get(),
+                 window_id, &error)) {
+      return RespondNow(Error(error));
     }
   }
 
+  // TODO(devlin): It's weird that whether or not the method provides a callback
+  // can determine its success (as we return errors below).
   if (!has_callback())
-    return true;
+    return RespondNow(NoArguments());
 
-  if (num_tabs == 0) {
-    error_ = "No tabs given.";
-    return false;
-  } else if (num_tabs == 1) {
+  if (num_tabs == 0)
+    return RespondNow(Error("No tabs given."));
+  if (num_tabs == 1) {
     std::unique_ptr<base::Value> value;
     CHECK(tab_values->Remove(0, &value));
-    SetResult(std::move(value));
-  } else {
-    // Only return the results as an array if there are multiple tabs.
-    SetResult(std::move(tab_values));
+    return RespondNow(OneArgument(std::move(value)));
   }
 
-  return true;
+  // Return the results as an array if there are multiple tabs.
+  return RespondNow(OneArgument(std::move(tab_values)));
 }
 
 bool TabsMoveFunction::MoveTab(int tab_id,
                                int* new_index,
                                int iteration,
                                base::ListValue* tab_values,
-                               int* window_id) {
+                               int* window_id,
+                               std::string* error) {
   Browser* source_browser = NULL;
   TabStripModel* source_tab_strip = NULL;
   WebContents* contents = NULL;
   int tab_index = -1;
-  if (!GetTabById(tab_id,
-                  GetProfile(),
-                  include_incognito(),
-                  &source_browser,
-                  &source_tab_strip,
-                  &contents,
-                  &tab_index,
-                  &error_)) {
+  if (!GetTabById(tab_id, browser_context(), include_incognito(),
+                  &source_browser, &source_tab_strip, &contents, &tab_index,
+                  error)) {
     return false;
   }
 
   // Don't let the extension move the tab if the user is dragging tabs.
   if (!source_browser->window()->IsTabStripEditable()) {
-    error_ = keys::kTabStripNotEditableError;
+    *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, &error_))
+    if (!GetBrowserFromWindowID(this, *window_id, &target_browser, error))
       return false;
 
     if (!target_browser->window()->IsTabStripEditable()) {
-      error_ = keys::kTabStripNotEditableError;
+      *error = keys::kTabStripNotEditableError;
       return false;
     }
 
     if (!target_browser->is_type_tabbed()) {
-      error_ = keys::kCanOnlyMoveTabsWithinNormalWindowsError;
+      *error = keys::kCanOnlyMoveTabsWithinNormalWindowsError;
       return false;
     }
 
     if (target_browser->profile() != source_browser->profile()) {
-      error_ = keys::kCanOnlyMoveTabsWithinSameProfileError;
+      *error = keys::kCanOnlyMoveTabsWithinSameProfileError;
       return false;
     }
 
     // If windowId is different from the current window, move between windows.
     if (ExtensionTabUtil::GetWindowId(target_browser) !=
         ExtensionTabUtil::GetWindowId(source_browser)) {
       TabStripModel* target_tab_strip = target_browser->tab_strip_model();
       WebContents* web_contents =
           source_tab_strip->DetachWebContentsAt(tab_index);
       if (!web_contents) {
-        error_ = ErrorUtils::FormatErrorMessage(
-            keys::kTabNotFoundError, base::IntToString(tab_id));
+        *error = ErrorUtils::FormatErrorMessage(keys::kTabNotFoundError,
+                                                base::IntToString(tab_id));
         return false;
       }
 
       // Clamp move location to the last position.
       // This is ">" because it can append to a new index position.
       // -1 means set the move location to the last position.
       if (*new_index > target_tab_strip->count() || *new_index < 0)
         *new_index = target_tab_strip->count();
 
       target_tab_strip->InsertWebContentsAt(
@@ skipping 22 matching lines @@
 
   if (has_callback()) {
     tab_values->Append(ExtensionTabUtil::CreateTabObject(
                            contents, source_tab_strip, *new_index, extension())
                            ->ToValue());
   }
 
   return true;
 }
 
-bool TabsReloadFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsReloadFunction::Run() {
   std::unique_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;
   }
 
   content::WebContents* web_contents = NULL;
 
   // If |tab_id| is specified, look for it. Otherwise default to selected tab
   // in the current window.
+  Browser* current_browser =
+      ChromeExtensionFunctionDetails(this).GetCurrentBrowser();
   if (!params->tab_id.get()) {
-    Browser* browser = GetCurrentBrowser();
-    if (!browser) {
-      error_ = keys::kNoCurrentWindowError;
-      return false;
-    }
+    if (!current_browser)
+      return RespondNow(Error(keys::kNoCurrentWindowError));
 
-    if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, NULL))
-      return false;
+    if (!ExtensionTabUtil::GetDefaultTab(current_browser, &web_contents, NULL))
+      return RespondNow(Error(kUnknownErrorDoNotUse));
   } else {
     int tab_id = *params->tab_id;
 
     Browser* browser = NULL;
-    if (!GetTabById(tab_id,
-                    GetProfile(),
-                    include_incognito(),
-                    &browser,
-                    NULL,
-                    &web_contents,
-                    NULL,
-                    &error_)) {
-      return false;
+    std::string error;
+    if (!GetTabById(tab_id, browser_context(), include_incognito(), &browser,
+                    NULL, &web_contents, NULL, &error)) {
+      return RespondNow(Error(error));
     }
   }
 
   if (web_contents->ShowingInterstitialPage()) {
     // This does as same as Browser::ReloadInternal.
     NavigationEntry* entry = web_contents->GetController().GetVisibleEntry();
     GURL reload_url = entry ? entry->GetURL() : GURL(url::kAboutBlankURL);
     OpenURLParams params(reload_url, Referrer(),
                          WindowOpenDisposition::CURRENT_TAB,
                          ui::PAGE_TRANSITION_RELOAD, false);
-    GetCurrentBrowser()->OpenURL(params);
+    current_browser->OpenURL(params);
   } else if (bypass_cache) {
     web_contents->GetController().ReloadBypassingCache(true);
   } else {
     web_contents->GetController().Reload(true);
   }
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool TabsRemoveFunction::RunSync() {
+ExtensionFunction::ResponseAction TabsRemoveFunction::Run() {
   std::unique_ptr<tabs::Remove::Params> params(
       tabs::Remove::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
+  std::string error;
   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;
+      if (!RemoveTab(tab_ids[i], &error))
+        return RespondNow(Error(error));
     }
   } else {
     EXTENSION_FUNCTION_VALIDATE(params->tab_ids.as_integer);
-    if (!RemoveTab(*params->tab_ids.as_integer))
-      return false;
+    if (!RemoveTab(*params->tab_ids.as_integer, &error))
+      return RespondNow(Error(error));
   }
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool TabsRemoveFunction::RemoveTab(int tab_id) {
+bool TabsRemoveFunction::RemoveTab(int tab_id, std::string* error) {
   Browser* browser = NULL;
   WebContents* contents = NULL;
-  if (!GetTabById(tab_id,
-                  GetProfile(),
-                  include_incognito(),
-                  &browser,
-                  NULL,
-                  &contents,
-                  NULL,
-                  &error_)) {
+  if (!GetTabById(tab_id, browser_context(), include_incognito(), &browser,
+                  nullptr, &contents, nullptr, 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;
+    *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;
 }
 
@@ skipping 99 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   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 (params->tab_id.get()) {
     tab_id = *params->tab_id;
-    if (!GetTabById(tab_id,
-                    GetProfile(),
-                    include_incognito(),
-                    &browser,
-                    NULL,
-                    &contents,
-                    NULL,
-                    &error_)) {
+    if (!GetTabById(tab_id, browser_context(), include_incognito(), &browser,
+                    nullptr, &contents, nullptr, &error_)) {
       return false;
     }
     if (!browser || !contents)
       return false;
   } else {
     browser = GetCurrentBrowser();
     if (!browser)
       return false;
     contents = browser->tab_strip_model()->GetActiveWebContents();
     if (!contents)
@@ skipping 109 matching lines @@
   set_host_id(HostID(HostID::EXTENSIONS, extension()->id()));
   return true;
 }
 
 bool ExecuteCodeInTabFunction::CanExecuteScriptOnPage() {
   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 (!GetTabById(execute_tab_id_,
-                  chrome_details_.GetProfile(),
-                  include_incognito(),
-                  NULL,
-                  NULL,
-                  &contents,
-                  NULL,
-                  &error_)) {
+  if (!GetTabById(execute_tab_id_, browser_context(), include_incognito(),
+                  nullptr, nullptr, &contents, nullptr, &error_)) {
     return false;
   }
 
   CHECK(contents);
 
   int frame_id = details_->frame_id ? *details_->frame_id
                                     : ExtensionApiFrameIdMap::kTopFrameId;
   content::RenderFrameHost* rfh =
       ExtensionApiFrameIdMap::GetRenderFrameHostById(contents, frame_id);
   if (!rfh) {
@@ skipping 34 matching lines @@
     return false;
   }
 
   return true;
 }
 
 ScriptExecutor* ExecuteCodeInTabFunction::GetScriptExecutor() {
   Browser* browser = NULL;
   content::WebContents* contents = NULL;
 
-  bool success = GetTabById(execute_tab_id_,
-                            chrome_details_.GetProfile(),
-                            include_incognito(),
-                            &browser,
-                            NULL,
-                            &contents,
-                            NULL,
-                            &error_) &&
-                 contents && browser;
+  bool success =
+      GetTabById(execute_tab_id_, browser_context(), include_incognito(),
+                 &browser, nullptr, &contents, nullptr, &error_) &&
+      contents && browser;
 
   if (!success)
     return NULL;
 
   return TabHelper::FromWebContents(contents)->script_executor();
 }
 
 bool ExecuteCodeInTabFunction::IsWebView() const {
   return false;
 }
@@ skipping 16 matching lines @@
 }
 
 bool TabsInsertCSSFunction::ShouldInsertCSS() const {
   return true;
 }
 
 content::WebContents* ZoomAPIFunction::GetWebContents(int tab_id) {
   content::WebContents* web_contents = NULL;
   if (tab_id != -1) {
     // We assume this call leaves web_contents unchanged if it is unsuccessful.
-    GetTabById(tab_id,
-               GetProfile(),
-               include_incognito(),
-               NULL /* ignore Browser* output */,
-               NULL /* ignore TabStripModel* output */,
-               &web_contents,
-               NULL /* ignore int tab_index output */,
-               &error_);
+    GetTabById(tab_id, browser_context(), include_incognito(),
+               nullptr /* ignore Browser* output */,
+               nullptr /* ignore TabStripModel* output */, &web_contents,
+               nullptr /* ignore int tab_index output */, &error_);
   } else {
     Browser* browser = GetCurrentBrowser();
     if (!browser)
       error_ = keys::kNoCurrentWindowError;
     else if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, NULL))
       error_ = keys::kNoSelectedTabError;
   }
   return web_contents;
 }
 
@@ skipping 121 matching lines @@
   SendResponse(true);
   return true;
 }
 
 ExtensionFunction::ResponseAction TabsDiscardFunction::Run() {
   std::unique_ptr<tabs::Discard::Params> params(
       tabs::Discard::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   WebContents* contents = nullptr;
-  Profile* profile = Profile::FromBrowserContext(browser_context());
   // If |tab_id| is given, find the web_contents respective to it.
   // Otherwise invoke discard function in TabManager with null web_contents
   // that will discard the least important tab.
   if (params->tab_id) {
     int tab_id = *params->tab_id;
     std::string error;
-    if (!GetTabById(tab_id, profile, include_incognito(), nullptr, nullptr,
-                    &contents, nullptr, &error)) {
+    if (!GetTabById(tab_id, browser_context(), include_incognito(), nullptr,
+                    nullptr, &contents, nullptr, &error)) {
       return RespondNow(Error(error));
     }
   }
   // Discard the tab.
   contents =
       g_browser_process->GetTabManager()->DiscardTabByExtension(contents);
 
   // Create the Tab object and return it in case of success.
   if (contents) {
     return RespondNow(ArgumentList(tabs::Discard::Results::Create(
         *ExtensionTabUtil::CreateTabObject(contents))));
   }
 
   // Return appropriate error message otherwise.
   return RespondNow(Error(
       params->tab_id
           ? ErrorUtils::FormatErrorMessage(keys::kCannotDiscardTab,
                                            base::IntToString(*params->tab_id))
           : keys::kCannotFindTabToDiscard));
 }
 
 TabsDiscardFunction::TabsDiscardFunction() {}
 TabsDiscardFunction::~TabsDiscardFunction() {}
 
 }  // namespace extensions