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

components/password_manager/core/browser/password_syncable_service_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/password_manager/core/browser/password_syncable_service.h"
 
 #include <algorithm>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/password_manager/core/browser/mock_password_store.h"
 #include "sync/api/sync_change_processor.h"
@@ skipping 177 matching lines @@
   }
 
   ~PasswordSyncableServiceWrapper() { password_store_->ShutdownOnUIThread(); }
 
   MockPasswordStore* password_store() { return password_store_.get(); }
 
   MockPasswordSyncableService* service() { return service_.get(); }
 
   // Returnes the scoped_ptr to |service_| thus NULLing out it.
   scoped_ptr<syncer::SyncChangeProcessor> ReleaseSyncableService() {
-    return service_.Pass();
+    return std::move(service_);
   }
 
  private:
   scoped_refptr<MockPasswordStore> password_store_;
   scoped_ptr<MockPasswordSyncableService> service_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordSyncableServiceWrapper);
 };
 
 class PasswordSyncableServiceTest : public testing::Test {
@@ skipping 26 matching lines @@
   autofill::PasswordForm new_from_sync =
       PasswordFromSpecifics(GetPasswordSpecifics(list.back()));
 
   EXPECT_CALL(*password_store(), FillAutofillableLogins(_))
       .WillOnce(AppendForm(form));
   EXPECT_CALL(*password_store(), FillBlacklistLogins(_)).WillOnce(Return(true));
   EXPECT_CALL(*password_store(), AddLoginImpl(PasswordIs(new_from_sync)));
   EXPECT_CALL(*processor_, ProcessSyncChanges(_, ElementsAre(
       SyncChangeIs(SyncChange::ACTION_ADD, form))));
 
-  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                      list,
-                                      processor_.Pass(),
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS, list,
+                                      std::move(processor_),
                                       scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Sync has data that is not present in the password db.
 TEST_F(PasswordSyncableServiceTest, AdditionOnlyInSync) {
   SyncDataList list;
   list.push_back(CreateSyncData(kSignonRealm));
   autofill::PasswordForm new_from_sync =
       PasswordFromSpecifics(GetPasswordSpecifics(list.back()));
 
   EXPECT_CALL(*password_store(), FillAutofillableLogins(_))
       .WillOnce(Return(true));
   EXPECT_CALL(*password_store(), FillBlacklistLogins(_)).WillOnce(Return(true));
   EXPECT_CALL(*password_store(), AddLoginImpl(PasswordIs(new_from_sync)));
   EXPECT_CALL(*processor_, ProcessSyncChanges(_, IsEmpty()));
 
-  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                      list,
-                                      processor_.Pass(),
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS, list,
+                                      std::move(processor_),
                                       scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Passwords db has data that is not present in sync.
 TEST_F(PasswordSyncableServiceTest, AdditionOnlyInPasswordStore) {
   autofill::PasswordForm form;
   form.signon_realm = kSignonRealm;
   form.times_used = kTimesUsed;
   form.type = kArbitraryType;
   form.display_name = base::ASCIIToUTF16(kDisplayName);
   form.icon_url = GURL(kIconUrl);
   form.federation_url = GURL(kFederationUrl);
   form.username_value = base::ASCIIToUTF16(kUsername);
   form.password_value = base::ASCIIToUTF16(kPassword);
   EXPECT_CALL(*password_store(), FillAutofillableLogins(_))
       .WillOnce(AppendForm(form));
   EXPECT_CALL(*password_store(), FillBlacklistLogins(_)).WillOnce(Return(true));
 
   EXPECT_CALL(*processor_, ProcessSyncChanges(_, ElementsAre(
       SyncChangeIs(SyncChange::ACTION_ADD, form))));
 
-  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                      SyncDataList(),
-                                      processor_.Pass(),
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS, SyncDataList(),
+                                      std::move(processor_),
                                       scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Both passwords db and sync contain the same data.
 TEST_F(PasswordSyncableServiceTest, BothInSync) {
   autofill::PasswordForm form;
   form.signon_realm = kSignonRealm;
   form.times_used = kTimesUsed;
   form.type = kArbitraryType;
   form.username_value = base::ASCIIToUTF16(kUsername);
   form.password_value = base::ASCIIToUTF16(kPassword);
   EXPECT_CALL(*password_store(), FillAutofillableLogins(_))
       .WillOnce(AppendForm(form));
   EXPECT_CALL(*password_store(), FillBlacklistLogins(_)).WillOnce(Return(true));
 
   EXPECT_CALL(*processor_, ProcessSyncChanges(_, IsEmpty()));
 
   service()->MergeDataAndStartSyncing(
-      syncer::PASSWORDS,
-      SyncDataList(1, SyncDataFromPassword(form)),
-      processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>());
+      syncer::PASSWORDS, SyncDataList(1, SyncDataFromPassword(form)),
+      std::move(processor_), scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Both passwords db and sync have the same data but they need to be merged
 // as some fields of the data differ.
 TEST_F(PasswordSyncableServiceTest, Merge) {
   autofill::PasswordForm form1;
   form1.signon_realm = kSignonRealm;
   form1.action = GURL("http://pie.com");
   form1.date_created = base::Time::Now();
   form1.preferred = true;
   form1.username_value = base::ASCIIToUTF16(kUsername);
   form1.password_value = base::ASCIIToUTF16(kPassword);
 
   autofill::PasswordForm form2(form1);
   form2.preferred = false;
   EXPECT_CALL(*password_store(), FillAutofillableLogins(_))
       .WillOnce(AppendForm(form1));
   EXPECT_CALL(*password_store(), FillBlacklistLogins(_)).WillOnce(Return(true));
   EXPECT_CALL(*password_store(), UpdateLoginImpl(PasswordIs(form2)));
   EXPECT_CALL(*processor_, ProcessSyncChanges(_, IsEmpty()));
 
   service()->MergeDataAndStartSyncing(
-      syncer::PASSWORDS,
-      SyncDataList(1, SyncDataFromPassword(form2)),
-      processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>());
+      syncer::PASSWORDS, SyncDataList(1, SyncDataFromPassword(form2)),
+      std::move(processor_), scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Initiate sync due to local DB changes.
 TEST_F(PasswordSyncableServiceTest, PasswordStoreChanges) {
   // Save the reference to the processor because |processor_| is NULL after
   // MergeDataAndStartSyncing().
   MockSyncChangeProcessor& weak_processor = *processor_;
   EXPECT_CALL(weak_processor, ProcessSyncChanges(_, IsEmpty()));
   EXPECT_CALL(*password_store(), FillAutofillableLogins(_))
       .WillOnce(Return(true));
   EXPECT_CALL(*password_store(), FillBlacklistLogins(_))
       .WillOnce(Return(true));
-  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                      SyncDataList(),
-                                      processor_.Pass(),
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS, SyncDataList(),
+                                      std::move(processor_),
                                       scoped_ptr<syncer::SyncErrorFactory>());
 
   autofill::PasswordForm form1;
   form1.signon_realm = kSignonRealm;
   autofill::PasswordForm form2;
   form2.signon_realm = kSignonRealm2;
   autofill::PasswordForm form3;
   form3.signon_realm = kSignonRealm3;
 
   SyncChangeList sync_list;
@@ skipping 139 matching lines @@
   syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
                           "Failed to get passwords from store.",
                           syncer::PASSWORDS);
   EXPECT_CALL(*password_store(), FillAutofillableLogins(_))
       .WillOnce(Return(false));
   EXPECT_CALL(*error_factory, CreateAndUploadError(_, _))
       .WillOnce(Return(error));
   // ActOnPasswordStoreChanges() below shouldn't generate any changes for Sync.
   // |processor_| will be destroyed in MergeDataAndStartSyncing().
   EXPECT_CALL(*processor_, ProcessSyncChanges(_, _)).Times(0);
-  syncer::SyncMergeResult result =
-      service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                          syncer::SyncDataList(),
-                                          processor_.Pass(),
-                                          error_factory.Pass());
+  syncer::SyncMergeResult result = service()->MergeDataAndStartSyncing(
+      syncer::PASSWORDS, syncer::SyncDataList(), std::move(processor_),
+      std::move(error_factory));
   EXPECT_TRUE(result.error().IsSet());
 
   autofill::PasswordForm form;
   form.signon_realm = kSignonRealm;
   PasswordStoreChangeList list;
   list.push_back(PasswordStoreChange(PasswordStoreChange::ADD, form));
   service()->ActOnPasswordStoreChanges(list);
 }
 
 // Start syncing with an error in ProcessSyncChanges. Subsequent password store
 // updates shouldn't be propagated to Sync.
 TEST_F(PasswordSyncableServiceTest, FailedProcessSyncChanges) {
   autofill::PasswordForm form;
   form.signon_realm = kSignonRealm;
   form.username_value = base::ASCIIToUTF16(kUsername);
   form.password_value = base::ASCIIToUTF16(kPassword);
   scoped_ptr<syncer::SyncErrorFactoryMock> error_factory(
       new syncer::SyncErrorFactoryMock);
   syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
                           "There is a problem", syncer::PASSWORDS);
   EXPECT_CALL(*password_store(), FillAutofillableLogins(_))
       .WillOnce(AppendForm(form));
   EXPECT_CALL(*password_store(), FillBlacklistLogins(_)).WillOnce(Return(true));
 
   // ActOnPasswordStoreChanges() below shouldn't generate any changes for Sync.
   // |processor_| will be destroyed in MergeDataAndStartSyncing().
   EXPECT_CALL(*processor_, ProcessSyncChanges(_, _))
       .Times(1)
       .WillOnce(Return(error));
-  syncer::SyncMergeResult result =
-      service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                          syncer::SyncDataList(),
-                                          processor_.Pass(),
-                                          error_factory.Pass());
+  syncer::SyncMergeResult result = service()->MergeDataAndStartSyncing(
+      syncer::PASSWORDS, syncer::SyncDataList(), std::move(processor_),
+      std::move(error_factory));
   EXPECT_TRUE(result.error().IsSet());
 
   form.signon_realm = kSignonRealm2;
   PasswordStoreChangeList list;
   list.push_back(PasswordStoreChange(PasswordStoreChange::ADD, form));
   service()->ActOnPasswordStoreChanges(list);
 }
 
 // Tests that empty forms known to the client and/or the server are deleted.
 TEST_F(PasswordSyncableServiceTest, MergeEmptyPasswords) {
@@ skipping 15 matching lines @@
       .WillOnce(DoAll(IgnoreResult(AppendForm(old_empty_form)),
                       AppendForm(db_empty_form)));
   EXPECT_CALL(*password_store(), FillBlacklistLogins(_)).WillOnce(Return(true));
 
   EXPECT_CALL(*password_store(), RemoveLoginImpl(PasswordIs(old_empty_form)));
   EXPECT_CALL(*password_store(), RemoveLoginImpl(PasswordIs(db_empty_form)));
   EXPECT_CALL(*processor_, ProcessSyncChanges(_, ElementsAre(
       SyncChangeIs(SyncChange::ACTION_DELETE, old_empty_form),
       SyncChangeIs(SyncChange::ACTION_DELETE, sync_empty_form))));
 
-  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                      sync_data,
-                                      processor_.Pass(),
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS, sync_data,
+                                      std::move(processor_),
                                       scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 }  // namespace
 
 }  // namespace password_manager