Bluetooth: clean up BluetoothDevice

device/bluetooth/bluetooth_adapter_chromeos.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 "device/bluetooth/bluetooth_adapter_chromeos.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 47 matching lines @@
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void BluetoothAdapterChromeOS::RemoveObserver(
     BluetoothAdapter::Observer* observer) {
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
-std::string BluetoothAdapterChromeOS::address() const {
+std::string BluetoothAdapterChromeOS::GetAddress() const {
   return address_;
 }
 
-std::string BluetoothAdapterChromeOS::name() const {
+std::string BluetoothAdapterChromeOS::GetName() const {
   return name_;
 }
 
 // TODO(youngki) Return true when object path and properties of the adapter are
 // initialized.
 bool BluetoothAdapterChromeOS::IsInitialized() const {
   return true;
 }
 
 bool BluetoothAdapterChromeOS::IsPresent() const {
@@ skipping 269 matching lines @@
   DevicesMap::iterator iter = devices_.find(address);
   BluetoothDeviceChromeOS* device;
   const bool update_device = (iter != devices_.end());
   if (update_device) {
     device = static_cast<BluetoothDeviceChromeOS*>(iter->second);
   } else {
     device = BluetoothDeviceChromeOS::Create(this);
     devices_[address] = device;
   }
 
-  const bool was_paired = device->IsPaired();
-  if (!was_paired) {
+  if (!device->HasObjectPath()) {
     VLOG(1) << "Assigned object path " << device_path.value() << " to device "
             << address;
     device->SetObjectPath(device_path);
   }
   device->Update(properties, true);
 
   if (update_device) {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceChanged(this, device));
   } else {
@@ skipping 36 matching lines @@
         static_cast<BluetoothDeviceChromeOS*>(iter->second);
     DevicesMap::iterator temp = iter;
     ++iter;
 
     if (device->object_path_ != device_path)
       continue;
 
     // DeviceRemoved can also be called to indicate a device that is visible
     // during discovery has disconnected, but it is still visible to the
     // adapter, so don't remove in that case and only clear the object path.
-    if (!device->IsVisible()) {
+    if (!device->WasDiscovered()) {
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         DeviceRemoved(this, device));
 
-      VLOG(1) << "Removed device " << device->address();
+      VLOG(1) << "Removed device " << device->GetAddress();
 
       delete device;
       devices_.erase(temp);
     } else {
-      VLOG(1) << "Removed object path from device " << device->address();
+      VLOG(1) << "Removed object path from device " << device->GetAddress();
       device->RemoveObjectPath();
 
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         DeviceChanged(this, device));
     }
   }
 }
 
 void BluetoothAdapterChromeOS::DevicesChanged(
     const std::vector<dbus::ObjectPath>& devices) {
   for (std::vector<dbus::ObjectPath>::const_iterator iter =
            devices.begin(); iter != devices.end(); ++iter)
     UpdateDevice(*iter);
 }
 
 void BluetoothAdapterChromeOS::ClearDiscoveredDevices() {
   DevicesMap::iterator iter = devices_.begin();
   while (iter != devices_.end()) {
-    BluetoothDevice* device = iter->second;
+    BluetoothDeviceChromeOS* device =
+        static_cast<BluetoothDeviceChromeOS*>(iter->second);
     DevicesMap::iterator temp = iter;
     ++iter;
 
-    if (!device->IsPaired()) {
+    if (!device->HasObjectPath()) {
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         DeviceRemoved(this, device));
 
       delete device;
       devices_.erase(temp);
-    }
+
+    } else
+      device->SetDiscovered(false);
   }
 }
 
 void BluetoothAdapterChromeOS::DeviceFound(
     const dbus::ObjectPath& adapter_path,
     const std::string& address,
     const BluetoothDeviceClient::Properties& properties) {
   if (adapter_path != object_path_)
     return;
 
   // DeviceFound can also be called to indicate that a device we've
   // paired with is now visible to the adapter during discovery, in which
   // case we want to update the existing object, not create a new one.
   BluetoothDeviceChromeOS* device;
   DevicesMap::iterator iter = devices_.find(address);
   const bool update_device = (iter != devices_.end());
   if (update_device) {
     device = static_cast<BluetoothDeviceChromeOS*>(iter->second);
   } else {
     device = BluetoothDeviceChromeOS::Create(this);
     devices_[address] = device;
   }
 
   VLOG(1) << "Device " << address << " is visible to the adapter";
-  device->SetVisible(true);
+  device->SetDiscovered(true);
   device->Update(&properties, false);
 
   if (update_device) {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceChanged(this, device));
   } else {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceAdded(this, device));
   }
 }
 
 void BluetoothAdapterChromeOS::DeviceDisappeared(
     const dbus::ObjectPath& adapter_path,
     const std::string& address) {
   if (adapter_path != object_path_)
     return;
 
   DevicesMap::iterator iter = devices_.find(address);
   if (iter == devices_.end())
     return;
 
   BluetoothDeviceChromeOS* device =
       static_cast<BluetoothDeviceChromeOS*>(iter->second);
 
   // DeviceDisappeared can also be called to indicate that a device we've
   // paired with is no longer visible to the adapter, so don't remove
   // in that case and only clear the visible flag.
-  if (!device->IsPaired()) {
+  if (!device->HasObjectPath()) {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceRemoved(this, device));
 
-    VLOG(1) << "Discovered device " << device->address()
+    VLOG(1) << "Discovered device " << device->GetAddress()
              << " is no longer visible to the adapter";
 
     delete device;
     devices_.erase(iter);
   } else {
-    VLOG(1) << "Paired device " << device->address()
+    VLOG(1) << "Paired device " << device->GetAddress()
             << " is no longer visible to the adapter";
-    device->SetVisible(false);
+    device->SetDiscovered(false);
 
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceChanged(this, device));
   }
 }
 
 }  // namespace chromeos