[Extensions] Convert some ChromeSyncExtensionFunctions

chrome/browser/chromeos/extensions/file_manager/private_api_misc.cc

 // Copyright 2013 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/chromeos/extensions/file_manager/private_api_misc.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 46 matching lines @@
 #include "url/gurl.h"
 
 namespace extensions {
 namespace {
 
 using api::file_manager_private::ProfileInfo;
 
 const char kCWSScope[] = "https://www.googleapis.com/auth/chromewebstore";
 
 // Obtains the current app window.
-AppWindow* GetCurrentAppWindow(ChromeSyncExtensionFunction* function) {
+AppWindow* GetCurrentAppWindow(UIThreadExtensionFunction* function) {
   content::WebContents* const contents = function->GetSenderWebContents();
-  return contents ?
-      AppWindowRegistry::Get(function->GetProfile())->
-          GetAppWindowForWebContents(contents) : nullptr;
+  return contents
+             ? AppWindowRegistry::Get(function->browser_context())
+                   ->GetAppWindowForWebContents(contents)
+             : nullptr;
 }
 
 std::vector<ProfileInfo> GetLoggedInProfileInfoList() {
   DCHECK(user_manager::UserManager::IsInitialized());
   const std::vector<Profile*>& profiles =
       g_browser_process->profile_manager()->GetLoadedProfiles();
   std::set<Profile*> original_profiles;
   std::vector<ProfileInfo> result_profiles;
 
   for (Profile* profile : profiles) {
@@ skipping 63 matching lines @@
 
   // Erase duplicates.
   std::sort(paths->begin(), paths->end());
   paths->erase(std::unique(paths->begin(), paths->end()), paths->end());
 
   return true;
 }
 
 }  // namespace
 
-bool FileManagerPrivateLogoutUserForReauthenticationFunction::RunSync() {
+ExtensionFunction::ResponseAction
+FileManagerPrivateLogoutUserForReauthenticationFunction::Run() {
   const user_manager::User* user =
-      chromeos::ProfileHelper::Get()->GetUserByProfile(GetProfile());
+      chromeos::ProfileHelper::Get()->GetUserByProfile(
+          Profile::FromBrowserContext(browser_context()));
   if (user) {
     user_manager::UserManager::Get()->SaveUserOAuthStatus(
         user->GetAccountId(), user_manager::User::OAUTH2_TOKEN_STATUS_INVALID);
   }
 
   chrome::AttemptUserExit();
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool FileManagerPrivateGetPreferencesFunction::RunSync() {
+ExtensionFunction::ResponseAction
+FileManagerPrivateGetPreferencesFunction::Run() {
   api::file_manager_private::Preferences result;
-  const PrefService* const service = GetProfile()->GetPrefs();
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  const PrefService* const service = profile->GetPrefs();
 
-  result.drive_enabled = drive::util::IsDriveEnabledForProfile(GetProfile());
+  result.drive_enabled = drive::util::IsDriveEnabledForProfile(profile);
   result.cellular_disabled =
       service->GetBoolean(drive::prefs::kDisableDriveOverCellular);
   result.hosted_files_disabled =
       service->GetBoolean(drive::prefs::kDisableDriveHostedFiles);
   result.search_suggest_enabled =
       service->GetBoolean(prefs::kSearchSuggestEnabled);
   result.use24hour_clock = service->GetBoolean(prefs::kUse24HourClock);
   result.allow_redeem_offers = true;
   if (!chromeos::CrosSettings::Get()->GetBoolean(
           chromeos::kAllowRedeemChromeOsRegistrationOffers,
           &result.allow_redeem_offers)) {
     result.allow_redeem_offers = true;
   }
   result.timezone =
       UTF16ToUTF8(chromeos::system::TimezoneSettings::GetInstance()
                       ->GetCurrentTimezoneID());
 
-  SetResult(result.ToValue());
-
-  drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
+  drive::EventLogger* logger = file_manager::util::GetLogger(profile);
   if (logger)
     logger->Log(logging::LOG_INFO, "%s succeeded.", name());
-  return true;
+
+  return RespondNow(OneArgument(result.ToValue()));
 }
 
-bool FileManagerPrivateSetPreferencesFunction::RunSync() {
+ExtensionFunction::ResponseAction
+FileManagerPrivateSetPreferencesFunction::Run() {
   using extensions::api::file_manager_private::SetPreferences::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  PrefService* const service = GetProfile()->GetPrefs();
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  PrefService* const service = profile->GetPrefs();
 
   if (params->change_info.cellular_disabled)
     service->SetBoolean(drive::prefs::kDisableDriveOverCellular,
                         *params->change_info.cellular_disabled);
 
   if (params->change_info.hosted_files_disabled)
     service->SetBoolean(drive::prefs::kDisableDriveHostedFiles,
                         *params->change_info.hosted_files_disabled);
 
-  drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
+  drive::EventLogger* logger = file_manager::util::GetLogger(profile);
   if (logger)
     logger->Log(logging::LOG_INFO, "%s succeeded.", name());
-  return true;
+  return RespondNow(NoArguments());
 }
 
 FileManagerPrivateInternalZipSelectionFunction::
     FileManagerPrivateInternalZipSelectionFunction() {}
 
 FileManagerPrivateInternalZipSelectionFunction::
     ~FileManagerPrivateInternalZipSelectionFunction() {}
 
 bool FileManagerPrivateInternalZipSelectionFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::ZipSelection::Params;
@@ skipping 49 matching lines @@
        src_dir, src_relative_paths, dest_file))
       ->Start();
   return true;
 }
 
 void FileManagerPrivateInternalZipSelectionFunction::OnZipDone(bool success) {
   SetResult(base::MakeUnique<base::FundamentalValue>(success));
   SendResponse(true);
 }
 
-bool FileManagerPrivateZoomFunction::RunSync() {
+ExtensionFunction::ResponseAction FileManagerPrivateZoomFunction::Run() {
   using extensions::api::file_manager_private::Zoom::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   content::PageZoom zoom_type;
   switch (params->operation) {
     case api::file_manager_private::ZOOM_OPERATION_TYPE_IN:
       zoom_type = content::PAGE_ZOOM_IN;
       break;
     case api::file_manager_private::ZOOM_OPERATION_TYPE_OUT:
       zoom_type = content::PAGE_ZOOM_OUT;
       break;
     case api::file_manager_private::ZOOM_OPERATION_TYPE_RESET:
       zoom_type = content::PAGE_ZOOM_RESET;
       break;
     default:
       NOTREACHED();
-      return false;
+      return RespondNow(Error(kUnknownErrorDoNotUse));
   }
   zoom::PageZoom::Zoom(GetSenderWebContents(), zoom_type);
-  return true;
+  return RespondNow(NoArguments());
 }
 
 FileManagerPrivateRequestWebStoreAccessTokenFunction::
     FileManagerPrivateRequestWebStoreAccessTokenFunction() {
 }
 
 FileManagerPrivateRequestWebStoreAccessTokenFunction::
     ~FileManagerPrivateRequestWebStoreAccessTokenFunction() {
 }
 
@@ skipping 48 matching lines @@
     if (logger) {
       logger->Log(logging::LOG_ERROR,
                   "CWS OAuth token fetch failed. (DriveApiErrorCode: %s)",
                   google_apis::DriveApiErrorCodeToString(code).c_str());
     }
     SetResult(base::Value::CreateNullValue());
     SendResponse(false);
   }
 }
 
-bool FileManagerPrivateGetProfilesFunction::RunSync() {
+ExtensionFunction::ResponseAction FileManagerPrivateGetProfilesFunction::Run() {
   const std::vector<ProfileInfo>& profiles = GetLoggedInProfileInfoList();
 
   // Obtains the display profile ID.
   AppWindow* const app_window = GetCurrentAppWindow(this);
   chrome::MultiUserWindowManager* const window_manager =
       chrome::MultiUserWindowManager::GetInstance();
-  const AccountId current_profile_id =
-      multi_user_util::GetAccountIdFromProfile(GetProfile());
+  const AccountId current_profile_id = multi_user_util::GetAccountIdFromProfile(
+      Profile::FromBrowserContext(browser_context()));
   const AccountId display_profile_id =
       window_manager && app_window
           ? window_manager->GetUserPresentingWindow(
                 app_window->GetNativeWindow())
           : EmptyAccountId();
 
-  results_ = api::file_manager_private::GetProfiles::Results::Create(
-      profiles, current_profile_id.GetUserEmail(),
-      display_profile_id.is_valid() ? display_profile_id.GetUserEmail()
-                                    : current_profile_id.GetUserEmail());
-  return true;
+  return RespondNow(
+      ArgumentList(api::file_manager_private::GetProfiles::Results::Create(
+          profiles, current_profile_id.GetUserEmail(),
+          display_profile_id.is_valid() ? display_profile_id.GetUserEmail()
+                                        : current_profile_id.GetUserEmail())));
 }
 
-bool FileManagerPrivateOpenInspectorFunction::RunSync() {
+ExtensionFunction::ResponseAction
+FileManagerPrivateOpenInspectorFunction::Run() {
   using extensions::api::file_manager_private::OpenInspector::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   switch (params->type) {
     case extensions::api::file_manager_private::INSPECTION_TYPE_NORMAL:
       // Open inspector for foreground page.
       DevToolsWindow::OpenDevToolsWindow(GetSenderWebContents());
       break;
     case extensions::api::file_manager_private::INSPECTION_TYPE_CONSOLE:
       // Open inspector for foreground page and bring focus to the console.
       DevToolsWindow::OpenDevToolsWindow(GetSenderWebContents(),
                                          DevToolsToggleAction::ShowConsole());
       break;
     case extensions::api::file_manager_private::INSPECTION_TYPE_ELEMENT:
       // Open inspector for foreground page in inspect element mode.
       DevToolsWindow::OpenDevToolsWindow(GetSenderWebContents(),
                                          DevToolsToggleAction::Inspect());
       break;
     case extensions::api::file_manager_private::INSPECTION_TYPE_BACKGROUND:
       // Open inspector for background page.
-      extensions::devtools_util::InspectBackgroundPage(extension(),
-                                                       GetProfile());
+      extensions::devtools_util::InspectBackgroundPage(
+          extension(), Profile::FromBrowserContext(browser_context()));
       break;
     default:
       NOTREACHED();
-      SetError(
+      return RespondNow(Error(
           base::StringPrintf("Unexpected inspection type(%d) is specified.",
-                             static_cast<int>(params->type)));
-      return false;
+                             static_cast<int>(params->type))));
   }
-  return true;
+  return RespondNow(NoArguments());
 }
 
 FileManagerPrivateInternalGetMimeTypeFunction::
     FileManagerPrivateInternalGetMimeTypeFunction() {
 }
 
 FileManagerPrivateInternalGetMimeTypeFunction::
     ~FileManagerPrivateInternalGetMimeTypeFunction() {
 }
 
@@ skipping 248 matching lines @@
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     Respond(Error("Failed to execute the action."));
     return;
   }
 
   Respond(NoArguments());
 }
 
 }  // namespace extensions