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

components/sync_driver/glue/sync_backend_registrar.cc

 // Copyright 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 "components/sync_driver/glue/sync_backend_registrar.h"
 
 #include <cstddef>
+#include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "components/sync_driver/change_processor.h"
 #include "components/sync_driver/sync_client.h"
 #include "sync/internal_api/public/user_share.h"
 
 namespace browser_sync {
 
 SyncBackendRegistrar::SyncBackendRegistrar(
     const std::string& name,
     sync_driver::SyncClient* sync_client,
     scoped_ptr<base::Thread> sync_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_thread)
     : name_(name),
       sync_client_(sync_client),
       ui_thread_(ui_thread),
       db_thread_(db_thread),
       file_thread_(file_thread) {
   DCHECK(ui_thread_->BelongsToCurrentThread());
   DCHECK(sync_client_);
 
-  sync_thread_ = sync_thread.Pass();
+  sync_thread_ = std::move(sync_thread);
   if (!sync_thread_) {
     sync_thread_.reset(new base::Thread("Chrome_SyncThread"));
     base::Thread::Options options;
     options.timer_slack = base::TIMER_SLACK_MAXIMUM;
     CHECK(sync_thread_->StartWithOptions(options));
   }
 
   MaybeAddWorker(syncer::GROUP_DB);
   MaybeAddWorker(syncer::GROUP_FILE);
   MaybeAddWorker(syncer::GROUP_UI);
@@ skipping 279 matching lines @@
 
   if (last_worker) {
     // Self-destruction after last worker.
     DVLOG(1) << "Destroy registrar on loop of "
              << ModelSafeGroupToString(group);
     delete this;
   }
 }
 
 scoped_ptr<base::Thread> SyncBackendRegistrar::ReleaseSyncThread() {
-  return sync_thread_.Pass();
+  return std::move(sync_thread_);
 }
 
 void SyncBackendRegistrar::Shutdown() {
   // All data types should have been deactivated by now.
   DCHECK(processors_.empty());
 
   // Unregister worker from observing loop destruction.
   base::AutoLock al(lock_);
   for (WorkerMap::iterator it = workers_.begin(); it != workers_.end(); ++it) {
     it->second->UnregisterForLoopDestruction(
         base::Bind(&SyncBackendRegistrar::OnWorkerUnregistrationDone,
                    base::Unretained(this)));
   }
 }
 
 base::Thread* SyncBackendRegistrar::sync_thread() {
   return sync_thread_.get();
 }
 
 }  // namespace browser_sync