bluetooth: bluez: GetName uses 'name' instead of 'alias'.

device/bluetooth/dbus/fake_bluetooth_device_client.cc

 // Copyright (c) 2013 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/fake_bluetooth_device_client.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ skipping 297 matching lines @@
       connection_rssi_(kUnkownPower),
       transmit_power_(kUnkownPower),
       max_transmit_power_(kUnkownPower),
       delay_start_discovery_(false) {
   std::unique_ptr<Properties> properties(new Properties(
       base::Bind(&FakeBluetoothDeviceClient::OnPropertyChanged,
                  base::Unretained(this), dbus::ObjectPath(kPairedDevicePath))));
   properties->address.ReplaceValue(kPairedDeviceAddress);
   properties->bluetooth_class.ReplaceValue(kPairedDeviceClass);
   properties->name.ReplaceValue(kPairedDeviceName);
+  properties->name.set_valid(true);
   properties->alias.ReplaceValue(kPairedDeviceAlias);
   properties->paired.ReplaceValue(true);
   properties->trusted.ReplaceValue(true);
   properties->adapter.ReplaceValue(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
   std::vector<std::string> uuids;
   uuids.push_back("00001800-0000-1000-8000-00805f9b34fb");
   uuids.push_back("00001801-0000-1000-8000-00805f9b34fb");
   properties->uuids.ReplaceValue(uuids);
 
   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
 
   properties_map_.insert(std::make_pair(dbus::ObjectPath(kPairedDevicePath),
                                         std::move(properties)));
   device_list_.push_back(dbus::ObjectPath(kPairedDevicePath));
 
   properties.reset(new Properties(base::Bind(
       &FakeBluetoothDeviceClient::OnPropertyChanged, base::Unretained(this),
       dbus::ObjectPath(kPairedUnconnectableDevicePath))));
   properties->address.ReplaceValue(kPairedUnconnectableDeviceAddress);
   properties->bluetooth_class.ReplaceValue(kPairedUnconnectableDeviceClass);
   properties->name.ReplaceValue(kPairedUnconnectableDeviceName);
+  properties->name.set_valid(true);
   properties->alias.ReplaceValue(kPairedUnconnectableDeviceAlias);
   properties->paired.ReplaceValue(true);
   properties->trusted.ReplaceValue(true);
   properties->adapter.ReplaceValue(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
   properties->uuids.ReplaceValue(uuids);
 
   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
 
@@ skipping 300 matching lines @@
   std::unique_ptr<Properties> properties(
       new Properties(base::Bind(&FakeBluetoothDeviceClient::OnPropertyChanged,
                                 base::Unretained(this), device_path)));
   properties->adapter.ReplaceValue(adapter_path);
   properties->type.ReplaceValue(BluetoothDeviceClient::kTypeBredr);
   properties->type.set_valid(true);
 
   if (device_path == dbus::ObjectPath(kLegacyAutopairPath)) {
     properties->address.ReplaceValue(kLegacyAutopairAddress);
     properties->bluetooth_class.ReplaceValue(kLegacyAutopairClass);
-    properties->name.ReplaceValue("LegacyAutopair");
-    properties->alias.ReplaceValue(kLegacyAutopairName);
+    properties->name.ReplaceValue(kLegacyAutopairName);
+    properties->name.set_valid(true);
 
     std::vector<std::string> uuids;
     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
     properties->uuids.ReplaceValue(uuids);
 
   } else if (device_path == dbus::ObjectPath(kDisplayPinCodePath)) {
     properties->address.ReplaceValue(kDisplayPinCodeAddress);
     properties->bluetooth_class.ReplaceValue(kDisplayPinCodeClass);
-    properties->name.ReplaceValue("DisplayPinCode");
-    properties->alias.ReplaceValue(kDisplayPinCodeName);
+    properties->name.ReplaceValue(kDisplayPinCodeName);
+    properties->name.set_valid(true);
 
     std::vector<std::string> uuids;
     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
     properties->uuids.ReplaceValue(uuids);
 
   } else if (device_path == dbus::ObjectPath(kVanishingDevicePath)) {
     properties->address.ReplaceValue(kVanishingDeviceAddress);
     properties->bluetooth_class.ReplaceValue(kVanishingDeviceClass);
-    properties->name.ReplaceValue("VanishingDevice");
-    properties->alias.ReplaceValue(kVanishingDeviceName);
+    properties->name.ReplaceValue(kVanishingDeviceName);
+    properties->name.set_valid(true);
 
   } else if (device_path == dbus::ObjectPath(kConnectUnpairablePath)) {
     properties->address.ReplaceValue(kConnectUnpairableAddress);
     properties->bluetooth_class.ReplaceValue(kConnectUnpairableClass);
-    properties->name.ReplaceValue("ConnectUnpairable");
-    properties->alias.ReplaceValue(kConnectUnpairableName);
+    properties->name.ReplaceValue(kConnectUnpairableName);
+    properties->name.set_valid(true);
 
     std::vector<std::string> uuids;
     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
     properties->uuids.ReplaceValue(uuids);
 
   } else if (device_path == dbus::ObjectPath(kDisplayPasskeyPath)) {
     properties->address.ReplaceValue(kDisplayPasskeyAddress);
     properties->bluetooth_class.ReplaceValue(kDisplayPasskeyClass);
-    properties->name.ReplaceValue("DisplayPasskey");
-    properties->alias.ReplaceValue(kDisplayPasskeyName);
+    properties->name.ReplaceValue(kDisplayPasskeyName);
+    properties->name.set_valid(true);
 
     std::vector<std::string> uuids;
     uuids.push_back("00001124-0000-1000-8000-00805f9b34fb");
     properties->uuids.ReplaceValue(uuids);
 
   } else if (device_path == dbus::ObjectPath(kRequestPinCodePath)) {
     properties->address.ReplaceValue(kRequestPinCodeAddress);
     properties->bluetooth_class.ReplaceValue(kRequestPinCodeClass);
-    properties->name.ReplaceValue("RequestPinCode");
-    properties->alias.ReplaceValue(kRequestPinCodeName);
+    properties->name.ReplaceValue(kRequestPinCodeName);
+    properties->name.set_valid(true);
 
   } else if (device_path == dbus::ObjectPath(kConfirmPasskeyPath)) {
     properties->address.ReplaceValue(kConfirmPasskeyAddress);
     properties->bluetooth_class.ReplaceValue(kConfirmPasskeyClass);
-    properties->name.ReplaceValue("ConfirmPasskey");
-    properties->alias.ReplaceValue(kConfirmPasskeyName);
+    properties->name.ReplaceValue(kConfirmPasskeyName);
+    properties->name.set_valid(true);
 
   } else if (device_path == dbus::ObjectPath(kRequestPasskeyPath)) {
     properties->address.ReplaceValue(kRequestPasskeyAddress);
     properties->bluetooth_class.ReplaceValue(kRequestPasskeyClass);
-    properties->name.ReplaceValue("RequestPasskey");
-    properties->alias.ReplaceValue(kRequestPasskeyName);
+    properties->name.ReplaceValue(kRequestPasskeyName);
+    properties->name.set_valid(true);
 
   } else if (device_path == dbus::ObjectPath(kUnconnectableDevicePath)) {
     properties->address.ReplaceValue(kUnconnectableDeviceAddress);
     properties->bluetooth_class.ReplaceValue(kUnconnectableDeviceClass);
-    properties->name.ReplaceValue("UnconnectableDevice");
-    properties->alias.ReplaceValue(kUnconnectableDeviceName);
+    properties->name.ReplaceValue(kUnconnectableDeviceName);
+    properties->name.set_valid(true);
 
   } else if (device_path == dbus::ObjectPath(kUnpairableDevicePath)) {
     properties->address.ReplaceValue(kUnpairableDeviceAddress);
     properties->bluetooth_class.ReplaceValue(kUnpairableDeviceClass);
-    properties->name.ReplaceValue("Fake Unpairable Device");
-    properties->alias.ReplaceValue(kUnpairableDeviceName);
+    properties->name.ReplaceValue(kUnpairableDeviceName);
+    properties->name.set_valid(true);
 
   } else if (device_path == dbus::ObjectPath(kJustWorksPath)) {
     properties->address.ReplaceValue(kJustWorksAddress);
     properties->bluetooth_class.ReplaceValue(kJustWorksClass);
-    properties->name.ReplaceValue("JustWorks");
-    properties->alias.ReplaceValue(kJustWorksName);
+    properties->name.ReplaceValue(kJustWorksName);
+    properties->name.set_valid(true);
 
   } else if (device_path == dbus::ObjectPath(kLowEnergyPath)) {
     properties->address.ReplaceValue(kLowEnergyAddress);
     properties->bluetooth_class.ReplaceValue(kLowEnergyClass);
-    properties->name.ReplaceValue("Heart Rate Monitor");
-    properties->alias.ReplaceValue(kLowEnergyName);
+    properties->name.ReplaceValue(kLowEnergyName);
+    properties->name.set_valid(true);
     properties->services_resolved.ReplaceValue(false);
     properties->type.ReplaceValue(BluetoothDeviceClient::kTypeLe);
 
     std::vector<std::string> uuids;
     uuids.push_back(FakeBluetoothGattServiceClient::kHeartRateServiceUUID);
     properties->uuids.ReplaceValue(uuids);
   } else if (device_path ==
              dbus::ObjectPath(kConnectedTrustedNotPairedDevicePath)) {
     properties->address.ReplaceValue(kConnectedTrustedNotPairedDeviceAddress);
     properties->bluetooth_class.ReplaceValue(
         kConnectedTrustedNotPairedDeviceClass);
     properties->trusted.ReplaceValue(true);
     properties->connected.ReplaceValue(true);
     properties->paired.ReplaceValue(false);
-    properties->name.ReplaceValue("Connected Pairable Device");
-    properties->alias.ReplaceValue(kConnectedTrustedNotPairedDeviceName);
+    properties->name.ReplaceValue(kConnectedTrustedNotPairedDeviceName);
+    properties->name.set_valid(true);
   } else {
     NOTREACHED();
   }
 
   properties_map_.insert(std::make_pair(device_path, std::move(properties)));
   device_list_.push_back(device_path);
 
   for (auto& observer : observers_)
     observer.DeviceAdded(device_path);
 }
 
 void FakeBluetoothDeviceClient::CreateDeviceWithProperties(
     const dbus::ObjectPath& adapter_path,
     const IncomingDeviceProperties& props) {
   dbus::ObjectPath device_path(props.device_path);
   if (std::find(device_list_.begin(), device_list_.end(), device_path) !=
       device_list_.end())
     return;
 
   std::unique_ptr<Properties> properties(
       new Properties(base::Bind(&FakeBluetoothDeviceClient::OnPropertyChanged,
                                 base::Unretained(this), device_path)));
   properties->adapter.ReplaceValue(adapter_path);
   properties->name.ReplaceValue(props.device_name);
+  properties->name.set_valid(true);
   properties->alias.ReplaceValue(props.device_alias);
   properties->address.ReplaceValue(props.device_address);
   properties->bluetooth_class.ReplaceValue(props.device_class);
   properties->trusted.ReplaceValue(props.is_trusted);
 
   if (props.is_trusted)
     properties->paired.ReplaceValue(true);
 
   std::unique_ptr<SimulatedPairingOptions> options(new SimulatedPairingOptions);
   options->pairing_method = props.pairing_method;
@@ skipping 256 matching lines @@
     const dbus::ObjectPath& adapter_path,
     const dbus::ObjectPath& device_path) {
   std::vector<dbus::ObjectPath>::iterator listiter =
       std::find(device_list_.begin(), device_list_.end(), device_path);
   if (listiter == device_list_.end())
     return;
 
   PropertiesMap::const_iterator iter = properties_map_.find(device_path);
   Properties* properties = iter->second.get();
 
-  VLOG(1) << "removing device: " << properties->alias.value();
+  VLOG(1) << "removing device: " << properties->name.value();
   device_list_.erase(listiter);
 
   // Remove the Input interface if it exists. This should be called before the
   // BluetoothDeviceClient::Observer::DeviceRemoved because it deletes the
   // BluetoothDeviceBlueZ object, including the device_path referenced here.
   FakeBluetoothInputClient* fake_bluetooth_input_client =
       static_cast<FakeBluetoothInputClient*>(
           bluez::BluezDBusManager::Get()->GetBluetoothInputClient());
   fake_bluetooth_input_client->RemoveInputDevice(device_path);
 
@@ skipping 670 matching lines @@
     error_callback.Run(bluetooth_device::kErrorFailed, "Rejected");
   }
 }
 
 void FakeBluetoothDeviceClient::RemoveAllDevices() {
   device_list_.clear();
 }
 
 void FakeBluetoothDeviceClient::CreateTestDevice(
     const dbus::ObjectPath& adapter_path,
-    const std::string name,
+    const base::Optional<std::string> name,
     const std::string alias,
     const std::string device_address,
     const std::vector<std::string>& service_uuids,
     device::BluetoothTransport type) {
   // Create a random device path.
   dbus::ObjectPath device_path;
   do {
     device_path = dbus::ObjectPath(adapter_path.value() + "/dev" +
                                    base::RandBytesAsString(10));
   } while (std::find(device_list_.begin(), device_list_.end(), device_path) !=
            device_list_.end());
 
   std::unique_ptr<Properties> properties(
       new Properties(base::Bind(&FakeBluetoothDeviceClient::OnPropertyChanged,
                                 base::Unretained(this), device_path)));
   properties->adapter.ReplaceValue(adapter_path);
 
   properties->address.ReplaceValue(device_address);
-  properties->name.ReplaceValue(name);
+  properties->name.ReplaceValue(
+      name.value_or("Invalid Device Name set in "
+                    "FakeBluetoothDeviceClient::CreateTestDevice"));
+  properties->name.set_valid(name.has_value());
   properties->alias.ReplaceValue(alias);
 
   properties->uuids.ReplaceValue(service_uuids);
 
   switch (type) {
     case device::BLUETOOTH_TRANSPORT_CLASSIC:
       properties->type.ReplaceValue(BluetoothDeviceClient::kTypeBredr);
       break;
     case device::BLUETOOTH_TRANSPORT_LE:
       properties->type.ReplaceValue(BluetoothDeviceClient::kTypeLe);
       break;
     case device::BLUETOOTH_TRANSPORT_DUAL:
       properties->type.ReplaceValue(BluetoothDeviceClient::kTypeDual);
       break;
     default:
       NOTREACHED();
   }
   properties->type.set_valid(true);
 
   properties_map_.insert(std::make_pair(device_path, std::move(properties)));
   device_list_.push_back(device_path);
   for (auto& observer : observers_)
     observer.DeviceAdded(device_path);
 }
 
 }  // namespace bluez