Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/drive/drive_api_requests_unittest.cc

 // Copyright (c) 2013 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 <stdint.h>
 #include <utility>
 
@@ skipping 40 matching lines @@
     "\"selfLink\": \"self_link\",\n"
     "}\n";
 
 const char kTestUploadExistingFilePath[] = "/upload/existingfile/path";
 const char kTestUploadNewFilePath[] = "/upload/newfile/path";
 const char kTestDownloadPathPrefix[] = "/host/";
 
 // Used as a GetContentCallback.
 void AppendContent(std::string* out,
                    DriveApiErrorCode error,
-                   scoped_ptr<std::string> content) {
+                   std::unique_ptr<std::string> content) {
   EXPECT_EQ(HTTP_SUCCESS, error);
   out->append(*content);
 }
 
 class TestBatchableDelegate : public BatchableDelegate {
  public:
   TestBatchableDelegate(const GURL url,
                         const std::string& content_type,
                         const std::string& content_data,
                         const base::Closure& callback)
@@ skipping 112 matching lines @@
     public_property.set_key("key2");
     public_property.set_value("value2");
 
     testing_properties_.clear();
     testing_properties_.push_back(private_property);
     testing_properties_.push_back(public_property);
   }
 
   base::MessageLoopForIO message_loop_;  // Test server needs IO thread.
   net::EmbeddedTestServer test_server_;
-  scoped_ptr<RequestSender> request_sender_;
-  scoped_ptr<DriveApiUrlGenerator> url_generator_;
+  std::unique_ptr<RequestSender> request_sender_;
+  std::unique_ptr<DriveApiUrlGenerator> url_generator_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   base::ScopedTempDir temp_dir_;
 
   // This is a path to the file which contains expected response from
   // the server. See also HandleDataFileRequest below.
   base::FilePath expected_data_file_path_;
 
   // This is a path string in the expected response header from the server
   // for initiating file uploading.
   std::string expected_upload_path_;
@@ skipping 18 matching lines @@
  private:
   void ResetExpectedResponse() {
     expected_data_file_path_.clear();
     expected_upload_path_.clear();
     expected_content_type_.clear();
     expected_content_.clear();
   }
 
   // For "Children: delete" request, the server will return "204 No Content"
   // response meaning "success".
