Remove base::StringValue

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>
@@ skipping 923 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(base::MakeUnique<base::StringValue>(std::string()));
+    SetResult(base::MakeUnique<base::Value>(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(base::MakeUnique<base::StringValue>(access_token));
+  SetResult(base::MakeUnique<base::Value>(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(base::MakeUnique<base::StringValue>(share_url.spec()));
+  SetResult(base::MakeUnique<base::Value>(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 57 matching lines @@
   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.");
     // Intentionally returns a blank.
-    SetResult(base::MakeUnique<base::StringValue>(std::string()));
+    SetResult(base::MakeUnique<base::Value>(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.");
     // Intentionally returns a blank.
-    SetResult(base::MakeUnique<base::StringValue>(std::string()));
+    SetResult(base::MakeUnique<base::Value>(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.");
     // Intentionally returns a blank.
-    SetResult(base::MakeUnique<base::StringValue>(std::string()));
+    SetResult(base::MakeUnique<base::Value>(std::string()));
     SendResponse(false);
     return;
   }
 
   DriveApiUrlGenerator url_generator(
       (GURL(google_apis::DriveApiUrlGenerator::kBaseUrlForProduction)),
       (GURL(
           google_apis::DriveApiUrlGenerator::kBaseThumbnailUrlForProduction)),
       google_apis::GetTeamDrivesIntegrationSwitch());
   download_url_ = url_generator.GenerateDownloadFileUrl(entry->resource_id());
@@ skipping 14 matching lines @@
   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.");
     // Intentionally returns a blank.
-    SetResult(base::MakeUnique<base::StringValue>(std::string()));
+    SetResult(base::MakeUnique<base::Value>(std::string()));
     SendResponse(false);
     return;
   }
 
   const std::string url =
       download_url_.Resolve("?alt=media&access_token=" + access_token).spec();
-  SetResult(base::MakeUnique<base::StringValue>(url));
+  SetResult(base::MakeUnique<base::Value>(url));
 
   SendResponse(true);
 }
 
 }  // namespace extensions