Reland "Add Linux support for the Bluetooth API"

device/bluetooth/bluetooth_gatt_bluez_unittest.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 "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
@@ skipping 18 matching lines @@
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothGattCharacteristic;
 using device::BluetoothGattConnection;
 using device::BluetoothGattDescriptor;
 using device::BluetoothGattService;
 using device::BluetoothGattNotifySession;
 using device::BluetoothUUID;
 using device::TestBluetoothAdapterObserver;
 
-namespace chromeos {
+namespace bluez {
 
 namespace {
 
 const BluetoothUUID kHeartRateMeasurementUUID(
     bluez::FakeBluetoothGattCharacteristicClient::kHeartRateMeasurementUUID);
 const BluetoothUUID kBodySensorLocationUUID(
     bluez::FakeBluetoothGattCharacteristicClient::kBodySensorLocationUUID);
 const BluetoothUUID kHeartRateControlPointUUID(
     bluez::FakeBluetoothGattCharacteristicClient::kHeartRateControlPointUUID);
 
 // Compares GATT characteristic/descriptor values. Returns true, if the values
 // are equal.
 bool ValuesEqual(const std::vector<uint8>& value0,
                  const std::vector<uint8>& value1) {
   if (value0.size() != value1.size())
     return false;
   for (size_t i = 0; i < value0.size(); ++i)
     if (value0[i] != value1[i])
       return false;
   return true;
 }
 
 }  // namespace
 
-class BluetoothGattChromeOSTest : public testing::Test {
+class BluetoothGattBlueZTest : public testing::Test {
  public:
-  BluetoothGattChromeOSTest()
+  BluetoothGattBlueZTest()
       : fake_bluetooth_gatt_service_client_(NULL),
         success_callback_count_(0),
-        error_callback_count_(0) {
-  }
+        error_callback_count_(0) {}
 
   void SetUp() override {
     scoped_ptr<bluez::BluezDBusManagerSetter> dbus_setter =
         bluez::BluezDBusManager::GetSetterForTesting();
     fake_bluetooth_device_client_ = new bluez::FakeBluetoothDeviceClient;
     fake_bluetooth_gatt_service_client_ =
         new bluez::FakeBluetoothGattServiceClient;
     fake_bluetooth_gatt_characteristic_client_ =
         new bluez::FakeBluetoothGattCharacteristicClient;
     fake_bluetooth_gatt_descriptor_client_ =
@@ skipping 15 matching lines @@
             new bluez::FakeBluetoothAdapterClient));
     dbus_setter->SetBluetoothInputClient(
         scoped_ptr<bluez::BluetoothInputClient>(
             new bluez::FakeBluetoothInputClient));
     dbus_setter->SetBluetoothAgentManagerClient(
         scoped_ptr<bluez::BluetoothAgentManagerClient>(
             new bluez::FakeBluetoothAgentManagerClient));
 
     GetAdapter();
 
-    adapter_->SetPowered(
-        true,
-        base::Bind(&base::DoNothing),
-        base::Bind(&base::DoNothing));
+    adapter_->SetPowered(true, base::Bind(&base::DoNothing),
+                         base::Bind(&base::DoNothing));
     ASSERT_TRUE(adapter_->IsPowered());
   }
 
   void TearDown() override {
     adapter_ = NULL;
     update_sessions_.clear();
     gatt_conn_.reset();
     bluez::BluezDBusManager::Shutdown();
   }
 
   void GetAdapter() {
-    device::BluetoothAdapterFactory::GetAdapter(
-        base::Bind(&BluetoothGattChromeOSTest::AdapterCallback,
-                   base::Unretained(this)));
+    device::BluetoothAdapterFactory::GetAdapter(base::Bind(
+        &BluetoothGattBlueZTest::AdapterCallback, base::Unretained(this)));
     ASSERT_TRUE(adapter_.get() != NULL);
     ASSERT_TRUE(adapter_->IsInitialized());
     ASSERT_TRUE(adapter_->IsPresent());
   }
 
   void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) {
     adapter_ = adapter;
   }
 
-  void SuccessCallback() {
-    ++success_callback_count_;
-  }
+  void SuccessCallback() { ++success_callback_count_; }
 
   void ValueCallback(const std::vector<uint8>& value) {
     ++success_callback_count_;
     last_read_value_ = value;
   }
 
   void GattConnectionCallback(scoped_ptr<BluetoothGattConnection> conn) {
     ++success_callback_count_;
     gatt_conn_ = conn.Pass();
   }
 
   void NotifySessionCallback(scoped_ptr<BluetoothGattNotifySession> session) {
     ++success_callback_count_;
     update_sessions_.push_back(session.release());
     QuitMessageLoop();
   }
 
   void ServiceErrorCallback(BluetoothGattService::GattErrorCode err) {
     ++error_callback_count_;
     last_service_error_ = err;
   }
 
-  void ErrorCallback() {
-    ++error_callback_count_;
-  }
+  void ErrorCallback() { ++error_callback_count_; }
 
   void DBusErrorCallback(const std::string& error_name,
                          const std::string& error_message) {
     ++error_callback_count_;
   }
 
   void ConnectErrorCallback(BluetoothDevice::ConnectErrorCode error) {
     ++error_callback_count_;
   }
 
@@ skipping 15 matching lines @@
   scoped_ptr<device::BluetoothGattConnection> gatt_conn_;
   ScopedVector<BluetoothGattNotifySession> update_sessions_;
   scoped_refptr<BluetoothAdapter> adapter_;
 
   int success_callback_count_;
   int error_callback_count_;
   std::vector<uint8> last_read_value_;
   BluetoothGattService::GattErrorCode last_service_error_;
 };
 