-  scoped_ptr<net::test_server::HttpResponse> HandleChildrenDeleteRequest(
+  std::unique_ptr<net::test_server::HttpResponse> HandleChildrenDeleteRequest(
       const net::test_server::HttpRequest& request) {
     if (request.method != net::test_server::METHOD_DELETE ||
         request.relative_url.find("/children/") == std::string::npos) {
       // The request is not the "Children: delete" request. Delegate the
       // processing to the next handler.
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
     // Return the response with just "204 No Content" status code.
-    scoped_ptr<net::test_server::BasicHttpResponse> http_response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse);
     http_response->set_code(net::HTTP_NO_CONTENT);
     return std::move(http_response);
   }
 
   // Reads the data file of |expected_data_file_path_| and returns its content
   // for the request.
   // To use this method, it is necessary to set |expected_data_file_path_|
   // to the appropriate file path before sending the request to the server.
-  scoped_ptr<net::test_server::HttpResponse> HandleDataFileRequest(
+  std::unique_ptr<net::test_server::HttpResponse> HandleDataFileRequest(
       const net::test_server::HttpRequest& request) {
     if (expected_data_file_path_.empty()) {
       // The file is not specified. Delegate the processing to the next
       // handler.
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
     // Return the response from the data file.
     return test_util::CreateHttpResponseFromFile(expected_data_file_path_);
   }
 
   // Deletes the resource and returns no content with HTTP_NO_CONTENT status
   // code.
-  scoped_ptr<net::test_server::HttpResponse> HandleDeleteRequest(
+  std::unique_ptr<net::test_server::HttpResponse> HandleDeleteRequest(
       const net::test_server::HttpRequest& request) {
     if (request.method != net::test_server::METHOD_DELETE ||
         request.relative_url.find("/files/") == std::string::npos) {
       // The file is not file deletion request. Delegate the processing to the
       // next handler.
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
-    scoped_ptr<net::test_server::BasicHttpResponse> response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_NO_CONTENT);
 
     return std::move(response);
   }
 
   // Returns PRECONDITION_FAILED response for ETag mismatching with error JSON
   // content specified by |expected_precondition_failed_file_path_|.
   // To use this method, it is necessary to set the variable to the appropriate
   // file path before sending the request to the server.
-  scoped_ptr<net::test_server::HttpResponse> HandlePreconditionFailedRequest(
+  std::unique_ptr<net::test_server::HttpResponse>
+  HandlePreconditionFailedRequest(
       const net::test_server::HttpRequest& request) {
     if (expected_precondition_failed_file_path_.empty()) {
       // The file is not specified. Delegate the process to the next handler.
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
-    scoped_ptr<net::test_server::BasicHttpResponse> response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_PRECONDITION_FAILED);
 
     std::string content;
     if (base::ReadFileToString(expected_precondition_failed_file_path_,
                                &content)) {
       response->set_content(content);
       response->set_content_type("application/json");
     }
 
     return std::move(response);
   }
 
   // Returns the response based on set expected upload url.
   // The response contains the url in its "Location: " header. Also, it doesn't
   // have any content.
   // To use this method, it is necessary to set |expected_upload_path_|
   // to the string representation of the url to be returned.
-  scoped_ptr<net::test_server::HttpResponse> HandleInitiateUploadRequest(
+  std::unique_ptr<net::test_server::HttpResponse> HandleInitiateUploadRequest(
       const net::test_server::HttpRequest& request) {
     if (request.relative_url == expected_upload_path_ ||
         expected_upload_path_.empty()) {
       // The request is for resume uploading or the expected upload url is not
       // set. Delegate the processing to the next handler.
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
-    scoped_ptr<net::test_server::BasicHttpResponse> response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
 
     // Check if the X-Upload-Content-Length is present. If yes, store the
     // length of the file.
     auto found = request.headers.find("X-Upload-Content-Length");
     if (found == request.headers.end() ||
         !base::StringToInt64(found->second, &content_length_)) {
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
     received_bytes_ = 0;
 
     response->set_code(net::HTTP_OK);
     response->AddCustomHeader(
         "Location",
         test_server_.base_url().Resolve(expected_upload_path_).spec());
     return std::move(response);
   }
 
-  scoped_ptr<net::test_server::HttpResponse> HandleResumeUploadRequest(
+  std::unique_ptr<net::test_server::HttpResponse> HandleResumeUploadRequest(
       const net::test_server::HttpRequest& request) {
     if (request.relative_url != expected_upload_path_) {
       // The request path is different from the expected path for uploading.
       // Delegate the processing to the next handler.
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
     if (!request.content.empty()) {
       auto iter = request.headers.find("Content-Range");
       if (iter == request.headers.end()) {
         // The range must be set.
-        return scoped_ptr<net::test_server::HttpResponse>();
+        return std::unique_ptr<net::test_server::HttpResponse>();
       }
 
       int64_t length = 0;
       int64_t start_position = 0;
       int64_t end_position = 0;
       if (!test_util::ParseContentRangeHeader(
               iter->second, &start_position, &end_position, &length)) {
         // Invalid "Content-Range" value.
-        return scoped_ptr<net::test_server::HttpResponse>();
+        return std::unique_ptr<net::test_server::HttpResponse>();
       }
 
       EXPECT_EQ(start_position, received_bytes_);
       EXPECT_EQ(length, content_length_);
 
       // end_position is inclusive, but so +1 to change the range to byte size.
       received_bytes_ = end_position + 1;
     }
 
     if (received_bytes_ < content_length_) {
-      scoped_ptr<net::test_server::BasicHttpResponse> response(
+      std::unique_ptr<net::test_server::BasicHttpResponse> response(
           new net::test_server::BasicHttpResponse);
       // Set RESUME INCOMPLETE (308) status code.
       response->set_code(static_cast<net::HttpStatusCode>(308));
 
       // Add Range header to the response, based on the values of
       // Content-Range header in the request.
       // The header is annotated only when at least one byte is received.
       if (received_bytes_ > 0) {
         response->AddCustomHeader(
             "Range", "bytes=0-" + base::Int64ToString(received_bytes_ - 1));
       }
 
       return std::move(response);
     }
 
     // All bytes are received. Return the "success" response with the file's
     // (dummy) metadata.
-    scoped_ptr<net::test_server::BasicHttpResponse> response =
+    std::unique_ptr<net::test_server::BasicHttpResponse> response =
         test_util::CreateHttpResponseFromFile(
             test_util::GetTestFilePath("drive/file_entry.json"));
 
     // The response code is CREATED if it is new file uploading.
     if (http_request_.relative_url == kTestUploadNewFilePath) {
       response->set_code(net::HTTP_CREATED);
     }
 
     return std::move(response);
   }
 
   // Returns the response based on set expected content and its type.
   // To use this method, both |expected_content_type_| and |expected_content_|
   // must be set in advance.
-  scoped_ptr<net::test_server::HttpResponse> HandleContentResponse(
+  std::unique_ptr<net::test_server::HttpResponse> HandleContentResponse(
       const net::test_server::HttpRequest& request) {
     if (expected_content_type_.empty() || expected_content_.empty()) {
       // Expected content is not set. Delegate the processing to the next
       // handler.
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
 
     http_request_ = request;
 
-    scoped_ptr<net::test_server::BasicHttpResponse> response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_OK);
     response->set_content_type(expected_content_type_);
     response->set_content(expected_content_);
     return std::move(response);
   }
 
   // Handles a request for downloading a file.
-  scoped_ptr<net::test_server::HttpResponse> HandleDownloadRequest(
+  std::unique_ptr<net::test_server::HttpResponse> HandleDownloadRequest(
       const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     std::string id;
     if (!test_util::RemovePrefix(absolute_url.path(),
                                  kTestDownloadPathPrefix,
                                  &id)) {
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
     }
 
     // For testing, returns a text with |id| repeated 3 times.
-    scoped_ptr<net::test_server::BasicHttpResponse> response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_OK);
     response->set_content(id + id + id);
     response->set_content_type("text/plain");
     return std::move(response);
   }
 
-  scoped_ptr<net::test_server::HttpResponse> HandleBatchUploadRequest(
+  std::unique_ptr<net::test_server::HttpResponse> HandleBatchUploadRequest(
       const net::test_server::HttpRequest& request) {
     http_request_ = request;
 
     const GURL absolute_url = test_server_.GetURL(request.relative_url);
     std::string id;
     if (absolute_url.path() != "/upload/drive")
-      return scoped_ptr<net::test_server::HttpResponse>();
+      return std::unique_ptr<net::test_server::HttpResponse>();
 
-    scoped_ptr<net::test_server::BasicHttpResponse> response(
+    std::unique_ptr<net::test_server::BasicHttpResponse> response(
         new net::test_server::BasicHttpResponse);
     response->set_code(net::HTTP_OK);
     response->set_content_type("multipart/mixed; boundary=BOUNDARY");
     response->set_content(
         "--BOUNDARY\r\n"
         "Content-Type: application/http\r\n"
         "\r\n"
         "HTTP/1.1 200 OK\r\n"
         "Content-Type: application/json; charset=UTF-8\r\n"
         "\r\n"
@@ skipping 22 matching lines @@
 
 TEST_F(DriveApiRequestsTest, DriveApiDataRequest_Fields) {
   // Make sure that "fields" query param is supported by using its subclass,
   // AboutGetRequest.
 
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/about.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<AboutResource> about_resource;
+  std::unique_ptr<AboutResource> about_resource;
 
   {
     base::RunLoop run_loop;
     drive::AboutGetRequest* request = new drive::AboutGetRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &about_resource)));
     request->set_fields("kind,quotaBytesTotal,quotaBytesUsedAggregate,"
                         "largestChangeId,rootFolderId");
     request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/about?"
             "fields=kind%2CquotaBytesTotal%2CquotaBytesUsedAggregate%2C"
             "largestChangeId%2CrootFolderId",
             http_request_.relative_url);
 
-  scoped_ptr<AboutResource> expected(
-      AboutResource::CreateFrom(
-          *test_util::LoadJSONFile("drive/about.json")));
+  std::unique_ptr<AboutResource> expected(
+      AboutResource::CreateFrom(*test_util::LoadJSONFile("drive/about.json")));
   ASSERT_TRUE(about_resource.get());
   EXPECT_EQ(expected->largest_change_id(), about_resource->largest_change_id());
   EXPECT_EQ(expected->quota_bytes_total(), about_resource->quota_bytes_total());
   EXPECT_EQ(expected->quota_bytes_used_aggregate(),
             about_resource->quota_bytes_used_aggregate());
   EXPECT_EQ(expected->root_folder_id(), about_resource->root_folder_id());
 }
 
 TEST_F(DriveApiRequestsTest, FilesInsertRequest) {
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
   const base::Time::Exploded kLastViewedByMeDate =
       {2013, 7, 0, 19, 15, 59, 13, 123};
 
   // Set an expected data file containing the directory's entry data.
   expected_data_file_path_ =
       test_util::GetTestFilePath("drive/directory_entry.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<FileResource> file_resource;
+  std::unique_ptr<FileResource> file_resource;
 
   // Create "new directory" in the root directory.
   {
     base::RunLoop run_loop;
     drive::FilesInsertRequest* request = new drive::FilesInsertRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
@@ skipping 19 matching lines @@
       "{\"lastViewedByMeDate\":\"2013-07-19T15:59:13.123Z\","
       "\"mimeType\":\"application/vnd.google-apps.folder\","
       "\"modifiedDate\":\"2012-07-19T15:59:13.123Z\","
       "\"parents\":[{\"id\":\"root\"}],"
       "\"properties\":["
       "{\"key\":\"key1\",\"value\":\"value1\",\"visibility\":\"PRIVATE\"},"
       "{\"key\":\"key2\",\"value\":\"value2\",\"visibility\":\"PUBLIC\"}],"
       "\"title\":\"new directory\"}",
       http_request_.content);
 
-  scoped_ptr<FileResource> expected(
-      FileResource::CreateFrom(
-          *test_util::LoadJSONFile("drive/directory_entry.json")));
+  std::unique_ptr<FileResource> expected(FileResource::CreateFrom(
+      *test_util::LoadJSONFile("drive/directory_entry.json")));
 
   // Sanity check.
   ASSERT_TRUE(file_resource.get());
 
   EXPECT_EQ(expected->file_id(), file_resource->file_id());
   EXPECT_EQ(expected->title(), file_resource->title());
   EXPECT_EQ(expected->mime_type(), file_resource->mime_type());
   EXPECT_EQ(expected->parents().size(), file_resource->parents().size());
 }
 
 TEST_F(DriveApiRequestsTest, FilesPatchRequest) {
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
   const base::Time::Exploded kLastViewedByMeDate =
       {2013, 7, 0, 19, 15, 59, 13, 123};
 
   // Set an expected data file containing valid result.
   expected_data_file_path_ =
       test_util::GetTestFilePath("drive/file_entry.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<FileResource> file_resource;
+  std::unique_ptr<FileResource> file_resource;
 
   {
     base::RunLoop run_loop;
     drive::FilesPatchRequest* request = new drive::FilesPatchRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
     request->set_file_id("resource_id");
@@ skipping 30 matching lines @@
       http_request_.content);
   EXPECT_TRUE(file_resource);
 }
 
 TEST_F(DriveApiRequestsTest, AboutGetRequest_ValidJson) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/about.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<AboutResource> about_resource;
+  std::unique_ptr<AboutResource> about_resource;
 
   {
     base::RunLoop run_loop;
     drive::AboutGetRequest* request = new drive::AboutGetRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &about_resource)));
     request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/about", http_request_.relative_url);
 
-  scoped_ptr<AboutResource> expected(
-      AboutResource::CreateFrom(
-          *test_util::LoadJSONFile("drive/about.json")));
+  std::unique_ptr<AboutResource> expected(
+      AboutResource::CreateFrom(*test_util::LoadJSONFile("drive/about.json")));
   ASSERT_TRUE(about_resource.get());
   EXPECT_EQ(expected->largest_change_id(), about_resource->largest_change_id());
   EXPECT_EQ(expected->quota_bytes_total(), about_resource->quota_bytes_total());
   EXPECT_EQ(expected->quota_bytes_used_aggregate(),
             about_resource->quota_bytes_used_aggregate());
   EXPECT_EQ(expected->root_folder_id(), about_resource->root_folder_id());
 }
 
 TEST_F(DriveApiRequestsTest, AboutGetRequest_InvalidJson) {
   // Set an expected data file containing invalid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/testfile.txt");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<AboutResource> about_resource;
+  std::unique_ptr<AboutResource> about_resource;
 
   {
     base::RunLoop run_loop;
     drive::AboutGetRequest* request = new drive::AboutGetRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &about_resource)));
     request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   // "parse error" should be returned, and the about resource should be NULL.
   EXPECT_EQ(DRIVE_PARSE_ERROR, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/about", http_request_.relative_url);
   EXPECT_FALSE(about_resource);
 }
 
 TEST_F(DriveApiRequestsTest, AppsListRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/applist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<AppList> app_list;
+  std::unique_ptr<AppList> app_list;
 
   {
     base::RunLoop run_loop;
     drive::AppsListRequest* request = new drive::AppsListRequest(
         request_sender_.get(),
         *url_generator_,
         false,  // use_internal_endpoint
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &app_list)));
     request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/apps", http_request_.relative_url);
   EXPECT_TRUE(app_list);
 }
 
 TEST_F(DriveApiRequestsTest, ChangesListRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/changelist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<ChangeList> result;
+  std::unique_ptr<ChangeList> result;
 
   {
     base::RunLoop run_loop;
     drive::ChangesListRequest* request = new drive::ChangesListRequest(
         request_sender_.get(), *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &result)));
     request->set_include_deleted(true);
     request->set_start_change_id(100);
     request->set_max_results(500);
     request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/changes?maxResults=500&startChangeId=100",
             http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, ChangesListNextPageRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/changelist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<ChangeList> result;
+  std::unique_ptr<ChangeList> result;
 
   {
     base::RunLoop run_loop;
     drive::ChangesListNextPageRequest* request =
         new drive::ChangesListNextPageRequest(
             request_sender_.get(),
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error, &result)));
     request->set_next_link(test_server_.GetURL("/continue/get/change/list"));
     request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/continue/get/change/list", http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, FilesCopyRequest) {
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
 
   // Set an expected data file containing the dummy file entry data.
   // It'd be returned if we copy a file.
   expected_data_file_path_ =
       test_util::GetTestFilePath("drive/file_entry.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<FileResource> file_resource;
+  std::unique_ptr<FileResource> file_resource;
 
   // Copy the file to a new file named "new title".
   {
     base::RunLoop run_loop;
     drive::FilesCopyRequest* request = new drive::FilesCopyRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
@@ skipping 20 matching lines @@
   EXPECT_TRUE(file_resource);
 }
 
 TEST_F(DriveApiRequestsTest, FilesCopyRequest_EmptyParentResourceId) {
   // Set an expected data file containing the dummy file entry data.
   // It'd be returned if we copy a file.
   expected_data_file_path_ =
       test_util::GetTestFilePath("drive/file_entry.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<FileResource> file_resource;
+  std::unique_ptr<FileResource> file_resource;
 
   // Copy the file to a new file named "new title".
   {
     base::RunLoop run_loop;
     drive::FilesCopyRequest* request = new drive::FilesCopyRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
@@ skipping 12 matching lines @@
   EXPECT_EQ("{\"title\":\"new title\"}", http_request_.content);
   EXPECT_TRUE(file_resource);
 }
 
 TEST_F(DriveApiRequestsTest, FilesListRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/filelist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<FileList> result;
+  std::unique_ptr<FileList> result;
 
   {
     base::RunLoop run_loop;
     drive::FilesListRequest* request = new drive::FilesListRequest(
         request_sender_.get(), *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &result)));
     request->set_max_results(50);
     request->set_q("\"abcde\" in parents");
     request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/files?maxResults=50&q=%22abcde%22+in+parents",
             http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, FilesListNextPageRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/filelist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<FileList> result;
+  std::unique_ptr<FileList> result;
 
   {
     base::RunLoop run_loop;
     drive::FilesListNextPageRequest* request =
         new drive::FilesListNextPageRequest(
             request_sender_.get(),
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error, &result)));
     request->set_next_link(test_server_.GetURL("/continue/get/file/list"));
@@ skipping 31 matching lines @@
   EXPECT_FALSE(http_request_.has_content);
 }
 
 TEST_F(DriveApiRequestsTest, FilesTrashRequest) {
   // Set data for the expected result. Directory entry should be returned
   // if the trashing entry is a directory, so using it here should be fine.
   expected_data_file_path_ =
       test_util::GetTestFilePath("drive/directory_entry.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
-  scoped_ptr<FileResource> file_resource;
+  std::unique_ptr<FileResource> file_resource;
 
   // Trash a resource with the given resource id.
   {
     base::RunLoop run_loop;
     drive::FilesTrashRequest* request = new drive::FilesTrashRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
@@ skipping 118 matching lines @@
       "\"kind\":\"drive#fileLink\""
       "}],"
       "\"properties\":["
       "{\"key\":\"key1\",\"value\":\"value1\",\"visibility\":\"PRIVATE\"},"
       "{\"key\":\"key2\",\"value\":\"value2\",\"visibility\":\"PUBLIC\"}],"
       "\"title\":\"new file title\"}",
       http_request_.content);
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
-  scoped_ptr<FileResource> new_entry;
+  std::unique_ptr<FileResource> new_entry;
 
   {
     base::RunLoop run_loop;
     drive::ResumeUploadRequest* resume_request =
         new drive::ResumeUploadRequest(
             request_sender_.get(),
             upload_url,
             0,  // start_position
             kTestContent.size(),  // end_position (exclusive)
             kTestContent.size(),  // content_length,
@@ skipping 70 matching lines @@
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("{\"parents\":[{"
             "\"id\":\"parent_resource_id\","
             "\"kind\":\"drive#fileLink\""
             "}],"
             "\"title\":\"new file title\"}",
             http_request_.content);
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
-  scoped_ptr<FileResource> new_entry;
+  std::unique_ptr<FileResource> new_entry;
 
   {
     base::RunLoop run_loop;
     drive::ResumeUploadRequest* resume_request =
         new drive::ResumeUploadRequest(
             request_sender_.get(),
             upload_url,
             0,  // start_position
             0,  // end_position (exclusive)
             0,  // content_length,
@@ skipping 71 matching lines @@
             "\"id\":\"parent_resource_id\","
             "\"kind\":\"drive#fileLink\""
             "}],"
             "\"title\":\"new file title\"}",
             http_request_.content);
 
   // Before sending any data, check the current status.
   // This is an edge case test for GetUploadStatusRequest.
   {
     UploadRangeResponse response;
-    scoped_ptr<FileResource> new_entry;
+    std::unique_ptr<FileResource> new_entry;
 
     // Check the response by GetUploadStatusRequest.
     {
       base::RunLoop run_loop;
       drive::GetUploadStatusRequest* get_upload_status_request =
           new drive::GetUploadStatusRequest(
               request_sender_.get(),
               upload_url,
               kTestContent.size(),
               test_util::CreateQuitCallback(
@@ skipping 21 matching lines @@
 
   // Upload the content to the upload URL.
   for (size_t start_position = 0; start_position < kTestContent.size();
        start_position += kNumChunkBytes) {
     const std::string payload = kTestContent.substr(
         start_position,
         std::min(kNumChunkBytes, kTestContent.size() - start_position));
     const size_t end_position = start_position + payload.size();
 
     UploadRangeResponse response;
-    scoped_ptr<FileResource> new_entry;
+    std::unique_ptr<FileResource> new_entry;
 
     {
       base::RunLoop run_loop;
       drive::ResumeUploadRequest* resume_request =
           new drive::ResumeUploadRequest(
               request_sender_.get(),
               upload_url,
               start_position,
               end_position,
               kTestContent.size(),  // content_length,
@@ skipping 168 matching lines @@
             http_request_.relative_url);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ(
       "{\"properties\":["
       "{\"key\":\"key1\",\"value\":\"value1\",\"visibility\":\"PRIVATE\"},"
       "{\"key\":\"key2\",\"value\":\"value2\",\"visibility\":\"PUBLIC\"}]}",
       http_request_.content);
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
-  scoped_ptr<FileResource> new_entry;
+  std::unique_ptr<FileResource> new_entry;
 
   {
     base::RunLoop run_loop;
     drive::ResumeUploadRequest* resume_request =
         new drive::ResumeUploadRequest(
             request_sender_.get(),
             upload_url,
             0,  // start_position
             kTestContent.size(),  // end_position (exclusive)
             kTestContent.size(),  // content_length,
@@ skipping 66 matching lines @@
   EXPECT_EQ(kTestETag, http_request_.headers["If-Match"]);
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(http_request_.content.empty());
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
-  scoped_ptr<FileResource> new_entry;
+  std::unique_ptr<FileResource> new_entry;
 
   {
     base::RunLoop run_loop;
     drive::ResumeUploadRequest* resume_request =
         new drive::ResumeUploadRequest(
             request_sender_.get(),
             upload_url,
             0,  // start_position
             kTestContent.size(),  // end_position (exclusive)
             kTestContent.size(),  // content_length,
@@ skipping 118 matching lines @@
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(http_request_.content.empty());
 
   // Set PRECONDITION_FAILED to the server. This is the emulation of the
   // confliction during uploading.
   expected_precondition_failed_file_path_ =
       test_util::GetTestFilePath("drive/error.json");
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
-  scoped_ptr<FileResource> new_entry;
+  std::unique_ptr<FileResource> new_entry;
 
   {
     base::RunLoop run_loop;
     drive::ResumeUploadRequest* resume_request =
         new drive::ResumeUploadRequest(
             request_sender_.get(),
             upload_url,
             0,  // start_position
             kTestContent.size(),  // end_position (exclusive)
             kTestContent.size(),  // content_length,
@@ skipping 183 matching lines @@
     request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/drive/v2/files/resource_id/permissions",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
-  scoped_ptr<base::Value> expected = base::JSONReader::Read(
+  std::unique_ptr<base::Value> expected = base::JSONReader::Read(
       "{\"additionalRoles\":[\"commenter\"], \"role\":\"reader\", "
       "\"type\":\"user\",\"value\":\"user@example.com\"}");
   ASSERT_TRUE(expected);
 
-  scoped_ptr<base::Value> result =
+  std::unique_ptr<base::Value> result =
       base::JSONReader::Read(http_request_.content);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(base::Value::Equals(expected.get(), result.get()));
 
   // Add "can edit" permission to users in "example.com".
   error = DRIVE_OTHER_ERROR;
   {
     base::RunLoop run_loop;
     drive::PermissionsInsertRequest* request =
         new drive::PermissionsInsertRequest(
@@ skipping 34 matching lines @@
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 
   // Create batch request.
   drive::BatchUploadRequest* const request =
       new drive::BatchUploadRequest(request_sender_.get(), *url_generator_);
   request->SetBoundaryForTesting("OUTERBOUNDARY");
   request_sender_->StartRequestWithAuthRetry(request);
 
   // Create child request.
   DriveApiErrorCode errors[] = {DRIVE_OTHER_ERROR, DRIVE_OTHER_ERROR};
-  scoped_ptr<FileResource> file_resources[2];
+  std::unique_ptr<FileResource> file_resources[2];
   base::RunLoop run_loop[2];
   for (int i = 0; i < 2; ++i) {
     const FileResourceCallback callback = test_util::CreateQuitCallback(
         &run_loop[i],
         test_util::CreateCopyResultCallback(&errors[i], &file_resources[i]));
     drive::MultipartUploadNewFileDelegate* const child_request =
         new drive::MultipartUploadNewFileDelegate(
             request_sender_->blocking_task_runner(),
             base::StringPrintf("new file title %d", i),
             "parent_resource_id", kTestContentType, kTestContent.size(),
@@ skipping 265 matching lines @@
                                     "Header: value\r\n"
                                     "\r\n"
                                     "BODY\r\n"
                                     "--BOUNDARY-- \t",
                                     &parts));
   ASSERT_EQ(1u, parts.size());
   EXPECT_EQ(HTTP_SUCCESS, parts[0].code);
   EXPECT_EQ("BODY", parts[0].body);
 }
 }  // namespace google_apis