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

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.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/easy_unlock_private/easy_unlock_private_api.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 729 matching lines @@
   proximity_auth::ProximityAuthClient* client =
       easy_unlock_service->proximity_auth_client();
 
   permit_id_ = "permit://google.com/easyunlock/v1/" + client->GetAccountId();
   secure_message_delegate_ = client->CreateSecureMessageDelegate();
   std::vector<cryptauth::ExternalDeviceInfo> unlock_keys = GetUnlockKeys();
   expected_devices_count_ = unlock_keys.size();
 
   remote_devices_.reset(new base::ListValue());
   if (expected_devices_count_ == 0) {
-    SetResult(remote_devices_.Pass());
+    SetResult(std::move(remote_devices_));
     SendResponse(true);
     return;
   }
 
   // If there is a BLE unlock key, then don't return anything, so the app does
   // not try the classic Bluetooth protocol.
   for (const auto& unlock_key : unlock_keys) {
     if (unlock_key.bluetooth_address().empty()) {
-      SetResult(remote_devices_.Pass());
+      SetResult(std::move(remote_devices_));
       SendResponse(true);
       return;
     }
   }
 
   // Derive the PSKs for the user's unlock keys.
   PA_LOG(INFO) << "Deriving PSKs for "
                << "chrome.easyUnlockPrivate.getRemoteDevices.\n"
                << "Expecting " << expected_devices_count_ << " devices.";
   for (const auto& unlock_key : unlock_keys) {
@@ skipping 22 matching lines @@
   device_dictionary->SetString("name", device.friendly_device_name());
   device_dictionary->SetString("bluetoothAddress", device.bluetooth_address());
   device_dictionary->SetString("psk", b64_psk);
 
   // Fill in the permit license for the unlock key.
   scoped_ptr<base::DictionaryValue> permit_license(new base::DictionaryValue());
   permit_license->SetString("permitId", permit_id_);
   permit_license->SetString("id", b64_public_key);
   permit_license->SetString("type", "license");
   permit_license->SetString("data", b64_public_key);
-  device_dictionary->Set("permitRecord", permit_license.Pass());
+  device_dictionary->Set("permitRecord", std::move(permit_license));
 
-  remote_devices_->Append(device_dictionary.Pass());
+  remote_devices_->Append(std::move(device_dictionary));
 
   // If all PSKs are derived, then return from the API call.
   PA_LOG(INFO) << "Derived PSK for " << b64_public_key << ": "
                << remote_devices_->GetSize() << "/" << expected_devices_count_;
   if (remote_devices_->GetSize() == expected_devices_count_) {
-    SetResult(remote_devices_.Pass());
+    SetResult(std::move(remote_devices_));
     SendResponse(true);
   }
 }
 
 EasyUnlockPrivateGetSignInChallengeFunction::
     EasyUnlockPrivateGetSignInChallengeFunction() {
 }
 
 EasyUnlockPrivateGetSignInChallengeFunction::
     ~EasyUnlockPrivateGetSignInChallengeFunction() {
@@ skipping 125 matching lines @@
       &EasyUnlockPrivateGetConnectionInfoFunction::OnConnectionInfo, this));
   return false;
 }
 
 void EasyUnlockPrivateGetConnectionInfoFunction::OnConnectionInfo(
     const device::BluetoothDevice::ConnectionInfo& connection_info) {
   scoped_ptr<base::ListValue> results(new base::ListValue());
   results->AppendInteger(connection_info.rssi);
   results->AppendInteger(connection_info.transmit_power);
   results->AppendInteger(connection_info.max_transmit_power);
-  SetResultList(results.Pass());
+  SetResultList(std::move(results));
   SendResponse(true);
 }
 
 EasyUnlockPrivateShowErrorBubbleFunction::
     EasyUnlockPrivateShowErrorBubbleFunction() {
 }
 
 EasyUnlockPrivateShowErrorBubbleFunction::
     ~EasyUnlockPrivateShowErrorBubbleFunction() {
 }
@@ skipping 94 matching lines @@
   SendResponse(false);
 }
 
 void EasyUnlockPrivateFindSetupConnectionFunction::OnConnectionFound(
     scoped_ptr<proximity_auth::Connection> connection) {
   // Connection are not persistent by default.
   std::string device_address = connection->remote_device().bluetooth_address;
   bool persistent = false;
   int connection_id =
       GetConnectionManager(browser_context())
-          ->AddConnection(extension(), connection.Pass(), persistent);
+          ->AddConnection(extension(), std::move(connection), persistent);
   results_ = easy_unlock_private::FindSetupConnection::Results::Create(
       connection_id, device_address);
   SendResponse(true);
 }
 
 bool EasyUnlockPrivateFindSetupConnectionFunction::RunAsync() {
   scoped_ptr<easy_unlock_private::FindSetupConnection::Params> params =
       easy_unlock_private::FindSetupConnection::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
@@ skipping 89 matching lines @@
           ->GetDeviceAddress(extension(), params->connection_id);
   results_ =
       easy_unlock_private::SetupConnectionGetDeviceAddress::Results::Create(
           device_address);
   if (device_address.empty())
     SetError("Invalid connectionId.");
   return true;
 }
 
 }  // namespace extensions