Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/drive/files_list_request_runner_unittest.cc

 // Copyright 2015 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/files_list_request_runner.h"
 
+#include <memory>
 #include <utility>
 
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "google_apis/drive/base_requests.h"
 #include "google_apis/drive/dummy_auth_service.h"
 #include "google_apis/drive/request_sender.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
@@ skipping 66 matching lines @@
 
   void TearDown() override {
     on_completed_callback_ = base::Closure();
     http_request_.reset();
     response_error_.reset();
     response_entry_.reset();
   }
 
   // Called when the request is completed and no more backoff retries will
   // happen.
-  void OnCompleted(DriveApiErrorCode error, scoped_ptr<FileList> entry) {
+  void OnCompleted(DriveApiErrorCode error, std::unique_ptr<FileList> entry) {
     response_error_.reset(new DriveApiErrorCode(error));
     response_entry_ = std::move(entry);
     on_completed_callback_.Run();
   }
 
  protected:
   // Sets a fake Drive API server response to be returned for the upcoming HTTP
   // request.
   void SetFakeServerResponse(net::HttpStatusCode code,
                              const std::string& content) {
     fake_server_response_.reset(new net::test_server::BasicHttpResponse);
     fake_server_response_->set_code(code);
     fake_server_response_->set_content(content);
     fake_server_response_->set_content_type("application/json");
   }
 
   // Handles a HTTP request to the Drive API server and returns a fake response.
-  scoped_ptr<net::test_server::HttpResponse> OnFilesListRequest(
+  std::unique_ptr<net::test_server::HttpResponse> OnFilesListRequest(
       const GURL& base_url,
       const net::test_server::HttpRequest& request) {
     http_request_.reset(new net::test_server::HttpRequest(request));
     return std::move(fake_server_response_);
   }
 
   base::MessageLoopForIO message_loop_;  // Test server needs IO thread.
-  scoped_ptr<RequestSender> request_sender_;
+  std::unique_ptr<RequestSender> request_sender_;
   net::EmbeddedTestServer test_server_;
-  scoped_ptr<FilesListRequestRunner> runner_;
+  std::unique_ptr<FilesListRequestRunner> runner_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   base::Closure on_completed_callback_;
 
   // Response set by test cases to be returned from the HTTP server.
-  scoped_ptr<net::test_server::BasicHttpResponse> fake_server_response_;
+  std::unique_ptr<net::test_server::BasicHttpResponse> fake_server_response_;
 
   // A requests and a response stored for verification in test cases.
-  scoped_ptr<net::test_server::HttpRequest> http_request_;
-  scoped_ptr<DriveApiErrorCode> response_error_;
-  scoped_ptr<FileList> response_entry_;
+  std::unique_ptr<net::test_server::HttpRequest> http_request_;
+  std::unique_ptr<DriveApiErrorCode> response_error_;
+  std::unique_ptr<FileList> response_entry_;
 };
 
 TEST_F(FilesListRequestRunnerTest, Success_NoBackoff) {
   SetFakeServerResponse(net::HTTP_OK, kSuccessResource);
   runner_->CreateAndStartWithSizeBackoff(
       kMaxResults, kQuery, kFields,
       base::Bind(&FilesListRequestRunnerTest::OnCompleted,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
@@ skipping 122 matching lines @@
       http_request_->relative_url);
 
   // There must be no backoff in case of an error different than
   // DRIVE_RESPONSE_TOO_LARGE.
   ASSERT_TRUE(response_error_.get());
   EXPECT_EQ(DRIVE_NO_SPACE, *response_error_);
   EXPECT_FALSE(response_entry_.get());
 }
 
 }  // namespace google_apis