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

chrome/browser/chromeos/extensions/file_manager/private_api_drive.cc

 // Copyright 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/file_manager/private_api_drive.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/private_api_util.h"
 #include "chrome/browser/chromeos/file_manager/file_tasks.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/file_manager/url_util.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/fileapi/external_file_url_util.h"
@@ skipping 150 matching lines @@
 
   file_manager::util::ConvertFileDefinitionListToEntryDefinitionList(
       profile,
       extension_id,
       file_definition_list,  // Safe, since copied internally.
       callback);
 }
 
 class SingleEntryPropertiesGetterForDrive {
  public:
-  typedef base::Callback<void(scoped_ptr<EntryProperties> properties,
-                              base::File::Error error)> ResultCallback;
+  typedef base::Callback<void(std::unique_ptr<EntryProperties> properties,
+                              base::File::Error error)>
+      ResultCallback;
 
   // Creates an instance and starts the process.
   static void Start(const base::FilePath local_path,
                     const std::set<EntryPropertyName>& names,
                     Profile* const profile,
                     const ResultCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     SingleEntryPropertiesGetterForDrive* instance =
         new SingleEntryPropertiesGetterForDrive(local_path, names, profile,
@@ skipping 43 matching lines @@
       return;
     }
 
     file_system->GetResourceEntry(
         file_path_,
         base::Bind(&SingleEntryPropertiesGetterForDrive::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetFileInfo(drive::FileError error,
-                     scoped_ptr<drive::ResourceEntry> entry) {
+                     std::unique_ptr<drive::ResourceEntry> entry) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (error != drive::FILE_ERROR_OK) {
       CompleteGetEntryProperties(error);
       return;
     }
 
     DCHECK(entry);
     owner_resource_entry_.swap(entry);
 
@@ skipping 34 matching lines @@
       return;
     }
 
     file_system->GetResourceEntry(
         file_path,
         base::Bind(&SingleEntryPropertiesGetterForDrive::OnGetShareInfo,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGetShareInfo(drive::FileError error,
-                      scoped_ptr<drive::ResourceEntry> entry) {
+                      std::unique_ptr<drive::ResourceEntry> entry) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (error != drive::FILE_ERROR_OK) {
       CompleteGetEntryProperties(error);
       return;
     }
 
     DCHECK(entry.get());
     StartParseFileInfo(entry->shared_with_me());
   }
@@ skipping 61 matching lines @@
                   drive::FileErrorToBaseFileError(error));
     BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
   }
 
   // Given parameters.
   const ResultCallback callback_;
   const base::FilePath local_path_;
   Profile* const running_profile_;
 
   // Values used in the process.
-  scoped_ptr<EntryProperties> properties_;
+  std::unique_ptr<EntryProperties> properties_;
   Profile* file_owner_profile_;
   base::FilePath file_path_;
-  scoped_ptr<drive::ResourceEntry> owner_resource_entry_;
+  std::unique_ptr<drive::ResourceEntry> owner_resource_entry_;
 
   base::WeakPtrFactory<SingleEntryPropertiesGetterForDrive> weak_ptr_factory_;
 };  // class SingleEntryPropertiesGetterForDrive
 
 class SingleEntryPropertiesGetterForFileSystemProvider {
  public:
-  typedef base::Callback<void(scoped_ptr<EntryProperties> properties,
-                              base::File::Error error)> ResultCallback;
+  typedef base::Callback<void(std::unique_ptr<EntryProperties> properties,
+                              base::File::Error error)>
+      ResultCallback;
 
   // Creates an instance and starts the process.
   static void Start(const storage::FileSystemURL file_system_url,
                     const std::set<EntryPropertyName>& names,
                     const ResultCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     SingleEntryPropertiesGetterForFileSystemProvider* instance =
         new SingleEntryPropertiesGetterForFileSystemProvider(file_system_url,
                                                              names, callback);
@@ skipping 49 matching lines @@
       field_mask |= ProvidedFileSystemInterface::METADATA_FIELD_THUMBNAIL;
     }
 
     parser.file_system()->GetMetadata(
         parser.file_path(), field_mask,
         base::Bind(&SingleEntryPropertiesGetterForFileSystemProvider::
                        OnGetMetadataCompleted,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  void OnGetMetadataCompleted(scoped_ptr<EntryMetadata> metadata,
+  void OnGetMetadataCompleted(std::unique_ptr<EntryMetadata> metadata,
                               base::File::Error result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     if (result != base::File::FILE_OK) {
       CompleteGetEntryProperties(result);
       return;
     }
 
     if (names_.find(api::file_manager_private::ENTRY_PROPERTY_NAME_SIZE) !=
         names_.end()) {
@@ skipping 32 matching lines @@
     callback_.Run(std::move(properties_), result);
     BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
   }
 
   // Given parameters.
   const ResultCallback callback_;
   const storage::FileSystemURL file_system_url_;
   const std::set<EntryPropertyName> names_;
 
   // Values used in the process.
-  scoped_ptr<EntryProperties> properties_;
+  std::unique_ptr<EntryProperties> properties_;
 
   base::WeakPtrFactory<SingleEntryPropertiesGetterForFileSystemProvider>
       weak_ptr_factory_;
 };  // class SingleEntryPropertiesGetterForDrive
 
 }  // namespace
 
 FileManagerPrivateInternalGetEntryPropertiesFunction::
     FileManagerPrivateInternalGetEntryPropertiesFunction()
     : processed_count_(0) {
 }
 
 FileManagerPrivateInternalGetEntryPropertiesFunction::
     ~FileManagerPrivateInternalGetEntryPropertiesFunction() {
 }
 
 bool FileManagerPrivateInternalGetEntryPropertiesFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using api::file_manager_private_internal::GetEntryProperties::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderFrameHost(
           GetProfile(), render_frame_host());
 
   properties_list_.resize(params->urls.size());
   const std::set<EntryPropertyName> names_as_set(params->names.begin(),
                                                  params->names.end());
   for (size_t i = 0; i < params->urls.size(); i++) {
@@ skipping 13 matching lines @@
             file_system_url, names_as_set,
             base::Bind(&FileManagerPrivateInternalGetEntryPropertiesFunction::
                            CompleteGetEntryProperties,
                        this, i, file_system_url));
         break;
       default:
         // TODO(yawano) Change this to support other voluems (e.g. local) ,and
         // integrate fileManagerPrivate.getMimeType to this method.
         LOG(ERROR) << "Not supported file system type.";
         CompleteGetEntryProperties(i, file_system_url,
-                                   make_scoped_ptr(new EntryProperties),
+                                   base::WrapUnique(new EntryProperties),
                                    base::File::FILE_ERROR_INVALID_OPERATION);
     }
   }
 
   return true;
 }
 
 void FileManagerPrivateInternalGetEntryPropertiesFunction::
     CompleteGetEntryProperties(size_t index,
                                const storage::FileSystemURL& url,
-                               scoped_ptr<EntryProperties> properties,
+                               std::unique_ptr<EntryProperties> properties,
                                base::File::Error error) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(0 <= processed_count_ && processed_count_ < properties_list_.size());
 
   if (error == base::File::FILE_OK) {
     properties->external_file_url.reset(
         new std::string(chromeos::FileSystemURLToExternalFileURL(url).spec()));
   }
   properties_list_[index] = std::move(*properties);
 
   processed_count_++;
   if (processed_count_ < properties_list_.size())
     return;
 
   results_ = extensions::api::file_manager_private_internal::
       GetEntryProperties::Results::Create(properties_list_);
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalPinDriveFileFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using extensions::api::file_manager_private_internal::PinDriveFile::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system)  // |file_system| is NULL if Drive is disabled.
     return false;
 
   const base::FilePath drive_path =
       drive::util::ExtractDrivePath(file_manager::util::GetLocalPathFromURL(
           render_frame_host(), GetProfile(), GURL(params->url)));
