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

components/sync_driver/non_blocking_data_type_controller.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_driver/non_blocking_data_type_controller.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "components/sync_driver/backend_data_type_configurer.h"
 #include "components/sync_driver/sync_client.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/internal_api/public/activation_context.h"
 #include "sync/internal_api/public/shared_model_type_processor.h"
@@ skipping 64 matching lines @@
     model_load_callback_.Run(type(), error);
   }
 }
 
 void NonBlockingDataTypeController::OnProcessorStarted(
     syncer::SyncError error,
     scoped_ptr<syncer_v2::ActivationContext> activation_context) {
   if (BelongsToUIThread()) {
     // Hold on to the activation context until ActivateDataType is called.
     if (state_ == MODEL_STARTING) {
-      activation_context_ = activation_context.Pass();
+      activation_context_ = std::move(activation_context);
     }
     // TODO(stanisc): Figure out if UNRECOVERABLE_ERROR is OK in this case.
     ConfigureResult result = error.IsSet() ? UNRECOVERABLE_ERROR : OK;
     LoadModelsDone(result, error);
   } else {
     RunOnUIThread(
         FROM_HERE,
         base::Bind(&NonBlockingDataTypeController::OnProcessorStarted, this,
-                   error, base::Passed(activation_context.Pass())));
+                   error, base::Passed(std::move(activation_context))));
   }
 }
 
 void NonBlockingDataTypeController::StartAssociating(
     const StartCallback& start_callback) {
   DCHECK(BelongsToUIThread());
   DCHECK(!start_callback.is_null());
 
   state_ = RUNNING;
 
   // There is no association, just call back promptly.
   syncer::SyncMergeResult merge_result(type());
   start_callback.Run(OK, merge_result, merge_result);
 }
 
 void NonBlockingDataTypeController::ActivateDataType(
     sync_driver::BackendDataTypeConfigurer* configurer) {
   DCHECK(BelongsToUIThread());
   DCHECK(configurer);
   DCHECK(activation_context_);
   DCHECK_EQ(RUNNING, state_);
-  configurer->ActivateNonBlockingDataType(type(), activation_context_.Pass());
+  configurer->ActivateNonBlockingDataType(type(),
+                                          std::move(activation_context_));
 }
 
 void NonBlockingDataTypeController::DeactivateDataType(
     sync_driver::BackendDataTypeConfigurer* configurer) {
   DCHECK(BelongsToUIThread());
   DCHECK(configurer);
   configurer->DeactivateNonBlockingDataType(type());
 }
 
 void NonBlockingDataTypeController::Stop() {
@@ skipping 69 matching lines @@
 #undef PER_DATA_TYPE_MACRO
 }
 
 void NonBlockingDataTypeController::RecordUnrecoverableError() {
   UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeRunFailures",
                             ModelTypeToHistogramInt(type()),
                             syncer::MODEL_TYPE_COUNT);
 }
 
 }  // namespace sync_driver_v2