[Extensions] Convert some ChromeSyncExtensionFunctions

chrome/browser/extensions/api/downloads/downloads_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/downloads/downloads_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <set>
@@ skipping 26 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_danger_prompt.h"
 #include "chrome/browser/download/download_file_icon_extractor.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_query.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/download/download_stats.h"
 #include "chrome/browser/download/drag_download_item.h"
+#include "chrome/browser/extensions/chrome_extension_function_details.h"
 #include "chrome/browser/icon_loader.h"
 #include "chrome/browser/icon_manager.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/extensions/api/downloads.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
@@ skipping 186 matching lines @@
   base::Time::Exploded exploded;
   t.UTCExplode(&exploded);
   return base::StringPrintf(
       "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", exploded.year, exploded.month,
       exploded.day_of_month, exploded.hour, exploded.minute, exploded.second,
       exploded.millisecond);
 }
 
 std::unique_ptr<base::DictionaryValue> DownloadItemToJSON(
     DownloadItem* download_item,
-    Profile* profile) {
+    content::BrowserContext* browser_context) {
   base::DictionaryValue* json = new base::DictionaryValue();
   json->SetBoolean(kExistsKey, !download_item->GetFileExternallyRemoved());
   json->SetInteger(kIdKey, download_item->GetId());
   const GURL& url = download_item->GetOriginalUrl();
   json->SetString(kUrlKey, (url.is_valid() ? url.spec() : std::string()));
   const GURL& finalUrl = download_item->GetURL();
   json->SetString(kFinalUrlKey,
                   (finalUrl.is_valid() ? finalUrl.spec() : std::string()));
   const GURL& referrer = download_item->GetReferrerUrl();
   json->SetString(kReferrerUrlKey, (referrer.is_valid() ? referrer.spec()
                                                         : std::string()));
   json->SetString(kFilenameKey,
                   download_item->GetTargetFilePath().LossyDisplayName());
   json->SetString(kDangerKey, DangerString(download_item->GetDangerType()));
   json->SetString(kStateKey, StateString(download_item->GetState()));
   json->SetBoolean(kCanResumeKey, download_item->CanResume());
   json->SetBoolean(kPausedKey, download_item->IsPaused());
   json->SetString(kMimeKey, download_item->GetMimeType());
   json->SetString(kStartTimeKey, TimeToISO8601(download_item->GetStartTime()));
   json->SetDouble(kBytesReceivedKey, download_item->GetReceivedBytes());
   json->SetDouble(kTotalBytesKey, download_item->GetTotalBytes());
-  json->SetBoolean(kIncognitoKey, profile->IsOffTheRecord());
+  json->SetBoolean(kIncognitoKey, browser_context->IsOffTheRecord());
   if (download_item->GetState() == DownloadItem::INTERRUPTED) {
     json->SetString(kErrorKey,
                     content::DownloadInterruptReasonToString(
                         download_item->GetLastReason()));
   } else if (download_item->GetState() == DownloadItem::CANCELLED) {
     json->SetString(kErrorKey,
                     content::DownloadInterruptReasonToString(
                         content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED));
   }
   if (!download_item->GetEndTime().is_null())
     json->SetString(kEndTimeKey, TimeToISO8601(download_item->GetEndTime()));
   base::TimeDelta time_remaining;
   if (download_item->TimeRemaining(&time_remaining)) {
     base::Time now = base::Time::Now();
     json->SetString(kEstimatedEndTimeKey, TimeToISO8601(now + time_remaining));
   }
   DownloadedByExtension* by_ext = DownloadedByExtension::Get(download_item);
   if (by_ext) {
     json->SetString(kByExtensionIdKey, by_ext->id());
     json->SetString(kByExtensionNameKey, by_ext->name());
     // Lookup the extension's current name() in case the user changed their
     // language. This won't work if the extension was uninstalled, so the name
     // might be the wrong language.
     const Extension* extension =
-        ExtensionRegistry::Get(profile)
+        ExtensionRegistry::Get(browser_context)
             ->GetExtensionById(by_ext->id(), ExtensionRegistry::EVERYTHING);
     if (extension)
       json->SetString(kByExtensionNameKey, extension->name());
   }
   // TODO(benjhayden): Implement fileSize.
   json->SetDouble(kFileSizeKey, download_item->GetTotalBytes());
   return std::unique_ptr<base::DictionaryValue>(json);
 }
 
 class DownloadFileIconExtractorImpl : public DownloadFileIconExtractor {
@@ skipping 94 matching lines @@
 }
 
 bool IsNotTemporaryDownloadFilter(const DownloadItem& download_item) {
   return !download_item.IsTemporary();
 }
 
 // Set |manager| to the on-record DownloadManager, and |incognito_manager| to
 // the off-record DownloadManager if one exists and is requested via
 // |include_incognito|. This should work regardless of whether |profile| is
 // original or incognito.