-TEST_F(BluetoothGattChromeOSTest, GattConnection) {
+TEST_F(BluetoothGattBlueZTest, GattConnection) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
   ASSERT_FALSE(device->IsConnected());
   ASSERT_FALSE(gatt_conn_.get());
   ASSERT_EQ(0, success_callback_count_);
   ASSERT_EQ(0, error_callback_count_);
 
   device->CreateGattConnection(
-      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+      base::Bind(&BluetoothGattBlueZTest::GattConnectionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(device->IsConnected());
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_TRUE(gatt_conn_->IsConnected());
   EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress,
             gatt_conn_->GetDeviceAddress());
 
   gatt_conn_->Disconnect();
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(gatt_conn_->IsConnected());
 
   device->CreateGattConnection(
-      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+      base::Bind(&BluetoothGattBlueZTest::GattConnectionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(device->IsConnected());
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_TRUE(gatt_conn_->IsConnected());
 
-  device->Disconnect(
-      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+  device->Disconnect(base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
+                                base::Unretained(this)),
+                     base::Bind(&BluetoothGattBlueZTest::ErrorCallback,
+                                base::Unretained(this)));
 
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_FALSE(gatt_conn_->IsConnected());
 
   device->CreateGattConnection(
-      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+      base::Bind(&BluetoothGattBlueZTest::GattConnectionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(device->IsConnected());
   EXPECT_TRUE(gatt_conn_->IsConnected());
 
   fake_bluetooth_device_client_->RemoveDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_FALSE(gatt_conn_->IsConnected());
 }
 
-TEST_F(BluetoothGattChromeOSTest, GattServiceAddedAndRemoved) {
+TEST_F(BluetoothGattBlueZTest, GattServiceAddedAndRemoved) {
   // Create a fake LE device. We store the device pointer here because this is a
   // test. It's unsafe to do this in production as the device might get deleted.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
@@ skipping 72 matching lines @@
   EXPECT_EQ(2, observer.gatt_service_added_count());
   EXPECT_EQ(2, observer.gatt_service_removed_count());
   EXPECT_FALSE(observer.last_gatt_service_id().empty());
   EXPECT_EQ(BluetoothUUID(
                 bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
             observer.last_gatt_service_uuid());
   EXPECT_EQ(NULL, adapter_->GetDevice(
                       bluez::FakeBluetoothDeviceClient::kLowEnergyAddress));
 }
 
-TEST_F(BluetoothGattChromeOSTest, ServicesDiscovered) {
+TEST_F(BluetoothGattBlueZTest, ServicesDiscovered) {
   // Create a fake LE device. We store the device pointer here because this is a
   // test. It's unsafe to do this in production as the device might get deleted.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
@@ skipping 10 matching lines @@
   // Notify that all services have been discovered.
   properties->gatt_services.ReplaceValue(
       fake_bluetooth_gatt_service_client_->GetServices());
 
   EXPECT_EQ(1, observer.gatt_services_discovered_count());
   EXPECT_EQ(device, observer.last_device());
   EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress,
             observer.last_device_address());
 }
 
-TEST_F(BluetoothGattChromeOSTest, GattCharacteristicAddedAndRemoved) {
+TEST_F(BluetoothGattBlueZTest, GattCharacteristicAddedAndRemoved) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
@@ skipping 47 matching lines @@
   EXPECT_EQ(3U, service->GetCharacteristics().size());
 
   // Hide the service. All characteristics should disappear.
   fake_bluetooth_gatt_service_client_->HideHeartRateService();
   EXPECT_EQ(0, observer.gatt_service_changed_count());
   EXPECT_EQ(6, observer.gatt_characteristic_added_count());
   EXPECT_EQ(6, observer.gatt_characteristic_removed_count());
   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count());
 }
 
-TEST_F(BluetoothGattChromeOSTest, GattDescriptorAddedAndRemoved) {
+TEST_F(BluetoothGattBlueZTest, GattDescriptorAddedAndRemoved) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
@@ skipping 15 matching lines @@
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
   EXPECT_EQ(0, observer.gatt_service_changed_count());
 
   // Only the Heart Rate Measurement characteristic has a descriptor.
   EXPECT_EQ(1, observer.gatt_descriptor_added_count());
   EXPECT_EQ(0, observer.gatt_descriptor_removed_count());
   EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count());
 
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetBodySensorLocationPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
+          .value());
   ASSERT_TRUE(characteristic);
   EXPECT_TRUE(characteristic->GetDescriptors().empty());
 
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateControlPointPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateControlPointPath()
+          .value());
   ASSERT_TRUE(characteristic);
   EXPECT_TRUE(characteristic->GetDescriptors().empty());
 
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateMeasurementPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
+          .value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
 
   BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
   EXPECT_FALSE(descriptor->IsLocal());
   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
             descriptor->GetUUID());
   EXPECT_EQ(descriptor->GetUUID(), observer.last_gatt_descriptor_uuid());
   EXPECT_EQ(descriptor->GetIdentifier(), observer.last_gatt_descriptor_id());
 
@@ skipping 20 matching lines @@
   EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count());
 
   descriptor = characteristic->GetDescriptors()[0];
   EXPECT_FALSE(descriptor->IsLocal());
   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
             descriptor->GetUUID());
   EXPECT_EQ(descriptor->GetUUID(), observer.last_gatt_descriptor_uuid());
   EXPECT_EQ(descriptor->GetIdentifier(), observer.last_gatt_descriptor_id());
 }
 
