Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/drive/test_util.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_TEST_UTIL_H_
 #define GOOGLE_APIS_DRIVE_TEST_UTIL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "google_apis/drive/base_requests.h"
 #include "google_apis/drive/drive_api_error_codes.h"
 #include "google_apis/drive/task_util.h"
 
 class GURL;
 
 namespace base {
 class FilePath;
 class RunLoop;
@@ skipping 45 matching lines @@
 // used.
 // Returns true on success with the created file's |path| and |data|, otherwise
 // false.
 bool CreateFileOfSpecifiedSize(const base::FilePath& temp_dir,
                                size_t size,
                                base::FilePath* path,
                                std::string* data);
 
 // Loads a test JSON file as a base::Value, from a test file stored under
 // chrome/test/data.
-scoped_ptr<base::Value> LoadJSONFile(const std::string& relative_path);
+std::unique_ptr<base::Value> LoadJSONFile(const std::string& relative_path);
 
 // Returns a HttpResponse created from the given file path.
-scoped_ptr<net::test_server::BasicHttpResponse> CreateHttpResponseFromFile(
+std::unique_ptr<net::test_server::BasicHttpResponse> CreateHttpResponseFromFile(
     const base::FilePath& file_path);
 
 // Handles a request for downloading a file. Reads a file from the test
 // directory and returns the content. Also, copies the |request| to the memory
 // pointed by |out_request|.
 // |base_url| must be set to the server's base url.
-scoped_ptr<net::test_server::HttpResponse> HandleDownloadFileRequest(
+std::unique_ptr<net::test_server::HttpResponse> HandleDownloadFileRequest(
     const GURL& base_url,
     net::test_server::HttpRequest* out_request,
     const net::test_server::HttpRequest& request);
 
 // Parses a value of Content-Range header, which looks like
 // "bytes <start_position>-<end_position>/<length>".
 // Returns true on success.
 bool ParseContentRangeHeader(const std::string& value,
                              int64_t* start_position,
                              int64_t* end_position,
@@ skipping 25 matching lines @@
 // Following helper templates are to support Chrome's move semantics.
 // Their goal is defining helper methods which are similar to:
 //   void CopyResultCallback1(T1* out1, T1&& in1)
 //   void CopyResultCallback2(T1* out1, T2* out2, T1&& in1, T2&& in2)
 //            :
 // in C++11.
 
 // Declare if the type is movable or not. Currently limited to scoped_ptr only.
 // We can add more types upon the usage.
 template<typename T> struct IsMovable : std::false_type {};
-template<typename T, typename D>
-struct IsMovable<scoped_ptr<T, D> > : std::true_type {};
+template <typename T, typename D>
+struct IsMovable<std::unique_ptr<T, D>> : std::true_type {};
 
 // InType is const T& if |UseConstRef| is true, otherwise |T|.
 template<bool UseConstRef, typename T> struct InTypeHelper {
   typedef const T& InType;
 };
 template<typename T> struct InTypeHelper<false, T> {
   typedef T InType;
 };
 
 // Simulates the std::move function in C++11. We use pointer here for argument,
@@ skipping 129 matching lines @@
   TestGetContentCallback();
   ~TestGetContentCallback();
 
   const GetContentCallback& callback() const { return callback_; }
   const ScopedVector<std::string>& data() const { return data_; }
   ScopedVector<std::string>* mutable_data() { return &data_; }
   std::string GetConcatenatedData() const;
 
  private:
   void OnGetContent(google_apis::DriveApiErrorCode error,
-                    scoped_ptr<std::string> data);
+                    std::unique_ptr<std::string> data);
 
   const GetContentCallback callback_;
   ScopedVector<std::string> data_;
 
   DISALLOW_COPY_AND_ASSIGN(TestGetContentCallback);
 };
 
 }  // namespace test_util
 }  // namespace google_apis
 
 #endif  // GOOGLE_APIS_DRIVE_TEST_UTIL_H_