Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/attachments/attachment_uploader_impl_unittest.cc

 // Copyright 2014 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 "sync/internal_api/public/attachments/attachment_uploader_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 190 matching lines @@
   void TearDown() override;
 
   // Run the message loop until UploadDone has been invoked |num_uploads| times.
   void RunAndWaitFor(int num_uploads);
 
   // Upload an attachment and have the server respond with |status_code|.
   //
   // Returns the attachment that was uploaded.
   Attachment UploadAndRespondWith(const net::HttpStatusCode& status_code);
 
-  scoped_ptr<AttachmentUploader>& uploader();
+  std::unique_ptr<AttachmentUploader>& uploader();
   const AttachmentUploader::UploadCallback& upload_callback() const;
   std::vector<HttpRequest>& http_requests_received();
   std::vector<AttachmentUploader::UploadResult>& upload_results();
   std::vector<AttachmentId>& attachment_ids();
   MockOAuth2TokenService& token_service();
   base::MessageLoopForIO& message_loop();
   RequestHandler& request_handler();
 
  private:
   // An UploadCallback invoked by AttachmentUploaderImpl.
   void UploadDone(const AttachmentUploader::UploadResult& result,
                   const AttachmentId& attachment_id);
 
   base::MessageLoopForIO message_loop_;
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
-  scoped_ptr<RequestHandler> request_handler_;
-  scoped_ptr<AttachmentUploader> uploader_;
+  std::unique_ptr<RequestHandler> request_handler_;
+  std::unique_ptr<AttachmentUploader> uploader_;
   AttachmentUploader::UploadCallback upload_callback_;
   net::EmbeddedTestServer server_;
   // A closure that signals an upload has finished.
   base::Closure signal_upload_done_;
   std::vector<HttpRequest> http_requests_received_;
   std::vector<AttachmentUploader::UploadResult> upload_results_;
   std::vector<AttachmentId> attachment_ids_;
-  scoped_ptr<MockOAuth2TokenService> token_service_;
+  std::unique_ptr<MockOAuth2TokenService> token_service_;
 
   // Must be last data member.
   base::WeakPtrFactory<AttachmentUploaderImplTest> weak_ptr_factory_;
 };
 
 // Handles HTTP requests received by the EmbeddedTestServer.
 //
 // Responds with HTTP_OK by default.  See |SetStatusCode|.
 class RequestHandler : public base::NonThreadSafe {
  public:
   // Construct a RequestHandler that will PostTask to |test| using
   // |test_task_runner|.
   RequestHandler(
       const scoped_refptr<base::SingleThreadTaskRunner>& test_task_runner,
       const base::WeakPtr<AttachmentUploaderImplTest>& test);
 
   ~RequestHandler();
 
-  scoped_ptr<HttpResponse> HandleRequest(const HttpRequest& request);
+  std::unique_ptr<HttpResponse> HandleRequest(const HttpRequest& request);
 
   // Set the HTTP status code to respond with.
   void SetStatusCode(const net::HttpStatusCode& status_code);
 
   // Returns the HTTP status code that will be used in responses.
   net::HttpStatusCode GetStatusCode() const;
 
  private:
   // Protects status_code_.
   mutable base::Lock mutex_;
@@ skipping 57 matching lines @@
     const net::HttpStatusCode& status_code) {
   token_service().AddAccount(kAccountId);
   request_handler().SetStatusCode(status_code);
   scoped_refptr<base::RefCountedString> some_data(new base::RefCountedString);
   some_data->data() = kAttachmentData;
   Attachment attachment = Attachment::Create(some_data);
   uploader()->UploadAttachment(attachment, upload_callback());
   return attachment;
 }
 
-scoped_ptr<AttachmentUploader>& AttachmentUploaderImplTest::uploader() {
+std::unique_ptr<AttachmentUploader>& AttachmentUploaderImplTest::uploader() {
   return uploader_;
 }
 
 const AttachmentUploader::UploadCallback&
 AttachmentUploaderImplTest::upload_callback() const {
   return upload_callback_;
 }
 
 std::vector<HttpRequest>& AttachmentUploaderImplTest::http_requests_received() {
   return http_requests_received_;
@@ skipping 37 matching lines @@
     : status_code_(net::HTTP_OK),
       test_task_runner_(test_task_runner),
       test_(test) {
   DetachFromThread();
 }
 
 RequestHandler::~RequestHandler() {
   DetachFromThread();
 }
 
-scoped_ptr<HttpResponse> RequestHandler::HandleRequest(
+std::unique_ptr<HttpResponse> RequestHandler::HandleRequest(
     const HttpRequest& request) {
   DCHECK(CalledOnValidThread());
   test_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &AttachmentUploaderImplTest::OnRequestReceived, test_, request));
-  scoped_ptr<BasicHttpResponse> response(new BasicHttpResponse);
+  std::unique_ptr<BasicHttpResponse> response(new BasicHttpResponse);
   response->set_code(GetStatusCode());
   response->set_content_type("text/plain");
   return std::move(response);
 }
 
 void RequestHandler::SetStatusCode(const net::HttpStatusCode& status_code) {
   base::AutoLock lock(mutex_);
   status_code_ = status_code;
 }
 
@@ skipping 265 matching lines @@
   scoped_refptr<base::RefCountedString> hello_world(new base::RefCountedString);
   hello_world->data() = "hello world";
   EXPECT_EQ("yZRlqg==", AttachmentUploaderImpl::FormatCrc32cHash(
                             ComputeCrc32c(hello_world)));
 }
 
 // TODO(maniscalco): Add test case for when we are uploading an attachment that
 // already exists.  409 Conflict? (bug 379825)
 
 }  // namespace syncer