Convert Pass()→std::move() in sync/

sync/internal_api/attachments/attachment_service_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_service_impl.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 213 matching lines @@
       scoped_ptr<MockAttachmentDownloader> downloader,
       AttachmentService::Delegate* delegate) {
     // Initialize mock attachment store
     scoped_refptr<base::SingleThreadTaskRunner> runner =
         base::ThreadTaskRunnerHandle::Get();
     scoped_ptr<MockAttachmentStoreBackend> attachment_store_backend(
         new MockAttachmentStoreBackend(runner));
     attachment_store_backend_ = attachment_store_backend->AsWeakPtr();
     scoped_ptr<AttachmentStore> attachment_store =
         AttachmentStore::CreateMockStoreForTest(
-            attachment_store_backend.Pass());
+            std::move(attachment_store_backend));
 
     if (uploader.get()) {
       attachment_uploader_ = uploader->AsWeakPtr();
     }
     if (downloader.get()) {
       attachment_downloader_ = downloader->AsWeakPtr();
     }
     attachment_service_.reset(new AttachmentServiceImpl(
-        attachment_store->CreateAttachmentStoreForSync(), uploader.Pass(),
-        downloader.Pass(), delegate, base::TimeDelta::FromMinutes(1),
+        attachment_store->CreateAttachmentStoreForSync(), std::move(uploader),
+        std::move(downloader), delegate, base::TimeDelta::FromMinutes(1),
         base::TimeDelta::FromMinutes(8)));
 
     scoped_ptr<base::MockTimer> timer_to_pass(
         new base::MockTimer(false, false));
     mock_timer_ = timer_to_pass.get();
-    attachment_service_->SetTimerForTest(timer_to_pass.Pass());
+    attachment_service_->SetTimerForTest(std::move(timer_to_pass));
   }
 
   AttachmentService* attachment_service() { return attachment_service_.get(); }
 
   base::MockTimer* mock_timer() { return mock_timer_; }
 
   AttachmentService::GetOrDownloadCallback download_callback() {
     return base::Bind(&AttachmentServiceImplTest::DownloadDone,
                       base::Unretained(this));
   }
 
   void DownloadDone(const AttachmentService::GetOrDownloadResult& result,
                     scoped_ptr<AttachmentMap> attachments) {
     download_results_.push_back(result);
-    last_download_attachments_ = attachments.Pass();
+    last_download_attachments_ = std::move(attachments);
   }
 
   void RunLoop() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   void RunLoopAndFireTimer() {
     RunLoop();
     if (mock_timer()->IsRunning()) {
@@ skipping 355 matching lines @@
   net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
       net::NetworkChangeNotifier::CONNECTION_WIFI);
   RunLoop();
 
   // No longer in backoff.
   ASSERT_TRUE(mock_timer()->IsRunning());
   ASSERT_EQ(base::TimeDelta(), mock_timer()->GetCurrentDelay());
 }
 
 }  // namespace syncer