-void GetManagers(
-    Profile* profile,
-    bool include_incognito,
-    DownloadManager** manager,
-    DownloadManager** incognito_manager) {
+void GetManagers(content::BrowserContext* context,
+                 bool include_incognito,
+                 DownloadManager** manager,
+                 DownloadManager** incognito_manager) {
+  Profile* profile = Profile::FromBrowserContext(context);
   *manager = BrowserContext::GetDownloadManager(profile->GetOriginalProfile());
   if (profile->HasOffTheRecordProfile() &&
       (include_incognito ||
        profile->IsOffTheRecord())) {
     *incognito_manager = BrowserContext::GetDownloadManager(
         profile->GetOffTheRecordProfile());
   } else {
     *incognito_manager = NULL;
   }
 }
 
-DownloadItem* GetDownload(Profile* profile, bool include_incognito, int id) {
+DownloadItem* GetDownload(content::BrowserContext* context,
+                          bool include_incognito,
+                          int id) {
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
-  GetManagers(profile, include_incognito, &manager, &incognito_manager);
+  GetManagers(context, include_incognito, &manager, &incognito_manager);
   DownloadItem* download_item = manager->GetDownload(id);
   if (!download_item && incognito_manager)
     download_item = incognito_manager->GetDownload(id);
   return download_item;
 }
 
 enum DownloadsFunctionName {
   DOWNLOADS_FUNCTION_DOWNLOAD = 0,
   DOWNLOADS_FUNCTION_SEARCH = 1,
   DOWNLOADS_FUNCTION_PAUSE = 2,
@@ skipping 624 matching lines @@
     DCHECK_NE(content::DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
     error_ = content::DownloadInterruptReasonToString(interrupt_reason);
   }
   SendResponse(error_.empty());
 }
 
 DownloadsSearchFunction::DownloadsSearchFunction() {}
 
 DownloadsSearchFunction::~DownloadsSearchFunction() {}
 
-bool DownloadsSearchFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsSearchFunction::Run() {
   std::unique_ptr<downloads::Search::Params> params(
       downloads::Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
-  GetManagers(GetProfile(), include_incognito(), &manager, &incognito_manager);
+  GetManagers(browser_context(), include_incognito(), &manager,
+              &incognito_manager);
   ExtensionDownloadsEventRouter* router =
       DownloadServiceFactory::GetForBrowserContext(
           manager->GetBrowserContext())->GetExtensionEventRouter();
   router->CheckForHistoryFilesRemoval();
   if (incognito_manager) {
     ExtensionDownloadsEventRouter* incognito_router =
         DownloadServiceFactory::GetForBrowserContext(
             incognito_manager->GetBrowserContext())->GetExtensionEventRouter();
     incognito_router->CheckForHistoryFilesRemoval();
   }
   DownloadQuery::DownloadVector results;
-  RunDownloadQuery(params->query,
-                   manager,
-                   incognito_manager,
-                   &error_,
-                   &results);
-  if (!error_.empty())
-    return false;
+  std::string error;
+  RunDownloadQuery(params->query, manager, incognito_manager, &error, &results);
+  if (!error.empty())
+    return RespondNow(Error(error));
 
   std::unique_ptr<base::ListValue> json_results(new base::ListValue());
   for (DownloadManager::DownloadVector::const_iterator it = results.begin();
        it != results.end(); ++it) {
     DownloadItem* download_item = *it;
     uint32_t download_id = download_item->GetId();
     bool off_record = ((incognito_manager != NULL) &&
                        (incognito_manager->GetDownload(download_id) != NULL));
-    std::unique_ptr<base::DictionaryValue> json_item(DownloadItemToJSON(
-        *it, off_record ? GetProfile()->GetOffTheRecordProfile()
-                        : GetProfile()->GetOriginalProfile()));
+    Profile* profile = Profile::FromBrowserContext(browser_context());
+    std::unique_ptr<base::DictionaryValue> json_item(
+        DownloadItemToJSON(*it, off_record ? profile->GetOffTheRecordProfile()
+                                           : profile->GetOriginalProfile()));
     json_results->Append(std::move(json_item));
   }
-  SetResult(std::move(json_results));
   RecordApiFunctions(DOWNLOADS_FUNCTION_SEARCH);
-  return true;
+  return RespondNow(OneArgument(std::move(json_results)));
 }
 
 DownloadsPauseFunction::DownloadsPauseFunction() {}
 
 DownloadsPauseFunction::~DownloadsPauseFunction() {}
 
-bool DownloadsPauseFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsPauseFunction::Run() {
   std::unique_ptr<downloads::Pause::Params> params(
       downloads::Pause::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), params->download_id);
-  if (InvalidId(download_item, &error_) ||
+      GetDownload(browser_context(), include_incognito(), params->download_id);
+  std::string error;
+  if (InvalidId(download_item, &error) ||
       Fault(download_item->GetState() != DownloadItem::IN_PROGRESS,
-            errors::kNotInProgress, &error_))
-    return false;
+            errors::kNotInProgress, &error)) {
+    return RespondNow(Error(error));
+  }
   // If the item is already paused, this is a no-op and the operation will
   // silently succeed.
   download_item->Pause();
   RecordApiFunctions(DOWNLOADS_FUNCTION_PAUSE);
-  return true;
+  return RespondNow(NoArguments());
 }
 
 DownloadsResumeFunction::DownloadsResumeFunction() {}
 
 DownloadsResumeFunction::~DownloadsResumeFunction() {}
 
-bool DownloadsResumeFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsResumeFunction::Run() {
   std::unique_ptr<downloads::Resume::Params> params(
       downloads::Resume::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), params->download_id);
-  if (InvalidId(download_item, &error_) ||
+      GetDownload(browser_context(), include_incognito(), params->download_id);
+  std::string error;
+  if (InvalidId(download_item, &error) ||
       Fault(download_item->IsPaused() && !download_item->CanResume(),
-            errors::kNotResumable, &error_))
-    return false;
+            errors::kNotResumable, &error)) {
+    return RespondNow(Error(error));
+  }
   // Note that if the item isn't paused, this will be a no-op, and the extension
   // call will seem successful.
   download_item->Resume();
   RecordApiFunctions(DOWNLOADS_FUNCTION_RESUME);
