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

chrome/browser/chromeos/extensions/file_manager/private_api_file_system.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_file_system.h"
 
 #include <sys/statvfs.h>
+
 #include <set>
 
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
@@ skipping 257 matching lines @@
       render_frame_host()->GetProcess()->GetID(), content::kExternalFileScheme);
   return RespondNow(NoArguments());
 }
 
 FileManagerPrivateGrantAccessFunction::FileManagerPrivateGrantAccessFunction()
     : chrome_details_(this) {
 }
 
 ExtensionFunction::ResponseAction FileManagerPrivateGrantAccessFunction::Run() {
   using extensions::api::file_manager_private::GrantAccess::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(
           chrome_details_.GetProfile(), render_frame_host());
 
   storage::ExternalFileSystemBackend* const backend =
       file_system_context->external_backend();
   DCHECK(backend);
 
@@ skipping 109 matching lines @@
     return;
   }
 
   // Obsolete. Fallback code if storage::WatcherManager is not implemented.
   event_router->RemoveFileWatch(file_system_url.path(), extension_id);
   Respond(true);
 }
 
 bool FileManagerPrivateGetSizeStatsFunction::RunAsync() {
   using extensions::api::file_manager_private::GetSizeStats::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using file_manager::VolumeManager;
   using file_manager::Volume;
   VolumeManager* const volume_manager = VolumeManager::Get(GetProfile());
   if (!volume_manager)
     return false;
 
   base::WeakPtr<Volume> volume =
       volume_manager->FindVolumeById(params->volume_id);
@@ skipping 106 matching lines @@
 
   sizes->SetDouble("totalSize", static_cast<double>(*total_size));
   sizes->SetDouble("remainingSize", static_cast<double>(*remaining_size));
 
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalValidatePathNameLengthFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::ValidatePathNameLength::
       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());
 
   const storage::FileSystemURL file_system_url(
       file_system_context->CrackURL(GURL(params->parent_url)));
   if (!chromeos::FileSystemBackend::CanHandleURL(file_system_url))
     return false;
@@ skipping 16 matching lines @@
 }
 
 void FileManagerPrivateInternalValidatePathNameLengthFunction::
     OnFilePathLimitRetrieved(size_t current_length, size_t max_length) {
   SetResult(new base::FundamentalValue(current_length <= max_length));
   SendResponse(true);
 }
 
 bool FileManagerPrivateFormatVolumeFunction::RunAsync() {
   using extensions::api::file_manager_private::FormatVolume::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using file_manager::VolumeManager;
   using file_manager::Volume;
   VolumeManager* const volume_manager = VolumeManager::Get(GetProfile());
   if (!volume_manager)
     return false;
 
   base::WeakPtr<Volume> volume =
       volume_manager->FindVolumeById(params->volume_id);
@@ skipping 21 matching lines @@
 bool CheckLocalDiskSpaceOnIOThread(const base::FilePath& path, int64_t bytes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return bytes <= base::SysInfo::AmountOfFreeDiskSpace(path) -
                       cryptohome::kMinFreeSpaceInBytes;
 }
 
 bool FileManagerPrivateInternalStartCopyFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using extensions::api::file_manager_private_internal::StartCopy::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (params->url.empty() || params->parent_url.empty() ||
       params->new_name.empty()) {
     // Error code in format of DOMError.name.
     SetError("EncodingError");
     return false;
   }
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
@@ skipping 99 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SetResult(new base::FundamentalValue(operation_id));
   SendResponse(true);
 }
 
 bool FileManagerPrivateCancelCopyFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using extensions::api::file_manager_private::CancelCopy::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());
 
   // We don't much take care about the result of cancellation.
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&CancelCopyOnIOThread, file_system_context, params->copy_id));
   SendResponse(true);
   return true;
 }
 
 bool FileManagerPrivateInternalResolveIsolatedEntriesFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::ResolveIsolatedEntries::
       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());
   DCHECK(file_system_context.get());
 
   const storage::ExternalFileSystemBackend* external_backend =
       file_system_context->external_backend();
   DCHECK(external_backend);
@@ skipping 21 matching lines @@
       extension_->id(),
       file_definition_list,  // Safe, since copied internally.
       base::Bind(
           &FileManagerPrivateInternalResolveIsolatedEntriesFunction::
               RunAsyncAfterConvertFileDefinitionListToEntryDefinitionList,
           this));
   return true;
 }
 
 void FileManagerPrivateInternalResolveIsolatedEntriesFunction::