-TEST_F(BluetoothGattChromeOSTest, AdapterAddedAfterGattService) {
+TEST_F(BluetoothGattBlueZTest, AdapterAddedAfterGattService) {
   // This unit test tests that all remote GATT objects are created for D-Bus
   // objects that were already exposed.
   adapter_ = NULL;
   ASSERT_FALSE(device::BluetoothAdapterFactory::HasSharedInstanceForTesting());
 
   // Create the fake D-Bus objects.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
@@ skipping 16 matching lines @@
   EXPECT_TRUE(service->IsPrimary());
   EXPECT_EQ(BluetoothUUID(
                 bluez::FakeBluetoothGattServiceClient::kHeartRateServiceUUID),
             service->GetUUID());
   EXPECT_EQ(service, device->GetGattServices()[0]);
   EXPECT_EQ(service, device->GetGattService(service->GetIdentifier()));
   EXPECT_FALSE(service->IsLocal());
   EXPECT_EQ(3U, service->GetCharacteristics().size());
 
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetBodySensorLocationPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
+          .value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(BluetoothUUID(bluez::FakeBluetoothGattCharacteristicClient::
                               kBodySensorLocationUUID),
             characteristic->GetUUID());
   EXPECT_FALSE(characteristic->IsLocal());
   EXPECT_TRUE(characteristic->GetDescriptors().empty());
 
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateControlPointPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateControlPointPath()
+          .value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(BluetoothUUID(bluez::FakeBluetoothGattCharacteristicClient::
                               kHeartRateControlPointUUID),
             characteristic->GetUUID());
   EXPECT_FALSE(characteristic->IsLocal());
   EXPECT_TRUE(characteristic->GetDescriptors().empty());
 
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateMeasurementPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
+          .value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(BluetoothUUID(bluez::FakeBluetoothGattCharacteristicClient::
                               kHeartRateMeasurementUUID),
             characteristic->GetUUID());
   EXPECT_FALSE(characteristic->IsLocal());
   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
 
   BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
   ASSERT_TRUE(descriptor);
   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
             descriptor->GetUUID());
   EXPECT_FALSE(descriptor->IsLocal());
 }
 
