Refactoring bluetooth API code.

chrome/browser/chromeos/bluetooth/bluetooth_adapter_chromeos_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter_chromeos.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter_factory.h"
 #include "chrome/browser/chromeos/bluetooth/test/mock_bluetooth_adapter.h"
 #include "chromeos/dbus/mock_bluetooth_adapter_client.h"
 #include "chromeos/dbus/mock_bluetooth_manager_client.h"
 #include "chromeos/dbus/mock_dbus_thread_manager.h"
 #include "dbus/object_path.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Return;
@@ skipping 40 matching lines @@
 };
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterNotPresent) {
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback; make out it failed.
   // BluetoothAdapter::Observer::AdapterPresentChanged must not be called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), _))
       .Times(0);
 
   adapter_callback.Run(dbus::ObjectPath(""), false);
 
   // Adapter should not be present.
   EXPECT_FALSE(adapter->IsPresent());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterWithAddress) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
@@ skipping 16 matching lines @@
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   // BluetoothAdapter::Observer::AdapterPresentChanged must not be called
   // yet.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), _))
       .Times(0);
 
   adapter_callback.Run(adapter_path, true);
 
   // Adapter should not be present yet.
   EXPECT_FALSE(adapter->IsPresent());
 
   // Tell the adapter the address now;
   // BluetoothAdapter::Observer::AdapterPresentChanged now must be called.
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.address.name());
 
   // Adapter should be present with the given address.
   EXPECT_TRUE(adapter->IsPresent());
   EXPECT_EQ(adapter_address, adapter->address());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterBecomesPresentWithAddress) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback; make out it failed.
   adapter_callback.Run(dbus::ObjectPath(""), false);
 
   // Tell the adapter the default adapter changed;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   // BluetoothAdapter::Observer::AdapterPresentChanged must be called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->DefaultAdapterChanged(adapter_path);
 
   // Adapter should be present with the new address.
   EXPECT_TRUE(adapter->IsPresent());
   EXPECT_EQ(adapter_address, adapter->address());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterReplacedWithAddress) {
   const dbus::ObjectPath initial_adapter_path("/fake/hci0");
   const dbus::ObjectPath new_adapter_path("/fake/hci1");
   const std::string initial_adapter_address = "CA:FE:4A:C0:FE:FE";
   const std::string new_adapter_address = "BA:C0:11:CO:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties initial_adapter_properties;
   initial_adapter_properties.address.ReplaceValue(initial_adapter_address);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(initial_adapter_path))
       .WillRepeatedly(Return(&initial_adapter_properties));
 
@@ skipping 12 matching lines @@
   // with false to indicate the old adapter being removed and once with true
   // to announce the new adapter.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), false))
       .Times(1);
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->DefaultAdapterChanged(new_adapter_path);
 
   // Adapter should be present with the new address.
   EXPECT_TRUE(adapter->IsPresent());
   EXPECT_EQ(new_adapter_address, adapter->address());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterBecomesPresentWithoutAddress) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback; make out it failed.
   adapter_callback.Run(dbus::ObjectPath(""), false);
 
   // Tell the adapter the default adapter changed;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   // BluetoothAdapter::Observer::AdapterPresentChanged must not be called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), _))
       .Times(0);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->DefaultAdapterChanged(adapter_path);
 
   // Adapter should not be present yet.
   EXPECT_FALSE(adapter->IsPresent());
 
   // Tell the adapter the address now;
   // BluetoothAdapter::Observer::AdapterPresentChanged now must be called.
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.address.name());
 
   // Adapter should be present with the new address.
   EXPECT_TRUE(adapter->IsPresent());
   EXPECT_EQ(adapter_address, adapter->address());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterReplacedWithoutAddress) {
   const dbus::ObjectPath initial_adapter_path("/fake/hci0");
   const dbus::ObjectPath new_adapter_path("/fake/hci1");
   const std::string initial_adapter_address = "CA:FE:4A:C0:FE:FE";
   const std::string new_adapter_address = "BA:C0:11:CO:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties initial_adapter_properties;
   initial_adapter_properties.address.ReplaceValue(initial_adapter_address);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(initial_adapter_path))
       .WillRepeatedly(Return(&initial_adapter_properties));
 
   adapter_callback.Run(initial_adapter_path, true);
 
   // Tell the adapter the default adapter changed;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties new_adapter_properties;
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(new_adapter_path))
       .WillRepeatedly(Return(&new_adapter_properties));
 
   // BluetoothAdapter::Observer::AdapterPresentChanged must be called to
   // indicate the adapter has gone away.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), false))
       .Times(1);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->DefaultAdapterChanged(new_adapter_path);
 
   // Adapter should be now marked not present.
   EXPECT_FALSE(adapter->IsPresent());
 
   // Tell the adapter the address now;
   // BluetoothAdapter::Observer::AdapterPresentChanged now must be called.
   new_adapter_properties.address.ReplaceValue(new_adapter_address);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(new_adapter_path,
                                new_adapter_properties.address.name());
 
   // Adapter should be present with the new address.
   EXPECT_TRUE(adapter->IsPresent());
   EXPECT_EQ(new_adapter_address, adapter->address());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterRemoved) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Report that the adapter has been removed;
   // BluetoothAdapter::Observer::AdapterPresentChanged will be called to
   // indicate the adapter is no longer present.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), false))
       .Times(1);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->AdapterRemoved(adapter_path);
 
   // Adapter should be no longer present.
   EXPECT_FALSE(adapter->IsPresent());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterWithoutAddressRemoved) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Report that the adapter has been removed;
   // BluetoothAdapter::Observer::AdapterPresentChanged must not be called
   // since we never should have announced it in the first place.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), _))
       .Times(0);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->AdapterRemoved(adapter_path);
 
   // Adapter should be still no longer present.
   EXPECT_FALSE(adapter->IsPresent());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterPoweredPropertyInitiallyFalse) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.powered.ReplaceValue(false);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Adapter should have the correct property value.
   EXPECT_FALSE(adapter->IsPowered());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterPoweredPropertyInitiallyTrue) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.powered.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
