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

components/proximity_auth/cryptauth/cryptauth_device_manager.cc

 // Copyright 2015 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/proximity_auth/cryptauth/cryptauth_device_manager.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/base64url.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "components/proximity_auth/cryptauth/cryptauth_client.h"
 #include "components/proximity_auth/cryptauth/pref_names.h"
 #include "components/proximity_auth/cryptauth/sync_scheduler_impl.h"
 #include "components/proximity_auth/logging/logging.h"
 
@@ skipping 33 matching lines @@
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         &device_name_b64);
   base::Base64UrlEncode(device.bluetooth_address(),
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         &bluetooth_address_b64);
 
   dictionary->SetString(kExternalDeviceKeyPublicKey, public_key_b64);
   dictionary->SetString(kExternalDeviceKeyDeviceName, device_name_b64);
   dictionary->SetString(kExternalDeviceKeyBluetoothAddress,
                         bluetooth_address_b64);
-  return dictionary.Pass();
+  return dictionary;
 }
 
 // Converts an unlock key dictionary stored in user prefs to an
 // ExternalDeviceInfo proto. Returns true if the dictionary is valid, and the
 // parsed proto is written to |external_device|.
 bool DictionaryToUnlockKey(const base::DictionaryValue& dictionary,
                            cryptauth::ExternalDeviceInfo* external_device) {
   std::string public_key_b64, device_name_b64, bluetooth_address_b64;
   if (!dictionary.GetString(kExternalDeviceKeyPublicKey, &public_key_b64) ||
       !dictionary.GetString(kExternalDeviceKeyDeviceName, &device_name_b64) ||
@@ skipping 25 matching lines @@
   return true;
 }
 
 }  // namespace
 
 CryptAuthDeviceManager::CryptAuthDeviceManager(
     scoped_ptr<base::Clock> clock,
     scoped_ptr<CryptAuthClientFactory> client_factory,
     CryptAuthGCMManager* gcm_manager,
     PrefService* pref_service)
-    : clock_(clock.Pass()),
-      client_factory_(client_factory.Pass()),
+    : clock_(std::move(clock)),
+      client_factory_(std::move(client_factory)),
       gcm_manager_(gcm_manager),
       pref_service_(pref_service),
       weak_ptr_factory_(this) {
   UpdateUnlockKeysFromPrefs();
 }
 
 CryptAuthDeviceManager::~CryptAuthDeviceManager() {
   gcm_manager_->RemoveObserver(this);
 }
 
@@ skipping 140 matching lines @@
       PA_LOG(ERROR) << "Can not get dictionary in list of unlock keys "
                     << "(index=" << i << "):\n" << *unlock_key_list;
     }
   }
 }
 
 void CryptAuthDeviceManager::OnSyncRequested(
     scoped_ptr<SyncScheduler::SyncRequest> sync_request) {
   FOR_EACH_OBSERVER(Observer, observers_, OnSyncStarted());
 
-  sync_request_ = sync_request.Pass();
+  sync_request_ = std::move(sync_request);
   cryptauth_client_ = client_factory_->CreateInstance();
 
   cryptauth::InvocationReason invocation_reason =
       cryptauth::INVOCATION_REASON_UNKNOWN;
 
   int reason_stored_in_prefs =
       pref_service_->GetInteger(prefs::kCryptAuthDeviceSyncReason);
 
   // If the sync attempt is not forced, it is acceptable for CryptAuth to return
   // a cached copy of the user's devices, rather taking a database hit for the
@@ skipping 17 matching lines @@
   request.set_invocation_reason(invocation_reason);
   request.set_allow_stale_read(is_sync_speculative);
   cryptauth_client_->GetMyDevices(
       request, base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesSuccess,
                           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&CryptAuthDeviceManager::OnGetMyDevicesFailure,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 }  // namespace proximity_auth