Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/drive/drive_api_requests.cc

 // Copyright (c) 2012 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 "google_apis/drive/drive_api_requests.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 42 matching lines @@
 const char kUMADriveBatchUploadResponseCode[] = "Drive.BatchUploadResponseCode";
 const char kUMADriveTotalFileCountInBatchUpload[] =
     "Drive.TotalFileCountInBatchUpload";
 const char kUMADriveTotalFileSizeInBatchUpload[] =
     "Drive.TotalFileSizeInBatchUpload";
 
 // Parses the JSON value to FileResource instance and runs |callback| on the
 // UI thread once parsing is done.
 // This is customized version of ParseJsonAndRun defined above to adapt the
 // remaining response type.
-void ParseFileResourceWithUploadRangeAndRun(const UploadRangeCallback& callback,
-                                            const UploadRangeResponse& response,
-                                            scoped_ptr<base::Value> value) {
+void ParseFileResourceWithUploadRangeAndRun(
+    const UploadRangeCallback& callback,
+    const UploadRangeResponse& response,
+    std::unique_ptr<base::Value> value) {
   DCHECK(!callback.is_null());
 
-  scoped_ptr<FileResource> file_resource;
+  std::unique_ptr<FileResource> file_resource;
   if (value) {
     file_resource = FileResource::CreateFrom(*value);
     if (!file_resource) {
-      callback.Run(
-          UploadRangeResponse(DRIVE_PARSE_ERROR,
-                              response.start_position_received,
-                              response.end_position_received),
-          scoped_ptr<FileResource>());
+      callback.Run(UploadRangeResponse(DRIVE_PARSE_ERROR,
+                                       response.start_position_received,
+                                       response.end_position_received),
+                   std::unique_ptr<FileResource>());
       return;
     }
   }
 
   callback.Run(response, std::move(file_resource));
 }
 
 // Attaches |properties| to the |request_body| if |properties| is not empty.
 // |request_body| must not be NULL.
 void AttachProperties(const Properties& properties,
@@ skipping 30 matching lines @@
     const std::string& parent_resource_id,
     const base::Time& modified_date,
     const base::Time& last_viewed_by_me_date,
     const Properties& properties) {
   base::DictionaryValue root;
   if (!title.empty())
     root.SetString("title", title);
 
   // Fill parent link.
   if (!parent_resource_id.empty()) {
-    scoped_ptr<base::ListValue> parents(new base::ListValue);
+    std::unique_ptr<base::ListValue> parents(new base::ListValue);
     parents->Append(
         google_apis::util::CreateParentValue(parent_resource_id).release());
     root.Set("parents", parents.release());
   }
 
   if (!modified_date.is_null()) {
     root.SetString("modifiedDate",
                    google_apis::util::FormatTimeAsString(modified_date));
   }
 
@@ skipping 30 matching lines @@
 base::StringPiece TrimTransportPadding(const base::StringPiece& piece) {
   size_t trim_size = 0;
   while (trim_size < piece.size() &&
          (piece[piece.size() - 1 - trim_size] == ' ' ||
           piece[piece.size() - 1 - trim_size] == '\t')) {
     ++trim_size;
   }
   return piece.substr(0, piece.size() - trim_size);
 }
 
-void EmptyClosure(scoped_ptr<BatchableDelegate>) {
-}
+void EmptyClosure(std::unique_ptr<BatchableDelegate>) {}
 
 }  // namespace
 
 MultipartHttpResponse::MultipartHttpResponse() : code(HTTP_SUCCESS) {
 }
 
 MultipartHttpResponse::~MultipartHttpResponse() {
 }
 
 // The |response| must be multipart/mixed format that contains child HTTP
@@ skipping 636 matching lines @@
 
 bool InitiateUploadNewFileRequest::GetContentData(
     std::string* upload_content_type,
     std::string* upload_content) {
   *upload_content_type = util::kContentTypeApplicationJson;
 
   base::DictionaryValue root;
   root.SetString("title", title_);
 
   // Fill parent link.
-  scoped_ptr<base::ListValue> parents(new base::ListValue);
+  std::unique_ptr<base::ListValue> parents(new base::ListValue);
   parents->Append(util::CreateParentValue(parent_resource_id_).release());
   root.Set("parents", parents.release());
 
   if (!modified_date_.is_null())
     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 
   if (!last_viewed_by_me_date_.is_null()) {
     root.SetString("lastViewedByMeDate",
                    util::FormatTimeAsString(last_viewed_by_me_date_));
   }
@@ skipping 39 matching lines @@
       InitiateUploadRequestBase::GetExtraRequestHeaders());
   headers.push_back(util::GenerateIfMatchHeader(etag_));
   return headers;
 }
 
 bool InitiateUploadExistingFileRequest::GetContentData(
     std::string* upload_content_type,
     std::string* upload_content) {
   base::DictionaryValue root;
   if (!parent_resource_id_.empty()) {
-    scoped_ptr<base::ListValue> parents(new base::ListValue);
+    std::unique_ptr<base::ListValue> parents(new base::ListValue);
     parents->Append(util::CreateParentValue(parent_resource_id_).release());
     root.Set("parents", parents.release());
   }
 
   if (!title_.empty())
     root.SetString("title", title_);
 
   if (!modified_date_.is_null())
     root.SetString("modifiedDate", util::FormatTimeAsString(modified_date_));
 
@@ skipping 34 matching lines @@
                               local_file_path),
       callback_(callback),
       progress_callback_(progress_callback) {
   DCHECK(!callback_.is_null());
 }
 
 ResumeUploadRequest::~ResumeUploadRequest() {}
 
 void ResumeUploadRequest::OnRangeRequestComplete(
     const UploadRangeResponse& response,
-    scoped_ptr<base::Value> value) {
+    std::unique_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
   ParseFileResourceWithUploadRangeAndRun(callback_, response, std::move(value));
 }
 
 void ResumeUploadRequest::OnURLFetchUploadProgress(
     const net::URLFetcher* source,
     int64_t current,
     int64_t total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
 //========================== GetUploadStatusRequest ==========================
 
 GetUploadStatusRequest::GetUploadStatusRequest(
     RequestSender* sender,
     const GURL& upload_url,
     int64_t content_length,
     const UploadRangeCallback& callback)
     : GetUploadStatusRequestBase(sender, upload_url, content_length),
       callback_(callback) {
   DCHECK(!callback.is_null());
 }
 
 GetUploadStatusRequest::~GetUploadStatusRequest() {}
 
 void GetUploadStatusRequest::OnRangeRequestComplete(
     const UploadRangeResponse& response,
-    scoped_ptr<base::Value> value) {
+    std::unique_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
   ParseFileResourceWithUploadRangeAndRun(callback_, response, std::move(value));
 }
 
 //======================= MultipartUploadNewFileDelegate =======================
 
 MultipartUploadNewFileDelegate::MultipartUploadNewFileDelegate(
     base::SequencedTaskRunner* task_runner,
     const std::string& title,
     const std::string& parent_resource_id,
@@ skipping 463 matching lines @@
     } else if (last_progress_value_ < child->data_offset + child->data_size &&
                child->data_offset + child->data_size < current) {
       child->request->NotifyUploadProgress(source, child->data_size,
                                            child->data_size);
     }
   }
   last_progress_value_ = current;
 }
 }  // namespace drive
 }  // namespace google_apis