-    RunAsyncAfterConvertFileDefinitionListToEntryDefinitionList(scoped_ptr<
-        file_manager::util::EntryDefinitionList> entry_definition_list) {
+    RunAsyncAfterConvertFileDefinitionListToEntryDefinitionList(
+        std::unique_ptr<file_manager::util::EntryDefinitionList>
+            entry_definition_list) {
   using extensions::api::file_manager_private_internal::EntryDescription;
   std::vector<EntryDescription> entries;
 
   for (const auto& definition : *entry_definition_list) {
     if (definition.error != base::File::FILE_OK)
       continue;
     EntryDescription entry;
     entry.file_system_name = definition.file_system_name;
     entry.file_system_root = definition.file_system_root_url;
     entry.file_full_path = "/" + definition.full_path.AsUTF8Unsafe();
@@ skipping 11 matching lines @@
     : digester_(new drive::util::FileStreamMd5Digester()) {
 }
 
 FileManagerPrivateInternalComputeChecksumFunction::
     ~FileManagerPrivateInternalComputeChecksumFunction() {
 }
 
 bool FileManagerPrivateInternalComputeChecksumFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::ComputeChecksum::Params;
   using drive::util::FileStreamMd5Digester;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (params->url.empty()) {
     SetError("File URL must be provided");
     return false;
   }
 
   scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderFrameHost(
           GetProfile(), render_frame_host());
 
   FileSystemURL file_system_url(
       file_system_context->CrackURL(GURL(params->url)));
   if (!file_system_url.is_valid()) {
     SetError("File URL was invalid");
     return false;
   }
 
-  scoped_ptr<storage::FileStreamReader> reader =
+  std::unique_ptr<storage::FileStreamReader> reader =
       file_system_context->CreateFileStreamReader(
           file_system_url, 0, storage::kMaximumLength, base::Time());
 
   FileStreamMd5Digester::ResultCallback result_callback = base::Bind(
       &ComputeChecksumRespondOnUIThread,
       base::Bind(&FileManagerPrivateInternalComputeChecksumFunction::Respond,
                  this));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&FileStreamMd5Digester::GetMd5Digest,
                                      base::Unretained(digester_.get()),
                                      base::Passed(&reader), result_callback));
 
   return true;
 }
 
 void FileManagerPrivateInternalComputeChecksumFunction::Respond(
     const std::string& hash) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SetResult(new base::StringValue(hash));
   SendResponse(true);
 }
 
 bool FileManagerPrivateSearchFilesByHashesFunction::RunAsync() {
   using api::file_manager_private::SearchFilesByHashes::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // TODO(hirono): Check the volume ID and fail the function for volumes other
   // than Drive.
 
   drive::EventLogger* const logger =
       file_manager::util::GetLogger(GetProfile());
   if (logger) {
     logger->Log(logging::LOG_INFO,
                 "%s[%d] called. (volume id: %s, number of hashes: %zd)", name(),
@@ skipping 21 matching lines @@
 
 void FileManagerPrivateSearchFilesByHashesFunction::OnSearchByHashes(
     const std::set<std::string>& hashes,
     drive::FileError error,
     const std::vector<drive::HashAndFilePath>& search_results) {
   if (error != drive::FileError::FILE_ERROR_OK) {
     SendResponse(false);
     return;
   }
 
-  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   for (const auto& hash : hashes) {
     result->SetWithoutPathExpansion(hash,
-                                    make_scoped_ptr(new base::ListValue()));
+                                    base::WrapUnique(new base::ListValue()));
   }
 
   for (const auto& hashAndPath : search_results) {
     DCHECK(result->HasKey(hashAndPath.hash));
     base::ListValue* list;
     result->GetListWithoutPathExpansion(hashAndPath.hash, &list);
     list->AppendString(
         file_manager::util::ConvertDrivePathToFileSystemUrl(
             GetProfile(), hashAndPath.path, extension_id()).spec());
   }
   SetResult(result.release());
   SendResponse(true);
 }
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateIsUMAEnabledFunction::Run() {
   return RespondNow(OneArgument(new base::FundamentalValue(
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled())));
 }
 
 FileManagerPrivateInternalSetEntryTagFunction::
     FileManagerPrivateInternalSetEntryTagFunction()
     : chrome_details_(this) {}
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateInternalSetEntryTagFunction::Run() {
   using extensions::api::file_manager_private_internal::SetEntryTag::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 local_path = file_manager::util::GetLocalPathFromURL(
       render_frame_host(), chrome_details_.GetProfile(), GURL(params->url));
   const base::FilePath drive_path = drive::util::ExtractDrivePath(local_path);
   if (drive_path.empty())
     return RespondNow(Error("Only Drive files and directories are supported."));
 
   drive::FileSystemInterface* const file_system =
       drive::util::GetFileSystemByProfile(chrome_details_.GetProfile());
@@ skipping 23 matching lines @@
   return RespondLater();
 }
 
 void FileManagerPrivateInternalSetEntryTagFunction::OnSetEntryPropertyCompleted(
     drive::FileError result) {
   Respond(result == drive::FILE_ERROR_OK ? NoArguments()
                                          : Error("Failed to set a tag."));
 }
 
 }  // namespace extensions