Remove ExtensionFunction::SetResult(T*) overload.

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 <utility>
 
 #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"
@@ skipping 301 matching lines @@
           ->GrantCreateReadWriteFile(render_frame_host()->GetProcess()->GetID(),
                                      file_system_url.path());
     }
   }
   return RespondNow(NoArguments());
 }
 
 void FileWatchFunctionBase::Respond(bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  SetResult(new base::FundamentalValue(success));
+  SetResult(base::MakeUnique<base::FundamentalValue>(success));
   SendResponse(success);
 }
 
 bool FileWatchFunctionBase::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!render_frame_host() || !render_frame_host()->GetProcess())
     return false;
 
   // First param is url of a file to watch.
@@ skipping 182 matching lines @@
   }
 
   const uint64_t max_capacity = mtp_storage_info.max_capacity();
   const uint64_t free_space_in_bytes = mtp_storage_info.free_space_in_bytes();
   OnGetSizeStats(&max_capacity, &free_space_in_bytes);
 }
 
 void FileManagerPrivateGetSizeStatsFunction::OnGetSizeStats(
     const uint64_t* total_size,
     const uint64_t* remaining_size) {
-  base::DictionaryValue* sizes = new base::DictionaryValue();
-  SetResult(sizes);
+  std::unique_ptr<base::DictionaryValue> sizes(new base::DictionaryValue());
 
   sizes->SetDouble("totalSize", static_cast<double>(*total_size));
   sizes->SetDouble("remainingSize", static_cast<double>(*remaining_size));
 
+  SetResult(std::move(sizes));
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalValidatePathNameLengthFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::ValidatePathNameLength::
       Params;
   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;
 
   // No explicit limit on the length of Drive file names.
   if (file_system_url.type() == storage::kFileSystemTypeDrive) {
-    SetResult(new base::FundamentalValue(true));
+    SetResult(base::MakeUnique<base::FundamentalValue>(true));
     SendResponse(true);
     return true;
   }
 
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(), FROM_HERE,
       base::Bind(&GetFileNameMaxLengthOnBlockingPool,
                  file_system_url.path().AsUTF8Unsafe()),
       base::Bind(&FileManagerPrivateInternalValidatePathNameLengthFunction::
                      OnFilePathLimitRetrieved,
                  this, params->name.size()));
   return true;
 }
 
 void FileManagerPrivateInternalValidatePathNameLengthFunction::
     OnFilePathLimitRetrieved(size_t current_length, size_t max_length) {
-  SetResult(new base::FundamentalValue(current_length <= max_length));
+  SetResult(
+      base::MakeUnique<base::FundamentalValue>(current_length <= max_length));
   SendResponse(true);
 }
 
 bool FileManagerPrivateFormatVolumeFunction::RunAsync() {
   using extensions::api::file_manager_private::FormatVolume::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using file_manager::VolumeManager;
   using file_manager::Volume;
@@ skipping 139 matching lines @@
           &FileManagerPrivateInternalStartCopyFunction::RunAfterStartCopy,
           this));
   if (!result)
     SendResponse(false);
 }
 
 void FileManagerPrivateInternalStartCopyFunction::RunAfterStartCopy(
     int operation_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  SetResult(new base::FundamentalValue(operation_id));
+  SetResult(base::MakeUnique<base::FundamentalValue>(operation_id));
   SendResponse(true);
 }
 
 bool FileManagerPrivateCancelCopyFunction::RunAsync() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   using extensions::api::file_manager_private::CancelCopy::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
@@ skipping 120 matching lines @@
                           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));
+  SetResult(base::MakeUnique<base::StringValue>(hash));
   SendResponse(true);
 }
 
 bool FileManagerPrivateSearchFilesByHashesFunction::RunAsync() {
   using api::file_manager_private::SearchFilesByHashes::Params;
   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.
@@ skipping 41 matching lines @@
   }
 
   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());
+  SetResult(std::move(result));
   SendResponse(true);
 }
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateIsUMAEnabledFunction::Run() {
   return RespondNow(OneArgument(new base::FundamentalValue(
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled())));
 }
 
 FileManagerPrivateInternalSetEntryTagFunction::
@@ skipping 40 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