BlueZ + DBus implementations of create/remove service record functions.

device/bluetooth/dbus/fake_bluetooth_adapter_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_adapter_client.h"
 
+#include <map>
+#include <utility>
+
+#include "base/bind_helpers.h"
+#include "base/callback_forward.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "dbus/bus.h"
+#include "device/bluetooth/bluez/bluetooth_service_record_bluez.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
 
 namespace {
 
 // Default interval for delayed tasks.
 const int kSimulationIntervalMs = 750;
@@ skipping 42 matching lines @@
   } else {
     callback.Run(false);
   }
 }
 
 FakeBluetoothAdapterClient::FakeBluetoothAdapterClient()
     : visible_(true),
       second_visible_(false),
       discovering_count_(0),
       set_discovery_filter_should_fail_(false),
-      simulation_interval_ms_(kSimulationIntervalMs) {
+      simulation_interval_ms_(kSimulationIntervalMs),
+      last_handle_(0) {
   properties_.reset(new Properties(base::Bind(
       &FakeBluetoothAdapterClient::OnPropertyChanged, base::Unretained(this))));
 
   properties_->address.ReplaceValue(kAdapterAddress);
   properties_->name.ReplaceValue("Fake Adapter (Name)");
   properties_->alias.ReplaceValue(kAdapterName);
   properties_->pairable.ReplaceValue(true);
 
   second_properties_.reset(new Properties(base::Bind(
       &FakeBluetoothAdapterClient::OnPropertyChanged, base::Unretained(this))));
@@ skipping 134 matching lines @@
     PostDelayedTask(base::Bind(error_callback, kNoResponseError, ""));
     set_discovery_filter_should_fail_ = false;
     return;
   }
 
   discovery_filter_.reset(new DiscoveryFilter());
   discovery_filter_->CopyFrom(discovery_filter);
   PostDelayedTask(callback);
 }
 
+void FakeBluetoothAdapterClient::CreateServiceRecord(
+    const dbus::ObjectPath& object_path,
+    const bluez::BluetoothServiceRecordBlueZ& record,
+    const ServiceRecordCallback& callback,
+    const ErrorCallback& error_callback) {
+  ++last_handle_;
+  records_.insert(
+      std::pair<uint32_t, BluetoothServiceRecordBlueZ>(last_handle_, record));
+  callback.Run(last_handle_);
+}
+
+void FakeBluetoothAdapterClient::RemoveServiceRecord(
+    const dbus::ObjectPath& object_path,
+    uint32_t handle,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  auto it = records_.find(handle);
+  if (it == records_.end()) {
+    error_callback.Run(bluetooth_adapter::kErrorDoesNotExist,
+                       "Service record does not exist.");
+    return;
+  }
+  records_.erase(it);
+  callback.Run();
+}
+
 void FakeBluetoothAdapterClient::SetSimulationIntervalMs(int interval_ms) {
   simulation_interval_ms_ = interval_ms;
 }
 
 BluetoothAdapterClient::DiscoveryFilter*
 FakeBluetoothAdapterClient::GetDiscoveryFilter() {
   return discovery_filter_.get();
 }
 
 void FakeBluetoothAdapterClient::SetVisible(bool visible) {
@@ skipping 58 matching lines @@
 }
 
 void FakeBluetoothAdapterClient::PostDelayedTask(
     const base::Closure& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, callback,
       base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 }
 
 }  // namespace bluez