@@ skipping 19 matching lines @@
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set but BluetoothAdapter::Observer::AdapterPoweredChanged
   // should not yet be called.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.powered.ReplaceValue(true);
 
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
@@ skipping 13 matching lines @@
   // BluetoothAdapter::Observer::AdapterPresentChanged and
   // BluetoothAdapter::Observer::AdapterPoweredChanged now must be called.
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
   EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.address.name());
 
   // Adapter should have the correct property value.
   EXPECT_TRUE(adapter->IsPowered());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterPoweredPropertyChanged) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.powered.ReplaceValue(false);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Adapter should have the correct property value.
   EXPECT_FALSE(adapter->IsPowered());
 
   // Report that the property has been changed;
   // BluetoothAdapter::Observer::AdapterPoweredChanged will be called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), true))
       .Times(1);
 
   adapter_properties.powered.ReplaceValue(true);
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.powered.name());
 
   // Adapter should have the new property values.
   EXPECT_TRUE(adapter->IsPowered());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterPoweredPropertyUnchanged) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.powered.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Adapter should have the correct property value.
   EXPECT_TRUE(adapter->IsPowered());
 
   // Report that the property has been changed, but don't change the value;
   // BluetoothAdapter::Observer::AdapterPoweredChanged should not be called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), _))
       .Times(0);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.powered.name());
 
   // Adapter should still have the same property values.
   EXPECT_TRUE(adapter->IsPowered());
 }
 
 TEST_F(BluetoothAdapterTest,
        DefaultAdapterPoweredPropertyChangedWithoutAddress) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set but BluetoothAdapter::Observer::AdapterPoweredChanged
   // should not yet be called.
   MockBluetoothAdapterClient::Properties adapter_properties;
 
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), _))
       .Times(0);
 
   adapter_callback.Run(adapter_path, true);
 
   // Tell the adapter that its powered property changed, the observer
   // method should still not be called because there is no address for
   // the adapter so it is not present.
   adapter_properties.powered.ReplaceValue(true);
 
   EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), _))
       .Times(0);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.powered.name());
 
   // Adapter should not yet have the property value.
   EXPECT_FALSE(adapter->IsPowered());
 
   // Tell the adapter the address now,
   // BluetoothAdapter::Observer::AdapterPresentChanged and
   // BluetoothAdapter::Observer::AdapterPoweredChanged now must be called.
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
   EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.address.name());
 
   // Adapter should now have the correct property value.
   EXPECT_TRUE(adapter->IsPowered());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterPoweredPropertyResetOnReplace) {
   const dbus::ObjectPath initial_adapter_path("/fake/hci0");
   const dbus::ObjectPath new_adapter_path("/fake/hci1");
   const std::string initial_adapter_address = "CA:FE:4A:C0:FE:FE";
   const std::string new_adapter_address = "00:C0:11:CO:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties initial_adapter_properties;
   initial_adapter_properties.address.ReplaceValue(initial_adapter_address);
   initial_adapter_properties.powered.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(initial_adapter_path))
       .WillRepeatedly(Return(&initial_adapter_properties));
