Refactoring bluetooth API code.

chrome/browser/chromeos/system/ash_system_tray_delegate.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/system/ash_system_tray_delegate.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/audio/audio_observer.h"
 #include "ash/system/bluetooth/bluetooth_observer.h"
@@ skipping 13 matching lines @@
 #include "ash/volume_control_delegate.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_util.h"
 #include "chrome/browser/chromeos/audio/audio_handler.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter_dbus.h"
+#include "chrome/browser/chromeos/bluetooth/bluetooth_device_dbus.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/operation_registry.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/input_method/xkeyboard.h"
 #include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_settings.h"
@@ skipping 103 matching lines @@
                            public SessionManagerClient::Observer,
                            public NetworkMenuIcon::Delegate,
                            public NetworkMenu::Delegate,
                            public NetworkLibrary::NetworkManagerObserver,
                            public NetworkLibrary::NetworkObserver,
                            public NetworkLibrary::CellularDataPlanObserver,
                            public gdata::OperationRegistry::Observer,
                            public content::NotificationObserver,
                            public input_method::InputMethodManager::Observer,
                            public system::TimezoneSettings::Observer,
-                           public BluetoothAdapter::Observer,
+                           public BluetoothAdapterDBus::Observer,
                            public SystemKeyEventListener::CapsLockObserver,
                            public MessageBubbleLinkListener {
  public:
   explicit SystemTrayDelegate(ash::SystemTray* tray)
       : tray_(tray),
         ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(
             new base::WeakPtrFactory<SystemTrayDelegate>(this))),
         network_icon_(ALLOW_THIS_IN_INITIALIZER_LIST(
                       new NetworkMenuIcon(this, NetworkMenuIcon::MENU_MODE))),
         network_icon_dark_(ALLOW_THIS_IN_INITIALIZER_LIST(
@@ skipping 38 matching lines @@
     registrar_.Add(this,
                    chrome::NOTIFICATION_PROFILE_CREATED,
                    content::NotificationService::AllSources());
 
     accessibility_enabled_.Init(prefs::kSpokenFeedbackEnabled,
                                 g_browser_process->local_state(), this);
 
     network_icon_->SetResourceColorTheme(NetworkMenuIcon::COLOR_LIGHT);
     network_icon_dark_->SetResourceColorTheme(NetworkMenuIcon::COLOR_DARK);
 
-    bluetooth_adapter_ = BluetoothAdapter::DefaultAdapter();
+    bluetooth_adapter_ = BluetoothAdapterDBus::DefaultAdapter();
     bluetooth_adapter_->AddObserver(this);
   }
 
   virtual ~SystemTrayDelegate() {
     AudioHandler* audiohandler = AudioHandler::GetInstance();
     if (audiohandler)
       audiohandler->RemoveVolumeObserver(this);
     DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(this);
     DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
     NetworkLibrary* crosnet = CrosLibrary::Get()->GetNetworkLibrary();
@@ skipping 125 matching lines @@
   virtual void RequestLockScreen() OVERRIDE {
     DBusThreadManager::Get()->GetSessionManagerClient()->RequestLockScreen();
   }
 
   virtual void RequestRestart() OVERRIDE {
     DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
   }
 
   virtual void GetAvailableBluetoothDevices(
       ash::BluetoothDeviceList* list) OVERRIDE {
-    BluetoothAdapter::DeviceList devices = bluetooth_adapter_->GetDevices();
+    BluetoothAdapterDBus::DeviceList devices =
+        bluetooth_adapter_->GetDevices();
     for (size_t i = 0; i < devices.size(); ++i) {
-      BluetoothDevice* device = devices[i];
+      BluetoothDeviceInterface* device = devices[i];
       if (!device->IsPaired())
         continue;
       ash::BluetoothDeviceInfo info;
       info.address = device->address();
       info.display_name = device->GetName();
       info.connected = device->IsConnected();
       list->push_back(info);
     }
   }
 
   virtual void ToggleBluetoothConnection(const std::string& address) OVERRIDE {
-    BluetoothDevice* device = bluetooth_adapter_->GetDevice(address);
+    BluetoothDeviceDBus* device =
+        static_cast<BluetoothDeviceDBus *>(
+            bluetooth_adapter_->GetDevice(address));
     if (!device)
       return;
     if (device->IsConnected()) {
       device->Disconnect(
           base::Bind(&base::DoNothing),
           base::Bind(&BluetoothDeviceDisconnectError));
     } else if (device->IsPaired()) {
       device->Connect(
           NULL,
           base::Bind(&base::DoNothing),
@@ skipping 740 matching lines @@
 
     OnProgressUpdate(system_service->drive_service()->operation_registry()->
         GetProgressStatusList());
   }
 
   // Overridden from system::TimezoneSettings::Observer.
   virtual void TimezoneChanged(const icu::TimeZone& timezone) OVERRIDE {
     NotifyRefreshClock();
   }
 
-  // Overridden from BluetoothAdapter::Observer.
-  virtual void AdapterPresentChanged(BluetoothAdapter* adapter,
+  // Overridden from BluetoothAdapterDBus::Observer.
+  virtual void AdapterPresentChanged(BluetoothAdapterDBus* adapter,
                                      bool present) OVERRIDE {
     NotifyRefreshBluetooth();
   }
 
-  virtual void AdapterPoweredChanged(BluetoothAdapter* adapter,
+  virtual void AdapterPoweredChanged(BluetoothAdapterDBus* adapter,
                                      bool powered) OVERRIDE {
     NotifyRefreshBluetooth();
   }
 
-  virtual void AdapterDiscoveringChanged(BluetoothAdapter* adapter,
+  virtual void AdapterDiscoveringChanged(BluetoothAdapterDBus* adapter,
                                          bool discovering) OVERRIDE {
     // TODO: Perhaps start/stop throbbing the icon, or some other visual
     // effects?
   }
 
-  virtual void DeviceAdded(BluetoothAdapter* adapter,
-                           BluetoothDevice* device) OVERRIDE {
+  virtual void DeviceAdded(BluetoothAdapterDBus* adapter,
+                           BluetoothDeviceDBus* device) OVERRIDE {
     NotifyRefreshBluetooth();
   }
 
-  virtual void DeviceChanged(BluetoothAdapter* adapter,
-                             BluetoothDevice* device) OVERRIDE {
+  virtual void DeviceChanged(BluetoothAdapterDBus* adapter,
+                             BluetoothDeviceDBus* device) OVERRIDE {
     NotifyRefreshBluetooth();
   }
 
-  virtual void DeviceRemoved(BluetoothAdapter* adapter,
-                             BluetoothDevice* device) OVERRIDE {
+  virtual void DeviceRemoved(BluetoothAdapterDBus* adapter,
+                             BluetoothDeviceDBus* device) OVERRIDE {
     NotifyRefreshBluetooth();
   }
 
   // Overridden from SystemKeyEventListener::CapsLockObserver.
   virtual void OnCapsLockChange(bool enabled) OVERRIDE {
     bool search_mapped_to_caps_lock = false;
     if (!base::chromeos::IsRunningOnChromeOS() ||
         search_key_mapped_to_ == input_method::kCapsLockKey)
       search_mapped_to_caps_lock = true;
 
@@ skipping 46 matching lines @@
   scoped_ptr<PrefChangeRegistrar> pref_registrar_;
   std::string cellular_device_path_;
   std::string active_network_path_;
   PowerSupplyStatus power_supply_status_;
   base::HourClockType clock_type_;
   int search_key_mapped_to_;
   bool screen_locked_;
   ConnectionState connected_network_state_;
   std::string connected_network_path_;
 
-  scoped_refptr<BluetoothAdapter> bluetooth_adapter_;
+  scoped_refptr<BluetoothAdapterDBus> bluetooth_adapter_;
 
   BooleanPrefMember accessibility_enabled_;
 
   scoped_ptr<DataPromoNotification> data_promo_notification_;
 
   scoped_ptr<ash::VolumeControlDelegate> volume_control_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemTrayDelegate);
 };
 
 }  // namespace
 
 ash::SystemTrayDelegate* CreateSystemTrayDelegate(ash::SystemTray* tray) {
   return new chromeos::SystemTrayDelegate(tray);
 }
 
 }  // namespace chromeos