Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/drive/drive_api_requests.h

 // 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.
 
 #ifndef GOOGLE_APIS_DRIVE_DRIVE_API_REQUESTS_H_
 #define GOOGLE_APIS_DRIVE_DRIVE_API_REQUESTS_H_
 
 #include <stdint.h>
+
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "google_apis/drive/base_requests.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/drive_api_url_generator.h"
 #include "google_apis/drive/drive_common_callbacks.h"
 
 namespace google_apis {
 
 // Callback used for requests that the server returns FileList data
 // formatted into JSON value.
 typedef base::Callback<void(DriveApiErrorCode error,
-                            scoped_ptr<FileList> entry)> FileListCallback;
+                            std::unique_ptr<FileList> entry)>
+    FileListCallback;
 
 // Callback used for requests that the server returns ChangeList data
 // formatted into JSON value.
 typedef base::Callback<void(DriveApiErrorCode error,
-                            scoped_ptr<ChangeList> entry)> ChangeListCallback;
+                            std::unique_ptr<ChangeList> entry)>
+    ChangeListCallback;
 
 namespace drive {
 
 // Represents a property for a file or a directory.
 // https://developers.google.com/drive/v2/reference/properties
 class Property {
  public:
   Property();
   ~Property();
 
@@ skipping 67 matching lines @@
 };
 
 //============================ DriveApiDataRequest ===========================
 
 // The base class of Drive API related requests that receive a JSON response
 // representing |DataType|.
 template<class DataType>
 class DriveApiDataRequest : public DriveApiPartialFieldRequest {
  public:
   typedef base::Callback<void(DriveApiErrorCode error,
-                              scoped_ptr<DataType> data)> Callback;
+                              std::unique_ptr<DataType> data)>
+      Callback;
 
   // |callback| is called when the request finishes either by success or by
   // failure. On success, a JSON Value object is passed. It must not be null.
   DriveApiDataRequest(RequestSender* sender, const Callback& callback)
       : DriveApiPartialFieldRequest(sender),
         callback_(callback),
         weak_ptr_factory_(this) {
     DCHECK(!callback_.is_null());
   }
   ~DriveApiDataRequest() override {}
@@ skipping 13 matching lines @@
                        weak_ptr_factory_.GetWeakPtr(), error));
         break;
       default:
         RunCallbackOnPrematureFailure(error);
         OnProcessURLFetchResultsComplete();
         break;
     }
   }
 
   void RunCallbackOnPrematureFailure(DriveApiErrorCode error) override {
-    callback_.Run(error, scoped_ptr<DataType>());
+    callback_.Run(error, std::unique_ptr<DataType>());
   }
 
  private:
   // Parses the |json| string by using DataType::CreateFrom.