@@ skipping 18 matching lines @@
 
     EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), false))
         .Times(1);
     EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
         .Times(1);
   }
 
   EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), false))
       .Times(1);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->DefaultAdapterChanged(new_adapter_path);
 
   // Adapter should have the new property value.
   EXPECT_FALSE(adapter->IsPowered());
 }
 
 TEST_F(BluetoothAdapterTest,
        DefaultAdapterPoweredPropertyResetOnReplaceWhenTrue) {
   const dbus::ObjectPath initial_adapter_path("/fake/hci0");
   const dbus::ObjectPath new_adapter_path("/fake/hci1");
   const std::string initial_adapter_address = "CA:FE:4A:C0:FE:FE";
   const std::string new_adapter_address = "BA:C0:11:CO:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties initial_adapter_properties;
   initial_adapter_properties.address.ReplaceValue(initial_adapter_address);
   initial_adapter_properties.powered.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(initial_adapter_path))
       .WillRepeatedly(Return(&initial_adapter_properties));
@@ skipping 27 matching lines @@
 
   {
     InSequence s;
 
     EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), false))
         .Times(1);
     EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), true))
         .Times(1);
   }
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->DefaultAdapterChanged(new_adapter_path);
 
   // Adapter should have the new property value.
   EXPECT_TRUE(adapter->IsPowered());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterPoweredPropertyResetOnRemove) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.powered.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Report that the adapter has been removed;
   // BluetoothAdapter::Observer::AdapterPoweredChanged will be called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), false))
       .Times(1);
   EXPECT_CALL(adapter_observer, AdapterPoweredChanged(adapter.get(), false))
       .Times(1);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->AdapterRemoved(adapter_path);
 
   // Adapter should have the new property value.
   EXPECT_FALSE(adapter->IsPowered());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterSetPowered) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
@@ skipping 26 matching lines @@
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
@@ skipping 26 matching lines @@
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.discovering.ReplaceValue(false);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Adapter should have the correct property value.
   EXPECT_FALSE(adapter->IsDiscovering());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterDiscoveringPropertyInitiallyTrue) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.discovering.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
@@ skipping 19 matching lines @@
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set but BluetoothAdapter::Observer::AdapterDiscoveringChanged
   // should not yet be called.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.discovering.ReplaceValue(true);
 
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
@@ skipping 13 matching lines @@
   // BluetoothAdapter::Observer::AdapterPresentChanged and
   // BluetoothAdapter::Observer::AdapterDiscoveringChanged now must be called.
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
   EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.address.name());
 
   // Adapter should have the correct property value.
   EXPECT_TRUE(adapter->IsDiscovering());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterDiscoveringPropertyChanged) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.discovering.ReplaceValue(false);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Adapter should have the correct property value.
   EXPECT_FALSE(adapter->IsDiscovering());
 
   // Report that the property has been changed;
   // BluetoothAdapter::Observer::AdapterDiscoveringChanged will be called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(), true))
       .Times(1);
 
   adapter_properties.discovering.ReplaceValue(true);
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.discovering.name());
 
   // Adapter should have the new property values.
   EXPECT_TRUE(adapter->IsDiscovering());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterDiscoveringPropertyUnchanged) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.discovering.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Adapter should have the correct property value.
   EXPECT_TRUE(adapter->IsDiscovering());
 
   // Report that the property has been changed, but don't change the value;
   // BluetoothAdapter::Observer::AdapterDiscoveringChanged should not be
   // called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(), _))
       .Times(0);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.discovering.name());
 
   // Adapter should still have the same property values.
   EXPECT_TRUE(adapter->IsDiscovering());
 }
 
 TEST_F(BluetoothAdapterTest,
        DefaultAdapterDiscoveringPropertyChangedWithoutAddress) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set but BluetoothAdapter::Observer::AdapterDiscoveringChanged
   // should not yet be called.
   MockBluetoothAdapterClient::Properties adapter_properties;
 
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(), _))
       .Times(0);
 
   adapter_callback.Run(adapter_path, true);
 
   // Tell the adapter that its discovering property changed, the observer
   // method should still not be called because there is no address for
   // the adapter so it is not present.
   adapter_properties.discovering.ReplaceValue(true);
 
   EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(), _))
       .Times(0);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.discovering.name());
 
   // Adapter should not yet have the property value.
   EXPECT_FALSE(adapter->IsDiscovering());
 
   // Tell the adapter the address now,
   // BluetoothAdapter::Observer::AdapterPresentChanged and
   // BluetoothAdapter::Observer::AdapterDiscoveringChanged now must be called.
   adapter_properties.address.ReplaceValue(adapter_address);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
       .Times(1);
 
   EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(), true))
       .Times(1);
 
