Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/drive/base_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.
 //
 // This file provides base classes used to issue HTTP requests for Google
 // APIs.
 
 #ifndef GOOGLE_APIS_DRIVE_BASE_REQUESTS_H_
 #define GOOGLE_APIS_DRIVE_BASE_REQUESTS_H_
 
@@ skipping 32 matching lines @@
 struct ContentTypeAndData {
   std::string type;
   std::string data;
 };
 
 typedef base::Callback<void(DriveApiErrorCode)> PrepareCallback;
 
 // Callback used for requests that the server returns FileResource data
 // formatted into JSON value.
 typedef base::Callback<void(DriveApiErrorCode error,
-                            scoped_ptr<FileResource> entry)>
+                            std::unique_ptr<FileResource> entry)>
     FileResourceCallback;
 
 // Callback used for DownloadFileRequest and ResumeUploadRequestBase.
 typedef base::Callback<void(int64_t progress, int64_t total)> ProgressCallback;
 
 // Callback used to get the content from DownloadFileRequest.
-typedef base::Callback<void(
-    DriveApiErrorCode error,
-    scoped_ptr<std::string> content)> GetContentCallback;
+typedef base::Callback<void(DriveApiErrorCode error,
+                            std::unique_ptr<std::string> content)>
+    GetContentCallback;
 
 // Parses JSON passed in |json|. Returns NULL on failure.
-scoped_ptr<base::Value> ParseJson(const std::string& json);
+std::unique_ptr<base::Value> ParseJson(const std::string& json);
 
 // Generate multipart body. If |predetermined_boundary| is not empty, it uses
 // the string as boundary. Otherwise it generates random boundary that does not
 // conflict with |parts|. If |data_offset| is not nullptr, it stores the
 // index of first byte of each part in multipart body.
 void GenerateMultipartBody(MultipartType multipart_type,
                            const std::string& predetermined_boundary,
                            const std::vector<ContentTypeAndData>& parts,
                            ContentTypeAndData* output,
                            std::vector<uint64_t>* data_offset);
@@ skipping 61 matching lines @@
             const net::CompletionCallback& callback) override;
   int Finish(const net::CompletionCallback& callback) override;
 
  private:
   void DidWrite(scoped_refptr<net::IOBuffer> buffer,
                 const net::CompletionCallback& callback,
                 int result);
 
   const GetContentCallback get_content_callback_;
   std::string data_;
-  scoped_ptr<net::URLFetcherFileWriter> file_writer_;
+  std::unique_ptr<net::URLFetcherFileWriter> file_writer_;
   base::WeakPtrFactory<ResponseWriter> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ResponseWriter);
 };
 
 //============================ UrlFetchRequestBase ===========================
 
 // Base class for requests that are fetching URLs.
 class UrlFetchRequestBase : public AuthenticatedRequestInterface,
                             public net::URLFetcherDelegate {
@@ skipping 84 matching lines @@
   void CompleteRequestWithError(DriveApiErrorCode code);
 
   // URLFetcherDelegate overrides.
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
   // AuthenticatedRequestInterface overrides.
   void OnAuthFailed(DriveApiErrorCode code) override;
 
   ReAuthenticateCallback re_authenticate_callback_;
   int re_authenticate_count_;
-  scoped_ptr<net::URLFetcher> url_fetcher_;
+  std::unique_ptr<net::URLFetcher> url_fetcher_;
   ResponseWriter* response_writer_;  // Owned by |url_fetcher_|.
   RequestSender* sender_;
   DriveApiErrorCode error_code_;
 
   base::ThreadChecker thread_checker_;
 
   // 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<UrlFetchRequestBase> weak_ptr_factory_;
 
@@ skipping 149 matching lines @@
   // 2) If the upload is complete, |code| is set to HTTP_CREATED for a new file
   // or HTTP_SUCCESS for an existing file. Positions are set to -1, and |value|
   // is set to a parsed JSON value representing the uploaded file.
   // 3) If a premature failure is found, |code| is set to a value representing
   // the situation. Positions are set to 0, and |value| is set to NULL.
   //
   // See also the comments for UploadRangeResponse.
   // Note: Subclasses should have responsibility to run some callback
   // in this method to notify the finish status to its clients (or ignore it
   // under its responsibility).
-  virtual void OnRangeRequestComplete(
-      const UploadRangeResponse& response, scoped_ptr<base::Value> value) = 0;
+  virtual void OnRangeRequestComplete(const UploadRangeResponse& response,
+                                      std::unique_ptr<base::Value> value) = 0;
 
  private:
   // Called when ParseJson() is completed.
-  void OnDataParsed(DriveApiErrorCode code, scoped_ptr<base::Value> value);
+  void OnDataParsed(DriveApiErrorCode code, std::unique_ptr<base::Value> value);
 
   const GURL upload_url_;
 
   // 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<UploadRangeRequestBase> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UploadRangeRequestBase);
 };
 
@@ skipping 105 matching lines @@
   void NotifyResult(DriveApiErrorCode code,
                     const std::string& body,
                     const base::Closure& callback) override;
   void NotifyError(DriveApiErrorCode code) override;
   void NotifyUploadProgress(const net::URLFetcher* source,
                             int64_t current,
                             int64_t total) override;
   // Parses the response value and invokes |callback_| with |FileResource|.
   void OnDataParsed(DriveApiErrorCode code,
                     const base::Closure& callback,
-                    scoped_ptr<base::Value> value);
+                    std::unique_ptr<base::Value> value);
 
  private:
   // Continues to rest part of |Start| method after determining boundary string
   // of multipart/related.
   void OnPrepareUploadContent(const PrepareCallback& callback,
                               std::string* upload_content_type,
                               std::string* upload_content_data,
                               bool result);
 
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
@@ skipping 74 matching lines @@
   const ProgressCallback progress_callback_;
   const GURL download_url_;
   const base::FilePath output_file_path_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadFileRequestBase);
 };
 
 }  // namespace google_apis
 
 #endif  // GOOGLE_APIS_DRIVE_BASE_REQUESTS_H_