-  static scoped_ptr<DataType> Parse(const std::string& json) {
-    scoped_ptr<base::Value> value = ParseJson(json);
-    return value ? DataType::CreateFrom(*value) : scoped_ptr<DataType>();
+  static std::unique_ptr<DataType> Parse(const std::string& json) {
+    std::unique_ptr<base::Value> value = ParseJson(json);
+    return value ? DataType::CreateFrom(*value) : std::unique_ptr<DataType>();
   }
 
   // Receives the parsed result and invokes the callback.
-  void OnDataParsed(DriveApiErrorCode error, scoped_ptr<DataType> value) {
+  void OnDataParsed(DriveApiErrorCode error, std::unique_ptr<DataType> value) {
     if (!value)
       error = DRIVE_PARSE_ERROR;
     callback_.Run(error, std::move(value));
     OnProcessURLFetchResultsComplete();
   }
 
   const Callback callback_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
@@ skipping 740 matching lines @@
   std::string parent_resource_id_;
   std::string title_;
   base::Time modified_date_;
   base::Time last_viewed_by_me_date_;
   Properties properties_;
 
   DISALLOW_COPY_AND_ASSIGN(InitiateUploadExistingFileRequest);
 };
 
 // Callback used for ResumeUpload() and GetUploadStatus().
-typedef base::Callback<void(
-    const UploadRangeResponse& response,
-    scoped_ptr<FileResource> new_resource)> UploadRangeCallback;
+typedef base::Callback<void(const UploadRangeResponse& response,
+                            std::unique_ptr<FileResource> new_resource)>
+    UploadRangeCallback;
 
 //============================ ResumeUploadRequest ===========================
 
 // Performs the request for resuming the upload of a file.
 class ResumeUploadRequest : public ResumeUploadRequestBase {
  public:
   // See also ResumeUploadRequestBase's comment for parameters meaning.
   // |callback| must not be null. |progress_callback| may be null.
   ResumeUploadRequest(RequestSender* sender,
                       const GURL& upload_location,
                       int64_t start_position,
                       int64_t end_position,
                       int64_t content_length,
                       const std::string& content_type,
                       const base::FilePath& local_file_path,
                       const UploadRangeCallback& callback,
                       const ProgressCallback& progress_callback);
   ~ResumeUploadRequest() override;
 
  protected:
   // UploadRangeRequestBase overrides.
   void OnRangeRequestComplete(const UploadRangeResponse& response,
-                              scoped_ptr<base::Value> value) override;
+                              std::unique_ptr<base::Value> value) override;
   // content::UrlFetcherDelegate overrides.
   void OnURLFetchUploadProgress(const net::URLFetcher* source,
                                 int64_t current,
                                 int64_t total) override;
 
  private:
   const UploadRangeCallback callback_;
   const ProgressCallback progress_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ResumeUploadRequest);
 };
 
 //========================== GetUploadStatusRequest ==========================
 
 // Performs the request to fetch the current upload status of a file.
 class GetUploadStatusRequest : public GetUploadStatusRequestBase {
  public:
   // See also GetUploadStatusRequestBase's comment for parameters meaning.
   // |callback| must not be null.
   GetUploadStatusRequest(RequestSender* sender,
                          const GURL& upload_url,
                          int64_t content_length,
                          const UploadRangeCallback& callback);
   ~GetUploadStatusRequest() override;
 
  protected:
   // UploadRangeRequestBase overrides.
   void OnRangeRequestComplete(const UploadRangeResponse& response,
-                              scoped_ptr<base::Value> value) override;
+                              std::unique_ptr<base::Value> value) override;
 
  private:
   const UploadRangeCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(GetUploadStatusRequest);
 };
 
 //======================= MultipartUploadNewFileDelegate =======================
 
 // This class performs the request for initiating the upload of a new file.
@@ skipping 151 matching lines @@
   net::URLFetcher::RequestType GetRequestType() const override;
   std::vector<std::string> GetExtraRequestHeaders() const override;
   void Prepare(const PrepareCallback& callback) override;
   bool GetContentData(std::string* upload_content_type,
                       std::string* upload_content) override;
   void RunCallbackOnPrematureFailure(DriveApiErrorCode code) override;
   void ProcessURLFetchResults(const net::URLFetcher* source) override;
   void OnURLFetchUploadProgress(const net::URLFetcher* source,
                                 int64_t current,
                                 int64_t total) override;
-  scoped_ptr<BatchableDelegate> delegate_;
+  std::unique_ptr<BatchableDelegate> delegate_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<SingleBatchableDelegateRequest> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SingleBatchableDelegateRequest);
 };
 
 //========================== BatchUploadRequest ==========================
 
 class BatchUploadChildEntry {
  public:
   explicit BatchUploadChildEntry(BatchableDelegate* request);
   ~BatchUploadChildEntry();
-  scoped_ptr<BatchableDelegate> request;
+  std::unique_ptr<BatchableDelegate> request;
   bool prepared;
   int64_t data_offset;
   int64_t data_size;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BatchUploadChildEntry);
 };
 
 class BatchUploadRequest : public UrlFetchRequestBase {
  public:
@@ skipping 73 matching lines @@
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<BatchUploadRequest> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BatchUploadRequest);
 };
 
 }  // namespace drive
 }  // namespace google_apis
 
 #endif  // GOOGLE_APIS_DRIVE_DRIVE_API_REQUESTS_H_