Remove ExtensionFunction::SetResult(T*) overload.

chrome/browser/extensions/api/notifications/notifications_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/notifications/notifications_api.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/guid.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_conversion_helper.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
@@ skipping 575 matching lines @@
     // If the caller provided a notificationId, use that.
     notification_id = *params_->notification_id;
   } else {
     // Otherwise, use a randomly created GUID. In case that GenerateGUID returns
     // the empty string, simply generate a random string.
     notification_id = base::GenerateGUID();
     if (notification_id.empty())
       notification_id = base::RandBytesAsString(16);
   }
 
-  SetResult(new base::StringValue(notification_id));
+  SetResult(base::MakeUnique<base::StringValue>(notification_id));
 
   // TODO(dewittj): Add more human-readable error strings if this fails.
   if (!CreateNotification(notification_id, &params_->options))
     return false;
 
   SendResponse(true);
 
   return true;
 }
 
 NotificationsUpdateFunction::NotificationsUpdateFunction() {
 }
 
 NotificationsUpdateFunction::~NotificationsUpdateFunction() {
 }
 
 bool NotificationsUpdateFunction::RunNotificationsApi() {
   params_ = api::notifications::Update::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   // We are in update.  If the ID doesn't exist, succeed but call the callback
   // with "false".
   const Notification* matched_notification =
       g_browser_process->notification_ui_manager()->FindById(
           CreateScopedIdentifier(extension_->id(), params_->notification_id),
           NotificationUIManager::GetProfileID(GetProfile()));
   if (!matched_notification) {
-    SetResult(new base::FundamentalValue(false));
+    SetResult(base::MakeUnique<base::FundamentalValue>(false));
     SendResponse(true);
     return true;
   }
 
   // Copy the existing notification to get a writable version of it.
   Notification notification = *matched_notification;
 
   // If we have trouble updating the notification (could be improper use of API
   // or some other reason), mark the function as failed, calling the callback
   // with false.
   // TODO(dewittj): Add more human-readable error strings if this fails.
   bool could_update_notification = UpdateNotification(
       params_->notification_id, &params_->options, &notification);
-  SetResult(new base::FundamentalValue(could_update_notification));
+  SetResult(
+      base::MakeUnique<base::FundamentalValue>(could_update_notification));
   if (!could_update_notification)
     return false;
 
   // No trouble, created the notification, send true to the callback and
   // succeed.
   SendResponse(true);
   return true;
 }
 
 NotificationsClearFunction::NotificationsClearFunction() {
 }
 
 NotificationsClearFunction::~NotificationsClearFunction() {
 }
 
 bool NotificationsClearFunction::RunNotificationsApi() {
   params_ = api::notifications::Clear::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   bool cancel_result = g_browser_process->notification_ui_manager()->CancelById(
       CreateScopedIdentifier(extension_->id(), params_->notification_id),
       NotificationUIManager::GetProfileID(GetProfile()));
 
-  SetResult(new base::FundamentalValue(cancel_result));
+  SetResult(base::MakeUnique<base::FundamentalValue>(cancel_result));
   SendResponse(true);
 
   return true;
 }
 
 NotificationsGetAllFunction::NotificationsGetAllFunction() {}
 
 NotificationsGetAllFunction::~NotificationsGetAllFunction() {}
 
 bool NotificationsGetAllFunction::RunNotificationsApi() {
   NotificationUIManager* notification_ui_manager =
       g_browser_process->notification_ui_manager();
   std::set<std::string> notification_ids =
       notification_ui_manager->GetAllIdsByProfileAndSourceOrigin(
           NotificationUIManager::GetProfileID(GetProfile()), extension_->url());
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 
   for (std::set<std::string>::iterator iter = notification_ids.begin();
        iter != notification_ids.end(); iter++) {
     result->SetBooleanWithoutPathExpansion(
         StripScopeFromIdentifier(extension_->id(), *iter), true);
   }
 
-  SetResult(result.release());
+  SetResult(std::move(result));
   SendResponse(true);
 
   return true;
 }
 
 NotificationsGetPermissionLevelFunction::
 NotificationsGetPermissionLevelFunction() {}
 
 NotificationsGetPermissionLevelFunction::
 ~NotificationsGetPermissionLevelFunction() {}
 
 bool NotificationsGetPermissionLevelFunction::CanRunWhileDisabled() const {
   return true;
 }
 
 bool NotificationsGetPermissionLevelFunction::RunNotificationsApi() {
   api::notifications::PermissionLevel result =
       AreExtensionNotificationsAllowed()
           ? api::notifications::PERMISSION_LEVEL_GRANTED
           : api::notifications::PERMISSION_LEVEL_DENIED;
 
-  SetResult(new base::StringValue(api::notifications::ToString(result)));
+  SetResult(base::MakeUnique<base::StringValue>(
+      api::notifications::ToString(result)));
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions