Remove ExtensionFunction::SetResult(T*) overload.

chrome/browser/chromeos/extensions/wallpaper_private_api.cc

 // Copyright (c) 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/wallpaper_private_api.h"
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 252 matching lines @@
     case wallpaper_private::WALLPAPER_SOURCE_THIRDPARTY:
       return user_manager::User::THIRDPARTY;
     default:
       return user_manager::User::ONLINE;
   }
 }
 
 }  // namespace
 
 bool WallpaperPrivateGetStringsFunction::RunSync() {
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  SetResult(dict);
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
 #define SET_STRING(id, idr) \
   dict->SetString(id, l10n_util::GetStringUTF16(idr))
   SET_STRING("webFontFamily", IDS_WEB_FONT_FAMILY);
   SET_STRING("webFontSize", IDS_WEB_FONT_SIZE);
   SET_STRING("allCategoryLabel", IDS_WALLPAPER_MANAGER_ALL_CATEGORY_LABEL);
   SET_STRING("deleteCommandLabel", IDS_WALLPAPER_MANAGER_DELETE_COMMAND_LABEL);
   SET_STRING("customCategoryLabel",
              IDS_WALLPAPER_MANAGER_CUSTOM_CATEGORY_LABEL);
   SET_STRING("selectCustomLabel",
@@ skipping 11 matching lines @@
              IDS_WALLPAPER_MANAGER_SHOW_CUSTOM_WALLPAPER_ON_START_WARNING);
   SET_STRING("accessFileFailure", IDS_WALLPAPER_MANAGER_ACCESS_FILE_FAILURE);
   SET_STRING("invalidWallpaper", IDS_WALLPAPER_MANAGER_INVALID_WALLPAPER);
   SET_STRING("surpriseMeLabel", IDS_WALLPAPER_MANAGER_SURPRISE_ME_LABEL);
   SET_STRING("learnMore", IDS_LEARN_MORE);
   SET_STRING("currentWallpaperSetByMessage",
              IDS_CURRENT_WALLPAPER_SET_BY_MESSAGE);
 #undef SET_STRING
 
   const std::string& app_locale = g_browser_process->GetApplicationLocale();
-  webui::SetLoadTimeDataDefaults(app_locale, dict);
+  webui::SetLoadTimeDataDefaults(app_locale, dict.get());
 
   chromeos::WallpaperManager* wallpaper_manager =
       chromeos::WallpaperManager::Get();
   wallpaper::WallpaperInfo info;
 
   if (wallpaper_manager->GetLoggedInUserWallpaperInfo(&info))
     dict->SetString("currentWallpaper", info.location);
 
 #if defined(GOOGLE_CHROME_BUILD)
   dict->SetString("manifestBaseURL", kWallpaperManifestBaseURL);
 #endif
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   std::string app_name(
       profile->GetPrefs()->GetString(prefs::kCurrentWallpaperAppName));
   if (!app_name.empty())
     dict->SetString("wallpaperAppName", app_name);
 
   dict->SetBoolean("isOEMDefaultWallpaper", IsOEMDefaultWallpaper());
   dict->SetString("canceledWallpaper",
                   wallpaper_api_util::kCancelWallpaperMessage);
+
+  SetResult(std::move(dict));
   return true;
 }
 
 bool WallpaperPrivateGetSyncSettingFunction::RunSync() {
   Profile* profile =  Profile::FromBrowserContext(browser_context());
   ProfileSyncService* sync =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  SetResult(dict);
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetBoolean("syncThemes",
                    sync->GetActiveDataTypes().Has(syncer::THEMES));
+  SetResult(std::move(dict));
   return true;
 }
 
 WallpaperPrivateSetWallpaperIfExistsFunction::
     WallpaperPrivateSetWallpaperIfExistsFunction() {}
 
 WallpaperPrivateSetWallpaperIfExistsFunction::
     ~WallpaperPrivateSetWallpaperIfExistsFunction() {}
 
 bool WallpaperPrivateSetWallpaperIfExistsFunction::RunAsync() {
@@ skipping 79 matching lines @@
       user_manager::UserManager::Get()->GetActiveUser()->GetAccountId();
   wallpaper_manager->SetWallpaperFromImageSkia(account_id_, image, layout,
                                                update_wallpaper);
   bool is_persistent = !user_manager::UserManager::Get()
                             ->IsCurrentUserNonCryptohomeDataEphemeral();
   wallpaper::WallpaperInfo info = {params->url,
                                    layout,
                                    user_manager::User::ONLINE,
                                    base::Time::Now().LocalMidnight()};
   wallpaper_manager->SetUserWallpaperInfo(account_id_, info, is_persistent);
-  SetResult(new base::FundamentalValue(true));
+  SetResult(base::MakeUnique<base::FundamentalValue>(true));
   Profile* profile = Profile::FromBrowserContext(browser_context());
   // This API is only available to the component wallpaper picker. We do not
   // need to show the app's name if it is the component wallpaper picker. So set
   // the pref to empty string.
   profile->GetPrefs()->SetString(prefs::kCurrentWallpaperAppName,
                                  std::string());
   SendResponse(true);
 }
 
 void WallpaperPrivateSetWallpaperIfExistsFunction::OnFileNotExists(
     const std::string& error) {
-  SetResult(new base::FundamentalValue(false));
+  SetResult(base::MakeUnique<base::FundamentalValue>(false));
   OnFailure(error);
 }
 
 WallpaperPrivateSetWallpaperFunction::WallpaperPrivateSetWallpaperFunction() {
 }
 
 WallpaperPrivateSetWallpaperFunction::~WallpaperPrivateSetWallpaperFunction() {
 }
 
 bool WallpaperPrivateSetWallpaperFunction::RunAsync() {
@@ skipping 211 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &WallpaperPrivateSetCustomWallpaperFunction::ThumbnailGenerated, this,
           base::RetainedRef(data)));
 }
 
 void WallpaperPrivateSetCustomWallpaperFunction::ThumbnailGenerated(
     base::RefCountedBytes* data) {
   BinaryValue* result = BinaryValue::CreateWithCopiedBuffer(
       reinterpret_cast<const char*>(data->front()), data->size());
-  SetResult(result);
+  SetResult(base::WrapUnique(result));
   SendResponse(true);
 }
 
 WallpaperPrivateSetCustomWallpaperLayoutFunction::
     WallpaperPrivateSetCustomWallpaperLayoutFunction() {}
 
 WallpaperPrivateSetCustomWallpaperLayoutFunction::
     ~WallpaperPrivateSetCustomWallpaperLayoutFunction() {}
 
 bool WallpaperPrivateSetCustomWallpaperLayoutFunction::RunAsync() {
@@ skipping 105 matching lines @@
 }
 
 void WallpaperPrivateGetThumbnailFunction::FileNotLoaded() {
   SendResponse(true);
 }
 
 void WallpaperPrivateGetThumbnailFunction::FileLoaded(
     const std::string& data) {
   BinaryValue* thumbnail = BinaryValue::CreateWithCopiedBuffer(data.c_str(),
                                                                data.size());
-  SetResult(thumbnail);
+  SetResult(base::WrapUnique(thumbnail));
   SendResponse(true);
 }
 
 void WallpaperPrivateGetThumbnailFunction::Get(const base::FilePath& path) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   std::string data;
   if (GetData(path, &data)) {
     if (data.empty()) {
       BrowserThread::PostTask(
@@ skipping 105 matching lines @@
     }
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&WallpaperPrivateGetOfflineWallpaperListFunction::OnComplete,
                  this, file_list));
 }
 
 void WallpaperPrivateGetOfflineWallpaperListFunction::OnComplete(
     const std::vector<std::string>& file_list) {
-  base::ListValue* results = new base::ListValue();
+  std::unique_ptr<base::ListValue> results(new base::ListValue());
   results->AppendStrings(file_list);
-  SetResult(results);
+  SetResult(std::move(results));
   SendResponse(true);
 }
 
 bool WallpaperPrivateRecordWallpaperUMAFunction::RunSync() {
   std::unique_ptr<record_wallpaper_uma::Params> params(
       record_wallpaper_uma::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   user_manager::User::WallpaperType source = getWallpaperType(params->source);
   UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.Source", source,
                             user_manager::User::WALLPAPER_TYPE_COUNT);
   return true;
 }