Reland "Add Linux support for the Bluetooth API"

device/bluetooth/bluetooth_bluez_unittest.cc

 // Copyright 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 "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
-#include "device/bluetooth/bluetooth_adapter_chromeos.h"
+#include "device/bluetooth/bluetooth_adapter_bluez.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
-#include "device/bluetooth/bluetooth_device_chromeos.h"
+#include "device/bluetooth/bluetooth_device_bluez.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
-#include "device/bluetooth/bluetooth_pairing_chromeos.h"
+#include "device/bluetooth/bluetooth_pairing_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_device_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_service_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_input_client.h"
 #include "device/bluetooth/test/test_bluetooth_adapter_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothAudioSink;
 using device::BluetoothDevice;
 using device::BluetoothDiscoveryFilter;
 using device::BluetoothDiscoverySession;
 using device::BluetoothUUID;
 using device::TestBluetoothAdapterObserver;
 
-namespace chromeos {
+namespace bluez {
 
 namespace {
 
 // Callback for BluetoothDevice::GetConnectionInfo() that simply saves the
 // connection info to the bound argument.
 void SaveConnectionInfo(BluetoothDevice::ConnectionInfo* out,
                         const BluetoothDevice::ConnectionInfo& conn_info) {
   *out = conn_info;
 };
 
@@ skipping 109 matching lines @@
   // Some tests use a message loop since background processing is simulated;
   // break out of those loops.
   void QuitMessageLoop() {
     if (base::MessageLoop::current() &&
         base::MessageLoop::current()->is_running()) {
       base::MessageLoop::current()->QuitWhenIdle();
     }
   }
 };
 
-class BluetoothChromeOSTest : public testing::Test {
+class BluetoothBlueZTest : public testing::Test {
  public:
   void SetUp() override {
     scoped_ptr<bluez::BluezDBusManagerSetter> dbus_setter =
         bluez::BluezDBusManager::GetSetterForTesting();
     // We need to initialize BluezDBusManager early to prevent
     // Bluetooth*::Create() methods from picking the real instead of fake
     // implementations.
     fake_bluetooth_adapter_client_ = new bluez::FakeBluetoothAdapterClient;
     dbus_setter->SetBluetoothAdapterClient(
         scoped_ptr<bluez::BluetoothAdapterClient>(
@@ skipping 15 matching lines @@
     fake_bluetooth_adapter_client_->SetSimulationIntervalMs(10);
 
     callback_count_ = 0;
     error_callback_count_ = 0;
     last_connect_error_ = BluetoothDevice::ERROR_UNKNOWN;
     last_client_error_ = "";
   }
 
   void TearDown() override {
     for (ScopedVector<BluetoothDiscoverySession>::iterator iter =
-            discovery_sessions_.begin();
-         iter != discovery_sessions_.end();
-         ++iter) {
+             discovery_sessions_.begin();
+         iter != discovery_sessions_.end(); ++iter) {
       BluetoothDiscoverySession* session = *iter;
       if (!session->IsActive())
         continue;
       callback_count_ = 0;
       session->Stop(GetCallback(), GetErrorCallback());
       message_loop_.Run();
       ASSERT_EQ(1, callback_count_);
     }
     discovery_sessions_.clear();
     adapter_ = nullptr;
     bluez::BluezDBusManager::Shutdown();
   }
 
   // Generic callbacks
   void Callback() {
     ++callback_count_;
     QuitMessageLoop();
   }
 
   base::Closure GetCallback() {
-    return base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this));
+    return base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this));
   }
 
   void DiscoverySessionCallback(
       scoped_ptr<BluetoothDiscoverySession> discovery_session) {
     ++callback_count_;
     discovery_sessions_.push_back(discovery_session.release());
     QuitMessageLoop();
   }
 
   void AudioSinkAcquiredCallback(scoped_refptr<BluetoothAudioSink>) {
     ++callback_count_;
     QuitMessageLoop();
   }
 
-  void ProfileRegisteredCallback(BluetoothAdapterProfileChromeOS* profile) {
+  void ProfileRegisteredCallback(BluetoothAdapterProfileBlueZ* profile) {
     adapter_profile_ = profile;
     ++callback_count_;
     QuitMessageLoop();
   }
 
   void ErrorCallback() {
     ++error_callback_count_;
     QuitMessageLoop();
   }
 
   void DiscoveryErrorCallback(device::UMABluetoothDiscoverySessionOutcome) {
     ErrorCallback();
   }
 
   base::Closure GetErrorCallback() {
-    return base::Bind(&BluetoothChromeOSTest::ErrorCallback,
+    return base::Bind(&BluetoothBlueZTest::ErrorCallback,
                       base::Unretained(this));
   }
 
   base::Callback<void(device::UMABluetoothDiscoverySessionOutcome)>
   GetDiscoveryErrorCallback() {
-    return base::Bind(&BluetoothChromeOSTest::DiscoveryErrorCallback,
+    return base::Bind(&BluetoothBlueZTest::DiscoveryErrorCallback,
                       base::Unretained(this));
   }
 
   void DBusErrorCallback(const std::string& error_name,
                          const std::string& error_message) {
     ++error_callback_count_;
     last_client_error_ = error_name;
     QuitMessageLoop();
   }
 
   void ConnectErrorCallback(BluetoothDevice::ConnectErrorCode error) {
     ++error_callback_count_;
     last_connect_error_ = error;
   }
 
   void AudioSinkErrorCallback(BluetoothAudioSink::ErrorCode) {
     ++error_callback_count_;
     QuitMessageLoop();
   }
 
   void ErrorCompletionCallback(const std::string& error_message) {
     ++error_callback_count_;
     QuitMessageLoop();
   }
 
   // Call to fill the adapter_ member with a BluetoothAdapter instance.
   void GetAdapter() {
-    adapter_ = new BluetoothAdapterChromeOS();
+    adapter_ = new BluetoothAdapterBlueZ();
     ASSERT_TRUE(adapter_.get() != nullptr);
     ASSERT_TRUE(adapter_->IsInitialized());
   }
 
   // Run a discovery phase until the named device is detected, or if the named
   // device is not created, the discovery process ends without finding it.
   //
   // The correct behavior of discovery is tested by the "Discovery" test case
   // without using this function.
   void DiscoverDevice(const std::string& address) {
     ASSERT_TRUE(adapter_.get() != nullptr);
     ASSERT_TRUE(base::MessageLoop::current() != nullptr);
     fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
     TestBluetoothAdapterObserver observer(adapter_);
 
     adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
     adapter_->StartDiscoverySession(
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         GetErrorCallback());
     base::MessageLoop::current()->Run();
     ASSERT_EQ(2, callback_count_);
     ASSERT_EQ(0, error_callback_count_);
     ASSERT_EQ((size_t)1, discovery_sessions_.size());
     ASSERT_TRUE(discovery_sessions_[0]->IsActive());
     callback_count_ = 0;
 
     ASSERT_TRUE(adapter_->IsPowered());
@@ skipping 23 matching lines @@
   base::MessageLoop message_loop_;
   bluez::FakeBluetoothAdapterClient* fake_bluetooth_adapter_client_;
   bluez::FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
   scoped_refptr<BluetoothAdapter> adapter_;
 
   int callback_count_;
   int error_callback_count_;
   enum BluetoothDevice::ConnectErrorCode last_connect_error_;
   std::string last_client_error_;
   ScopedVector<BluetoothDiscoverySession> discovery_sessions_;
-  BluetoothAdapterProfileChromeOS* adapter_profile_;
+  BluetoothAdapterProfileBlueZ* adapter_profile_;
 
  private:
   // Some tests use a message loop since background processing is simulated;
   // break out of those loops.
   void QuitMessageLoop() {
     if (base::MessageLoop::current() &&
         base::MessageLoop::current()->is_running()) {
       base::MessageLoop::current()->QuitWhenIdle();
     }
   }
 };
 
-TEST_F(BluetoothChromeOSTest, AlreadyPresent) {
+TEST_F(BluetoothBlueZTest, AlreadyPresent) {
   GetAdapter();
 
   // This verifies that the class gets the list of adapters when created;
   // and initializes with an existing adapter if there is one.
   EXPECT_TRUE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
   EXPECT_EQ(bluez::FakeBluetoothAdapterClient::kAdapterAddress,
             adapter_->GetAddress());
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // There should be 2 devices
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   EXPECT_EQ(2U, devices.size());
 
   // |devices| are not ordered, verify it contains the 2 device addresses.
   EXPECT_NE(
       -1, GetDeviceIndexByAddress(
               devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress));
   EXPECT_NE(
       -1,
       GetDeviceIndexByAddress(
           devices,
           bluez::FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress));
 }
 
-TEST_F(BluetoothChromeOSTest, BecomePresent) {
+TEST_F(BluetoothBlueZTest, BecomePresent) {
   fake_bluetooth_adapter_client_->SetVisible(false);
   GetAdapter();
   ASSERT_FALSE(adapter_->IsPresent());
 
   // Install an observer; expect the AdapterPresentChanged to be called
   // with true, and IsPresent() to return true.
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(true);
 
   EXPECT_EQ(1, observer.present_changed_count());
   EXPECT_TRUE(observer.last_present());
 
   EXPECT_TRUE(adapter_->IsPresent());
 
   // We should have had a device announced.
   EXPECT_EQ(2, observer.device_added_count());
   EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress,
             observer.last_device_address());
 
   // Other callbacks shouldn't be called if the values are false.
   EXPECT_EQ(0, observer.powered_changed_count());
   EXPECT_EQ(0, observer.discovering_changed_count());
   EXPECT_FALSE(adapter_->IsPowered());
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
-TEST_F(BluetoothChromeOSTest, BecomeNotPresent) {
+TEST_F(BluetoothBlueZTest, BecomeNotPresent) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
 
   // Install an observer; expect the AdapterPresentChanged to be called
   // with false, and IsPresent() to return false.
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count());
@@ skipping 10 matching lines @@
               address.compare(
                   bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress) == 0);
 
   // Other callbacks shouldn't be called since the values are false.
   EXPECT_EQ(0, observer.powered_changed_count());
   EXPECT_EQ(0, observer.discovering_changed_count());
   EXPECT_FALSE(adapter_->IsPowered());
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
-TEST_F(BluetoothChromeOSTest, SecondAdapter) {
+TEST_F(BluetoothBlueZTest, SecondAdapter) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
 
   // Install an observer, then add a second adapter. Nothing should change,
   // we ignore the second adapter.
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetSecondVisible(true);
 
   EXPECT_EQ(0, observer.present_changed_count());
@@ skipping 30 matching lines @@
   observer.Reset();
 
   // Removing the second adapter shouldn't set anything either.
   fake_bluetooth_adapter_client_->SetSecondVisible(false);
 
   EXPECT_EQ(0, observer.device_removed_count());
   EXPECT_EQ(0, observer.powered_changed_count());
   EXPECT_EQ(0, observer.discovering_changed_count());
 }
 
-TEST_F(BluetoothChromeOSTest, BecomePowered) {
+TEST_F(BluetoothBlueZTest, BecomePowered) {
   GetAdapter();
   ASSERT_FALSE(adapter_->IsPowered());
 
   // Install an observer; expect the AdapterPoweredChanged to be called
   // with true, and IsPowered() to return true.
   TestBluetoothAdapterObserver observer(adapter_);
 
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.powered_changed_count());
   EXPECT_TRUE(observer.last_powered());
 
   EXPECT_TRUE(adapter_->IsPowered());
 }
 
-TEST_F(BluetoothChromeOSTest, BecomeNotPowered) {
+TEST_F(BluetoothBlueZTest, BecomeNotPowered) {
   GetAdapter();
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
 
   // Install an observer; expect the AdapterPoweredChanged to be called
   // with false, and IsPowered() to return false.
   TestBluetoothAdapterObserver observer(adapter_);
 
   adapter_->SetPowered(false, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.powered_changed_count());
   EXPECT_FALSE(observer.last_powered());
 
   EXPECT_FALSE(adapter_->IsPowered());
 }
 
-TEST_F(BluetoothChromeOSTest, SetPoweredWhenNotPresent) {
+TEST_F(BluetoothBlueZTest, SetPoweredWhenNotPresent) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
 
   // Install an observer; expect the AdapterPresentChanged to be called
   // with false, and IsPresent() to return false.
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count());
   EXPECT_FALSE(observer.last_present());
 
   EXPECT_FALSE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
 
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.powered_changed_count());
   EXPECT_FALSE(observer.last_powered());
 
   EXPECT_FALSE(adapter_->IsPowered());
 }
 
-TEST_F(BluetoothChromeOSTest, ChangeAdapterName) {
+TEST_F(BluetoothBlueZTest, ChangeAdapterName) {
   GetAdapter();
 
   static const std::string new_name(".__.");
 
   adapter_->SetName(new_name, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(new_name, adapter_->GetName());
 }
 
-TEST_F(BluetoothChromeOSTest, ChangeAdapterNameWhenNotPresent) {
+TEST_F(BluetoothBlueZTest, ChangeAdapterNameWhenNotPresent) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
 
   // Install an observer; expect the AdapterPresentChanged to be called
   // with false, and IsPresent() to return false.
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count());
   EXPECT_FALSE(observer.last_present());
 
   EXPECT_FALSE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
 
   adapter_->SetName("^o^", GetCallback(), GetErrorCallback());
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ("", adapter_->GetName());
 }
 
-TEST_F(BluetoothChromeOSTest, BecomeDiscoverable) {
+TEST_F(BluetoothBlueZTest, BecomeDiscoverable) {
   GetAdapter();
   ASSERT_FALSE(adapter_->IsDiscoverable());
 
   // Install an observer; expect the AdapterDiscoverableChanged to be called
   // with true, and IsDiscoverable() to return true.
   TestBluetoothAdapterObserver observer(adapter_);
 
   adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.discoverable_changed_count());
 
   EXPECT_TRUE(adapter_->IsDiscoverable());
 }
 
-TEST_F(BluetoothChromeOSTest, BecomeNotDiscoverable) {
+TEST_F(BluetoothBlueZTest, BecomeNotDiscoverable) {
   GetAdapter();
   adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsDiscoverable());
 
   // Install an observer; expect the AdapterDiscoverableChanged to be called
   // with false, and IsDiscoverable() to return false.
   TestBluetoothAdapterObserver observer(adapter_);
 
   adapter_->SetDiscoverable(false, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.discoverable_changed_count());
 
   EXPECT_FALSE(adapter_->IsDiscoverable());
 }
 
-TEST_F(BluetoothChromeOSTest, SetDiscoverableWhenNotPresent) {
+TEST_F(BluetoothBlueZTest, SetDiscoverableWhenNotPresent) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
   ASSERT_FALSE(adapter_->IsDiscoverable());
 
   // Install an observer; expect the AdapterDiscoverableChanged to be called
   // with true, and IsDiscoverable() to return true.
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count());
   EXPECT_FALSE(observer.last_present());
 
   EXPECT_FALSE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsDiscoverable());
 
   adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.discoverable_changed_count());
 
   EXPECT_FALSE(adapter_->IsDiscoverable());
 }
 
-TEST_F(BluetoothChromeOSTest, StopDiscovery) {
+TEST_F(BluetoothBlueZTest, StopDiscovery) {
   GetAdapter();
 
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
@@ skipping 13 matching lines @@
   EXPECT_FALSE(observer.last_discovering());
 
   EXPECT_FALSE(adapter_->IsDiscovering());
   discovery_sessions_.clear();
   callback_count_ = 0;
 
   // Test that the Stop callbacks get called even if the
   // BluetoothDiscoverySession objects gets deleted
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
 
   discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
   discovery_sessions_.clear();
 
   message_loop_.Run();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 
-TEST_F(BluetoothChromeOSTest, Discovery) {
+TEST_F(BluetoothBlueZTest, Discovery) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
@@ skipping 12 matching lines @@
 
   // Okay, let's run forward until a device is actually removed...
   while (!observer.device_removed_count())
     message_loop_.Run();
 
   EXPECT_EQ(1, observer.device_removed_count());
   EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kVanishingDeviceAddress,
             observer.last_device_address());
 }
 
-TEST_F(BluetoothChromeOSTest, PoweredAndDiscovering) {
+TEST_F(BluetoothBlueZTest, PoweredAndDiscovering) {
   GetAdapter();
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Stop the timers that the simulation uses
@@ skipping 41 matching lines @@
   EXPECT_FALSE(observer.last_powered());
   EXPECT_FALSE(adapter_->IsPowered());
 
   EXPECT_EQ(1, observer.discovering_changed_count());
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 // This unit test asserts that the basic reference counting logic works
 // correctly for discovery requests done via the BluetoothAdapter.
-TEST_F(BluetoothChromeOSTest, MultipleDiscoverySessions) {
+TEST_F(BluetoothBlueZTest, MultipleDiscoverySessions) {
   GetAdapter();
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count());
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     adapter_->StartDiscoverySession(
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
 
   // The observer should have received the discovering changed event exactly
   // once, the success callback should have been called 3 times and the adapter
   // should be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count());
@@ skipping 17 matching lines @@
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
   EXPECT_FALSE(discovery_sessions_[1]->IsActive());
   EXPECT_TRUE(discovery_sessions_[2]->IsActive());
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     adapter_->StartDiscoverySession(
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         GetErrorCallback());
   }
 
   // The observer should have received no additional discovering changed events,
   // the success callback should have been called 3 times and the adapter should
   // still be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count());
   EXPECT_EQ(8, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 28 matching lines @@
   EXPECT_EQ(2, observer.discovering_changed_count());
   EXPECT_EQ(12, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 // This unit test asserts that the reference counting logic works correctly in
 // the cases when the adapter gets reset and D-Bus calls are made outside of
 // the BluetoothAdapter.
-TEST_F(BluetoothChromeOSTest,
-       UnexpectedChangesDuringMultipleDiscoverySessions) {
+TEST_F(BluetoothBlueZTest, UnexpectedChangesDuringMultipleDiscoverySessions) {
   GetAdapter();
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count());
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     adapter_->StartDiscoverySession(
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
 
   // The observer should have received the discovering changed event exactly
   // once, the success callback should have been called 3 times and the adapter
   // should be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count());
@@ skipping 16 matching lines @@
   // Stop device discovery behind the adapter. The adapter and the observer
   // should be notified of the change and the reference count should be reset.
   // Even though bluez::FakeBluetoothAdapterClient does its own reference
   // counting and
   // we called 3 BluetoothAdapter::StartDiscoverySession 3 times, the
   // bluez::FakeBluetoothAdapterClient's count should be only 1 and a single
   // call to
   // bluez::FakeBluetoothAdapterClient::StopDiscovery should work.
   fake_bluetooth_adapter_client_->StopDiscovery(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
-      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                 base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(2, observer.discovering_changed_count());
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // All discovery session instances should have been updated.
   for (int i = 0; i < 3; i++)
     EXPECT_FALSE(discovery_sessions_[i]->IsActive());
   discovery_sessions_.clear();
 
   // It should be possible to successfully start discovery.
   for (int i = 0; i < 2; i++) {
     adapter_->StartDiscoverySession(
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
   EXPECT_EQ(3, observer.discovering_changed_count());
   EXPECT_EQ(6, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
@@ skipping 27 matching lines @@
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
 
   // Start and stop discovery. At this point, bluez::FakeBluetoothAdapterClient
   // has
   // a reference count that is equal to 1. Pretend that this was done by an
   // application other than us. Starting and stopping discovery will succeed
   // but it won't cause the discovery state to change.
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();  // Run the loop, as there should have been a D-Bus call.
   EXPECT_EQ(5, observer.discovering_changed_count());
   EXPECT_EQ(7, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
 
   discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
   message_loop_.Run();  // Run the loop, as there should have been a D-Bus call.
   EXPECT_EQ(5, observer.discovering_changed_count());
   EXPECT_EQ(8, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
   discovery_sessions_.clear();
 
   // Start discovery again.
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();  // Run the loop, as there should have been a D-Bus call.
   EXPECT_EQ(5, observer.discovering_changed_count());
   EXPECT_EQ(9, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Stop discovery via D-Bus. The fake client's reference count will drop but
   // the discovery state won't change since our BluetoothAdapter also just
   // requested it via D-Bus.
   fake_bluetooth_adapter_client_->StopDiscovery(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
-      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                 base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(5, observer.discovering_changed_count());
   EXPECT_EQ(10, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
 
   // Now end the discovery session. This should change the adapter's discovery
   // state.
   discovery_sessions_[0]->Stop(GetCallback(), GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(6, observer.discovering_changed_count());
   EXPECT_EQ(11, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
 }
 
-TEST_F(BluetoothChromeOSTest, InvalidatedDiscoverySessions) {
+TEST_F(BluetoothBlueZTest, InvalidatedDiscoverySessions) {
   GetAdapter();
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count());
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     adapter_->StartDiscoverySession(
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         GetErrorCallback());
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
 
   // The observer should have received the discovering changed event exactly
   // once, the success callback should have been called 3 times and the adapter
   // should be discovering.
   EXPECT_EQ(1, observer.discovering_changed_count());
@@ skipping 19 matching lines @@
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
   EXPECT_TRUE(adapter_->IsDiscovering());
 
   // Stop device discovery behind the adapter. The one active discovery session
   // should become inactive, but more importantly, we shouldn't run into any
   // memory errors as the sessions that we explicitly deleted should get
   // cleaned up.
   fake_bluetooth_adapter_client_->StopDiscovery(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
-      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                 base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(2, observer.discovering_changed_count());
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_FALSE(discovery_sessions_[0]->IsActive());
 }
 
-TEST_F(BluetoothChromeOSTest, QueuedDiscoveryRequests) {
+TEST_F(BluetoothBlueZTest, QueuedDiscoveryRequests) {
   GetAdapter();
 
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count());
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // Request to start discovery. The call should be pending.
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   EXPECT_EQ(0, callback_count_);
 
   fake_bluetooth_device_client_->EndDiscoverySimulation(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath));
 
   // The underlying adapter has started discovery, but our call hasn't returned
   // yet.
   EXPECT_EQ(1, observer.discovering_changed_count());
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(discovery_sessions_.empty());
 
   // Request to start discovery twice. These should get queued and there should
   // be no change in state.
   for (int i = 0; i < 2; i++) {
     adapter_->StartDiscoverySession(
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         GetErrorCallback());
   }
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.discovering_changed_count());
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_TRUE(discovery_sessions_.empty());
 
@@ skipping 25 matching lines @@
   discovery_sessions_[2]->Stop(GetCallback(), GetErrorCallback());
   EXPECT_EQ(5, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(2, observer.discovering_changed_count());
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_TRUE(discovery_sessions_[2]->IsActive());
 
   // Request to start should get queued.
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   EXPECT_EQ(5, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(2, observer.discovering_changed_count());
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
 
   // Run the pending request.
@@ skipping 11 matching lines @@
   message_loop_.Run();
   EXPECT_EQ(7, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(3, observer.discovering_changed_count());
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)4, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[3]->IsActive());
 }
 
-TEST_F(BluetoothChromeOSTest, StartDiscoverySession) {
+TEST_F(BluetoothBlueZTest, StartDiscoverySession) {
   GetAdapter();
 
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   EXPECT_EQ(0, observer.discovering_changed_count());
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_TRUE(discovery_sessions_.empty());
 
   // Request a new discovery session.
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count());
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Start another session. A new one should be returned in the callback, which
   // in turn will destroy the previous session. Adapter should still be
   // discovering and the reference count should be 1.
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count());
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)2, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[0]->IsActive());
 
   // Request a new session.
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   message_loop_.Run();
   EXPECT_EQ(1, observer.discovering_changed_count());
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(observer.last_discovering());
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
   EXPECT_TRUE(discovery_sessions_[1]->IsActive());
@@ skipping 17 matching lines @@
   while (observer.last_discovering())
     message_loop_.RunUntilIdle();
 
   EXPECT_EQ(2, observer.discovering_changed_count());
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering());
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
-TEST_F(BluetoothChromeOSTest, SetDiscoveryFilterBeforeStartDiscovery) {
+TEST_F(BluetoothBlueZTest, SetDiscoveryFilterBeforeStartDiscovery) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
+  adapter_->SetPowered(
+      true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
   ASSERT_TRUE(df->Equals(*discovery_sessions_[0]->GetDiscoveryFilter()));
 
   auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_NE(nullptr, filter);
   EXPECT_EQ("le", *filter->transport);
   EXPECT_EQ(-60, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   std::vector<std::string> uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
 
   discovery_sessions_[0]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_FALSE(discovery_sessions_[0]->IsActive());
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(),
             (BluetoothDiscoveryFilter*)nullptr);
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
-TEST_F(BluetoothChromeOSTest, SetDiscoveryFilterBeforeStartDiscoveryFail) {
+TEST_F(BluetoothBlueZTest, SetDiscoveryFilterBeforeStartDiscoveryFail) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
+  adapter_->SetPowered(
+      true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
   EXPECT_EQ(1, callback_count_);
   callback_count_ = 0;
 
   fake_bluetooth_adapter_client_->MakeSetDiscoveryFilterFail();
 
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(1, error_callback_count_);
   error_callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)0, discovery_sessions_.size());
 
   auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 // This test queues two requests to StartDiscovery with pre set filter. This
 // should result in SetDiscoveryFilter, then StartDiscovery, and SetDiscovery
 // DBus calls
-TEST_F(BluetoothChromeOSTest, QueuedSetDiscoveryFilterBeforeStartDiscovery) {
+TEST_F(BluetoothBlueZTest, QueuedSetDiscoveryFilterBeforeStartDiscovery) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
   df2->SetRSSI(-65);
   df2->AddUUID(BluetoothUUID("1002"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
+  adapter_->SetPowered(
+      true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   // Queue two requests to start discovery session with filter.
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter2.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   // Run requests, on DBus level there should be call SetDiscoveryFilter, then
   // StartDiscovery, then SetDiscoveryFilter again.
   message_loop_.Run();
   message_loop_.Run();
 
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)2, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
   ASSERT_TRUE(df->Equals(*discovery_sessions_[0]->GetDiscoveryFilter()));
   ASSERT_TRUE(discovery_sessions_[1]->IsActive());
   ASSERT_TRUE(df2->Equals(*discovery_sessions_[1]->GetDiscoveryFilter()));
 
   auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_NE(nullptr, filter);
   EXPECT_EQ("auto", *filter->transport);
   EXPECT_EQ(-65, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   auto uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1002"));
 
   discovery_sessions_[0]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   discovery_sessions_[1]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_FALSE(discovery_sessions_[0]->IsActive());
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(),
             (BluetoothDiscoveryFilter*)nullptr);
   ASSERT_FALSE(discovery_sessions_[1]->IsActive());
   ASSERT_EQ(discovery_sessions_[1]->GetDiscoveryFilter(),
             (BluetoothDiscoveryFilter*)nullptr);
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 // Call StartFilteredDiscovery twice (2nd time while 1st call is still pending).
 // Make the first SetDiscoveryFilter fail and the second one succeed. It should
 // end up with one active discovery session.
-TEST_F(BluetoothChromeOSTest,
-       QueuedSetDiscoveryFilterBeforeStartDiscoveryFail) {
+TEST_F(BluetoothBlueZTest, QueuedSetDiscoveryFilterBeforeStartDiscoveryFail) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
   df2->SetRSSI(-65);
   df2->AddUUID(BluetoothUUID("1002"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
+  adapter_->SetPowered(
+      true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   fake_bluetooth_adapter_client_->MakeSetDiscoveryFilterFail();
 
   // Queue two requests to start discovery session with filter.
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter2.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   // First request to SetDiscoveryFilter should fail, resulting in no session
   // being created.
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   error_callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
@@ skipping 14 matching lines @@
 
   auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_NE(nullptr, filter);
   EXPECT_EQ("bredr", *filter->transport);
   EXPECT_EQ(-65, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   auto uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1002"));
 
   discovery_sessions_[0]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_FALSE(discovery_sessions_[0]->IsActive());
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(),
             (BluetoothDiscoveryFilter*)nullptr);
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
-TEST_F(BluetoothChromeOSTest, SetDiscoveryFilterAfterStartDiscovery) {
+TEST_F(BluetoothBlueZTest, SetDiscoveryFilterAfterStartDiscovery) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
+  adapter_->SetPowered(
+      true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
   EXPECT_EQ(1, observer.discovering_changed_count());
   observer.Reset();
 
   auto null_instance = scoped_ptr<BluetoothDiscoveryFilter>();
   null_instance.reset();
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(), null_instance.get());
 
   auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 
   BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   discovery_sessions_[0]->SetDiscoveryFilter(
       discovery_filter.Pass(),
-      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(df->Equals(*discovery_sessions_[0]->GetDiscoveryFilter()));
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_NE(nullptr, filter);
   EXPECT_EQ("le", *filter->transport);
   EXPECT_EQ(-60, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   std::vector<std::string> uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
 
   discovery_sessions_[0]->Stop(
-      base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_FALSE(discovery_sessions_[0]->IsActive());
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(),
             (BluetoothDiscoveryFilter*)nullptr);
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 // This unit test asserts that the basic reference counting, and filter merging
 // works correctly for discovery requests done via the BluetoothAdapter.
-TEST_F(BluetoothChromeOSTest, SetDiscoveryFilterBeforeStartDiscoveryMultiple) {
+TEST_F(BluetoothBlueZTest, SetDiscoveryFilterBeforeStartDiscoveryMultiple) {
   GetAdapter();
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
+  adapter_->SetPowered(
+      true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Request device discovery with pre-set filter 3 times.
   for (int i = 0; i < 3; i++) {
     scoped_ptr<BluetoothDiscoveryFilter> discovery_filter;
@@ skipping 14 matching lines @@
       BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
           BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
       df->SetRSSI(-65);
       df->AddUUID(BluetoothUUID("1020"));
       df->AddUUID(BluetoothUUID("1003"));
       discovery_filter.reset(df);
     }
 
     adapter_->StartDiscoverySessionWithFilter(
         discovery_filter.Pass(),
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
-        base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                   base::Unretained(this)));
+        base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
     message_loop_.Run();
 
     if (i == 0) {
       EXPECT_EQ(1, observer.discovering_changed_count());
       observer.Reset();
 
       auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-85, *filter->rssi);
@@ skipping 26 matching lines @@
   // be discovering.
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
 
   callback_count_ = 0;
   // Request to stop discovery twice.
   for (int i = 0; i < 2; i++) {
     discovery_sessions_[i]->Stop(
-        base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-        base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                   base::Unretained(this)));
+        base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+        base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
     message_loop_.Run();
 
     if (i == 0) {
       auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-65, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_EQ(3UL, uuids.size());
       EXPECT_EQ(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
@@ skipping 53 matching lines @@
       BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
           BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
       df->SetRSSI(-65);
       df->AddUUID(BluetoothUUID("1020"));
       df->AddUUID(BluetoothUUID("1003"));
       discovery_filter.reset(df);
     }
 
     adapter_->StartDiscoverySessionWithFilter(
         discovery_filter.Pass(),
-        base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+        base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
-        base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                   base::Unretained(this)));
+        base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
     // each result in 1 requests.
     message_loop_.Run();
 
     if (i == 0) {
       auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-85, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
@@ skipping 17 matching lines @@
   // still be discovering.
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)6, discovery_sessions_.size());
 
   callback_count_ = 0;
   // Request to stop discovery 4 times.
   for (int i = 2; i < 6; i++) {
     discovery_sessions_[i]->Stop(
-        base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-        base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                   base::Unretained(this)));
+        base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+        base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
     // filter no  2 is same as filter no 5, so removing it shouldn't cause any
     // filter update
     if (i != 2 && i != 5)
       message_loop_.Run();
   }
   // Run only once, as there should have been one D-Bus call.
   message_loop_.Run();
 
   // The success callback should have been called 4 times and the adapter should
   // no longer be discovering.
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_EQ(1, observer.discovering_changed_count());
 
   // All discovery sessions should be inactive.
   for (int i = 0; i < 6; i++)
     EXPECT_FALSE(discovery_sessions_[i]->IsActive());
 
   auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 // This unit test asserts that filter merging logic works correctly for filtered
 // discovery requests done via the BluetoothAdapter.
-TEST_F(BluetoothChromeOSTest, SetDiscoveryFilterMergingTest) {
+TEST_F(BluetoothBlueZTest, SetDiscoveryFilterMergingTest) {
   GetAdapter();
-  adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
-                                        base::Unretained(this)),
-                       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                                  base::Unretained(this)));
+  adapter_->SetPowered(
+      true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-15);
   df->AddUUID(BluetoothUUID("1000"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ("le", *filter->transport);
   EXPECT_EQ(-15, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   std::vector<std::string> uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
 
   df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1020"));
   df->AddUUID(BluetoothUUID("1001"));
   discovery_filter = scoped_ptr<BluetoothDiscoveryFilter>(df);
 
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ("le", *filter->transport);
   EXPECT_EQ(-60, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1001"));
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1020"));
 
   BluetoothDiscoveryFilter* df3 = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
   df3->SetRSSI(-65);
   df3->AddUUID(BluetoothUUID("1020"));
   df3->AddUUID(BluetoothUUID("1003"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter3(df3);
 
   adapter_->StartDiscoverySessionWithFilter(
       discovery_filter3.Pass(),
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ("auto", *filter->transport);
   EXPECT_EQ(-65, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1001"));
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1003"));
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1020"));
 
   // start additionally classic scan
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                 base::Unretained(this)));
+      base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ("auto", *filter->transport);
   EXPECT_EQ(nullptr, filter->rssi.get());
   EXPECT_EQ(nullptr, filter->pathloss.get());
   EXPECT_EQ(nullptr, filter->uuids.get());
 
   // Request to stop discovery 4 times.
   for (int i = 3; i >= 0; i--) {
     discovery_sessions_[i]->Stop(
-        base::Bind(&BluetoothChromeOSTest::Callback, base::Unretained(this)),
-        base::Bind(&BluetoothChromeOSTest::ErrorCallback,
-                   base::Unretained(this)));
+        base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
+        base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
     // Every session stopping would trigger filter update
     message_loop_.Run();
   }
 }
 
-TEST_F(BluetoothChromeOSTest, DeviceProperties) {
+TEST_F(BluetoothBlueZTest, DeviceProperties) {
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   ASSERT_EQ(2U, devices.size());
 
   int idx = GetDeviceIndexByAddress(
       devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_NE(-1, idx);
   ASSERT_EQ(bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[idx]->GetAddress());
@@ skipping 14 matching lines @@
   ASSERT_EQ(2U, uuids.size());
   EXPECT_EQ(uuids[0], BluetoothUUID("1800"));
   EXPECT_EQ(uuids[1], BluetoothUUID("1801"));
 
   EXPECT_EQ(BluetoothDevice::VENDOR_ID_USB, devices[idx]->GetVendorIDSource());
   EXPECT_EQ(0x05ac, devices[idx]->GetVendorID());
   EXPECT_EQ(0x030d, devices[idx]->GetProductID());
   EXPECT_EQ(0x0306, devices[idx]->GetDeviceID());
 }
 
-TEST_F(BluetoothChromeOSTest, DeviceClassChanged) {
+TEST_F(BluetoothBlueZTest, DeviceClassChanged) {
   // Simulate a change of class of a device, as sometimes occurs
   // during discovery.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   ASSERT_EQ(2U, devices.size());
 
   int idx = GetDeviceIndexByAddress(
       devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_NE(-1, idx);
   ASSERT_EQ(BluetoothDevice::DEVICE_COMPUTER, devices[idx]->GetDeviceType());
 
   // Install an observer; expect the DeviceChanged method to be called when
   // we change the class of the device.
   TestBluetoothAdapterObserver observer(adapter_);
 
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kPairedDevicePath));
 
   properties->bluetooth_class.ReplaceValue(0x002580);
 
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_EQ(devices[idx], observer.last_device());
 
   EXPECT_EQ(BluetoothDevice::DEVICE_MOUSE, devices[idx]->GetDeviceType());
 }
 
-TEST_F(BluetoothChromeOSTest, DeviceNameChanged) {
+TEST_F(BluetoothBlueZTest, DeviceNameChanged) {
   // Simulate a change of name of a device.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   ASSERT_EQ(2U, devices.size());
 
   int idx = GetDeviceIndexByAddress(
       devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_NE(-1, idx);
   ASSERT_EQ(bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress,
@@ skipping 12 matching lines @@
 
   static const std::string new_name("New Device Name");
   properties->alias.ReplaceValue(new_name);
 
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_EQ(devices[idx], observer.last_device());
 
   EXPECT_EQ(base::UTF8ToUTF16(new_name), devices[idx]->GetName());
 }
 
-TEST_F(BluetoothChromeOSTest, DeviceAddressChanged) {
+TEST_F(BluetoothBlueZTest, DeviceAddressChanged) {
   // Simulate a change of address of a device.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   ASSERT_EQ(2U, devices.size());
 
   int idx = GetDeviceIndexByAddress(
       devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_NE(-1, idx);
   ASSERT_EQ(bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress,
@@ skipping 13 matching lines @@
   static const char* kNewAddress = "D9:1F:FC:11:22:33";
   properties->address.ReplaceValue(kNewAddress);
 
   EXPECT_EQ(1, observer.device_address_changed_count());
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_EQ(devices[idx], observer.last_device());
 
   EXPECT_EQ(std::string(kNewAddress), devices[idx]->GetAddress());
 }
 
-TEST_F(BluetoothChromeOSTest, DeviceUuidsChanged) {
+TEST_F(BluetoothBlueZTest, DeviceUuidsChanged) {
   // Simulate a change of advertised services of a device.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   ASSERT_EQ(2U, devices.size());
 
   int idx = GetDeviceIndexByAddress(
       devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_NE(-1, idx);
   ASSERT_EQ(bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress,
@@ skipping 27 matching lines @@
   // Fetching the value should give the new one.
   uuids = devices[idx]->GetUUIDs();
   ASSERT_EQ(5U, uuids.size());
   EXPECT_EQ(uuids[0], BluetoothUUID("1800"));
   EXPECT_EQ(uuids[1], BluetoothUUID("1801"));
   EXPECT_EQ(uuids[2], BluetoothUUID("110c"));
   EXPECT_EQ(uuids[3], BluetoothUUID("110e"));
   EXPECT_EQ(uuids[4], BluetoothUUID("110a"));
 }
 
-TEST_F(BluetoothChromeOSTest, DeviceInquiryRSSIInvalidated) {
+TEST_F(BluetoothBlueZTest, DeviceInquiryRSSIInvalidated) {
   // Simulate invalidation of inquiry RSSI of a device, as it occurs
   // when discovery is finished.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   ASSERT_EQ(2U, devices.size());
 
   int idx = GetDeviceIndexByAddress(
       devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_NE(-1, idx);
@@ skipping 16 matching lines @@
   properties->rssi.set_valid(false);
   properties->NotifyPropertyChanged(properties->rssi.name());
 
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_EQ(devices[idx], observer.last_device());
 
   int unknown_power = BluetoothDevice::kUnknownPower;
   EXPECT_EQ(unknown_power, devices[idx]->GetInquiryRSSI());
 }
 
-TEST_F(BluetoothChromeOSTest, DeviceInquiryTxPowerInvalidated) {
+TEST_F(BluetoothBlueZTest, DeviceInquiryTxPowerInvalidated) {
   // Simulate invalidation of inquiry TxPower of a device, as it occurs
   // when discovery is finished.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   ASSERT_EQ(2U, devices.size());
 
   int idx = GetDeviceIndexByAddress(
       devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_NE(-1, idx);
@@ skipping 16 matching lines @@
   properties->tx_power.set_valid(false);
   properties->NotifyPropertyChanged(properties->tx_power.name());
 
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_EQ(devices[idx], observer.last_device());
 
   int unknown_power = BluetoothDevice::kUnknownPower;
   EXPECT_EQ(unknown_power, devices[idx]->GetInquiryTxPower());
 }
 
-TEST_F(BluetoothChromeOSTest, ForgetDevice) {
+TEST_F(BluetoothBlueZTest, ForgetDevice) {
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
   ASSERT_EQ(2U, devices.size());
 
   int idx = GetDeviceIndexByAddress(
       devices, bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_NE(-1, idx);
   ASSERT_EQ(bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[idx]->GetAddress());
 
   std::string address = devices[idx]->GetAddress();
 
   // Install an observer; expect the DeviceRemoved method to be called
   // with the device we remove.
   TestBluetoothAdapterObserver observer(adapter_);
 
   devices[idx]->Forget(GetErrorCallback());
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.device_removed_count());
   EXPECT_EQ(address, observer.last_device_address());
 
   // GetDevices shouldn't return the device either.
   devices = adapter_->GetDevices();
   ASSERT_EQ(1U, devices.size());
 }
 
-TEST_F(BluetoothChromeOSTest, ForgetUnpairedDevice) {
+TEST_F(BluetoothBlueZTest, ForgetUnpairedDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   // Connect the device so it becomes trusted and remembered.
   device->Connect(nullptr, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
   ASSERT_FALSE(device->IsConnecting());
 
   // Make sure the trusted property has been set to true.
@@ skipping 12 matching lines @@
   EXPECT_EQ(1, observer.device_removed_count());
   EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kConnectUnpairableAddress,
             observer.last_device_address());
 
   // GetDevices shouldn't return the device either.
   device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   EXPECT_FALSE(device != nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, ConnectPairedDevice) {
+TEST_F(BluetoothBlueZTest, ConnectPairedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_TRUE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device is already Paired
   // this should succeed and the device should become connected.
   device->Connect(nullptr, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one for connected and one for for trusted
   // after connecting.
   EXPECT_EQ(4, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
-TEST_F(BluetoothChromeOSTest, ConnectUnpairableDevice) {
+TEST_F(BluetoothBlueZTest, ConnectUnpairableDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device does not require
   // pairing, this should succeed and the device should become connected.
   device->Connect(nullptr, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one for connected, one for for trusted after
   // connection, and one for the reconnect mode (IsConnectable).
   EXPECT_EQ(5, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kConnectUnpairablePath));
   EXPECT_TRUE(properties->trusted.value());
 
   // Verify is a HID device and is not connectable.
   BluetoothDevice::UUIDList uuids = device->GetUUIDs();
   ASSERT_EQ(1U, uuids.size());
   EXPECT_EQ(uuids[0], BluetoothUUID("1124"));
   EXPECT_FALSE(device->IsConnectable());
 }
 
-TEST_F(BluetoothChromeOSTest, ConnectConnectedDevice) {
+TEST_F(BluetoothBlueZTest, ConnectConnectedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_TRUE(device->IsPaired());
 
   device->Connect(nullptr, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
 
   // Connect again; since the device is already Connected, this shouldn't do
   // anything to initiate the connection.
   TestBluetoothAdapterObserver observer(adapter_);
 
   device->Connect(nullptr, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // The observer will be called because Connecting will toggle true and false,
   // and the trusted property will be updated to true.
   EXPECT_EQ(3, observer.device_changed_count());
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
-TEST_F(BluetoothChromeOSTest, ConnectDeviceFails) {
+TEST_F(BluetoothBlueZTest, ConnectDeviceFails) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device requires pairing,
   // this should fail with an error.
   device->Connect(nullptr, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_);
 
   EXPECT_EQ(2, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
-TEST_F(BluetoothChromeOSTest, DisconnectDevice) {
+TEST_F(BluetoothBlueZTest, DisconnectDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_TRUE(device->IsPaired());
 
   device->Connect(nullptr, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
   ASSERT_FALSE(device->IsConnecting());
 
   // Disconnect the device, we should see the observer method fire and the
   // device get dropped.
   TestBluetoothAdapterObserver observer(adapter_);
 
   device->Disconnect(GetCallback(), GetErrorCallback());
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_FALSE(device->IsConnected());
 }
 
-TEST_F(BluetoothChromeOSTest, DisconnectUnconnectedDevice) {
+TEST_F(BluetoothBlueZTest, DisconnectUnconnectedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_TRUE(device->IsPaired());
   ASSERT_FALSE(device->IsConnected());
 
   // Disconnect the device, we should see the observer method fire and the
   // device get dropped.
   TestBluetoothAdapterObserver observer(adapter_);
 
   device->Disconnect(GetCallback(), GetErrorCallback());
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsConnected());
 }
 
-TEST_F(BluetoothChromeOSTest, PairTrustedDevice) {
+TEST_F(BluetoothBlueZTest, PairTrustedDevice) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::
                            kConnectedTrustedNotPairedDevicePath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::
                               kConnectedTrustedNotPairedDeviceAddress);
   ASSERT_TRUE(device != nullptr);
 
   // On the DBus level the device is trusted but not paired. But the current
   // implementation of |BluetoothDevice::IsPaired()| returns true in this case.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::
                                kConnectedTrustedNotPairedDevicePath));
   EXPECT_FALSE(properties->paired.value());
   EXPECT_TRUE(properties->trusted.value());
   ASSERT_TRUE(device->IsPaired());
 
   // The |kConnectedTrustedNotPairedDevicePath| requests a passkey confirmation.
   // Obs.: This is the flow when CrOS triggers pairing with a iOS device.
   TestBluetoothAdapterObserver observer(adapter_);
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
   device->Pair(&pairing_delegate, GetCallback(),
-               base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+               base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                           base::Unretained(this)));
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
 
   // Confirm the passkey.
   device->ConfirmPairing();
   message_loop_.Run();
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Make sure the paired property has been set to true.
   properties = fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
       bluez::FakeBluetoothDeviceClient::kConnectedTrustedNotPairedDevicePath));
   EXPECT_TRUE(properties->paired.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairAlreadyPairedDevice) {
+TEST_F(BluetoothBlueZTest, PairAlreadyPairedDevice) {
   GetAdapter();
 
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kPairedDevicePath));
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != nullptr);
 
   // On the DBus level a device can be trusted but not paired.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kPairedDevicePath));
   EXPECT_TRUE(properties->paired.value());
   EXPECT_TRUE(properties->trusted.value());
   ASSERT_TRUE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
   device->Pair(&pairing_delegate, GetCallback(),
-               base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+               base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                           base::Unretained(this)));
 
   // For already paired devices a call to |Pair| should succeed without calling
   // the pairing delegate.
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 }
 
-TEST_F(BluetoothChromeOSTest, PairLegacyAutopair) {
+TEST_F(BluetoothBlueZTest, PairLegacyAutopair) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // The Legacy Autopair device requires no PIN or Passkey to pair because
   // the daemon provides 0000 to the device for us.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
@@ skipping 14 matching lines @@
   EXPECT_EQ(uuids[0], BluetoothUUID("1124"));
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kLegacyAutopairPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairDisplayPinCode) {
+TEST_F(BluetoothBlueZTest, PairDisplayPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requires that we display a randomly generated PIN on the screen.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kDisplayPinCodeAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.display_pincode_count_);
   EXPECT_EQ("123456", pairing_delegate.last_pincode_);
   EXPECT_TRUE(device->IsConnecting());
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
@@ skipping 16 matching lines @@
   EXPECT_EQ(uuids[0], BluetoothUUID("1124"));
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kDisplayPinCodePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairDisplayPasskey) {
+TEST_F(BluetoothBlueZTest, PairDisplayPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requires that we display a randomly generated Passkey on the screen,
   // and notifies us as it's typed in.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kDisplayPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   // One call for DisplayPasskey() and one for KeysEntered().
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.display_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
   EXPECT_EQ(1, pairing_delegate.keys_entered_count_);
   EXPECT_EQ(0U, pairing_delegate.last_entered_);
 
   EXPECT_TRUE(device->IsConnecting());
@@ skipping 37 matching lines @@
   // And usually not connectable.
   EXPECT_FALSE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kDisplayPasskeyPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairRequestPinCode) {
+TEST_F(BluetoothBlueZTest, PairRequestPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requires that the user enters a PIN for them.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Set the PIN.
   device->SetPinCode("1234");
   message_loop_.Run();
 
@@ skipping 17 matching lines @@
   // Non HID devices are always connectable.
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kRequestPinCodePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairConfirmPasskey) {
+TEST_F(BluetoothBlueZTest, PairConfirmPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requests that we confirm a displayed passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Confirm the passkey.
   device->ConfirmPairing();
   message_loop_.Run();
@@ skipping 14 matching lines @@
   // Non HID devices are always connectable.
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairRequestPasskey) {
+TEST_F(BluetoothBlueZTest, PairRequestPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requires that the user enters a Passkey, this would be some kind of
   // device that has a display, but doesn't use "just works" - maybe a car?
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Set the Passkey.
   device->SetPasskey(1234);
   message_loop_.Run();
 
@@ skipping 13 matching lines @@
   // Non HID devices are always connectable.
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kRequestPasskeyPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairJustWorks) {
+TEST_F(BluetoothBlueZTest, PairJustWorks) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Uses just-works pairing, since this is an outgoing pairing, no delegate
   // interaction is required.
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one change for connected, one for paired and
   // two for trusted (after pairing and connection).
   EXPECT_EQ(6, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Non HID devices are always connectable.
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kJustWorksPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairUnpairableDeviceFails) {
+TEST_F(BluetoothBlueZTest, PairUnpairableDeviceFails) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevice(bluez::FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
 
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kUnpairableDeviceAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Run the loop to get the error..
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_);
 
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingFails) {
+TEST_F(BluetoothBlueZTest, PairingFails) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevice(bluez::FakeBluetoothDeviceClient::kVanishingDeviceAddress);
 
   // The vanishing device times out during pairing
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kVanishingDeviceAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Run the loop to get the error..
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_TIMEOUT, last_connect_error_);
 
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingFailsAtConnection) {
+TEST_F(BluetoothBlueZTest, PairingFailsAtConnection) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Everything seems to go according to plan with the unconnectable device;
   // it pairs, but then you can't make connections to it after.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_);
 
   // Two changes for connecting, one for paired and one for trusted after
   // pairing. The device should not be connected.
   EXPECT_EQ(4, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Make sure the trusted property has been set to true still (since pairing
   // worked).
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kUnconnectableDevicePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingRejectedAtPinCode) {
+TEST_F(BluetoothBlueZTest, PairingRejectedAtPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Reject the pairing.
   device->RejectPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_REJECTED, last_connect_error_);
 
   // Should be no changes except connecting going true and false.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingCancelledAtPinCode) {
+TEST_F(BluetoothBlueZTest, PairingCancelledAtPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Cancel the pairing.
   device->CancelPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_);
 
   // Should be no changes except connecting going true and false.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingRejectedAtPasskey) {
+TEST_F(BluetoothBlueZTest, PairingRejectedAtPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Reject the pairing.
   device->RejectPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_REJECTED, last_connect_error_);
 
   // Should be no changes except connecting going true and false.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingCancelledAtPasskey) {
+TEST_F(BluetoothBlueZTest, PairingCancelledAtPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Cancel the pairing.
   device->CancelPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_);
 
   // Should be no changes except connecting going true and false.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingRejectedAtConfirmation) {
+TEST_F(BluetoothBlueZTest, PairingRejectedAtConfirmation) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for passkey confirmation.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Reject the pairing.
   device->RejectPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_REJECTED, last_connect_error_);
 
   // Should be no changes except connecting going true and false.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingCancelledAtConfirmation) {
+TEST_F(BluetoothBlueZTest, PairingCancelledAtConfirmation) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Cancel the pairing.
   device->CancelPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_);
 
   // Should be no changes except connecting going true and false.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, PairingCancelledInFlight) {
+TEST_F(BluetoothBlueZTest, PairingCancelledInFlight) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing while we're waiting for the remote host.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   // Cancel the pairing.
   device->CancelPairing();
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_);
 
   // Should be no changes except connecting going true and false.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairRequestPinCode) {
+TEST_F(BluetoothBlueZTest, IncomingPairRequestPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
-      &pairing_delegate,
-      BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+      &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Requires that we provide a PIN code.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPinCodePath));
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPinCodePath),
-      true, GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      true, GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                       base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
 
   // Set the PIN.
   device->SetPinCode("1234");
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One change for paired, and one for trusted.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kRequestPinCodePath));
   ASSERT_TRUE(properties->trusted.value());
 
   // No pairing context should remain on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairConfirmPasskey) {
+TEST_F(BluetoothBlueZTest, IncomingPairConfirmPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
-      &pairing_delegate,
-      BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+      &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Requests that we confirm a displayed passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kConfirmPasskeyPath),
-      true, GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      true, GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                       base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
 
   // Confirm the passkey.
   device->ConfirmPairing();
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One change for paired, and one for trusted.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   ASSERT_TRUE(properties->trusted.value());
 
   // No pairing context should remain on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairRequestPasskey) {
+TEST_F(BluetoothBlueZTest, IncomingPairRequestPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
-      &pairing_delegate,
-      BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+      &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Requests that we provide a Passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPasskeyPath),
-      true, GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      true, GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                       base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
 
   // Set the Passkey.
   device->SetPasskey(1234);
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One change for paired, and one for trusted.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kRequestPasskeyPath));
   ASSERT_TRUE(properties->trusted.value());
 
   // No pairing context should remain on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairJustWorks) {
+TEST_F(BluetoothBlueZTest, IncomingPairJustWorks) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
-      &pairing_delegate,
-      BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+      &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Uses just-works pairing so, sinec this an incoming pairing, require
   // authorization from the user.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kJustWorksPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kJustWorksPath), true,
-      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.authorize_pairing_count_);
 
   // Confirm the pairing.
   device->ConfirmPairing();
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One change for paired, and one for trusted.
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Make sure the trusted property has been set to true.
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kJustWorksPath));
   ASSERT_TRUE(properties->trusted.value());
 
   // No pairing context should remain on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairRequestPinCodeWithoutDelegate) {
+TEST_F(BluetoothBlueZTest, IncomingPairRequestPinCodeWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   // Requires that we provide a PIN Code, without a pairing delegate,
   // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPinCodePath));
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPinCodePath),
-      true, GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      true, GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                       base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairConfirmPasskeyWithoutDelegate) {
+TEST_F(BluetoothBlueZTest, IncomingPairConfirmPasskeyWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   // Requests that we confirm a displayed passkey, without a pairing delegate,
   // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kConfirmPasskeyPath),
-      true, GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      true, GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                       base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairRequestPasskeyWithoutDelegate) {
+TEST_F(BluetoothBlueZTest, IncomingPairRequestPasskeyWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   // Requests that we provide a displayed passkey, without a pairing delegate,
   // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPasskeyPath),
-      true, GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      true, GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                       base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairJustWorksWithoutDelegate) {
+TEST_F(BluetoothBlueZTest, IncomingPairJustWorksWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   // Uses just-works pairing and thus requires authorization for incoming
   // pairings, without a pairing delegate, that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kJustWorksPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kJustWorksPath), true,
-      GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 }
 
-TEST_F(BluetoothChromeOSTest, RemovePairingDelegateDuringPairing) {
+TEST_F(BluetoothBlueZTest, RemovePairingDelegateDuringPairing) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
-      &pairing_delegate,
-      BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+      &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Requests that we provide a Passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kRequestPasskeyPath),
-      true, GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
+      true, GetCallback(), base::Bind(&BluetoothBlueZTest::DBusErrorCallback,
                                       base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
 
   // A pairing context should now be set on the device.
-  BluetoothDeviceChromeOS* device_chromeos =
-      static_cast<BluetoothDeviceChromeOS*>(device);
-  ASSERT_TRUE(device_chromeos->GetPairing() != nullptr);
+  BluetoothDeviceBlueZ* device_bluez =
+      static_cast<BluetoothDeviceBlueZ*>(device);
+  ASSERT_TRUE(device_bluez->GetPairing() != nullptr);
 
   // Removing the pairing delegate should remove that pairing context.
   adapter_->RemovePairingDelegate(&pairing_delegate);
 
-  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
+  EXPECT_TRUE(device_bluez->GetPairing() == nullptr);
 
   // Set the Passkey, this should now have no effect since the pairing has
   // been, in-effect, cancelled
   device->SetPasskey(1234);
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, DeviceId) {
+TEST_F(BluetoothBlueZTest, DeviceId) {
   GetAdapter();
 
   // Use the built-in paired device for this test, grab its Properties
   // structure so we can adjust the underlying modalias property.
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
   bluez::FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(dbus::ObjectPath(
           bluez::FakeBluetoothDeviceClient::kPairedDevicePath));
 
@@ skipping 34 matching lines @@
 
   // Unknown vendor specification identifier.
   properties->modalias.ReplaceValue("chrome:v00E0p2400d0400");
 
   EXPECT_EQ(BluetoothDevice::VENDOR_ID_UNKNOWN, device->GetVendorIDSource());
   EXPECT_EQ(0, device->GetVendorID());
   EXPECT_EQ(0, device->GetProductID());
   EXPECT_EQ(0, device->GetDeviceID());
 }
 
-TEST_F(BluetoothChromeOSTest, GetConnectionInfoForDisconnectedDevice) {
+TEST_F(BluetoothBlueZTest, GetConnectionInfoForDisconnectedDevice) {
   GetAdapter();
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
 
   // Calling GetConnectionInfo for an unconnected device should return a result
   // in which all fields are filled with BluetoothDevice::kUnknownPower.
   BluetoothDevice::ConnectionInfo conn_info(0, 0, 0);
   device->GetConnectionInfo(base::Bind(&SaveConnectionInfo, &conn_info));
   int unknown_power = BluetoothDevice::kUnknownPower;
   EXPECT_NE(0, unknown_power);
   EXPECT_EQ(unknown_power, conn_info.rssi);
   EXPECT_EQ(unknown_power, conn_info.transmit_power);
   EXPECT_EQ(unknown_power, conn_info.max_transmit_power);
 }
 
-TEST_F(BluetoothChromeOSTest, GetConnectionInfoForConnectedDevice) {
+TEST_F(BluetoothBlueZTest, GetConnectionInfoForConnectedDevice) {
   GetAdapter();
   BluetoothDevice* device = adapter_->GetDevice(
       bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress);
 
   device->Connect(nullptr, GetCallback(),
-                  base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
+                  base::Bind(&BluetoothBlueZTest::ConnectErrorCallback,
                              base::Unretained(this)));
   EXPECT_TRUE(device->IsConnected());
 
   // Calling GetConnectionInfo for a connected device should return valid
   // results.
   fake_bluetooth_device_client_->UpdateConnectionInfo(-10, 3, 4);
   BluetoothDevice::ConnectionInfo conn_info;
   device->GetConnectionInfo(base::Bind(&SaveConnectionInfo, &conn_info));
   EXPECT_EQ(-10, conn_info.rssi);
   EXPECT_EQ(3, conn_info.transmit_power);
   EXPECT_EQ(4, conn_info.max_transmit_power);
 }
 
 // Verifies Shutdown shuts down the adapter as expected.
-TEST_F(BluetoothChromeOSTest, Shutdown) {
+TEST_F(BluetoothBlueZTest, Shutdown) {
   // Set up adapter. Set powered & discoverable, start discovery.
   GetAdapter();
   adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
   adapter_->SetDiscoverable(true, GetCallback(), GetErrorCallback());
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   base::MessageLoop::current()->Run();
   ASSERT_EQ(3, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Validate running adapter state.
   EXPECT_NE("", adapter_->GetAddress());
   EXPECT_NE("", adapter_->GetName());
   EXPECT_TRUE(adapter_->IsInitialized());
   EXPECT_TRUE(adapter_->IsPresent());
   EXPECT_TRUE(adapter_->IsPowered());
   EXPECT_TRUE(adapter_->IsDiscoverable());
   EXPECT_TRUE(adapter_->IsDiscovering());
   EXPECT_EQ(2U, adapter_->GetDevices().size());
   EXPECT_NE(nullptr,
             adapter_->GetDevice(
                 bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress));
-  EXPECT_NE(dbus::ObjectPath(""), static_cast<BluetoothAdapterChromeOS*>(
-                                      adapter_.get())->object_path());
+  EXPECT_NE(dbus::ObjectPath(""),
+            static_cast<BluetoothAdapterBlueZ*>(adapter_.get())->object_path());
 
   // Shutdown
   adapter_->Shutdown();
 
-  // Validate post shutdown state by calling all BluetoothAdapterChromeOS
+  // Validate post shutdown state by calling all BluetoothAdapterBlueZ
   // members, in declaration order:
 
   adapter_->Shutdown();
   // DeleteOnCorrectThread omitted as we don't want to delete in this test.
   {
     TestBluetoothAdapterObserver observer(adapter_);  // Calls AddObserver
   }  // ~TestBluetoothAdapterObserver calls RemoveObserver.
   EXPECT_EQ("", adapter_->GetAddress());
   EXPECT_EQ("", adapter_->GetName());
 
@@ skipping 15 matching lines @@
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_--) << "SetDiscoverable error";
 
   EXPECT_FALSE(adapter_->IsDiscovering());
   // CreateRfcommService will DCHECK after Shutdown().
   // CreateL2capService will DCHECK after Shutdown().
 
   BluetoothAudioSink::Options audio_sink_options;
   adapter_->RegisterAudioSink(
       audio_sink_options,
-      base::Bind(&BluetoothChromeOSTest::AudioSinkAcquiredCallback,
+      base::Bind(&BluetoothBlueZTest::AudioSinkAcquiredCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::AudioSinkErrorCallback,
+      base::Bind(&BluetoothBlueZTest::AudioSinkErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_--) << "RegisterAudioSink error";
 
-  BluetoothAdapterChromeOS* adapter_chrome_os =
-      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+  BluetoothAdapterBlueZ* adapter_chrome_os =

[ortuno, 2015/11/06 18:15:42]

This should probably be renamed to "adapter" or "adapter_bluez". There are more
"adapter_chrome_os" throughout this file that should be renamed.

[rkc, 2015/11/25 00:48:16]

Done.

+      static_cast<BluetoothAdapterBlueZ*>(adapter_.get());
   EXPECT_EQ(nullptr,
             adapter_chrome_os->GetDeviceWithPath(dbus::ObjectPath("")));
 
   // Notify methods presume objects exist that are owned by the adapter and
   // destroyed in Shutdown(). Mocks are not attempted here that won't exist,
   // as verified below by EXPECT_EQ(0U, adapter_->GetDevices().size());
   // NotifyDeviceChanged
   // NotifyGattServiceAdded
   // NotifyGattServiceRemoved
   // NotifyGattServiceChanged
   // NotifyGattDiscoveryComplete
   // NotifyGattCharacteristicAdded
   // NotifyGattCharacteristicRemoved
   // NotifyGattDescriptorAdded
   // NotifyGattDescriptorRemoved
   // NotifyGattCharacteristicValueChanged
   // NotifyGattDescriptorValueChanged
 
   EXPECT_EQ(dbus::ObjectPath(""), adapter_chrome_os->object_path());
 
   adapter_profile_ = nullptr;
 
   FakeBluetoothProfileServiceProviderDelegate profile_delegate;
   adapter_chrome_os->UseProfile(
       BluetoothUUID(), dbus::ObjectPath(""),
       bluez::BluetoothProfileManagerClient::Options(), &profile_delegate,
-      base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
+      base::Bind(&BluetoothBlueZTest::ProfileRegisteredCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
+      base::Bind(&BluetoothBlueZTest::ErrorCompletionCallback,
                  base::Unretained(this)));
 
   EXPECT_FALSE(adapter_profile_) << "UseProfile error";
   EXPECT_EQ(0, callback_count_) << "UseProfile error";
   EXPECT_EQ(1, error_callback_count_--) << "UseProfile error";
 
   // Protected and private methods:
 
   adapter_chrome_os->RemovePairingDelegateInternal(&pairing_delegate);
   // AdapterAdded() invalid post Shutdown because it calls SetAdapter.
   adapter_chrome_os->AdapterRemoved(dbus::ObjectPath("x"));
   adapter_chrome_os->AdapterPropertyChanged(dbus::ObjectPath("x"), "");
   adapter_chrome_os->DeviceAdded(dbus::ObjectPath(""));
   adapter_chrome_os->DeviceRemoved(dbus::ObjectPath(""));
   adapter_chrome_os->DevicePropertyChanged(dbus::ObjectPath(""), "");
   adapter_chrome_os->InputPropertyChanged(dbus::ObjectPath(""), "");
   // bluez::BluetoothAgentServiceProvider::Delegate omitted, dbus will be
   // shutdown,
   //   with the exception of Released.
   adapter_chrome_os->Released();
 
   adapter_chrome_os->OnRegisterAgent();
   adapter_chrome_os->OnRegisterAgentError("", "");
   adapter_chrome_os->OnRequestDefaultAgent();
   adapter_chrome_os->OnRequestDefaultAgentError("", "");
 
   adapter_chrome_os->OnRegisterAudioSink(
-      base::Bind(&BluetoothChromeOSTest::AudioSinkAcquiredCallback,
+      base::Bind(&BluetoothBlueZTest::AudioSinkAcquiredCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::AudioSinkErrorCallback,
+      base::Bind(&BluetoothBlueZTest::AudioSinkErrorCallback,
                  base::Unretained(this)),
       scoped_refptr<device::BluetoothAudioSink>());
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_--) << "RegisterAudioSink error";
 
   // GetPairing will DCHECK after Shutdown().
   // SetAdapter will DCHECK after Shutdown().
   // SetDefaultAdapterName will DCHECK after Shutdown().
   // RemoveAdapter will DCHECK after Shutdown().
   adapter_chrome_os->PoweredChanged(false);
@@ skipping 25 matching lines @@
   // OnStopDiscovery tested in Shutdown_OnStopDiscovery
   // OnStopDiscoveryError tested in Shutdown_OnStopDiscoveryError
 
   adapter_profile_ = nullptr;
 
   // OnRegisterProfile SetProfileDelegate, OnRegisterProfileError, require
   // UseProfile to be set first, do so again here just before calling them.
   adapter_chrome_os->UseProfile(
       BluetoothUUID(), dbus::ObjectPath(""),
       bluez::BluetoothProfileManagerClient::Options(), &profile_delegate,
-      base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
+      base::Bind(&BluetoothBlueZTest::ProfileRegisteredCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
+      base::Bind(&BluetoothBlueZTest::ErrorCompletionCallback,
                  base::Unretained(this)));
 
   EXPECT_FALSE(adapter_profile_) << "UseProfile error";
   EXPECT_EQ(0, callback_count_) << "UseProfile error";
   EXPECT_EQ(1, error_callback_count_--) << "UseProfile error";
 
   adapter_chrome_os->SetProfileDelegate(
       BluetoothUUID(), dbus::ObjectPath(""), &profile_delegate,
-      base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
+      base::Bind(&BluetoothBlueZTest::ProfileRegisteredCallback,
                  base::Unretained(this)),
-      base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
+      base::Bind(&BluetoothBlueZTest::ErrorCompletionCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, callback_count_) << "SetProfileDelegate error";
   EXPECT_EQ(1, error_callback_count_--) << "SetProfileDelegate error";
 
   adapter_chrome_os->OnRegisterProfileError(BluetoothUUID(), "", "");
   EXPECT_EQ(0, callback_count_) << "OnRegisterProfileError error";
   EXPECT_EQ(0, error_callback_count_) << "OnRegisterProfileError error";
 
   adapter_chrome_os->ProcessQueuedDiscoveryRequests();
 
   // From BluetoothAdapater:
 
   adapter_->StartDiscoverySession(
-      base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
+      base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       GetErrorCallback());
   EXPECT_EQ(0, callback_count_) << "StartDiscoverySession error";
   EXPECT_EQ(1, error_callback_count_--) << "StartDiscoverySession error";
 
   EXPECT_EQ(0U, adapter_->GetDevices().size());
   EXPECT_EQ(nullptr,
             adapter_->GetDevice(
                 bluez::FakeBluetoothDeviceClient::kPairedDeviceAddress));
   TestPairingDelegate pairing_delegate2;
   adapter_->AddPairingDelegate(
       &pairing_delegate2, BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
   adapter_->RemovePairingDelegate(&pairing_delegate2);
 }
 
 // Verifies post-Shutdown of discovery sessions and OnStartDiscovery.
-TEST_F(BluetoothChromeOSTest, Shutdown_OnStartDiscovery) {
+TEST_F(BluetoothBlueZTest, Shutdown_OnStartDiscovery) {
   const int kNumberOfDiscoverySessions = 10;
   GetAdapter();
-  BluetoothAdapterChromeOS* adapter_chrome_os =
-      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+  BluetoothAdapterBlueZ* adapter_chrome_os =
+      static_cast<BluetoothAdapterBlueZ*>(adapter_.get());
 
   for (int i = 0; i < kNumberOfDiscoverySessions; i++) {
     adapter_chrome_os->AddDiscoverySession(nullptr, GetCallback(),
                                            GetDiscoveryErrorCallback());
   }
   adapter_->Shutdown();
   adapter_chrome_os->OnStartDiscovery(GetCallback(),
                                       GetDiscoveryErrorCallback());
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(kNumberOfDiscoverySessions, error_callback_count_);
 }
 
 // Verifies post-Shutdown of discovery sessions and OnStartDiscoveryError.
-TEST_F(BluetoothChromeOSTest, Shutdown_OnStartDiscoveryError) {
+TEST_F(BluetoothBlueZTest, Shutdown_OnStartDiscoveryError) {
   const int kNumberOfDiscoverySessions = 10;
   GetAdapter();
-  BluetoothAdapterChromeOS* adapter_chrome_os =
-      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+  BluetoothAdapterBlueZ* adapter_chrome_os =
+      static_cast<BluetoothAdapterBlueZ*>(adapter_.get());
 
   for (int i = 0; i < kNumberOfDiscoverySessions; i++) {
     adapter_chrome_os->AddDiscoverySession(nullptr, GetCallback(),
                                            GetDiscoveryErrorCallback());
   }
   adapter_->Shutdown();
   adapter_chrome_os->OnStartDiscoveryError(GetCallback(),
                                            GetDiscoveryErrorCallback(), "", "");
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(kNumberOfDiscoverySessions, error_callback_count_);
 }
 
 // Verifies post-Shutdown of discovery sessions and OnStartDiscovery.
-TEST_F(BluetoothChromeOSTest, Shutdown_OnStopDiscovery) {
+TEST_F(BluetoothBlueZTest, Shutdown_OnStopDiscovery) {
   const int kNumberOfDiscoverySessions = 10;
   GetAdapter();
-  BluetoothAdapterChromeOS* adapter_chrome_os =
-      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+  BluetoothAdapterBlueZ* adapter_chrome_os =
+      static_cast<BluetoothAdapterBlueZ*>(adapter_.get());
 
   // In order to queue up discovery sessions before an OnStopDiscovery call
   // RemoveDiscoverySession must be called, so Add, Start, and Remove:
   adapter_chrome_os->AddDiscoverySession(nullptr, GetCallback(),
                                          GetDiscoveryErrorCallback());
   adapter_chrome_os->OnStartDiscovery(GetCallback(),
                                       GetDiscoveryErrorCallback());
   adapter_chrome_os->RemoveDiscoverySession(nullptr, GetCallback(),
                                             GetDiscoveryErrorCallback());
   callback_count_ = 0;
   error_callback_count_ = 0;
   // Can now queue discovery sessions while waiting for OnStopDiscovery.
   for (int i = 0; i < kNumberOfDiscoverySessions; i++) {
     adapter_chrome_os->AddDiscoverySession(nullptr, GetCallback(),
                                            GetDiscoveryErrorCallback());
   }
   adapter_->Shutdown();
   adapter_chrome_os->OnStopDiscovery(GetCallback());
 
   // 1 successful stopped discovery from RemoveDiscoverySession, and
   // kNumberOfDiscoverySessions errors from AddDiscoverySession/OnStopDiscovery.
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(kNumberOfDiscoverySessions, error_callback_count_);
 }
 
 // Verifies post-Shutdown of discovery sessions and OnStopDiscoveryError.
-TEST_F(BluetoothChromeOSTest, Shutdown_OnStopDiscoveryError) {
+TEST_F(BluetoothBlueZTest, Shutdown_OnStopDiscoveryError) {
   const int kNumberOfDiscoverySessions = 10;
   GetAdapter();
-  BluetoothAdapterChromeOS* adapter_chrome_os =
-      static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
+  BluetoothAdapterBlueZ* adapter_chrome_os =
+      static_cast<BluetoothAdapterBlueZ*>(adapter_.get());
 
   // In order to queue up discovery sessions before an OnStopDiscoveryError call
   // RemoveDiscoverySession must be called, so Add, Start, and Remove:
   adapter_chrome_os->AddDiscoverySession(nullptr, GetCallback(),
                                          GetDiscoveryErrorCallback());
   adapter_chrome_os->OnStartDiscovery(GetCallback(),
                                       GetDiscoveryErrorCallback());
   adapter_chrome_os->RemoveDiscoverySession(nullptr, GetCallback(),
                                             GetDiscoveryErrorCallback());
   callback_count_ = 0;
   error_callback_count_ = 0;
   // Can now queue discovery sessions while waiting for OnStopDiscoveryError.
   for (int i = 0; i < kNumberOfDiscoverySessions; i++) {
     adapter_chrome_os->AddDiscoverySession(nullptr, GetCallback(),
                                            GetDiscoveryErrorCallback());
   }
   adapter_->Shutdown();
   adapter_chrome_os->OnStopDiscoveryError(GetDiscoveryErrorCallback(), "", "");
 
   // 1 error reported to RemoveDiscoverySession because of OnStopDiscoveryError,
   // and kNumberOfDiscoverySessions errors queued with AddDiscoverySession.
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1 + kNumberOfDiscoverySessions, error_callback_count_);
 }
 
-}  // namespace chromeos
+}  // namespace bluez