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

components/proximity_auth/webui/proximity_auth_webui_handler.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/webui/proximity_auth_webui_handler.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/prefs/pref_service.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "base/time/default_tick_clock.h"
 #include "base/values.h"
 #include "components/proximity_auth/ble/pref_names.h"
@@ skipping 36 matching lines @@
     const LogBuffer::LogMessage& log_message) {
   scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
   dictionary->SetString(kLogMessageTextKey, log_message.text);
   dictionary->SetString(
       kLogMessageTimeKey,
       base::TimeFormatTimeOfDayWithMilliseconds(log_message.time));
   dictionary->SetString(kLogMessageFileKey, log_message.file);
   dictionary->SetInteger(kLogMessageLineKey, log_message.line);
   dictionary->SetInteger(kLogMessageSeverityKey,
                          static_cast<int>(log_message.severity));
-  return dictionary.Pass();
+  return dictionary;
 }
 
 // Keys in the JSON representation of an ExternalDeviceInfo proto.
 const char kExternalDevicePublicKey[] = "publicKey";
 const char kExternalDeviceFriendlyName[] = "friendlyDeviceName";
 const char kExternalDeviceBluetoothAddress[] = "bluetoothAddress";
 const char kExternalDeviceUnlockKey[] = "unlockKey";
 const char kExternalDeviceConnectionStatus[] = "connectionStatus";
 const char kExternalDeviceRemoteState[] = "remoteState";
 
@@ skipping 453 matching lines @@
   if (last_remote_status_update_) {
     scoped_ptr<base::DictionaryValue> status_dictionary(
         new base::DictionaryValue());
     status_dictionary->SetInteger("userPresent",
                                   last_remote_status_update_->user_presence);
     status_dictionary->SetInteger(
         "secureScreenLock",
         last_remote_status_update_->secure_screen_lock_state);
     status_dictionary->SetInteger(
         "trustAgent", last_remote_status_update_->trust_agent_state);
-    dictionary->Set(kExternalDeviceRemoteState, status_dictionary.Pass());
+    dictionary->Set(kExternalDeviceRemoteState, std::move(status_dictionary));
   }
 
   return dictionary;
 }
 
 scoped_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::IneligibleDeviceToDictionary(
     const cryptauth::IneligibleDevice& ineligible_device) {
   scoped_ptr<base::ListValue> ineligibility_reasons(new base::ListValue());
   for (const std::string& reason : ineligible_device.reasons()) {
     ineligibility_reasons->AppendString(reason);
   }
 
   scoped_ptr<base::DictionaryValue> device_dictionary =
       ExternalDeviceInfoToDictionary(ineligible_device.device());
   device_dictionary->Set(kIneligibleDeviceReasons,
-                         ineligibility_reasons.Pass());
+                         std::move(ineligibility_reasons));
   return device_dictionary;
 }
 
 void ProximityAuthWebUIHandler::CleanUpRemoteDeviceLifeCycle() {
   PA_LOG(INFO) << "Cleaning up connection to " << selected_remote_device_.name
                << " [" << selected_remote_device_.bluetooth_address << "]";
   life_cycle_.reset();
   selected_remote_device_ = RemoteDevice();
   last_remote_status_update_.reset();
   web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
@@ skipping 33 matching lines @@
                << "\n  trust_agent_state: "
                << static_cast<int>(status_update.trust_agent_state);
 
   last_remote_status_update_.reset(new RemoteStatusUpdate(status_update));
   scoped_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
   web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                    *unlock_keys);
 }
 
 }  // namespace proximity_auth