Convert Pass()→std::move() in //device

device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider.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 "device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
@@ skipping 114 matching lines @@
 
     dbus::MessageReader reader(method_call);
 
     std::string interface_name;
     std::string property_name;
     if (!reader.PopString(&interface_name) ||
         !reader.PopString(&property_name) || reader.HasMoreData()) {
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(method_call, kErrorInvalidArgs,
                                               "Expected 'ss'.");
-      response_sender.Run(error_response.Pass());
+      response_sender.Run(std::move(error_response));
       return;
     }
 
     // Only the GATT descriptor interface is supported.
     if (interface_name !=
         bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(
               method_call, kErrorInvalidArgs,
               "No such interface: '" + interface_name + "'.");
-      response_sender.Run(error_response.Pass());
+      response_sender.Run(std::move(error_response));
       return;
     }
 
     // If getting the "Value" property, obtain the value from the delegate.
     if (property_name == bluetooth_gatt_descriptor::kValueProperty) {
       DCHECK(delegate_);
       delegate_->GetDescriptorValue(
           base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnGet,
                      weak_ptr_factory_.GetWeakPtr(), method_call,
                      response_sender),
@@ skipping 17 matching lines @@
                bluetooth_gatt_descriptor::kCharacteristicProperty) {
       writer.OpenVariant("o", &variant_writer);
       variant_writer.AppendObjectPath(characteristic_path_);
       writer.CloseContainer(&variant_writer);
     } else {
       response = dbus::ErrorResponse::FromMethodCall(
           method_call, kErrorInvalidArgs,
           "No such property: '" + property_name + "'.");
     }
 
