Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

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 <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"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/extensions/blob_reader.h"
 #include "chrome/browser/extensions/chrome_extension_function_details.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
@@ skipping 122 matching lines @@
   MediaGalleriesPermission::CheckParam copy_to_param(
       MediaGalleriesPermission::kCopyToPermission);
   bool has_copy_to_permission = permissions_data->CheckAPIPermissionWithParam(
       APIPermission::kMediaGalleries, &copy_to_param);
   MediaGalleriesPermission::CheckParam delete_param(
       MediaGalleriesPermission::kDeletePermission);
   bool has_delete_permission = permissions_data->CheckAPIPermissionWithParam(
       APIPermission::kMediaGalleries, &delete_param);
 
   const int child_id = rfh->GetProcess()->GetID();
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < filesystems.size(); ++i) {
-    scoped_ptr<base::DictionaryValue> file_system_dict_value(
+    std::unique_ptr<base::DictionaryValue> file_system_dict_value(
         new base::DictionaryValue());
 
     // Send the file system id so the renderer can create a valid FileSystem
     // object.
     file_system_dict_value->SetStringWithoutPathExpansion(
         "fsid", filesystems[i].fsid);
 
     file_system_dict_value->SetStringWithoutPathExpansion(
         kNameKey, filesystems[i].name);
     file_system_dict_value->SetStringWithoutPathExpansion(
@@ skipping 134 matching lines @@
 bool MediaGalleriesEventRouter::ExtensionHasGalleryChangeListener(
     const std::string& extension_id) const {
   return EventRouter::Get(profile_)->ExtensionHasEventListener(
       extension_id, MediaGalleries::OnGalleryChanged::kEventName);
 }
 
 void MediaGalleriesEventRouter::DispatchEventToExtension(
     const std::string& extension_id,
     events::HistogramValue histogram_value,
     const std::string& event_name,
-    scoped_ptr<base::ListValue> event_args) {
+    std::unique_ptr<base::ListValue> event_args) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   EventRouter* router = EventRouter::Get(profile_);
   if (!router->ExtensionHasEventListener(extension_id, event_name))
     return;
 
-  scoped_ptr<extensions::Event> event(new extensions::Event(
+  std::unique_ptr<extensions::Event> event(new extensions::Event(
       histogram_value, event_name, std::move(event_args)));
   router->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 void MediaGalleriesEventRouter::OnGalleryChanged(
     const std::string& extension_id, MediaGalleryPrefId gallery_id) {
   MediaGalleries::GalleryChangeDetails details;
   details.type = MediaGalleries::GALLERY_CHANGE_TYPE_CONTENTS_CHANGED;
   details.gallery_id = base::Uint64ToString(gallery_id);
   DispatchEventToExtension(extension_id,
@@ skipping 22 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //               MediaGalleriesGetMediaFileSystemsFunction                   //
 ///////////////////////////////////////////////////////////////////////////////
 MediaGalleriesGetMediaFileSystemsFunction::
     ~MediaGalleriesGetMediaFileSystemsFunction() {}
 
 bool MediaGalleriesGetMediaFileSystemsFunction::RunAsync() {
   media_galleries::UsageCount(media_galleries::GET_MEDIA_FILE_SYSTEMS);
-  scoped_ptr<GetMediaFileSystems::Params> params(
+  std::unique_ptr<GetMediaFileSystems::Params> params(
       GetMediaFileSystems::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   MediaGalleries::GetMediaFileSystemsInteractivity interactive =
       MediaGalleries::GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NO;
   if (params->details.get() && params->details->interactive != MediaGalleries::
          GET_MEDIA_FILE_SYSTEMS_INTERACTIVITY_NONE) {
     interactive = params->details->interactive;
   }
 
   return Setup(GetProfile(), &error_, base::Bind(
@@ skipping 42 matching lines @@
     ReturnGalleries(filesystems);
 }
 
 void MediaGalleriesGetMediaFileSystemsFunction::GetAndReturnGalleries() {
   GetMediaFileSystemsForExtension(base::Bind(
       &MediaGalleriesGetMediaFileSystemsFunction::ReturnGalleries, this));
 }
 
 void MediaGalleriesGetMediaFileSystemsFunction::ReturnGalleries(
     const std::vector<MediaFileSystemInfo>& filesystems) {
-  scoped_ptr<base::ListValue> list(
+  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());
   SendResponse(true);
 }
@@ skipping 87 matching lines @@
 
   GetMediaFileSystemsForExtension(base::Bind(
       &MediaGalleriesAddUserSelectedFolderFunction::ReturnGalleriesAndId,
       this,
       pref_id));
 }
 
 void MediaGalleriesAddUserSelectedFolderFunction::ReturnGalleriesAndId(
     MediaGalleryPrefId pref_id,
     const std::vector<MediaFileSystemInfo>& filesystems) {
-  scoped_ptr<base::ListValue> list(
+  std::unique_ptr<base::ListValue> list(
       ConstructFileSystemList(render_frame_host(), extension(), filesystems));
   if (!list.get()) {
     SendResponse(false);
     return;
   }
 
   int index = -1;
   if (pref_id != kInvalidMediaGalleryPrefId) {
     for (size_t i = 0; i < filesystems.size(); ++i) {
       if (filesystems[i].pref_id == pref_id) {
@@ skipping 28 matching lines @@
 MediaGalleriesGetMetadataFunction::~MediaGalleriesGetMetadataFunction() {}
 
 bool MediaGalleriesGetMetadataFunction::RunAsync() {
   media_galleries::UsageCount(media_galleries::GET_METADATA);
   std::string blob_uuid;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &blob_uuid));
 
   const base::Value* options_value = NULL;
   if (!args_->Get(1, &options_value))
     return false;
-  scoped_ptr<MediaGalleries::MediaMetadataOptions> options =
+  std::unique_ptr<MediaGalleries::MediaMetadataOptions> options =
       MediaGalleries::MediaMetadataOptions::FromValue(*options_value);
   if (!options)
     return false;
 
   return Setup(GetProfile(), &error_, base::Bind(
       &MediaGalleriesGetMetadataFunction::OnPreferencesInit, this,
       options->metadata_type, blob_uuid));
 }
 
 void MediaGalleriesGetMetadataFunction::OnPreferencesInit(
     MediaGalleries::GetMetadataType metadata_type,
     const std::string& blob_uuid) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // BlobReader is self-deleting.
   BlobReader* reader = new BlobReader(
       GetProfile(),
       blob_uuid,
       base::Bind(&MediaGalleriesGetMetadataFunction::GetMetadata, this,
                  metadata_type, blob_uuid));
   reader->SetByteRange(0, net::kMaxBytesToSniff);
   reader->Start();
 }
 
 void MediaGalleriesGetMetadataFunction::GetMetadata(
     MediaGalleries::GetMetadataType metadata_type,
     const std::string& blob_uuid,
-    scoped_ptr<std::string> blob_header,
+    std::unique_ptr<std::string> blob_header,
     int64_t total_blob_length) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   std::string mime_type;
   bool mime_type_sniffed = net::SniffMimeTypeFromLocalData(
       blob_header->c_str(), blob_header->size(), &mime_type);
 
   if (!mime_type_sniffed) {
     SendResponse(false);
     return;
@@ skipping 18 matching lines @@
 
   scoped_refptr<metadata::SafeMediaMetadataParser> parser(
       new metadata::SafeMediaMetadataParser(GetProfile(), blob_uuid,
                                             total_blob_length, mime_type,
                                             get_attached_images));
   parser->Start(base::Bind(
       &MediaGalleriesGetMetadataFunction::OnSafeMediaMetadataParserDone, this));
 }
 
 void MediaGalleriesGetMetadataFunction::OnSafeMediaMetadataParserDone(
-    bool parse_success, scoped_ptr<base::DictionaryValue> metadata_dictionary,
-    scoped_ptr<std::vector<metadata::AttachedImage> > attached_images) {
+    bool parse_success,
+    std::unique_ptr<base::DictionaryValue> metadata_dictionary,
+    std::unique_ptr<std::vector<metadata::AttachedImage>> attached_images) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!parse_success) {
     SendResponse(false);
     return;
   }
 
   DCHECK(metadata_dictionary.get());
   DCHECK(attached_images.get());
 
-  scoped_ptr<base::DictionaryValue> result_dictionary(
+  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());
     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),
+      GetProfile(), first_image->data.c_str(), first_image->data.size(),
+      base::Bind(&MediaGalleriesGetMetadataFunction::ConstructNextBlob, this,
+                 base::Passed(&result_dictionary),
                  base::Passed(&attached_images),
-                 base::Passed(make_scoped_ptr(new std::vector<std::string>))));
+                 base::Passed(base::WrapUnique(new std::vector<std::string>))));
 }
 
 void MediaGalleriesGetMetadataFunction::ConstructNextBlob(
-    scoped_ptr<base::DictionaryValue> result_dictionary,
-    scoped_ptr<std::vector<metadata::AttachedImage> > attached_images,
-    scoped_ptr<std::vector<std::string> > blob_uuids,
-    scoped_ptr<content::BlobHandle> current_blob) {
+    std::unique_ptr<base::DictionaryValue> result_dictionary,
+    std::unique_ptr<std::vector<metadata::AttachedImage>> attached_images,
+    std::unique_ptr<std::vector<std::string>> blob_uuids,
+    std::unique_ptr<content::BlobHandle> current_blob) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   DCHECK(result_dictionary.get());
   DCHECK(attached_images.get());
   DCHECK(blob_uuids.get());
   DCHECK(current_blob.get());
 
   DCHECK(!attached_images->empty());
   DCHECK_LT(blob_uuids->size(), attached_images->size());
 
@@ skipping 46 matching lines @@
 MediaGalleriesAddGalleryWatchFunction::
     ~MediaGalleriesAddGalleryWatchFunction() {
 }
 
 bool MediaGalleriesAddGalleryWatchFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(GetProfile());
   if (!render_frame_host() || !render_frame_host()->GetProcess())
     return false;
 
-  scoped_ptr<AddGalleryWatch::Params> params(
+  std::unique_ptr<AddGalleryWatch::Params> params(
       AddGalleryWatch::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   MediaGalleriesPreferences* preferences =
       g_browser_process->media_file_system_registry()->GetPreferences(
           GetProfile());
   preferences->EnsureInitialized(
       base::Bind(&MediaGalleriesAddGalleryWatchFunction::OnPreferencesInit,
                  this,
                  params->gallery_id));
@@ skipping 63 matching lines @@
 
 MediaGalleriesRemoveGalleryWatchFunction::
     ~MediaGalleriesRemoveGalleryWatchFunction() {
 }
 
 bool MediaGalleriesRemoveGalleryWatchFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!render_frame_host() || !render_frame_host()->GetProcess())
     return false;
 
-  scoped_ptr<RemoveGalleryWatch::Params> params(
+  std::unique_ptr<RemoveGalleryWatch::Params> params(
       RemoveGalleryWatch::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   MediaGalleriesPreferences* preferences =
       g_browser_process->media_file_system_registry()->GetPreferences(
           GetProfile());
   preferences->EnsureInitialized(
       base::Bind(&MediaGalleriesRemoveGalleryWatchFunction::OnPreferencesInit,
                  this,
                  params->gallery_id));
@@ skipping 13 matching lines @@
     SendResponse(false);
     return;
   }
 
   gallery_watch_manager()->RemoveWatch(
       GetProfile(), extension_id(), gallery_pref_id);
   SendResponse(true);
 }
 
 }  // namespace extensions