Remove ExtensionFunction::SetResult(T*) overload.

chrome/browser/extensions/api/autotest_private/autotest_private_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/autotest_private/autotest_private_api.h"
 
+#include <memory>
+#include <utility>
+
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/autotest_private.h"
 #include "extensions/browser/extension_function_registry.h"
@@ skipping 74 matching lines @@
   DVLOG(1) << "AutotestPrivateShutdownFunction " << params->force;
 
   if (!IsTestMode(GetProfile()))
     chrome::AttemptExit();
   return true;
 }
 
 bool AutotestPrivateLoginStatusFunction::RunSync() {
   DVLOG(1) << "AutotestPrivateLoginStatusFunction";
 
-  base::DictionaryValue* result(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
 #if defined(OS_CHROMEOS)
   const user_manager::UserManager* user_manager =
       user_manager::UserManager::Get();
   const bool is_screen_locked =
       !!chromeos::ScreenLocker::default_screen_locker();
 
   if (user_manager) {
     result->SetBoolean("isLoggedIn", user_manager->IsUserLoggedIn());
     result->SetBoolean("isOwner", user_manager->IsCurrentUserOwner());
     result->SetBoolean("isScreenLocked", is_screen_locked);
@@ skipping 19 matching lines @@
 
         default:
           user_image = base::IntToString(user->image_index());
           break;
       }
       result->SetString("userImage", user_image);
     }
   }
 #endif
 
-  SetResult(result);
+  SetResult(std::move(result));
   return true;
 }
 
 bool AutotestPrivateLockScreenFunction::RunSync() {
   DVLOG(1) << "AutotestPrivateLockScreenFunction";
 #if defined(OS_CHROMEOS)
   chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->
       RequestLockScreen();
 #endif
   return true;
@@ skipping 46 matching lines @@
     extension_value->SetBoolean("isEnabled", service->IsExtensionEnabled(id));
     extension_value->SetBoolean("allowedInIncognito",
         util::IsIncognitoEnabled(id, GetProfile()));
     extension_value->SetBoolean(
         "hasPageAction",
         extension_action_manager->GetPageAction(*extension) != NULL);
 
     extensions_values->Append(extension_value);
   }
 
-  base::DictionaryValue* return_value(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> return_value(
+      new base::DictionaryValue);
   return_value->Set("extensions", extensions_values);
-  SetResult(return_value);
+  SetResult(std::move(return_value));
   return true;
 }
 
 static int AccessArray(const volatile int arr[], const volatile int *index) {
   return arr[*index];
 }
 
 bool AutotestPrivateSimulateAsanMemoryBugFunction::RunSync() {
   DVLOG(1) << "AutotestPrivateSimulateAsanMemoryBugFunction";
   if (!IsTestMode(GetProfile())) {
@@ skipping 118 matching lines @@
       return "multiple";
     case message_center::NOTIFICATION_TYPE_PROGRESS:
       return "progress";
   }
 #endif
   return "unknown";
 }
 
 bool AutotestPrivateGetVisibleNotificationsFunction::RunSync() {
   DVLOG(1) << "AutotestPrivateGetVisibleNotificationsFunction";
-  base::ListValue* values = new base::ListValue;
+  std::unique_ptr<base::ListValue> values(new base::ListValue);
 #if defined(OS_CHROMEOS)
-  for (auto notification :
+  for (auto* notification :
        message_center::MessageCenter::Get()->GetVisibleNotifications()) {
     base::DictionaryValue* result(new base::DictionaryValue);
     result->SetString("id", notification->id());
     result->SetString("type", ConvertToString(notification->type()));
     result->SetString("title", notification->title());
     result->SetString("message", notification->message());
     result->SetInteger("priority", notification->priority());
     result->SetInteger("progress", notification->progress());
     values->Append(result);
   }
 
 #endif
-  SetResult(values);
+  SetResult(std::move(values));
   return true;
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<AutotestPrivateAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<AutotestPrivateAPI>*
 AutotestPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 template <>
 KeyedService*
 BrowserContextKeyedAPIFactory<AutotestPrivateAPI>::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   return new AutotestPrivateAPI();
 }
 
 AutotestPrivateAPI::AutotestPrivateAPI() : test_mode_(false) {
 }
 
 AutotestPrivateAPI::~AutotestPrivateAPI() {
 }
 
 }  // namespace extensions