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

chrome/browser/extensions/api/storage/sync_storage_backend.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 "chrome/browser/extensions/api/storage/sync_storage_backend.h"
 
+#include <utility>
+
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_processor.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/api/storage/syncable_settings_storage.h"
 #include "content/public/browser/browser_thread.h"
 #include "sync/api/sync_error_factory.h"
 
 using content::BrowserThread;
 
@@ skipping 58 matching lines @@
 
   // It's fine to create the quota enforcer underneath the sync layer, since
   // sync will only go ahead if each underlying storage operation succeeds.
   linked_ptr<SyncableSettingsStorage> syncable_storage(
       new SyncableSettingsStorage(
           observers_, extension_id, storage.release(), sync_type_, flare_));
   storage_objs_[extension_id] = syncable_storage;
 
   if (sync_processor_.get()) {
     syncer::SyncError error = syncable_storage->StartSyncing(
-        sync_data.Pass(), CreateSettingsSyncProcessor(extension_id).Pass());
+        std::move(sync_data), CreateSettingsSyncProcessor(extension_id));
     if (error.IsSet())
       syncable_storage->StopSyncing();
   }
   return syncable_storage.get();
 }
 
 void SyncStorageBackend::DeleteStorage(const std::string& extension_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   // Clear settings when the extension is uninstalled.  Leveldb implementations
@@ skipping 69 matching lines @@
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK_EQ(sync_type_, type);
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(sync_error_factory.get());
 
-  sync_processor_ = sync_processor.Pass();
-  sync_error_factory_ = sync_error_factory.Pass();
+  sync_processor_ = std::move(sync_processor);
+  sync_error_factory_ = std::move(sync_error_factory);
 
   // Group the initial sync data by extension id.
   // The raw pointers are safe because ownership of each item is passed to
   // storage->StartSyncing or GetOrCreateStorageWithSyncData.
   std::map<std::string, base::DictionaryValue*> grouped_sync_data;
 
   for (const syncer::SyncData& sync_data : initial_sync_data) {
     SettingSyncData data(sync_data);
     // Yes this really is a reference to a pointer.
     base::DictionaryValue*& settings = grouped_sync_data[data.extension_id()];
     if (!settings)
       settings = new base::DictionaryValue();
     DCHECK(!settings->HasKey(data.key())) << "Duplicate settings for "
                                           << data.extension_id() << "/"
                                           << data.key();
     settings->SetWithoutPathExpansion(data.key(), data.PassValue());
   }
 
   // Start syncing all existing storage areas.  Any storage areas created in
   // the future will start being synced as part of the creation process.
   for (const auto& storage_obj : storage_objs_) {
     const std::string& extension_id = storage_obj.first;
     SyncableSettingsStorage* storage = storage_obj.second.get();
 
     auto group = grouped_sync_data.find(extension_id);
     syncer::SyncError error;
     if (group != grouped_sync_data.end()) {
-      error = storage->StartSyncing(
-          make_scoped_ptr(group->second),
-          CreateSettingsSyncProcessor(extension_id).Pass());
+      error = storage->StartSyncing(make_scoped_ptr(group->second),
+                                    CreateSettingsSyncProcessor(extension_id));
       grouped_sync_data.erase(group);
     } else {
-      error = storage->StartSyncing(
-          EmptyDictionaryValue(),
-          CreateSettingsSyncProcessor(extension_id).Pass());
+      error = storage->StartSyncing(EmptyDictionaryValue(),
+                                    CreateSettingsSyncProcessor(extension_id));
     }
 
     if (error.IsSet())
       storage->StopSyncing();
   }
 
   // Eagerly create and init the rest of the storage areas that have sync data.
   // Under normal circumstances (i.e. not first-time sync) this will be all of
   // them.
   for (const auto& group : grouped_sync_data) {
@@ skipping 12 matching lines @@
   // Group changes by extension, to pass all changes in a single method call.
   // The raw pointers are safe because ownership of each item is passed to
   // storage->ProcessSyncChanges.
   std::map<std::string, SettingSyncDataList*> grouped_sync_data;
 
   for (const syncer::SyncChange& change : sync_changes) {
     scoped_ptr<SettingSyncData> data(new SettingSyncData(change));
     SettingSyncDataList*& group = grouped_sync_data[data->extension_id()];
     if (!group)
       group = new SettingSyncDataList();
-    group->push_back(data.Pass());
+    group->push_back(std::move(data));
   }
 
   // Create any storage areas that don't exist yet but have sync data.
   for (const auto& group : grouped_sync_data) {
     SyncableSettingsStorage* storage =
         GetOrCreateStorageWithSyncData(group.first, EmptyDictionaryValue());
     syncer::SyncError error =
         storage->ProcessSyncChanges(make_scoped_ptr(group.second));
     if (error.IsSet())
       storage->StopSyncing();
@@ skipping 19 matching lines @@
 
 scoped_ptr<SettingsSyncProcessor>
 SyncStorageBackend::CreateSettingsSyncProcessor(const std::string& extension_id)
     const {
   CHECK(sync_processor_.get());
   return scoped_ptr<SettingsSyncProcessor>(new SettingsSyncProcessor(
       extension_id, sync_type_, sync_processor_.get()));
 }
 
 }  // namespace extensions