Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/drive/base_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/base_requests.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/request_sender.h"
 #include "google_apis/drive/request_util.h"
 #include "google_apis/drive/task_util.h"
@@ skipping 50 matching lines @@
 
 // Footer for whole multipart message.
 const char kMultipartFooterFormat[] = "--%s--";
 
 // Parses JSON passed in |json| on |blocking_task_runner|. Runs |callback| on
 // the calling thread when finished with either success or failure.
 // The callback must not be null.
 void ParseJsonOnBlockingPool(
     base::TaskRunner* blocking_task_runner,
     const std::string& json,
-    const base::Callback<void(scoped_ptr<base::Value> value)>& callback) {
+    const base::Callback<void(std::unique_ptr<base::Value> value)>& callback) {
   base::PostTaskAndReplyWithResult(
       blocking_task_runner,
       FROM_HERE,
       base::Bind(&google_apis::ParseJson, json),
       callback);
 }
 
 // Returns response headers as a string. Returns a warning message if
 // |url_fetcher| does not contain a valid response. Used only for debugging.
 std::string GetResponseHeadersAsString(const URLFetcher* url_fetcher) {
@@ skipping 48 matching lines @@
   DVLOG(1) << error_body;
   const char kErrorKey[] = "error";
   const char kErrorErrorsKey[] = "errors";
   const char kErrorReasonKey[] = "reason";
   const char kErrorMessageKey[] = "message";
   const char kErrorReasonRateLimitExceeded[] = "rateLimitExceeded";
   const char kErrorReasonUserRateLimitExceeded[] = "userRateLimitExceeded";
   const char kErrorReasonQuotaExceeded[] = "quotaExceeded";
   const char kErrorReasonResponseTooLarge[] = "responseTooLarge";
 
-  scoped_ptr<const base::Value> value(google_apis::ParseJson(error_body));
+  std::unique_ptr<const base::Value> value(google_apis::ParseJson(error_body));
   const base::DictionaryValue* dictionary = NULL;
   const base::DictionaryValue* error = NULL;
   if (value &&
       value->GetAsDictionary(&dictionary) &&
       dictionary->GetDictionaryWithoutPathExpansion(kErrorKey, &error)) {
     // Get error message.
     std::string message;
     error->GetStringWithoutPathExpansion(kErrorMessageKey, &message);
     DLOG(ERROR) << "code: " << code << ", message: " << message;
 
@@ skipping 15 matching lines @@
     }
   }
 
   return code;
 }
 
 }  // namespace
 
 namespace google_apis {
 
-scoped_ptr<base::Value> ParseJson(const std::string& json) {
+std::unique_ptr<base::Value> ParseJson(const std::string& json) {
   int error_code = -1;
   std::string error_message;
-  scoped_ptr<base::Value> value = base::JSONReader::ReadAndReturnError(
+  std::unique_ptr<base::Value> value = base::JSONReader::ReadAndReturnError(
       json, base::JSON_PARSE_RFC, &error_code, &error_message);
 
   if (!value.get()) {
     std::string trimmed_json;
     if (json.size() < 80) {
       trimmed_json  = json;
     } else {
       // Take the first 50 and the last 10 bytes.
       trimmed_json = base::StringPrintf(
           "%s [%s bytes] %s",
@@ skipping 80 matching lines @@
     return file_writer_->Initialize(callback);
 
   data_.clear();
   return net::OK;
 }
 
 int ResponseWriter::Write(net::IOBuffer* buffer,
                           int num_bytes,
                           const net::CompletionCallback& callback) {
   if (!get_content_callback_.is_null()) {
-    get_content_callback_.Run(
-        HTTP_SUCCESS,
-        make_scoped_ptr(new std::string(buffer->data(), num_bytes)));
+    get_content_callback_.Run(HTTP_SUCCESS, base::WrapUnique(new std::string(
+                                                buffer->data(), num_bytes)));

[Roger Tawa OOO till Jul 10th, 2016/04/08 15:03:33]

Line formatting does not seem right here.

[dcheng, 2016/04/08 17:27:26]

This is technically compliant to the style guide:
http://google.github.io/styleguide/cppguide.html#Function_Calls
The wrapped line is indented four spaces from the function call
(base::WrapUnique), but it looks unusual because it's nested like this.

My personal preference is the original formatting, but since the clang-formatted
result is still style compliant, I'd prefer not to fight the tools.

   }
 
   if (file_writer_) {
     const int result = file_writer_->Write(
         buffer, num_bytes,
         base::Bind(&ResponseWriter::DidWrite,
                    weak_ptr_factory_.GetWeakPtr(),
                    make_scoped_refptr(buffer), callback));
     if (result != net::ERR_IO_PENDING)
       DidWrite(buffer, net::CompletionCallback(), result);
@@ skipping 103 matching lines @@
 
   base::FilePath output_file_path;
   GetContentCallback get_content_callback;
   GetOutputFilePath(&output_file_path, &get_content_callback);
   if (!get_content_callback.is_null())
     get_content_callback = CreateRelayCallback(get_content_callback);
   response_writer_ = new ResponseWriter(blocking_task_runner(),
                                         output_file_path,
                                         get_content_callback);
   url_fetcher_->SaveResponseWithWriter(
-      scoped_ptr<net::URLFetcherResponseWriter>(response_writer_));
+      std::unique_ptr<net::URLFetcherResponseWriter>(response_writer_));
 
   // Add request headers.
   // Note that SetExtraRequestHeaders clears the current headers and sets it
   // to the passed-in headers, so calling it for each header will result in
   // only the last header being set in request headers.
   if (!custom_user_agent.empty())
     url_fetcher_->AddExtraRequestHeader("User-Agent: " + custom_user_agent);
   url_fetcher_->AddExtraRequestHeader(kGDataVersionHeader);
   url_fetcher_->AddExtraRequestHeader(
       base::StringPrintf(kAuthorizationHeaderFormat, access_token.data()));
@@ skipping 265 matching lines @@
         // ranges exclusively (i.e., end_position_received should be one passed
         // the last valid index). So "+ 1" is added.
         start_position_received = ranges[0].first_byte_position();
         end_position_received = ranges[0].last_byte_position() + 1;
       }
     }
     // The Range header has the received data range, so the start position
     // should be always 0.
     DCHECK_EQ(start_position_received, 0);
 
-    OnRangeRequestComplete(UploadRangeResponse(code,
-                                               start_position_received,
+    OnRangeRequestComplete(UploadRangeResponse(code, start_position_received,
                                                end_position_received),
-                           scoped_ptr<base::Value>());
+                           std::unique_ptr<base::Value>());
 
     OnProcessURLFetchResultsComplete();
   } else if (code == HTTP_CREATED || code == HTTP_SUCCESS) {
     // The upload is successfully done. Parse the response which should be
     // the entry's metadata.
     ParseJsonOnBlockingPool(blocking_task_runner(),
                             response_writer()->data(),
                             base::Bind(&UploadRangeRequestBase::OnDataParsed,
                                        weak_ptr_factory_.GetWeakPtr(),
                                        code));
   } else {
     // Failed to upload. Run callbacks to notify the error.
-    OnRangeRequestComplete(
-        UploadRangeResponse(code, -1, -1), scoped_ptr<base::Value>());
+    OnRangeRequestComplete(UploadRangeResponse(code, -1, -1),
+                           std::unique_ptr<base::Value>());
     OnProcessURLFetchResultsComplete();
   }
 }
 
 void UploadRangeRequestBase::OnDataParsed(DriveApiErrorCode code,
-                                          scoped_ptr<base::Value> value) {
+                                          std::unique_ptr<base::Value> value) {
   DCHECK(CalledOnValidThread());
   DCHECK(code == HTTP_CREATED || code == HTTP_SUCCESS);
 
   OnRangeRequestComplete(UploadRangeResponse(code, -1, -1), std::move(value));
   OnProcessURLFetchResultsComplete();
 }
 
 void UploadRangeRequestBase::RunCallbackOnPrematureFailure(
     DriveApiErrorCode code) {
-  OnRangeRequestComplete(
-      UploadRangeResponse(code, 0, 0), scoped_ptr<base::Value>());
+  OnRangeRequestComplete(UploadRangeResponse(code, 0, 0),
+                         std::unique_ptr<base::Value>());
 }
 
 //========================== ResumeUploadRequestBase =========================
 
 ResumeUploadRequestBase::ResumeUploadRequestBase(
     RequestSender* sender,
     const GURL& upload_location,
     int64_t start_position,
     int64_t end_position,
     int64_t content_length,
@@ skipping 165 matching lines @@
         base::Bind(&MultipartUploadRequestBase::OnDataParsed,
                    weak_ptr_factory_.GetWeakPtr(), code,
                    notify_complete_callback));
   } else {
     NotifyError(MapJsonError(code, body));
     notify_complete_callback.Run();
   }
 }
 
 void MultipartUploadRequestBase::NotifyError(DriveApiErrorCode code) {
-  callback_.Run(code, scoped_ptr<FileResource>());
+  callback_.Run(code, std::unique_ptr<FileResource>());
 }
 
 void MultipartUploadRequestBase::NotifyUploadProgress(
     const net::URLFetcher* source,
     int64_t current,
     int64_t total) {
   if (!progress_callback_.is_null())
     progress_callback_.Run(current, total);
 }
 
 void MultipartUploadRequestBase::OnDataParsed(
     DriveApiErrorCode code,
     const base::Closure& notify_complete_callback,
-    scoped_ptr<base::Value> value) {
+    std::unique_ptr<base::Value> value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (value)
     callback_.Run(code, google_apis::FileResource::CreateFrom(*value));
   else
     NotifyError(DRIVE_PARSE_ERROR);
   notify_complete_callback.Run();
 }
 
 //============================ DownloadFileRequestBase =========================
 
@@ skipping 51 matching lines @@
   download_action_callback_.Run(code, temp_file);
   OnProcessURLFetchResultsComplete();
 }
 
 void DownloadFileRequestBase::RunCallbackOnPrematureFailure(
     DriveApiErrorCode code) {
   download_action_callback_.Run(code, base::FilePath());
 }
 
 }  // namespace google_apis