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

components/sync_sessions/sessions_sync_manager.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/sync_sessions/sessions_sync_manager.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/metrics/field_trial.h"
 #include "build/build_config.h"
 #include "components/sync_driver/local_device_info_provider.h"
 #include "components/sync_sessions/sync_sessions_client.h"
 #include "components/sync_sessions/synced_tab_delegate.h"
 #include "components/sync_sessions/synced_window_delegate.h"
 #include "components/sync_sessions/synced_window_delegates_getter.h"
 #include "components/variations/variations_associated_data.h"
 #include "sync/api/sync_error.h"
@@ skipping 54 matching lines @@
     : sessions_client_(sessions_client),
       session_tracker_(sessions_client),
       favicon_cache_(sessions_client->GetFaviconService(),
                      sessions_client->GetHistoryService(),
                      kMaxSyncFavicons),
       local_tab_pool_out_of_sync_(true),
       sync_prefs_(sync_prefs),
       local_device_(local_device),
       local_session_header_node_id_(TabNodePool::kInvalidTabNodeID),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
-      local_event_router_(router.Pass()),
+      local_event_router_(std::move(router)),
       page_revisit_broadcaster_(this, sessions_client),
       sessions_updated_callback_(sessions_updated_callback),
-      datatype_refresh_callback_(datatype_refresh_callback) {
-}
+      datatype_refresh_callback_(datatype_refresh_callback) {}
 
 SessionsSyncManager::~SessionsSyncManager() {}
 
 // Returns the GUID-based string that should be used for
 // |SessionsSyncManager::current_machine_tag_|.
 static std::string BuildMachineTag(const std::string& cache_guid) {
   std::string machine_tag = "session_sync";
   machine_tag.append(cache_guid);
   return machine_tag;
 }
 
 syncer::SyncMergeResult SessionsSyncManager::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
   syncer::SyncMergeResult merge_result(type);
   DCHECK(session_tracker_.Empty());
   DCHECK_EQ(0U, local_tab_pool_.Capacity());
 
-  error_handler_ = error_handler.Pass();
-  sync_processor_ = sync_processor.Pass();
+  error_handler_ = std::move(error_handler);
+  sync_processor_ = std::move(sync_processor);
 
   local_session_header_node_id_ = TabNodePool::kInvalidTabNodeID;
 
   // Make sure we have a machine tag.  We do this now (versus earlier) as it's
   // a conveniently safe time to assert sync is ready and the cache_guid is
   // initialized.
   if (current_machine_tag_.empty()) {
     InitializeCurrentMachineTag();
   }
 
@@ skipping 225 matching lines @@
     page_revisit_broadcaster_.OnPageVisit(
         new_url, tab->GetTransitionAtIndex(current_index));
   }
 
   session_tracker_.GetSession(current_machine_tag())->modified_time =
       base::Time::Now();
 }
 
 void SessionsSyncManager::RebuildAssociations() {
   syncer::SyncDataList data(sync_processor_->GetAllSyncData(syncer::SESSIONS));
-  scoped_ptr<syncer::SyncErrorFactory> error_handler(error_handler_.Pass());
-  scoped_ptr<syncer::SyncChangeProcessor> processor(sync_processor_.Pass());
+  scoped_ptr<syncer::SyncErrorFactory> error_handler(std::move(error_handler_));
+  scoped_ptr<syncer::SyncChangeProcessor> processor(std::move(sync_processor_));
 
   StopSyncing(syncer::SESSIONS);
-  MergeDataAndStartSyncing(syncer::SESSIONS, data, processor.Pass(),
-                           error_handler.Pass());
+  MergeDataAndStartSyncing(syncer::SESSIONS, data, std::move(processor),
+                           std::move(error_handler));
 }
 
 bool SessionsSyncManager::IsValidSessionHeader(
     const sync_pb::SessionHeader& header) {
   // Verify that tab IDs appear only once within a session.
   // Intended to prevent http://crbug.com/360822.
   std::set<int> session_tab_ids;
   for (int i = 0; i < header.window_size(); ++i) {
     const sync_pb::SessionWindow& window = header.window(i);
     for (int j = 0; j < window.tab_size(); ++j) {
@@ skipping 680 matching lines @@
                << session_age_in_days << ", deleting.";
       DeleteForeignSessionInternal(session_tag, &changes);
     }
   }
 
   if (!changes.empty())
     sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 };  // namespace browser_sync