-  return true;
+  return RespondNow(NoArguments());
 }
 
 DownloadsCancelFunction::DownloadsCancelFunction() {}
 
 DownloadsCancelFunction::~DownloadsCancelFunction() {}
 
-bool DownloadsCancelFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsCancelFunction::Run() {
   std::unique_ptr<downloads::Resume::Params> params(
       downloads::Resume::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), params->download_id);
+      GetDownload(browser_context(), include_incognito(), params->download_id);
   if (download_item &&
       (download_item->GetState() == DownloadItem::IN_PROGRESS))
     download_item->Cancel(true);
   // |download_item| can be NULL if the download ID was invalid or if the
   // download is not currently active.  Either way, it's not a failure.
   RecordApiFunctions(DOWNLOADS_FUNCTION_CANCEL);
-  return true;
+  return RespondNow(NoArguments());
 }
 
 DownloadsEraseFunction::DownloadsEraseFunction() {}
 
 DownloadsEraseFunction::~DownloadsEraseFunction() {}
 
-bool DownloadsEraseFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsEraseFunction::Run() {
   std::unique_ptr<downloads::Erase::Params> params(
       downloads::Erase::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
-  GetManagers(GetProfile(), include_incognito(), &manager, &incognito_manager);
+  GetManagers(browser_context(), include_incognito(), &manager,
+              &incognito_manager);
   DownloadQuery::DownloadVector results;
-  RunDownloadQuery(params->query,
-                   manager,
-                   incognito_manager,
-                   &error_,
-                   &results);
-  if (!error_.empty())
-    return false;
+  std::string error;
+  RunDownloadQuery(params->query, manager, incognito_manager, &error, &results);
+  if (!error.empty())
+    return RespondNow(Error(error));
   std::unique_ptr<base::ListValue> json_results(new base::ListValue());
   for (DownloadManager::DownloadVector::const_iterator it = results.begin();
        it != results.end(); ++it) {
     json_results->AppendInteger(static_cast<int>((*it)->GetId()));
     (*it)->Remove();
   }
-  SetResult(std::move(json_results));
   RecordApiFunctions(DOWNLOADS_FUNCTION_ERASE);
-  return true;
+  return RespondNow(OneArgument(std::move(json_results)));
 }
 
 DownloadsRemoveFileFunction::DownloadsRemoveFileFunction() {
 }
 
 DownloadsRemoveFileFunction::~DownloadsRemoveFileFunction() {
 }
 
 bool DownloadsRemoveFileFunction::RunAsync() {
   std::unique_ptr<downloads::RemoveFile::Params> params(
       downloads::RemoveFile::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), params->download_id);
+      GetDownload(browser_context(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
       Fault((download_item->GetState() != DownloadItem::COMPLETE),
             errors::kNotComplete, &error_) ||
       Fault(download_item->GetFileExternallyRemoved(),
             errors::kFileAlreadyDeleted, &error_))
     return false;
   RecordApiFunctions(DOWNLOADS_FUNCTION_REMOVE_FILE);
   download_item->DeleteFile(
       base::Bind(&DownloadsRemoveFileFunction::Done, this));
   return true;
@@ skipping 17 matching lines @@
 bool DownloadsAcceptDangerFunction::RunAsync() {
   std::unique_ptr<downloads::AcceptDanger::Params> params(
       downloads::AcceptDanger::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   PromptOrWait(params->download_id, 10);
   return true;
 }
 
 void DownloadsAcceptDangerFunction::PromptOrWait(int download_id, int retries) {
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), download_id);
+      GetDownload(browser_context(), include_incognito(), download_id);
   content::WebContents* web_contents = dispatcher()->GetVisibleWebContents();
   if (InvalidId(download_item, &error_) ||
       Fault(download_item->GetState() != DownloadItem::IN_PROGRESS,
             errors::kNotInProgress, &error_) ||
       Fault(!download_item->IsDangerous(), errors::kNotDangerous, &error_) ||
       Fault(!web_contents, errors::kInvisibleContext, &error_)) {
     SendResponse(error_.empty());
     return;
   }
   bool visible = platform_util::IsVisible(web_contents->GetNativeView());
@@ skipping 21 matching lines @@
   // DownloadDangerPrompt deletes itself
   if (on_prompt_created_ && !on_prompt_created_->is_null())
     on_prompt_created_->Run(prompt);
   // Function finishes in DangerPromptCallback().
 }
 
 void DownloadsAcceptDangerFunction::DangerPromptCallback(
     int download_id, DownloadDangerPrompt::Action action) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), download_id);
+      GetDownload(browser_context(), include_incognito(), download_id);
   if (InvalidId(download_item, &error_) ||
       Fault(download_item->GetState() != DownloadItem::IN_PROGRESS,
             errors::kNotInProgress, &error_))
     return;
   switch (action) {
     case DownloadDangerPrompt::ACCEPT:
       download_item->ValidateDangerousDownload();
       break;
     case DownloadDangerPrompt::CANCEL:
       download_item->Remove();
       break;
     case DownloadDangerPrompt::DISMISS:
       break;
   }
   SendResponse(error_.empty());
 }
 
 DownloadsShowFunction::DownloadsShowFunction() {}
 
 DownloadsShowFunction::~DownloadsShowFunction() {}
 
-bool DownloadsShowFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsShowFunction::Run() {
   std::unique_ptr<downloads::Show::Params> params(
       downloads::Show::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), params->download_id);
-  if (InvalidId(download_item, &error_))
-    return false;
+      GetDownload(browser_context(), include_incognito(), params->download_id);
+  std::string error;
+  if (InvalidId(download_item, &error))
+    return RespondNow(Error(error));
   download_item->ShowDownloadInShell();
   RecordApiFunctions(DOWNLOADS_FUNCTION_SHOW);
-  return true;
+  return RespondNow(NoArguments());
 }
 
 DownloadsShowDefaultFolderFunction::DownloadsShowDefaultFolderFunction() {}
 
 DownloadsShowDefaultFolderFunction::~DownloadsShowDefaultFolderFunction() {}
 
-bool DownloadsShowDefaultFolderFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsShowDefaultFolderFunction::Run() {
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
-  GetManagers(GetProfile(), include_incognito(), &manager, &incognito_manager);
+  GetManagers(browser_context(), include_incognito(), &manager,
+              &incognito_manager);
   platform_util::OpenItem(
-      GetProfile(), DownloadPrefs::FromDownloadManager(manager)->DownloadPath(),
+      Profile::FromBrowserContext(browser_context()),
+      DownloadPrefs::FromDownloadManager(manager)->DownloadPath(),
       platform_util::OPEN_FOLDER, platform_util::OpenOperationCallback());
   RecordApiFunctions(DOWNLOADS_FUNCTION_SHOW_DEFAULT_FOLDER);
-  return true;
+  return RespondNow(NoArguments());
 }
 
 DownloadsOpenFunction::DownloadsOpenFunction() {}
 
 DownloadsOpenFunction::~DownloadsOpenFunction() {}
 
-bool DownloadsOpenFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsOpenFunction::Run() {
   std::unique_ptr<downloads::Open::Params> params(
       downloads::Open::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), params->download_id);
-  if (InvalidId(download_item, &error_) ||
-      Fault(!user_gesture(), errors::kUserGesture, &error_) ||
+      GetDownload(browser_context(), include_incognito(), params->download_id);
+  std::string error;
+  if (InvalidId(download_item, &error) ||
+      Fault(!user_gesture(), errors::kUserGesture, &error) ||
       Fault(download_item->GetState() != DownloadItem::COMPLETE,
-            errors::kNotComplete,
-            &error_) ||
+            errors::kNotComplete, &error) ||
       Fault(!extension()->permissions_data()->HasAPIPermission(
                 APIPermission::kDownloadsOpen),
-            errors::kOpenPermission,
-            &error_))
-    return false;
+            errors::kOpenPermission, &error)) {
+    return RespondNow(Error(error));
+  }
   download_item->OpenDownload();
   RecordApiFunctions(DOWNLOADS_FUNCTION_OPEN);
-  return true;
+  return RespondNow(NoArguments());
 }
 
 DownloadsDragFunction::DownloadsDragFunction() {}
 
 DownloadsDragFunction::~DownloadsDragFunction() {}
 
-bool DownloadsDragFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsDragFunction::Run() {
   std::unique_ptr<downloads::Drag::Params> params(
       downloads::Drag::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), params->download_id);
+      GetDownload(browser_context(), include_incognito(), params->download_id);
   content::WebContents* web_contents =
       dispatcher()->GetVisibleWebContents();
-  if (InvalidId(download_item, &error_) ||
-      Fault(!web_contents, errors::kInvisibleContext, &error_))
-    return false;
+  std::string error;
+  if (InvalidId(download_item, &error) ||
+      Fault(!web_contents, errors::kInvisibleContext, &error)) {
+    return RespondNow(Error(error));
+  }
   RecordApiFunctions(DOWNLOADS_FUNCTION_DRAG);
   gfx::Image* icon = g_browser_process->icon_manager()->LookupIconFromFilepath(
       download_item->GetTargetFilePath(), IconLoader::NORMAL);
   gfx::NativeView view = web_contents->GetNativeView();
   {
     // Enable nested tasks during DnD, while |DragDownload()| blocks.
     base::MessageLoop::ScopedNestableTaskAllower allow(
         base::MessageLoop::current());
     DragDownloadItem(download_item, icon, view);
   }