-  static_cast<BluetoothAdapterClient::Observer*>(adapter.get())
+  static_cast<BluetoothAdapterClient::Observer*>(adapter_chromeos)
       ->AdapterPropertyChanged(adapter_path,
                                adapter_properties.address.name());
 
   // Adapter should now have the correct property value.
   EXPECT_TRUE(adapter->IsDiscovering());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterDiscoveringPropertyResetOnReplace) {
   const dbus::ObjectPath initial_adapter_path("/fake/hci0");
   const dbus::ObjectPath new_adapter_path("/fake/hci1");
   const std::string initial_adapter_address = "CA:FE:4A:C0:FE:FE";
   const std::string new_adapter_address = "BA:C0:11:CO:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties initial_adapter_properties;
   initial_adapter_properties.address.ReplaceValue(initial_adapter_address);
   initial_adapter_properties.discovering.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(initial_adapter_path))
       .WillRepeatedly(Return(&initial_adapter_properties));
@@ skipping 18 matching lines @@
 
     EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), false))
         .Times(1);
     EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), true))
         .Times(1);
   }
 
   EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(), false))
       .Times(1);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->DefaultAdapterChanged(new_adapter_path);
 
   // Adapter should have the new property value.
   EXPECT_FALSE(adapter->IsDiscovering());
 }
 
 TEST_F(BluetoothAdapterTest,
        DefaultAdapterDiscoveringPropertyResetOnReplaceWhenTrue) {
   const dbus::ObjectPath initial_adapter_path("/fake/hci0");
   const dbus::ObjectPath new_adapter_path("/fake/hci1");
   const std::string initial_adapter_address = "CA:FE:4A:C0:FE:FE";
   const std::string new_adapter_address = "BA:C0:11:CO:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties initial_adapter_properties;
   initial_adapter_properties.address.ReplaceValue(initial_adapter_address);
   initial_adapter_properties.discovering.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(initial_adapter_path))
       .WillRepeatedly(Return(&initial_adapter_properties));
@@ skipping 29 matching lines @@
     InSequence s;
 
     EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(),
                                                             false))
         .Times(1);
     EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(),
                                                             true))
         .Times(1);
   }
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->DefaultAdapterChanged(new_adapter_path);
 
   // Adapter should have the new property value.
   EXPECT_TRUE(adapter->IsDiscovering());
 }
 
 TEST_F(BluetoothAdapterTest, DefaultAdapterDiscoveringPropertyResetOnRemove) {
   const dbus::ObjectPath adapter_path("/fake/hci0");
   const std::string adapter_address = "CA:FE:4A:C0:FE:FE";
 
   // Create the default adapter instance;
   // BluetoothManagerClient::DefaultAdapter will be called once, passing
   // a callback to obtain the adapter path.
   BluetoothManagerClient::AdapterCallback adapter_callback;
   EXPECT_CALL(*mock_manager_client_, DefaultAdapter(_))
       .WillOnce(SaveArg<0>(&adapter_callback));
 
-  scoped_refptr<BluetoothAdapter> adapter = BluetoothAdapter::DefaultAdapter();
+  scoped_refptr<BluetoothAdapter> adapter =
+      BluetoothAdapterFactory::DefaultAdapter();
 
   // Call the adapter callback;
   // BluetoothAdapterClient::GetProperties will be called once to obtain
   // the property set.
   MockBluetoothAdapterClient::Properties adapter_properties;
   adapter_properties.address.ReplaceValue(adapter_address);
   adapter_properties.discovering.ReplaceValue(true);
 
   EXPECT_CALL(*mock_adapter_client_, GetProperties(adapter_path))
       .WillRepeatedly(Return(&adapter_properties));
 
   adapter_callback.Run(adapter_path, true);
 
   // Report that the adapter has been removed;
   // BluetoothAdapter::Observer::AdapterDiscoveringChanged will be called.
   MockBluetoothAdapter::Observer adapter_observer;
   adapter->AddObserver(&adapter_observer);
 
   EXPECT_CALL(adapter_observer, AdapterPresentChanged(adapter.get(), false))
       .Times(1);
   EXPECT_CALL(adapter_observer, AdapterDiscoveringChanged(adapter.get(), false))
       .Times(1);
 
-  static_cast<BluetoothManagerClient::Observer*>(adapter.get())
+  BluetoothAdapterChromeOs* adapter_chromeos =
+      static_cast<BluetoothAdapterChromeOs*>(adapter.get());
+  ASSERT_TRUE(adapter_chromeos != NULL);
+
+  static_cast<BluetoothManagerClient::Observer*>(adapter_chromeos)
       ->AdapterRemoved(adapter_path);
 
   // Adapter should have the new property value.
   EXPECT_FALSE(adapter->IsDiscovering());
 }
 
 }  // namespace chromeos