Bluetooth: clean up BluetoothDevice

device/bluetooth/bluetooth_device_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_device_chromeos.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 32 matching lines @@
 void DoNothingServiceRecordList(const BluetoothDevice::ServiceRecordList&) {}
 
 } // namespace
 
 namespace chromeos {
 
 BluetoothDeviceChromeOS::BluetoothDeviceChromeOS(
     BluetoothAdapterChromeOS* adapter)
     : BluetoothDevice(),
       adapter_(adapter),
+      bluetooth_class_(0),
+      paired_(false),
+      connected_(false),
+      connectable_(true),
+      connecting_(false),
       pairing_delegate_(NULL),
       connecting_applications_counter_(0),
       connecting_calls_(0),
       service_records_loaded_(false),
       weak_ptr_factory_(this) {
 }
 
 BluetoothDeviceChromeOS::~BluetoothDeviceChromeOS() {
 }
 
-bool BluetoothDeviceChromeOS::IsPaired() const {
-  return !object_path_.value().empty();
+uint32 BluetoothDeviceChromeOS::GetBluetoothClass() const {
+  return bluetooth_class_;
 }
 
-const BluetoothDevice::ServiceList&
+std::string BluetoothDeviceChromeOS::GetDeviceName() const {
+  return name_;
+}
+
+std::string BluetoothDeviceChromeOS::GetAddress() const {
+  return address_;
+}
+
+bool BluetoothDeviceChromeOS::IsPaired() const {
+  return paired_;
+}
+
+bool BluetoothDeviceChromeOS::IsConnected() const {
+  return connected_;
+}
+
+bool BluetoothDeviceChromeOS::IsConnectable() const {
+  return connectable_;
+}
+
+bool BluetoothDeviceChromeOS::IsConnecting() const {
+  return connecting_;
+}
+
+BluetoothDeviceChromeOS::ServiceList
 BluetoothDeviceChromeOS::GetServices() const {
   return service_uuids_;
 }
 
 void BluetoothDeviceChromeOS::GetServiceRecords(
     const ServiceRecordsCallback& callback,
     const ErrorCallback& error_callback) {
   DBusThreadManager::Get()->GetBluetoothDeviceClient()->
       DiscoverServices(
           object_path_,
@@ skipping 44 matching lines @@
   // Set the decrement to be issued when either callback is called.
   base::Closure wrapped_callback = base::Bind(
       &BluetoothDeviceChromeOS::OnConnectCallbackCalled,
       weak_ptr_factory_.GetWeakPtr(),
       callback);
   ConnectErrorCallback wrapped_error_callback = base::Bind(
       &BluetoothDeviceChromeOS::OnConnectErrorCallbackCalled,
       weak_ptr_factory_.GetWeakPtr(),
       error_callback);
 
-  if (IsPaired() || IsBonded() || IsConnected()) {
+  if (IsPaired() || IsConnected()) {
     // Connection to already paired or connected device.
     ConnectApplications(wrapped_callback, wrapped_error_callback);
 
   } else if (!pairing_delegate) {
     // No pairing delegate supplied, initiate low-security connection only.
     DBusThreadManager::Get()->GetBluetoothAdapterClient()->
         CreateDevice(adapter_->object_path_,
                      address_,
                      base::Bind(&BluetoothDeviceChromeOS::OnCreateDevice,
                                 weak_ptr_factory_.GetWeakPtr(),
@@ skipping 151 matching lines @@
           callback));
 }
 
 void BluetoothDeviceChromeOS::SetOutOfBandPairingData(
     const BluetoothOutOfBandPairingData& data,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DBusThreadManager::Get()->GetBluetoothOutOfBandClient()->
       AddRemoteData(
           object_path_,
-          address(),
+          address_,
           data,
           base::Bind(&BluetoothDeviceChromeOS::OnRemoteDataCallback,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback,
                      error_callback));
 }
 
 void BluetoothDeviceChromeOS::ClearOutOfBandPairingData(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DBusThreadManager::Get()->GetBluetoothOutOfBandClient()->
       RemoveRemoteData(
           object_path_,
-          address(),
+          address_,
           base::Bind(&BluetoothDeviceChromeOS::OnRemoteDataCallback,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback,
                      error_callback));
 }
 
 void BluetoothDeviceChromeOS::SetObjectPath(
     const dbus::ObjectPath& object_path) {
   DCHECK(object_path_ == dbus::ObjectPath(""));
   object_path_ = object_path;
@@ skipping 24 matching lines @@
   }
 
   if (update_state) {
     // When the device reconnects and we don't have any service records for it,
     // try to update the cache or fail silently.
     if (!service_records_loaded_ && !connected_ &&
         properties->connected.value())
       GetServiceRecords(base::Bind(&DoNothingServiceRecordList),
                         base::Bind(&base::DoNothing));
 
-    // BlueZ uses paired to mean link keys exchanged, whereas the Bluetooth
-    // spec refers to this as bonded. Use the spec name for our interface.
-    bonded_ = properties->paired.value();
+    paired_ = properties->paired.value();
     connected_ = properties->connected.value();
   }
 }
 
 void BluetoothDeviceChromeOS::OnCreateDevice(
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback,
     const dbus::ObjectPath& device_path) {
   VLOG(1) << "Connection successful: " << device_path.value();
   if (object_path_.value().empty()) {
@@ skipping 71 matching lines @@
   // callback, so it is safe to delete the previous objects here.
   service_records_.clear();
   // TODO(deymo): Perhaps don't update the cache if the new SDP information is
   // empty and we had something before. Some devices only answer this
   // information while paired, and this callback could be called in any order if
   // several calls to GetServiceRecords are made while initial pairing with the
   // device. This requires more investigation.
   for (BluetoothDeviceClient::ServiceMap::const_iterator i =
       service_map.begin(); i != service_map.end(); ++i) {
     service_records_.push_back(
-        new BluetoothServiceRecordChromeOS(address(), i->second));
+        new BluetoothServiceRecordChromeOS(address_, i->second));
   }
   service_records_loaded_ = true;
 
   callback.Run(service_records_);
 }
 
 void BluetoothDeviceChromeOS::OnSetTrusted(bool success) {
   LOG_IF(WARNING, !success) << "Failed to set device as trusted: " << address_;
 }
 
@@ skipping 353 matching lines @@
 }
 
 
 // static
 BluetoothDeviceChromeOS* BluetoothDeviceChromeOS::Create(
     BluetoothAdapterChromeOS* adapter) {
   return new BluetoothDeviceChromeOS(adapter);
 }
 
 }  // namespace chromeos