Remove ExtensionFunction::SetResult(T*) overload.

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 <memory>
 #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"
@@ skipping 744 matching lines @@
        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();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->Set("entries", entries);
   result->SetString("nextFeed", next_link.spec());
 
-  SetResult(result);
+  SetResult(std::move(result));
   SendResponse(true);
 }
 
 bool FileManagerPrivateSearchDriveMetadataFunction::RunAsync() {
   using api::file_manager_private::SearchDriveMetadata::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
   if (logger) {
@@ skipping 60 matching lines @@
       base::Bind(
           &FileManagerPrivateSearchDriveMetadataFunction::OnEntryDefinitionList,
           this,
           base::Passed(&results)));
 }
 
 void FileManagerPrivateSearchDriveMetadataFunction::OnEntryDefinitionList(
     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();
+  std::unique_ptr<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();
 
     // FileEntry fields.
     base::DictionaryValue* entry = new base::DictionaryValue();
     entry->SetString(
         "fileSystemName", entry_definition_list->at(i).file_system_name);
     entry->SetString(
         "fileSystemRoot", entry_definition_list->at(i).file_system_root_url);
     entry->SetString(
         "fileFullPath",
         "/" + entry_definition_list->at(i).full_path.AsUTF8Unsafe());
     entry->SetBoolean("fileIsDirectory",
                       entry_definition_list->at(i).is_directory);
 
     result_dict->Set("entry", entry);
     result_dict->SetString(
         "highlightedBaseName",
         search_result_info_list->at(i).highlighted_base_name);
     results_list->Append(result_dict);
   }
 
-  SetResult(results_list);
+  SetResult(std::move(results_list));
   SendResponse(true);
 }
 
 bool FileManagerPrivateGetDriveConnectionStateFunction::RunSync() {
   api::file_manager_private::DriveConnectionState result;
 
   switch (drive::util::GetDriveConnectionStatus(GetProfile())) {
     case drive::util::DRIVE_DISCONNECTED_NOSERVICE:
       result.type = kDriveConnectionTypeOffline;
       result.reason.reset(new std::string(kDriveConnectionReasonNoService));
@@ skipping 30 matching lines @@
 bool FileManagerPrivateRequestAccessTokenFunction::RunAsync() {
   using extensions::api::file_manager_private::RequestAccessToken::Params;
   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(""));
+    SetResult(base::MakeUnique<base::StringValue>(std::string()));
     SendResponse(true);
     return true;
   }
 
   // If refreshing is requested, then clear the token to refetch it.
   if (params->refresh)
     drive_service->ClearAccessToken();
 
   // Retrieve the cached auth token (if available), otherwise the AuthService
   // instance will try to refetch it.
   drive_service->RequestAccessToken(
       base::Bind(&FileManagerPrivateRequestAccessTokenFunction::
                       OnAccessTokenFetched, this));
   return true;
 }
 
 void FileManagerPrivateRequestAccessTokenFunction::OnAccessTokenFetched(
     google_apis::DriveApiErrorCode code,
     const std::string& access_token) {
-  SetResult(new base::StringValue(access_token));
+  SetResult(base::MakeUnique<base::StringValue>(access_token));
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalGetShareUrlFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::GetShareUrl::Params;
   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));
@@ skipping 18 matching lines @@
 
 void FileManagerPrivateInternalGetShareUrlFunction::OnGetShareUrl(
     drive::FileError error,
     const GURL& share_url) {
   if (error != drive::FILE_ERROR_OK) {
     SetError("Share Url for this item is not available.");
     SendResponse(false);
     return;
   }
 
-  SetResult(new base::StringValue(share_url.spec()));
+  SetResult(base::MakeUnique<base::StringValue>(share_url.spec()));
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalRequestDriveShareFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::RequestDriveShare::
       Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
@@ skipping 55 matching lines @@
   using extensions::api::file_manager_private_internal::GetShareUrl::Params;
   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.
+    // Intentionally returns a blank.
+    SetResult(base::MakeUnique<base::StringValue>(std::string()));
     return false;
   }
 
   const base::FilePath path = file_manager::util::GetLocalPathFromURL(
       render_frame_host(), GetProfile(), GURL(params->url));
   if (!drive::util::IsUnderDriveMountPoint(path)) {
     SetError("The given file is not in Drive.");
-    SetResult(new base::StringValue(""));  // Intentionally returns a blank.
+    // Intentionally returns a blank.
+    SetResult(base::MakeUnique<base::StringValue>(std::string()));
     return false;
   }
   base::FilePath file_path = drive::util::ExtractDrivePath(path);
 
   file_system->GetResourceEntry(
       file_path,
       base::Bind(
           &FileManagerPrivateInternalGetDownloadUrlFunction::OnGetResourceEntry,
           this));
   return true;
 }
 
 void FileManagerPrivateInternalGetDownloadUrlFunction::OnGetResourceEntry(
     drive::FileError error,
     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.
+    // Intentionally returns a blank.
+    SetResult(base::MakeUnique<base::StringValue>(std::string()));
     SendResponse(false);
     return;
   }
 
   DriveApiUrlGenerator url_generator(
       (GURL(google_apis::DriveApiUrlGenerator::kBaseUrlForProduction)),
       (GURL(
           google_apis::DriveApiUrlGenerator::kBaseThumbnailUrlForProduction)));
   download_url_ = url_generator.GenerateDownloadFileUrl(entry->resource_id());
 
@@ skipping 12 matching lines @@
                                    scopes));
   auth_service_->StartAuthentication(base::Bind(
       &FileManagerPrivateInternalGetDownloadUrlFunction::OnTokenFetched, this));
 }
 
 void FileManagerPrivateInternalGetDownloadUrlFunction::OnTokenFetched(
     google_apis::DriveApiErrorCode code,
     const std::string& access_token) {
   if (code != google_apis::HTTP_SUCCESS) {
     SetError("Not able to fetch the token.");
-    SetResult(new base::StringValue(""));  // Intentionally returns a blank.
+    // Intentionally returns a blank.
+    SetResult(base::MakeUnique<base::StringValue>(std::string()));
     SendResponse(false);
     return;
   }
 
   const std::string url =
       download_url_.Resolve("?alt=media&access_token=" + access_token).spec();
-  SetResult(new base::StringValue(url));
+  SetResult(base::MakeUnique<base::StringValue>(url));
 
   SendResponse(true);
 }
 
 }  // namespace extensions