[Bluetooth] Improve the adapter's awareness of connected devices.

device/bluetooth/bluetooth_socket_mac.mm

 // 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 "device/bluetooth/bluetooth_socket_mac.h"
 
 #import <IOBluetooth/IOBluetooth.h>
 
 #include <limits>
 #include <sstream>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_adapter_mac.h"
 #include "device/bluetooth/bluetooth_channel_mac.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_mac.h"
 #include "device/bluetooth/bluetooth_l2cap_channel_mac.h"
 #include "device/bluetooth/bluetooth_rfcomm_channel_mac.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 // Replicate specific 10.7 SDK declarations for building with prior SDKs.
 #if !defined(MAC_OS_X_VERSION_10_7) || \
@@ skipping 424 matching lines @@
   SDPQueryListener* listener =
       [[SDPQueryListener alloc] initWithSocket:this
                                         device:device
                               success_callback:success_callback
                                 error_callback:error_callback];
   [device performSDPQuery:[listener autorelease]
                     uuids:@[GetIOBluetoothSDPUUID(uuid_)]];
 }
 
 void BluetoothSocketMac::ListenUsingRfcomm(
-    scoped_refptr<BluetoothAdapter> adapter,
+    scoped_refptr<BluetoothAdapterMac> adapter,
     const BluetoothUUID& uuid,
     int channel_id,
     const base::Closure& success_callback,
     const ErrorCompletionCallback& error_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   adapter_ = adapter;
   uuid_ = uuid;
 
   DVLOG(1) << uuid_.canonical_value() << ": Registering RFCOMM service.";
   BluetoothRFCOMMChannelID registered_channel_id;
   service_record_handle_ =
       RegisterRfcommService(uuid, channel_id, &registered_channel_id);
   if (service_record_handle_ == kInvalidServiceRecordHandle) {
     error_callback.Run(kInvalidOrUsedChannel);
     return;
   }
 
   rfcomm_connection_listener_.reset(
       [[BluetoothRfcommConnectionListener alloc]
           initWithSocket:this
                channelID:registered_channel_id]);
 
   success_callback.Run();
 }
 
 void BluetoothSocketMac::ListenUsingL2cap(
-    scoped_refptr<BluetoothAdapter> adapter,
+    scoped_refptr<BluetoothAdapterMac> adapter,
     const BluetoothUUID& uuid,
     int psm,
     const base::Closure& success_callback,
     const ErrorCompletionCallback& error_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   adapter_ = adapter;
   uuid_ = uuid;
 
   DVLOG(1) << uuid_.canonical_value() << ": Registering L2CAP service.";
@@ skipping 60 matching lines @@
              << uuid_.canonical_value() << ": Opening RFCOMM channel: "
              << rfcomm_channel_id;
   } else {
     DCHECK_NE(l2cap_psm, BluetoothAdapter::kPsmAuto);
     DVLOG(1) << BluetoothDeviceMac::GetDeviceAddress(device) << " "
              << uuid_.canonical_value() << ": Opening L2CAP channel: "
              << l2cap_psm;
   }
 
   // Note: It's important to set the connect callbacks *prior* to opening the
-  // channel as the delegate is passed in and can synchronously call into
+  // channel, as opening the channel can synchronously call into
   // OnChannelOpenComplete().
   connect_callbacks_.reset(new ConnectCallbacks());
   connect_callbacks_->success_callback = success_callback;
   connect_callbacks_->error_callback = error_callback;
 
   if (rfcomm_channel_id != BluetoothAdapter::kChannelAuto) {
     channel_ = BluetoothRfcommChannelMac::OpenAsync(
         this, device, rfcomm_channel_id, &status);
   } else {
     DCHECK_NE(l2cap_psm, BluetoothAdapter::kPsmAuto);
     channel_ =
         BluetoothL2capChannelMac::OpenAsync(this, device, l2cap_psm, &status);
   }
   if (status != kIOReturnSuccess) {
+    ReleaseChannel();
     std::stringstream error;
     error << "Failed to connect bluetooth socket ("
           << BluetoothDeviceMac::GetDeviceAddress(device) << "): (" << status
           << ")";
     error_callback.Run(error.str());
     return;
   }
 
   DVLOG(1) << BluetoothDeviceMac::GetDeviceAddress(device) << " "
            << uuid_.canonical_value()
@@ skipping 244 matching lines @@
     AcceptConnectionRequest();
 }
 
 void BluetoothSocketMac::AcceptConnectionRequest() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << uuid_.canonical_value() << ": Accepting pending connection.";
 
   linked_ptr<BluetoothChannelMac> channel = accept_queue_.front();
   accept_queue_.pop();
 
-  // TODO(isherman): It isn't guaranteed that the adapter knows about the device
-  // at this point. Fix this logic.
+  adapter_->DeviceConnected(channel->GetDevice());
   BluetoothDevice* device = adapter_->GetDevice(channel->GetDeviceAddress());
   DCHECK(device);
 
   scoped_refptr<BluetoothSocketMac> client_socket =
       BluetoothSocketMac::CreateSocket();
 
   client_socket->uuid_ = uuid_;
   client_socket->channel_.reset(channel.release());
 
   // Associating the socket can synchronously call into OnChannelOpenComplete().
@@ skipping 59 matching lines @@
   rfcomm_connection_listener_.reset();
   l2cap_connection_listener_.reset();
 
   // Destroying the listener above prevents the callback delegate from being
   // called so it is now safe to release all callback state.
   accept_request_.reset();
   empty_queue(accept_queue_);
 }
 
 }  // namespace device