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

chrome/browser/spellchecker/spellcheck_custom_dictionary.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 <functional>
+#include <utility>
 
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/md5.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/spellcheck_common.h"
@@ skipping 203 matching lines @@
 }
 
 bool SpellcheckCustomDictionary::AddWord(const std::string& word) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<Change> dictionary_change(new Change);
   dictionary_change->AddWord(word);
   int result = dictionary_change->Sanitize(GetWords());
   Apply(*dictionary_change);
   Notify(*dictionary_change);
   Sync(*dictionary_change);
-  Save(dictionary_change.Pass());
+  Save(std::move(dictionary_change));
   return result == VALID_CHANGE;
 }
 
 bool SpellcheckCustomDictionary::RemoveWord(const std::string& word) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<Change> dictionary_change(new Change);
   dictionary_change->RemoveWord(word);
   int result = dictionary_change->Sanitize(GetWords());
   Apply(*dictionary_change);
   Notify(*dictionary_change);
   Sync(*dictionary_change);
-  Save(dictionary_change.Pass());
+  Save(std::move(dictionary_change));
   return result == VALID_CHANGE;
 }
 
 bool SpellcheckCustomDictionary::HasWord(const std::string& word) const {
   return !!words_.count(word);
 }
 
 void SpellcheckCustomDictionary::AddObserver(Observer* observer) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(observer);
@@ skipping 31 matching lines @@
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_handler) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!sync_processor_.get());
   DCHECK(!sync_error_handler_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_handler.get());
   DCHECK_EQ(syncer::DICTIONARY, type);
-  sync_processor_ = sync_processor.Pass();
-  sync_error_handler_ = sync_error_handler.Pass();
+  sync_processor_ = std::move(sync_processor);
+  sync_error_handler_ = std::move(sync_error_handler);
 
   // Build a list of words to add locally.
   scoped_ptr<Change> to_change_locally(new Change);
   for (const syncer::SyncData& data : initial_sync_data) {
     DCHECK_EQ(syncer::DICTIONARY, data.GetDataType());
     to_change_locally->AddWord(data.GetSpecifics().dictionary().word());
   }
 
   // Add as many as possible local words remotely.
   to_change_locally->Sanitize(GetWords());
   Change to_change_remotely;
   to_change_remotely.AddWords(base::STLSetDifference<std::set<std::string>>(
       words_, to_change_locally->to_add()));
 
   // Add remote words locally.
   Apply(*to_change_locally);
   Notify(*to_change_locally);
-  Save(to_change_locally.Pass());
+  Save(std::move(to_change_locally));
 
   // Send local changes to the sync server.
   syncer::SyncMergeResult result(type);
   result.set_error(Sync(to_change_remotely));
   return result;
 }
 
 void SpellcheckCustomDictionary::StopSyncing(syncer::ModelType type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(syncer::DICTIONARY, type);
@@ skipping 42 matching lines @@
         return sync_error_handler_->CreateAndUploadError(
             FROM_HERE,
             "Processing sync changes failed on change type " +
                 syncer::SyncChange::ChangeTypeToString(change.change_type()));
     }
   }
 
   dictionary_change->Sanitize(GetWords());
   Apply(*dictionary_change);
   Notify(*dictionary_change);
-  Save(dictionary_change.Pass());
+  Save(std::move(dictionary_change));
 
   return syncer::SyncError();
 }
 
 SpellcheckCustomDictionary::LoadFileResult::LoadFileResult()
     : is_valid_file(false) {}
 
 SpellcheckCustomDictionary::LoadFileResult::~LoadFileResult() {}
 
 // static
@@ skipping 136 matching lines @@
 }
 
 void SpellcheckCustomDictionary::Notify(const Change& dictionary_change) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!IsLoaded() || dictionary_change.empty())
     return;
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnCustomDictionaryChanged(dictionary_change));
 }