-TEST_F(BluetoothGattChromeOSTest, GattCharacteristicValue) {
+TEST_F(BluetoothGattBlueZTest, GattCharacteristicValue) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_EQ(1, observer.gatt_service_added_count());
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id());
 
   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
 
   // Issue write request to non-writable characteristics.
   observer.Reset();
 
   std::vector<uint8> write_value;
   write_value.push_back(0x01);
-  BluetoothGattCharacteristic* characteristic =
-      service->GetCharacteristic(fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateMeasurementPath().value());
+  BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
+          .value());
   ASSERT_TRUE(characteristic);
   EXPECT_FALSE(characteristic->IsNotifying());
-  EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
-                GetHeartRateMeasurementPath().value(),
-            characteristic->GetIdentifier());
+  EXPECT_EQ(
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
+          .value(),
+      characteristic->GetIdentifier());
   EXPECT_EQ(kHeartRateMeasurementUUID, characteristic->GetUUID());
   characteristic->WriteRemoteCharacteristic(
-      write_value,
-      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      write_value, base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
+                              base::Unretained(this)),
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_TRUE(observer.last_gatt_characteristic_id().empty());
   EXPECT_FALSE(observer.last_gatt_characteristic_uuid().IsValid());
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothGattService::GATT_ERROR_NOT_SUPPORTED,
             last_service_error_);
   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count());
 
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetBodySensorLocationPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
+          .value());
   ASSERT_TRUE(characteristic);
-  EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
-                GetBodySensorLocationPath().value(),
-            characteristic->GetIdentifier());
+  EXPECT_EQ(
+      fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
+          .value(),
+      characteristic->GetIdentifier());
   EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
   characteristic->WriteRemoteCharacteristic(
-      write_value,
-      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      write_value, base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
+                              base::Unretained(this)),
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_TRUE(observer.last_gatt_characteristic_id().empty());
   EXPECT_FALSE(observer.last_gatt_characteristic_uuid().IsValid());
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(2, error_callback_count_);
   EXPECT_EQ(BluetoothGattService::GATT_ERROR_NOT_PERMITTED,
             last_service_error_);
   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count());
 
   // Issue write request to writable characteristic. The "Body Sensor Location"
   // characteristic does not send notifications and WriteValue does not result
   // in a CharacteristicValueChanged event, thus no such event should be
   // received.
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateControlPointPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateControlPointPath()
+          .value());
   ASSERT_TRUE(characteristic);
-  EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
-                GetHeartRateControlPointPath().value(),
-            characteristic->GetIdentifier());
+  EXPECT_EQ(
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateControlPointPath()
+          .value(),
+      characteristic->GetIdentifier());
   EXPECT_EQ(kHeartRateControlPointUUID, characteristic->GetUUID());
   characteristic->WriteRemoteCharacteristic(
-      write_value,
-      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      write_value, base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
+                              base::Unretained(this)),
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_TRUE(observer.last_gatt_characteristic_id().empty());
   EXPECT_FALSE(observer.last_gatt_characteristic_uuid().IsValid());
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(2, error_callback_count_);
   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count());
 
   // Issue some invalid write requests to the characteristic.
   // The value should still not change.
 
   std::vector<uint8> invalid_write_length;
   invalid_write_length.push_back(0x01);
   invalid_write_length.push_back(0x00);
   characteristic->WriteRemoteCharacteristic(
-      invalid_write_length,
-      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      invalid_write_length, base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
+                                       base::Unretained(this)),
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(3, error_callback_count_);
   EXPECT_EQ(BluetoothGattService::GATT_ERROR_INVALID_LENGTH,
             last_service_error_);
   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count());
 
   std::vector<uint8> invalid_write_value;
   invalid_write_value.push_back(0x02);
   characteristic->WriteRemoteCharacteristic(
-      invalid_write_value,
-      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      invalid_write_value, base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
+                                      base::Unretained(this)),
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(4, error_callback_count_);
   EXPECT_EQ(BluetoothGattService::GATT_ERROR_FAILED, last_service_error_);
   EXPECT_EQ(0, observer.gatt_characteristic_value_changed_count());
 
   // Issue a read request. A successful read results in a
   // CharacteristicValueChanged notification.
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetBodySensorLocationPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
+          .value());
   ASSERT_TRUE(characteristic);
