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

sync/test/fake_server/fake_server.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/test/fake_server/fake_server.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 173 matching lines @@
 
 bool FakeServer::CreatePermanentBookmarkFolder(const std::string& server_tag,
                                                const std::string& name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_ptr<FakeServerEntity> entity =
       PermanentEntity::Create(syncer::BOOKMARKS, server_tag, name,
                               ModelTypeToRootTag(syncer::BOOKMARKS));
   if (!entity)
     return false;
 
-  SaveEntity(entity.Pass());
+  SaveEntity(std::move(entity));
   return true;
 }
 
 bool FakeServer::CreateDefaultPermanentItems() {
   // Permanent folders are always required for Bookmarks (hierarchical
   // structure) and Nigori (data stored in permanent root folder).
   ModelTypeSet permanent_folder_types =
       ModelTypeSet(syncer::BOOKMARKS, syncer::NIGORI);
 
   for (ModelTypeSet::Iterator it = permanent_folder_types.First(); it.Good();
        it.Inc()) {
     ModelType model_type = it.Get();
 
     scoped_ptr<FakeServerEntity> top_level_entity =
         PermanentEntity::CreateTopLevel(model_type);
     if (!top_level_entity) {
       return false;
     }
-    SaveEntity(top_level_entity.Pass());
+    SaveEntity(std::move(top_level_entity));
 
     if (model_type == syncer::BOOKMARKS) {
       if (!CreatePermanentBookmarkFolder(kBookmarkBarFolderServerTag,
                                          kBookmarkBarFolderName))
         return false;
       if (!CreatePermanentBookmarkFolder(kOtherBookmarksFolderServerTag,
                                          kOtherBookmarksFolderName))
         return false;
     }
   }
@@ skipping 177 matching lines @@
     }
   }
 
   if (!entity) {
     // TODO(pvalenzuela): Add logging so that it is easier to determine why
     // creation failed.
     return string();
   }
 
   const std::string id = entity->GetId();
-  SaveEntity(entity.Pass());
+  SaveEntity(std::move(entity));
   BuildEntryResponseForSuccessfulCommit(id, entry_response);
   return id;
 }
 
 void FakeServer::BuildEntryResponseForSuccessfulCommit(
     const std::string& entity_id,
     sync_pb::CommitResponse_EntryResponse* entry_response) {
   EntityMap::const_iterator iter = entities_.find(entity_id);
   CHECK(iter != entities_.end());
   const FakeServerEntity& entity = *iter->second;
@@ skipping 102 matching lines @@
     if (!dictionary->GetList(ModelTypeToString(entity.GetModelType()),
                              &list_value)) {
       return scoped_ptr<base::DictionaryValue>();
     }
     // TODO(pvalenzuela): Store more data for each entity so additional
     // verification can be performed. One example of additional verification
     // is checking the correctness of the bookmark hierarchy.
     list_value->Append(new base::StringValue(entity.GetName()));
   }
 
-  return dictionary.Pass();
+  return dictionary;
 }
 
 std::vector<sync_pb::SyncEntity> FakeServer::GetSyncEntitiesByModelType(
     ModelType model_type) {
   std::vector<sync_pb::SyncEntity> sync_entities;
   DCHECK(thread_checker_.CalledOnValidThread());
   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
        ++it) {
     const FakeServerEntity& entity = *it->second;
     if (!IsDeletedOrPermanent(entity) && entity.GetModelType() == model_type) {
       sync_pb::SyncEntity sync_entity;
       entity.SerializeAsProto(&sync_entity);
       sync_entities.push_back(sync_entity);
     }
   }
   return sync_entities;
 }
 
 void FakeServer::InjectEntity(scoped_ptr<FakeServerEntity> entity) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  SaveEntity(entity.Pass());
+  SaveEntity(std::move(entity));
 }
 
 bool FakeServer::ModifyEntitySpecifics(
     const std::string& id,
     const sync_pb::EntitySpecifics& updated_specifics) {
   EntityMap::const_iterator iter = entities_.find(id);
   if (iter == entities_.end() ||
       iter->second->GetModelType() !=
           GetModelTypeFromSpecifics(updated_specifics)) {
     return false;
@@ skipping 139 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 std::string FakeServer::GetStoreBirthday() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::Int64ToString(store_birthday_);
 }
 
 }  // namespace fake_server