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

chrome/browser/spellchecker/spellcheck_custom_dictionary_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/spellchecker/spellcheck_custom_dictionary.h"
 
 #include <stddef.h>
-
+#include <utility>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
@@ skipping 61 matching lines @@
       const base::FilePath& path) {
     return SpellcheckCustomDictionary::LoadDictionaryFile(path);
   }
 
   // A wrapper around SpellcheckCustomDictionary::UpdateDictionaryFile private
   // function to avoid a large number of FRIEND_TEST declarations in
   // SpellcheckCustomDictionary.
   void UpdateDictionaryFile(
       scoped_ptr<SpellcheckCustomDictionary::Change> dictionary_change,
       const base::FilePath& path) {
-    SpellcheckCustomDictionary::UpdateDictionaryFile(dictionary_change.Pass(),
-                                                     path);
+    SpellcheckCustomDictionary::UpdateDictionaryFile(
+        std::move(dictionary_change), path);
   }
 
   // A wrapper around SpellcheckCustomDictionary::OnLoaded private method to
   // avoid a large number of FRIEND_TEST declarations in
   // SpellcheckCustomDictionary.
   void OnLoaded(SpellcheckCustomDictionary& dictionary,
                 scoped_ptr<std::set<std::string>> words) {
     scoped_ptr<SpellcheckCustomDictionary::LoadFileResult> result(
         new SpellcheckCustomDictionary::LoadFileResult);
     result->is_valid_file = true;
     result->words = *words;
-    dictionary.OnLoaded(result.Pass());
+    dictionary.OnLoaded(std::move(result));
   }
 
   // A wrapper around SpellcheckCustomDictionary::Apply private method to avoid
   // a large number of FRIEND_TEST declarations in SpellcheckCustomDictionary.
   void Apply(
       SpellcheckCustomDictionary& dictionary,
       const SpellcheckCustomDictionary::Change& change) {
     return dictionary.Apply(change);
   }
 
@@ skipping 55 matching lines @@
       profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
 
   // The custom word list should be empty now.
   EXPECT_TRUE(LoadDictionaryFile(path)->words.empty());
 
   scoped_ptr<SpellcheckCustomDictionary::Change> change(
       new SpellcheckCustomDictionary::Change);
   change->AddWord("bar");
   change->AddWord("foo");
 
-  UpdateDictionaryFile(change.Pass(), path);
+  UpdateDictionaryFile(std::move(change), path);
   std::set<std::string> expected;
   expected.insert("bar");
   expected.insert("foo");
 
   // The custom word list should include written words.
   EXPECT_EQ(expected, LoadDictionaryFile(path)->words);
 
   scoped_ptr<SpellcheckCustomDictionary::Change> change2(
       new SpellcheckCustomDictionary::Change);
   change2->RemoveWord("bar");
   change2->RemoveWord("foo");
-  UpdateDictionaryFile(change2.Pass(), path);
+  UpdateDictionaryFile(std::move(change2), path);
   EXPECT_TRUE(LoadDictionaryFile(path)->words.empty());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, MultiProfile) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
@@ skipping 76 matching lines @@
   std::string content = "foo\nbar";
   base::WriteFile(path, content.c_str(), content.length());
   std::set<std::string> expected;
   expected.insert("bar");
   expected.insert("foo");
   EXPECT_EQ(expected, LoadDictionaryFile(path)->words);
 
   scoped_ptr<SpellcheckCustomDictionary::Change> change(
       new SpellcheckCustomDictionary::Change);
   change->AddWord("baz");
-  UpdateDictionaryFile(change.Pass(), path);
+  UpdateDictionaryFile(std::move(change), path);
   content.clear();
   base::ReadFileToString(path, &content);
   content.append("corruption");
   base::WriteFile(path, content.c_str(), content.length());
   EXPECT_EQ(expected, LoadDictionaryFile(path)->words);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest,
        GetAllSyncDataAccuratelyReflectsDictionaryState) {
   SpellcheckCustomDictionary* dictionary =
@@ skipping 194 matching lines @@
               &profile2, &BuildSpellcheckService))
           ->GetCustomDictionary();
 
   scoped_ptr<SpellcheckCustomDictionary::Change> change(
       new SpellcheckCustomDictionary::Change);
   change->AddWord("foo");
   Apply(*custom_dictionary2, *change);
 
   base::FilePath path =
       profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