-  EXPECT_EQ(fake_bluetooth_gatt_characteristic_client_->
-                GetBodySensorLocationPath().value(),
-            characteristic->GetIdentifier());
+  EXPECT_EQ(
+      fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
+          .value(),
+      characteristic->GetIdentifier());
   EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
   characteristic->ReadRemoteCharacteristic(
-      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
+      base::Bind(&BluetoothGattBlueZTest::ValueCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(4, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(ValuesEqual(characteristic->GetValue(), last_read_value_));
 
   // Test long-running actions.
   fake_bluetooth_gatt_characteristic_client_->SetExtraProcessing(1);
   characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
           .value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(
       fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
           .value(),
       characteristic->GetIdentifier());
   EXPECT_EQ(kBodySensorLocationUUID, characteristic->GetUUID());
   characteristic->ReadRemoteCharacteristic(
-      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
+      base::Bind(&BluetoothGattBlueZTest::ValueCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
 
   // Callback counts shouldn't change, this one will be delayed until after
   // tne next one.
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(4, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
 
   // Next read should error because IN_PROGRESS
   characteristic->ReadRemoteCharacteristic(
-      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
+      base::Bind(&BluetoothGattBlueZTest::ValueCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(5, error_callback_count_);
   EXPECT_EQ(BluetoothGattService::GATT_ERROR_IN_PROGRESS, last_service_error_);
 
   // But previous call finished.
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(2, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(ValuesEqual(characteristic->GetValue(), last_read_value_));
   fake_bluetooth_gatt_characteristic_client_->SetExtraProcessing(0);
 
   // Test unauthorized actions.
   fake_bluetooth_gatt_characteristic_client_->SetAuthorized(false);
   characteristic->ReadRemoteCharacteristic(
-      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
+      base::Bind(&BluetoothGattBlueZTest::ValueCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(6, error_callback_count_);
   EXPECT_EQ(BluetoothGattService::GATT_ERROR_NOT_AUTHORIZED,
             last_service_error_);
   EXPECT_EQ(2, observer.gatt_characteristic_value_changed_count());
   fake_bluetooth_gatt_characteristic_client_->SetAuthorized(true);
 
   // Test unauthenticated / needs login.
   fake_bluetooth_gatt_characteristic_client_->SetAuthenticated(false);
   characteristic->ReadRemoteCharacteristic(
-      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
+      base::Bind(&BluetoothGattBlueZTest::ValueCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(7, error_callback_count_);
   EXPECT_EQ(BluetoothGattService::GATT_ERROR_NOT_PAIRED, last_service_error_);
   EXPECT_EQ(2, observer.gatt_characteristic_value_changed_count());
   fake_bluetooth_gatt_characteristic_client_->SetAuthenticated(true);
 }
 
-TEST_F(BluetoothGattChromeOSTest, GattCharacteristicProperties) {
+TEST_F(BluetoothGattBlueZTest, GattCharacteristicProperties) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
   // characteristics.
   fake_bluetooth_gatt_service_client_->ExposeHeartRateService(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
 
   BluetoothGattService* service =
       device->GetGattService(observer.last_gatt_service_id());
 
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
 
-  BluetoothGattCharacteristic *characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetBodySensorLocationPath().value());
+  BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
+      fake_bluetooth_gatt_characteristic_client_->GetBodySensorLocationPath()
+          .value());
   EXPECT_EQ(BluetoothGattCharacteristic::PROPERTY_READ,
             characteristic->GetProperties());
 
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateControlPointPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateControlPointPath()
+          .value());
   EXPECT_EQ(BluetoothGattCharacteristic::PROPERTY_WRITE,
             characteristic->GetProperties());
 
   characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateMeasurementPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
+          .value());
   EXPECT_EQ(BluetoothGattCharacteristic::PROPERTY_NOTIFY,
             characteristic->GetProperties());
 }
 
-TEST_F(BluetoothGattChromeOSTest, GattDescriptorValue) {
+TEST_F(BluetoothGattBlueZTest, GattDescriptorValue) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
@@ skipping 10 matching lines @@
   EXPECT_EQ(0, observer.gatt_descriptor_value_changed_count());
   EXPECT_TRUE(service->GetCharacteristics().empty());
 
   // Run the message loop so that the characteristics appear.
   base::MessageLoop::current()->Run();
   EXPECT_EQ(0, observer.gatt_service_changed_count());
   EXPECT_EQ(1, observer.gatt_discovery_complete_count());
 
   // Only the Heart Rate Measurement characteristic has a descriptor.
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
-      fake_bluetooth_gatt_characteristic_client_->
-          GetHeartRateMeasurementPath().value());
+      fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
+          .value());
   ASSERT_TRUE(characteristic);
   EXPECT_EQ(1U, characteristic->GetDescriptors().size());
   EXPECT_FALSE(characteristic->IsNotifying());
 
   BluetoothGattDescriptor* descriptor = characteristic->GetDescriptors()[0];
   EXPECT_FALSE(descriptor->IsLocal());
   EXPECT_EQ(BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid(),
             descriptor->GetUUID());
 
   std::vector<uint8_t> desc_value = {0x00, 0x00};
 
   /* The cached value will be empty until the first read request */
   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
   EXPECT_TRUE(descriptor->GetValue().empty());
 
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(last_read_value_.empty());
 
   // Read value. GattDescriptorValueChanged event will be sent after a
   // successful read.
   descriptor->ReadRemoteDescriptor(
-      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
+      base::Bind(&BluetoothGattBlueZTest::ValueCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_TRUE(ValuesEqual(desc_value, descriptor->GetValue()));
   EXPECT_EQ(0, observer.gatt_service_changed_count());
   EXPECT_EQ(1, observer.gatt_descriptor_value_changed_count());
 
   // Write value. Writes to this descriptor will fail.
   desc_value[0] = 0x03;
   descriptor->WriteRemoteDescriptor(
-      desc_value,
-      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
-                 base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      desc_value, base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
+                             base::Unretained(this)),
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothGattService::GATT_ERROR_NOT_PERMITTED,
             last_service_error_);
   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
   EXPECT_EQ(0, observer.gatt_service_changed_count());
   EXPECT_EQ(1, observer.gatt_descriptor_value_changed_count());
 
   // Read value. The value should remain unchanged.
   descriptor->ReadRemoteDescriptor(
-      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
+      base::Bind(&BluetoothGattBlueZTest::ValueCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
   EXPECT_EQ(0, observer.gatt_service_changed_count());
   EXPECT_EQ(1, observer.gatt_descriptor_value_changed_count());
 
   // Start notifications on the descriptor's characteristic. The descriptor
   // value should change.
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   base::MessageLoop::current()->Run();
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Read the new descriptor value. We should receive a value updated event.
   descriptor->ReadRemoteDescriptor(
-      base::Bind(&BluetoothGattChromeOSTest::ValueCallback,
+      base::Bind(&BluetoothGattBlueZTest::ValueCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
   EXPECT_EQ(0, observer.gatt_service_changed_count());
   EXPECT_EQ(2, observer.gatt_descriptor_value_changed_count());
 }
 
-TEST_F(BluetoothGattChromeOSTest, NotifySessions) {
+TEST_F(BluetoothGattBlueZTest, NotifySessions) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
@@ skipping 12 matching lines @@
 
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
           .value());
   ASSERT_TRUE(characteristic);
   EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   // Request to start notifications.
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
 
   // The operation still hasn't completed but we should have received the first
   // notification.
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(update_sessions_.empty());
 
   // Send a two more requests, which should get queued.
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(update_sessions_.empty());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Run the main loop. The initial call should complete. The queued call should
   // succeed immediately.
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_EQ(3U, update_sessions_.size());
 
   // Notifications should be getting sent regularly now.
   base::MessageLoop::current()->Run();
   EXPECT_GT(observer.gatt_characteristic_value_changed_count(), 1);
 
   // Stop one of the sessions. The session should become inactive but the
   // characteristic should still be notifying.
   BluetoothGattNotifySession* session = update_sessions_[0];
   EXPECT_TRUE(session->IsActive());
-  session->Stop(base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
+  session->Stop(base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
                            base::Unretained(this)));
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(session->IsActive());
   EXPECT_EQ(characteristic->GetIdentifier(),
             session->GetCharacteristicIdentifier());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Delete another session. Characteristic should still be notifying.
   update_sessions_.pop_back();
   EXPECT_EQ(2U, update_sessions_.size());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_FALSE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(update_sessions_[1]->IsActive());
 
   // Clear the last session.
   update_sessions_.clear();
   EXPECT_TRUE(update_sessions_.empty());
   EXPECT_FALSE(characteristic->IsNotifying());
 
   success_callback_count_ = 0;
   observer.Reset();
 
   // Enable notifications again.
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(update_sessions_.empty());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Run the message loop. Notifications should begin.
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Check that notifications are happening.
   base::MessageLoop::current()->Run();
   EXPECT_GT(observer.gatt_characteristic_value_changed_count(), 1);
 
   // Request another session. This should return immediately.
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(2U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
   EXPECT_TRUE(update_sessions_[1]->IsActive());
   EXPECT_TRUE(characteristic->IsNotifying());
 
   // Hide the characteristic. The sessions should become inactive.
   fake_bluetooth_gatt_characteristic_client_->HideHeartRateCharacteristics();
   EXPECT_EQ(2U, update_sessions_.size());
   EXPECT_FALSE(update_sessions_[0]->IsActive());
   EXPECT_FALSE(update_sessions_[1]->IsActive());
 }
 
-TEST_F(BluetoothGattChromeOSTest, NotifySessionsMadeInactive) {
+TEST_F(BluetoothGattBlueZTest, NotifySessionsMadeInactive) {
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Expose the fake Heart Rate service. This will asynchronously expose
@@ skipping 12 matching lines @@
 
   BluetoothGattCharacteristic* characteristic = service->GetCharacteristic(
       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath()
           .value());
   ASSERT_TRUE(characteristic);
   EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   // Send several requests to start notifications.
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
 
   // The operation still hasn't completed but we should have received the first
   // notification.
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   // Run the main loop. The initial call should complete. The queued calls
   // should succeed immediately.
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(4U, update_sessions_.size());
 
   for (int i = 0; i < 4; i++)
     EXPECT_TRUE(update_sessions_[0]->IsActive());
 
   // Stop notifications directly through the client. The sessions should get
   // marked as inactive.
   fake_bluetooth_gatt_characteristic_client_->StopNotify(
       fake_bluetooth_gatt_characteristic_client_->GetHeartRateMeasurementPath(),
-      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
+      base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::DBusErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::DBusErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(5, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(characteristic->IsNotifying());
   EXPECT_EQ(4U, update_sessions_.size());
 
   for (int i = 0; i < 4; i++)
     EXPECT_FALSE(update_sessions_[0]->IsActive());
 
   // It should be possible to restart notifications and the call should reset
   // the session count and make a request through the client.
   update_sessions_.clear();
   success_callback_count_ = 0;
   observer.Reset();
   characteristic->StartNotifySession(
-      base::Bind(&BluetoothGattChromeOSTest::NotifySessionCallback,
+      base::Bind(&BluetoothGattBlueZTest::NotifySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothGattChromeOSTest::ServiceErrorCallback,
+      base::Bind(&BluetoothGattBlueZTest::ServiceErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(0, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_TRUE(update_sessions_.empty());
 
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
 }
 
-}  // namespace chromeos
+}  // namespace bluez