Remove ExtensionFunction::SetResult(T*) overload.

chrome/browser/extensions/api/media_galleries/media_galleries_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.
 
 // Implements the Chrome Extensions Media Galleries API.
 
 #include "chrome/browser/extensions/api/media_galleries/media_galleries_api.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 409 matching lines @@
 void MediaGalleriesGetMediaFileSystemsFunction::ReturnGalleries(
     const std::vector<MediaFileSystemInfo>& filesystems) {
   std::unique_ptr<base::ListValue> list(
       ConstructFileSystemList(render_frame_host(), extension(), filesystems));
   if (!list.get()) {
     SendResponse(false);
     return;
   }
 
   // The custom JS binding will use this list to create DOMFileSystem objects.
-  SetResult(list.release());
+  SetResult(std::move(list));
   SendResponse(true);
 }
 
 void MediaGalleriesGetMediaFileSystemsFunction::ShowDialog() {
   media_galleries::UsageCount(media_galleries::SHOW_DIALOG);
   WebContents* contents =
       ChromeExtensionFunctionDetails(this).GetOriginWebContents();
   if (!contents) {
     SendResponse(false);
     return;
@@ skipping 95 matching lines @@
 
   int index = -1;
   if (pref_id != kInvalidMediaGalleryPrefId) {
     for (size_t i = 0; i < filesystems.size(); ++i) {
       if (filesystems[i].pref_id == pref_id) {
         index = i;
         break;
       }
     }
   }
-  base::DictionaryValue* results = new base::DictionaryValue;
+  std::unique_ptr<base::DictionaryValue> results(new base::DictionaryValue);
   results->SetWithoutPathExpansion("mediaFileSystems", list.release());
   results->SetIntegerWithoutPathExpansion("selectedFileSystemIndex", index);
-  SetResult(results);
+  SetResult(std::move(results));
   SendResponse(true);
 }
 
 void
 MediaGalleriesAddUserSelectedFolderFunction::GetMediaFileSystemsForExtension(
     const MediaFileSystemsCallback& cb) {
   if (!render_frame_host()) {
     cb.Run(std::vector<MediaFileSystemInfo>());
     return;
   }
@@ skipping 54 matching lines @@
 
   if (!mime_type_sniffed) {
     SendResponse(false);
     return;
   }
 
   if (metadata_type == MediaGalleries::GET_METADATA_TYPE_MIMETYPEONLY) {
     MediaGalleries::MediaMetadata metadata;
     metadata.mime_type = mime_type;
 
-    base::DictionaryValue* result_dictionary = new base::DictionaryValue;
+    std::unique_ptr<base::DictionaryValue> result_dictionary(
+        new base::DictionaryValue);
     result_dictionary->Set(kMetadataKey, metadata.ToValue().release());
-    SetResult(result_dictionary);
+    SetResult(std::move(result_dictionary));
     SendResponse(true);
     return;
   }
 
   // We get attached images by default. GET_METADATA_TYPE_NONE is the default
   // value if the caller doesn't specify the metadata type.
   bool get_attached_images =
       metadata_type == MediaGalleries::GET_METADATA_TYPE_ALL ||
       metadata_type == MediaGalleries::GET_METADATA_TYPE_NONE;
 
@@ skipping 17 matching lines @@
   }
 
   DCHECK(metadata_dictionary.get());
   DCHECK(attached_images.get());
 
   std::unique_ptr<base::DictionaryValue> result_dictionary(
       new base::DictionaryValue);
   result_dictionary->Set(kMetadataKey, metadata_dictionary.release());
 
   if (attached_images->empty()) {
-    SetResult(result_dictionary.release());
+    SetResult(std::move(result_dictionary));
     SendResponse(true);
     return;
   }
 
   result_dictionary->Set(kAttachedImagesBlobInfoKey, new base::ListValue);
   metadata::AttachedImage* first_image = &attached_images->front();
   content::BrowserContext::CreateMemoryBackedBlob(
       GetProfile(), first_image->data.c_str(), first_image->data.size(),
       base::Bind(&MediaGalleriesGetMetadataFunction::ConstructNextBlob, this,
                  base::Passed(&result_dictionary),
@@ skipping 47 matching lines @@
         GetProfile(),
         next_image->data.c_str(),
         next_image->data.size(),
         base::Bind(&MediaGalleriesGetMetadataFunction::ConstructNextBlob,
                    this, base::Passed(&result_dictionary),
                    base::Passed(&attached_images), base::Passed(&blob_uuids)));
     return;
   }
 
   // All Blobs have been constructed. The renderer will take ownership.
-  SetResult(result_dictionary.release());
+  SetResult(std::move(result_dictionary));
   SetTransferredBlobUUIDs(*blob_uuids);
   SendResponse(true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesAddGalleryWatchFunction                        //
 ///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesAddGalleryWatchFunction::
     ~MediaGalleriesAddGalleryWatchFunction() {
 }
@@ skipping 25 matching lines @@
   MediaGalleryPrefId gallery_pref_id = kInvalidMediaGalleryPrefId;
   if (!GetGalleryFilePathAndId(pref_id,
                                GetProfile(),
                                extension(),
                                &gallery_file_path,
                                &gallery_pref_id)) {
     api::media_galleries::AddGalleryWatchResult result;
     error_ = kInvalidGalleryIdMsg;
     result.gallery_id = kInvalidGalleryId;
     result.success = false;
-    SetResult(result.ToValue().release());
+    SetResult(result.ToValue());
     SendResponse(false);
     return;
   }
 
   gallery_watch_manager()->AddWatch(
       GetProfile(),
       extension(),
       gallery_pref_id,
       base::Bind(&MediaGalleriesAddGalleryWatchFunction::HandleResponse,
                  this,
                  gallery_pref_id));
 }
 
 void MediaGalleriesAddGalleryWatchFunction::HandleResponse(
     MediaGalleryPrefId gallery_id,
     const std::string& error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // If an app added a file watch without any event listeners on the
   // onGalleryChanged event, that's an error.
   MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
   api::media_galleries::AddGalleryWatchResult result;
   result.gallery_id = base::Uint64ToString(gallery_id);
 
   if (!api->ExtensionHasGalleryChangeListener(extension()->id())) {
     result.success = false;
-    SetResult(result.ToValue().release());
+    SetResult(result.ToValue());
     error_ = kMissingEventListener;
     SendResponse(false);
     return;
   }
 
   result.success = error.empty();
-  SetResult(result.ToValue().release());
+  SetResult(result.ToValue());
   if (error.empty()) {
     SendResponse(true);
   } else {
     error_ = error.c_str();
     SendResponse(false);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //              MediaGalleriesRemoveGalleryWatchFunction                     //
@@ skipping 35 matching lines @@
     SendResponse(false);
     return;
   }
 
   gallery_watch_manager()->RemoveWatch(
       GetProfile(), extension_id(), gallery_pref_id);
   SendResponse(true);
 }
 
 }  // namespace extensions