Convert Pass()→std::move() in //components/[n-z]*

components/sync_driver/generic_change_processor_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 "components/sync_driver/generic_change_processor.h"
 
 #include <stddef.h>
-
 #include <string>
+#include <utility>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/sync_driver/data_type_error_handler_mock.h"
 #include "components/sync_driver/fake_sync_client.h"
 #include "components/sync_driver/local_device_info_provider.h"
 #include "components/sync_driver/sync_api_component_factory.h"
@@ skipping 29 matching lines @@
   void UploadAttachments(
       const syncer::AttachmentIdList& attachment_ids) override;
   std::vector<syncer::AttachmentIdList>* attachment_id_lists();
 
  private:
   std::vector<syncer::AttachmentIdList> attachment_id_lists_;
 };
 
 MockAttachmentService::MockAttachmentService(
     scoped_ptr<syncer::AttachmentStoreForSync> attachment_store)
-    : AttachmentServiceImpl(attachment_store.Pass(),
+    : AttachmentServiceImpl(std::move(attachment_store),
                             scoped_ptr<syncer::AttachmentUploader>(
                                 new syncer::FakeAttachmentUploader),
                             scoped_ptr<syncer::AttachmentDownloader>(
                                 new syncer::FakeAttachmentDownloader),
                             NULL,
                             base::TimeDelta(),
-                            base::TimeDelta()) {
-}
+                            base::TimeDelta()) {}
 
 MockAttachmentService::~MockAttachmentService() {
 }
 
 void MockAttachmentService::UploadAttachments(
     const syncer::AttachmentIdList& attachment_ids) {
   attachment_id_lists_.push_back(attachment_ids);
   AttachmentServiceImpl::UploadAttachments(attachment_ids);
 }
 
@@ skipping 35 matching lines @@
     return SyncComponents(nullptr, nullptr);
   }
 
   scoped_ptr<syncer::AttachmentService> CreateAttachmentService(
       scoped_ptr<syncer::AttachmentStoreForSync> attachment_store,
       const syncer::UserShare& user_share,
       const std::string& store_birthday,
       syncer::ModelType model_type,
       syncer::AttachmentService::Delegate* delegate) override {
     scoped_ptr<MockAttachmentService> attachment_service(
-        new MockAttachmentService(attachment_store.Pass()));
+        new MockAttachmentService(std::move(attachment_store)));
     // GenericChangeProcessor takes ownership of the AttachmentService, but we
     // need to have a pointer to it so we can see that it was used properly.
     // Take a pointer and trust that GenericChangeProcessor does not prematurely
     // destroy it.
     mock_attachment_service_ = attachment_service.get();
-    return attachment_service.Pass();
+    return std::move(attachment_service);
   }
 
   MockAttachmentService* GetMockAttachmentService() {
     return mock_attachment_service_;
   }
 
  private:
   MockAttachmentService* mock_attachment_service_;
 };
 
@@ skipping 396 matching lines @@
   syncer::SyncDataList sync_data =
       change_processor()->GetAllSyncData(syncer::SESSIONS);
   ASSERT_EQ(sync_data.size(), 1U);
   ASSERT_EQ("session tag 2",
             sync_data[0].GetSpecifics().session().session_tag());
 }
 
 }  // namespace
 
 }  // namespace sync_driver