@@ skipping 21 matching lines @@
     SendResponse(true);
   } else {
     SetError(drive::FileErrorToString(error));
     SendResponse(false);
   }
 }
 
 bool FileManagerPrivateInternalCancelFileTransfersFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::CancelFileTransfers::
       Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::FindForProfile(GetProfile());
   if (!integration_service || !integration_service->IsMounted())
     return false;
 
   drive::JobListInterface* const job_list = integration_service->job_list();
   DCHECK(job_list);
   const std::vector<drive::JobInfo> jobs = job_list->GetJobInfoList();
@@ skipping 41 matching lines @@
     if (drive::IsActiveFileTransferJobInfo(jobs[i]))
       job_list->CancelJob(jobs[i].job_id);
   }
 
   SendResponse(true);
   return true;
 }
 
 bool FileManagerPrivateSearchDriveFunction::RunAsync() {
   using extensions::api::file_manager_private::SearchDrive::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system) {
     // |file_system| is NULL if Drive is disabled.
     return false;
   }
 
   file_system->Search(
       params->search_params.query, GURL(params->search_params.next_feed),
       base::Bind(&FileManagerPrivateSearchDriveFunction::OnSearch, this));
   return true;
 }
 
 void FileManagerPrivateSearchDriveFunction::OnSearch(
     drive::FileError error,
     const GURL& next_link,
-    scoped_ptr<SearchResultInfoList> results) {
+    std::unique_ptr<SearchResultInfoList> results) {
   if (error != drive::FILE_ERROR_OK) {
     SendResponse(false);
     return;
   }
 
   // Outlives the following conversion, since the pointer is bound to the
   // callback.
   DCHECK(results.get());
   const SearchResultInfoList& results_ref = *results.get();
 
   ConvertSearchResultInfoListToEntryDefinitionList(
       GetProfile(),
       extension_->id(),
       results_ref,
       base::Bind(&FileManagerPrivateSearchDriveFunction::OnEntryDefinitionList,
                  this,
                  next_link,
                  base::Passed(&results)));
 }
 
 void FileManagerPrivateSearchDriveFunction::OnEntryDefinitionList(
     const GURL& next_link,
-    scoped_ptr<SearchResultInfoList> search_result_info_list,
-    scoped_ptr<EntryDefinitionList> entry_definition_list) {
+    std::unique_ptr<SearchResultInfoList> search_result_info_list,
+    std::unique_ptr<EntryDefinitionList> entry_definition_list) {
   DCHECK_EQ(search_result_info_list->size(), entry_definition_list->size());
   base::ListValue* entries = new base::ListValue();
 
   // Convert Drive files to something File API stack can understand.
   for (EntryDefinitionList::const_iterator it = entry_definition_list->begin();
        it != entry_definition_list->end();
        ++it) {
     base::DictionaryValue* entry = new base::DictionaryValue();
     entry->SetString("fileSystemName", it->file_system_name);
     entry->SetString("fileSystemRoot", it->file_system_root_url);
     entry->SetString("fileFullPath", "/" + it->full_path.AsUTF8Unsafe());
     entry->SetBoolean("fileIsDirectory", it->is_directory);
     entries->Append(entry);
   }
 
   base::DictionaryValue* result = new base::DictionaryValue();
   result->Set("entries", entries);
   result->SetString("nextFeed", next_link.spec());
 
   SetResult(result);
   SendResponse(true);
 }
 
 bool FileManagerPrivateSearchDriveMetadataFunction::RunAsync() {
   using api::file_manager_private::SearchDriveMetadata::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
   if (logger) {
     logger->Log(logging::LOG_INFO,
                 "%s[%d] called. (types: '%s', maxResults: '%d')", name(),
                 request_id(), api::file_manager_private::ToString(
                                   params->search_params.types).c_str(),
                 params->search_params.max_results);
   }
@@ skipping 29 matching lines @@
       params->search_params.query,
       options,
       params->search_params.max_results,
       base::Bind(&FileManagerPrivateSearchDriveMetadataFunction::
                      OnSearchMetadata, this));
   return true;
 }
 
 void FileManagerPrivateSearchDriveMetadataFunction::OnSearchMetadata(
     drive::FileError error,
-    scoped_ptr<drive::MetadataSearchResultVector> results) {
+    std::unique_ptr<drive::MetadataSearchResultVector> results) {
   if (error != drive::FILE_ERROR_OK) {
     SendResponse(false);
     return;
   }
 
   // Outlives the following conversion, since the pointer is bound to the
   // callback.
   DCHECK(results.get());
   const drive::MetadataSearchResultVector& results_ref = *results.get();
 
   ConvertSearchResultInfoListToEntryDefinitionList(
       GetProfile(),
       extension_->id(),
       results_ref,
       base::Bind(
           &FileManagerPrivateSearchDriveMetadataFunction::OnEntryDefinitionList,
           this,
           base::Passed(&results)));
 }
 
 void FileManagerPrivateSearchDriveMetadataFunction::OnEntryDefinitionList(
-    scoped_ptr<drive::MetadataSearchResultVector> search_result_info_list,
-    scoped_ptr<EntryDefinitionList> entry_definition_list) {
+    std::unique_ptr<drive::MetadataSearchResultVector> search_result_info_list,
+    std::unique_ptr<EntryDefinitionList> entry_definition_list) {
   DCHECK_EQ(search_result_info_list->size(), entry_definition_list->size());
   base::ListValue* results_list = new base::ListValue();
 
   // Convert Drive files to something File API stack can understand.  See
   // file_browser_handler_custom_bindings.cc and
   // file_manager_private_custom_bindings.js for how this is magically
   // converted to a FileEntry.
   for (size_t i = 0; i < entry_definition_list->size(); ++i) {
     base::DictionaryValue* result_dict = new base::DictionaryValue();
 
@@ skipping 52 matching lines @@
       Create(result);
 
   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
   if (logger)
     logger->Log(logging::LOG_INFO, "%s succeeded.", name());
   return true;
 }
 
 bool FileManagerPrivateRequestAccessTokenFunction::RunAsync() {
   using extensions::api::file_manager_private::RequestAccessToken::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::DriveServiceInterface* const drive_service =
       drive::util::GetDriveServiceByProfile(GetProfile());
 
   if (!drive_service) {
     // DriveService is not available.
     SetResult(new base::StringValue(""));
     SendResponse(true);
     return true;
@@ skipping 13 matching lines @@
 
 void FileManagerPrivateRequestAccessTokenFunction::OnAccessTokenFetched(
     google_apis::DriveApiErrorCode code,
     const std::string& access_token) {
   SetResult(new base::StringValue(access_token));
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalGetShareUrlFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::GetShareUrl::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_frame_host(), GetProfile(), GURL(params->url));
   DCHECK(drive::util::IsUnderDriveMountPoint(path));
 
   const base::FilePath drive_path = drive::util::ExtractDrivePath(path);
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
@@ skipping 19 matching lines @@
     return;
   }
 
   SetResult(new base::StringValue(share_url.spec()));
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalRequestDriveShareFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::RequestDriveShare::
       Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_frame_host(), GetProfile(), GURL(params->url));
   const base::FilePath drive_path = drive::util::ExtractDrivePath(path);
   Profile* const owner_profile = drive::util::ExtractProfileFromPath(path);
 
   if (!owner_profile)
     return false;
 
@@ skipping 39 matching lines @@
 }
 
 FileManagerPrivateInternalGetDownloadUrlFunction::
     FileManagerPrivateInternalGetDownloadUrlFunction() {}
 
 FileManagerPrivateInternalGetDownloadUrlFunction::
     ~FileManagerPrivateInternalGetDownloadUrlFunction() {}
 
 bool FileManagerPrivateInternalGetDownloadUrlFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::GetShareUrl::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Start getting the file info.
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(GetProfile());
   if (!file_system) {
     // |file_system| is NULL if Drive is disabled or not mounted.
     SetError("Drive is disabled or not mounted.");
     SetResult(new base::StringValue(""));  // Intentionally returns a blank.
     return false;
@@ skipping 11 matching lines @@
   file_system->GetResourceEntry(
       file_path,
       base::Bind(
           &FileManagerPrivateInternalGetDownloadUrlFunction::OnGetResourceEntry,
           this));
   return true;
 }
 
 void FileManagerPrivateInternalGetDownloadUrlFunction::OnGetResourceEntry(
     drive::FileError error,
-    scoped_ptr<drive::ResourceEntry> entry) {
+    std::unique_ptr<drive::ResourceEntry> entry) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (error != drive::FILE_ERROR_OK) {
     SetError("Download Url for this item is not available.");
     SetResult(new base::StringValue(""));  // Intentionally returns a blank.
     SendResponse(false);
     return;
   }
 
   DriveApiUrlGenerator url_generator(
@@ skipping 31 matching lines @@
   }
 
   const std::string url =
       download_url_.Resolve("?access_token=" + access_token).spec();
   SetResult(new base::StringValue(url));
 
   SendResponse(true);
 }
 
 }  // namespace extensions