-  UpdateDictionaryFile(change.Pass(), path);
+  UpdateDictionaryFile(std::move(change), path);
   EXPECT_TRUE(custom_dictionary->GetWords().empty());
 
   int error_counter = 0;
   EXPECT_FALSE(
       custom_dictionary->MergeDataAndStartSyncing(
                            syncer::DICTIONARY,
                            custom_dictionary2->GetAllSyncData(
                                syncer::DICTIONARY),
                            scoped_ptr<syncer::SyncChangeProcessor>(
                                new syncer::SyncChangeProcessorWrapperForTest(
@@ skipping 313 matching lines @@
                                      custom_dictionary2)),
                              scoped_ptr<syncer::SyncErrorFactory>(
                                  new SyncErrorFactoryStub(&error_counter)))
           .error()
           .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   scoped_ptr<std::set<std::string>> custom_words(new std::set<std::string>);
   custom_words->insert("bar");
-  OnLoaded(*custom_dictionary, custom_words.Pass());
+  OnLoaded(*custom_dictionary, std::move(custom_words));
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(2UL, custom_dictionary->GetWords().size());
   EXPECT_EQ(2UL, custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(2UL, custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
   EXPECT_EQ(2UL, custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, LoadAfterSyncStartTooBigToSync) {
@@ skipping 26 matching lines @@
           .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   scoped_ptr<std::set<std::string>> custom_words(new std::set<std::string>);
   for (size_t i = 0;
        i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
        ++i) {
     custom_words->insert(custom_words->end(), "foo" + base::Uint64ToString(i));
   }
-  OnLoaded(*custom_dictionary, custom_words.Pass());
+  OnLoaded(*custom_dictionary, std::move(custom_words));
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
@@ skipping 59 matching lines @@
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
 
   DictionaryObserverCounter observer;
   custom_dictionary->AddObserver(&observer);
 
   scoped_ptr<std::set<std::string>> custom_words(new std::set<std::string>);
   custom_words->insert("foo");
   custom_words->insert("bar");
-  OnLoaded(*custom_dictionary, custom_words.Pass());
+  OnLoaded(*custom_dictionary, std::move(custom_words));
 
   EXPECT_GE(observer.loads(), 1);
   EXPECT_LE(observer.loads(), 2);
   EXPECT_EQ(0, observer.changes());
 
   custom_dictionary->RemoveObserver(&observer);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryAddWordNotification) {
   SpellcheckService* spellcheck_service =
@@ skipping 220 matching lines @@
   ASSERT_TRUE(histogram != NULL);
   scoped_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
 
   samples->Subtract(*baseline);
   EXPECT_EQ(0,samples->sum());
 
   scoped_ptr<SpellcheckCustomDictionary::Change> change(
       new SpellcheckCustomDictionary::Change);
   change->AddWord("bar");
   change->AddWord("foo");
-  UpdateDictionaryFile(change.Pass(), path);
+  UpdateDictionaryFile(std::move(change), path);
 
   // Load the dictionary again and it should have 2 entries.
   EXPECT_EQ(2u, LoadDictionaryFile(path)->words.size());
 
   histogram =
       StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
   ASSERT_TRUE(histogram != NULL);
   scoped_ptr<HistogramSamples> samples2 = histogram->SnapshotSamples();
 
   samples2->Subtract(*baseline);
   EXPECT_EQ(2,samples2->sum());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, HasWord) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   OnLoaded(*custom_dictionary, make_scoped_ptr(new std::set<std::string>));
   EXPECT_FALSE(custom_dictionary->HasWord("foo"));
   EXPECT_FALSE(custom_dictionary->HasWord("bar"));
   custom_dictionary->AddWord("foo");
   EXPECT_TRUE(custom_dictionary->HasWord("foo"));
   EXPECT_FALSE(custom_dictionary->HasWord("bar"));
 }