-    response_sender.Run(response.Pass());
+    response_sender.Run(std::move(response));
   }
 
   // Called by dbus:: when the Bluetooth daemon sets a single property of the
   // descriptor.
   void Set(dbus::MethodCall* method_call,
            dbus::ExportedObject::ResponseSender response_sender) {
     VLOG(2) << "BluetoothGattDescriptorServiceProvider::Set: "
             << object_path_.value();
     DCHECK(OnOriginThread());
 
     dbus::MessageReader reader(method_call);
 
     std::string interface_name;
     std::string property_name;
     dbus::MessageReader variant_reader(NULL);
     if (!reader.PopString(&interface_name) ||
         !reader.PopString(&property_name) ||
         !reader.PopVariant(&variant_reader) || reader.HasMoreData()) {
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(method_call, kErrorInvalidArgs,
                                               "Expected 'ssv'.");
-      response_sender.Run(error_response.Pass());
+      response_sender.Run(std::move(error_response));
       return;
     }
 
     // Only the GATT descriptor interface is allowed.
     if (interface_name !=
         bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(
               method_call, kErrorInvalidArgs,
               "No such interface: '" + interface_name + "'.");
-      response_sender.Run(error_response.Pass());
+      response_sender.Run(std::move(error_response));
       return;
     }
 
     // Only the "Value" property is writeable.
     if (property_name != bluetooth_gatt_descriptor::kValueProperty) {
       std::string error_name;
       std::string error_message;
       if (property_name == bluetooth_gatt_descriptor::kUUIDProperty ||
           property_name == bluetooth_gatt_descriptor::kCharacteristicProperty) {
         error_name = kErrorPropertyReadOnly;
         error_message = "Read-only property: '" + property_name + "'.";
       } else {
         error_name = kErrorInvalidArgs;
         error_message = "No such property: '" + property_name + "'.";
       }
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(method_call, error_name,
                                               error_message);
-      response_sender.Run(error_response.Pass());
+      response_sender.Run(std::move(error_response));
       return;
     }
 
     // Obtain the value.
     const uint8_t* bytes = NULL;
     size_t length = 0;
     if (!variant_reader.PopArrayOfBytes(&bytes, &length)) {
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(
               method_call, kErrorInvalidArgs,
               "Property '" + property_name + "' has type 'ay'.");
-      response_sender.Run(error_response.Pass());
+      response_sender.Run(std::move(error_response));
       return;
     }
 
     // Pass the set request onto the delegate.
     std::vector<uint8_t> value(bytes, bytes + length);
     DCHECK(delegate_);
     delegate_->SetDescriptorValue(
         value, base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnSet,
                           weak_ptr_factory_.GetWeakPtr(), method_call,
                           response_sender),
@@ skipping 10 matching lines @@
             << object_path_.value();
     DCHECK(OnOriginThread());
 
     dbus::MessageReader reader(method_call);
 
     std::string interface_name;
     if (!reader.PopString(&interface_name) || reader.HasMoreData()) {
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(method_call, kErrorInvalidArgs,
                                               "Expected 's'.");
-      response_sender.Run(error_response.Pass());
+      response_sender.Run(std::move(error_response));
       return;
     }
 
     // Only the GATT descriptor interface is supported.
     if (interface_name !=
         bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
       scoped_ptr<dbus::ErrorResponse> error_response =
           dbus::ErrorResponse::FromMethodCall(
               method_call, kErrorInvalidArgs,
               "No such interface: '" + interface_name + "'.");
-      response_sender.Run(error_response.Pass());
+      response_sender.Run(std::move(error_response));
       return;
     }
 
     // Try to obtain the value from the delegate. We will construct the
     // response in the success callback.
     DCHECK(delegate_);
     delegate_->GetDescriptorValue(
         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnGetAll,
                    weak_ptr_factory_.GetWeakPtr(), method_call,
                    response_sender),
@@ skipping 43 matching lines @@
     dict_entry_writer.AppendString(bluetooth_gatt_descriptor::kValueProperty);
     dict_entry_writer.OpenVariant("ay", &variant_writer);
     variant_writer.AppendArrayOfBytes(value.data(), value.size());
     dict_entry_writer.CloseContainer(&variant_writer);
     array_writer.CloseContainer(&dict_entry_writer);
 
     // TODO(armansito): Process "Permissions" property.
 
     writer.CloseContainer(&array_writer);
 
-    response_sender.Run(response.Pass());
+    response_sender.Run(std::move(response));
   }
 
   // Called by the Delegate in response to a successful method call to get the
   // descriptor value.
   void OnGet(dbus::MethodCall* method_call,
              dbus::ExportedObject::ResponseSender response_sender,
              const std::vector<uint8_t>& value) {
     VLOG(2) << "Returning descriptor value obtained from delegate.";
     scoped_ptr<dbus::Response> response =
         dbus::Response::FromMethodCall(method_call);
     dbus::MessageWriter writer(response.get());
     dbus::MessageWriter variant_writer(NULL);
 
     writer.OpenVariant("ay", &variant_writer);
     variant_writer.AppendArrayOfBytes(value.data(), value.size());
     writer.CloseContainer(&variant_writer);
 
-    response_sender.Run(response.Pass());
+    response_sender.Run(std::move(response));
   }
 
   // Called by the Delegate in response to a successful method call to set the
   // descriptor value.
   void OnSet(dbus::MethodCall* method_call,
              dbus::ExportedObject::ResponseSender response_sender) {
     VLOG(2) << "Successfully set descriptor value. Return success.";
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
   // Called by the Delegate in response to a failed method call to get or set
   // the descriptor value.
   void OnFailure(dbus::MethodCall* method_call,
                  dbus::ExportedObject::ResponseSender response_sender) {
     VLOG(2) << "Failed to get/set descriptor value. Report error.";
     scoped_ptr<dbus::ErrorResponse> error_response =
         dbus::ErrorResponse::FromMethodCall(
             method_call, kErrorFailed, "Failed to get/set descriptor value.");
-    response_sender.Run(error_response.Pass());
+    response_sender.Run(std::move(error_response));
   }
 
   // Origin thread (i.e. the UI thread in production).
   base::PlatformThreadId origin_thread_id_;
 
   // 128-bit descriptor UUID of this object.
   std::string uuid_;
 
   // D-Bus bus object is exported on, not owned by this object and must
   // outlive it.
@@ skipping 42 matching lines @@
     const dbus::ObjectPath& characteristic_path) {
   if (!bluez::BluezDBusManager::Get()->IsUsingStub()) {
     return new BluetoothGattDescriptorServiceProviderImpl(
         bus, object_path, delegate, uuid, permissions, characteristic_path);
   }
   return new FakeBluetoothGattDescriptorServiceProvider(
       object_path, delegate, uuid, permissions, characteristic_path);
 }
 
 }  // namespace bluez