-  return true;
+  return RespondNow(NoArguments());
 }
 
 DownloadsSetShelfEnabledFunction::DownloadsSetShelfEnabledFunction() {}
 
 DownloadsSetShelfEnabledFunction::~DownloadsSetShelfEnabledFunction() {}
 
-bool DownloadsSetShelfEnabledFunction::RunSync() {
+ExtensionFunction::ResponseAction DownloadsSetShelfEnabledFunction::Run() {
   std::unique_ptr<downloads::SetShelfEnabled::Params> params(
       downloads::SetShelfEnabled::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
+  // TODO(devlin): Solve this with the feature system.
   if (!extension()->permissions_data()->HasAPIPermission(
           APIPermission::kDownloadsShelf)) {
-    error_ = download_extension_errors::kShelfPermission;
-    return false;
+    return RespondNow(Error(download_extension_errors::kShelfPermission));
   }
 
   RecordApiFunctions(DOWNLOADS_FUNCTION_SET_SHELF_ENABLED);
   DownloadManager* manager = NULL;
   DownloadManager* incognito_manager = NULL;
-  GetManagers(GetProfile(), include_incognito(), &manager, &incognito_manager);
+  GetManagers(browser_context(), include_incognito(), &manager,
+              &incognito_manager);
   DownloadService* service = NULL;
   DownloadService* incognito_service = NULL;
   if (manager) {
     service = DownloadServiceFactory::GetForBrowserContext(
         manager->GetBrowserContext());
     service->GetExtensionEventRouter()->SetShelfEnabled(extension(),
                                                         params->enabled);
   }
   if (incognito_manager) {
     incognito_service = DownloadServiceFactory::GetForBrowserContext(
@@ skipping 13 matching lines @@
            (current_service == incognito_service)) &&
           browser->window()->IsDownloadShelfVisible() &&
           !current_service->IsShelfEnabled())
         browser->window()->GetDownloadShelf()->Close(DownloadShelf::AUTOMATIC);
     }
   }
 
   if (params->enabled &&
       ((manager && !service->IsShelfEnabled()) ||
        (incognito_manager && !incognito_service->IsShelfEnabled()))) {
-    error_ = download_extension_errors::kShelfDisabled;
-    return false;
+    return RespondNow(Error(download_extension_errors::kShelfDisabled));
   }
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
 DownloadsGetFileIconFunction::DownloadsGetFileIconFunction()
     : icon_extractor_(new DownloadFileIconExtractorImpl()) {
 }
 
 DownloadsGetFileIconFunction::~DownloadsGetFileIconFunction() {}
 
 void DownloadsGetFileIconFunction::SetIconExtractorForTesting(
     DownloadFileIconExtractor* extractor) {
   DCHECK(extractor);
   icon_extractor_.reset(extractor);
 }
 
 bool DownloadsGetFileIconFunction::RunAsync() {
   std::unique_ptr<downloads::GetFileIcon::Params> params(
       downloads::GetFileIcon::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const downloads::GetFileIconOptions* options =
       params->options.get();
   int icon_size = kDefaultIconSize;
   if (options && options->size.get())
     icon_size = *options->size;
   DownloadItem* download_item =
-      GetDownload(GetProfile(), include_incognito(), params->download_id);
+      GetDownload(browser_context(), include_incognito(), params->download_id);
   if (InvalidId(download_item, &error_) ||
       Fault(download_item->GetTargetFilePath().empty(),
             errors::kEmptyFile, &error_))
     return false;
   // In-progress downloads return the intermediate filename for GetFullPath()
   // which doesn't have the final extension. Therefore a good file icon can't be
   // found, so use GetTargetFilePath() instead.
   DCHECK(icon_extractor_.get());
   DCHECK(icon_size == 16 || icon_size == 32);
   float scale = 1.0;
@@ skipping 413 matching lines @@
     return;
   base::Time now(base::Time::Now());
   int delta = now.ToTimeT() - last_checked_removal_.ToTimeT();
   if (delta <= kFileExistenceRateLimitSeconds)
     return;
   last_checked_removal_ = now;
   manager->CheckForHistoryFilesRemoval();
 }
 
 }  // namespace extensions