Implement BluetoothDeviceBlueZ::GetServiceRecords.

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>
 #include <unistd.h>
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 
+#include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/ref_counted.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "dbus/file_descriptor.h"
+#include "device/bluetooth/bluez/bluetooth_service_attribute_value_bluez.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "device/bluetooth/dbus/fake_bluetooth_adapter_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_agent_manager_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_agent_service_provider.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_service_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_input_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_profile_manager_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_profile_service_provider.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
+namespace bluez {
+
 namespace {
 
 // Default interval between simulated events.
 const int kSimulationIntervalMs = 750;
 
 // Minimum and maximum bounds for randomly generated RSSI values.
 const int kMinRSSI = -90;
 const int kMaxRSSI = -30;
 
 // The default value of connection info properties from GetConnInfo().
@@ skipping 39 matching lines @@
   }
 
   close(fd);
 }
 
 void SimpleErrorCallback(const std::string& error_name,
                          const std::string& error_message) {
   VLOG(1) << "Bluetooth Error: " << error_name << ": " << error_message;
 }
 
+BluetoothDeviceClient::ServiceRecordList CreateFakeServiceRecords() {
+  BluetoothDeviceClient::ServiceRecordList records;
+
+  std::unique_ptr<BluetoothServiceRecordBlueZ> record1 =
+      base::MakeUnique<BluetoothServiceRecordBlueZ>();
+  // ID 0 = handle.
+  record1->AddRecordEntry(0x0, BluetoothServiceAttributeValueBlueZ(
+                                   BluetoothServiceAttributeValueBlueZ::UINT, 4,
+                                   base::MakeUnique<base::FundamentalValue>(
+                                       static_cast<int32_t>(0x1337))));
+  // ID 1 = service class id list.
+  std::unique_ptr<BluetoothServiceAttributeValueBlueZ::Sequence> class_id_list =
+      base::MakeUnique<BluetoothServiceAttributeValueBlueZ::Sequence>();
+  class_id_list->emplace_back(BluetoothServiceAttributeValueBlueZ(

[Miao, 2016/06/30 04:55:59]

emplace_back(...) allows in-place construction of the object to be inserted. So
instead of creating a temp BluetoothServiceAttributeValueBlueZ, this should be 
class_id_list->emplace_back(BluetoothServiceAttributeValueBlueZ::UUID, 4,
base::MakeUnique<base::StringValue>("1802"));

[rkc, 2016/06/30 20:02:24]

Done.

+      BluetoothServiceAttributeValueBlueZ::UUID, 4,
+      base::MakeUnique<base::StringValue>("1802")));
+  record1->AddRecordEntry(
+      0x1, BluetoothServiceAttributeValueBlueZ(std::move(class_id_list)));
+  records.emplace_back(*record1);
+
+  std::unique_ptr<BluetoothServiceRecordBlueZ> record2 =
+      base::MakeUnique<BluetoothServiceRecordBlueZ>();
+  // ID 0 = handle.
+  record2->AddRecordEntry(0x0, BluetoothServiceAttributeValueBlueZ(
+                                   BluetoothServiceAttributeValueBlueZ::UINT, 4,
+                                   base::MakeUnique<base::FundamentalValue>(
+                                       static_cast<int32_t>(0xffffffff))));
+  records.emplace_back(*record2);
+
+  return records;
+}
+
 }  // namespace
 
-namespace bluez {
-
 const char FakeBluetoothDeviceClient::kTestPinCode[] = "123456";
 const int FakeBluetoothDeviceClient::kTestPassKey = 123456;
 
 const char FakeBluetoothDeviceClient::kPairingMethodNone[] = "None";
 const char FakeBluetoothDeviceClient::kPairingMethodPinCode[] = "PIN Code";
 const char FakeBluetoothDeviceClient::kPairingMethodPassKey[] = "PassKey";
 
 const char FakeBluetoothDeviceClient::kPairingActionConfirmation[] =
     "Confirmation";
 const char FakeBluetoothDeviceClient::kPairingActionDisplay[] = "Display";
@@ skipping 296 matching lines @@
 }
 
 void FakeBluetoothDeviceClient::Disconnect(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "Disconnect: " << object_path.value();
   Properties* properties = GetProperties(object_path);
 
   if (!properties->connected.value()) {
-    error_callback.Run("org.bluez.Error.NotConnected", "Not Connected");
+    error_callback.Run(bluetooth_device::kErrorNotConnected, "Not Connected");
     return;
   }
 
   // Hide the Heart Rate Service if disconnected from LE device.
   if (object_path == dbus::ObjectPath(kLowEnergyPath)) {
     FakeBluetoothGattServiceClient* gatt_service_client =
         static_cast<FakeBluetoothGattServiceClient*>(
             bluez::BluezDBusManager::Get()->GetBluetoothGattServiceClient());
     gatt_service_client->HideHeartRateService();
   }
@@ skipping 111 matching lines @@
   pairing_cancelled_ = true;
   callback.Run();
 }
 
 void FakeBluetoothDeviceClient::GetConnInfo(
     const dbus::ObjectPath& object_path,
     const ConnInfoCallback& callback,
     const ErrorCallback& error_callback) {
   Properties* properties = GetProperties(object_path);
   if (!properties->connected.value()) {
-    error_callback.Run("org.bluez.Error.NotConnected", "Not Connected");
+    error_callback.Run(bluetooth_device::kErrorNotConnected, "Not Connected");
     return;
   }
 
   callback.Run(connection_rssi_, transmit_power_, max_transmit_power_);
 }
 
+void FakeBluetoothDeviceClient::GetServiceRecords(
+    const dbus::ObjectPath& object_path,
+    const ServiceRecordsCallback& callback,
+    const ErrorCallback& error_callback) {
+  Properties* properties = GetProperties(object_path);
+  if (!properties->connected.value()) {
+    error_callback.Run(bluetooth_device::kErrorNotConnected, "Not Connected");
+    return;
+  }
+  callback.Run(CreateFakeServiceRecords());
+}
+
 void FakeBluetoothDeviceClient::BeginDiscoverySimulation(
     const dbus::ObjectPath& adapter_path) {
   VLOG(1) << "starting discovery simulation";
 
   discovery_simulation_step_ = 1;
   int delay = delay_start_discovery_ ? simulation_interval_ms_ : 0;
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeBluetoothDeviceClient::DiscoverySimulationTimer,
@@ skipping 1179 matching lines @@
   }
   properties->type.set_valid(true);
 
   properties_map_.insert(std::make_pair(device_path, std::move(properties)));
   device_list_.push_back(device_path);
   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
                     DeviceAdded(device_path));
 }
 
 }  // namespace bluez