Implement Bluetooth server socket support for RFCOMM on Mac.

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/objc/IOBluetoothDevice.h>
-#import <IOBluetooth/objc/IOBluetoothRFCOMMChannel.h>
-#import <IOBluetooth/objc/IOBluetoothSDPServiceRecord.h>
+#import <IOBluetooth/IOBluetooth.h>
 
 #include <limits>
 #include <sstream>
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "device/bluetooth/bluetooth_service_record.h"
 #include "device/bluetooth/bluetooth_service_record_mac.h"
 #include "net/base/io_buffer.h"
 
@@ skipping 74 matching lines @@
 
 BluetoothSocketMac::ReceiveCallbacks::ReceiveCallbacks() {}
 
 BluetoothSocketMac::ReceiveCallbacks::~ReceiveCallbacks() {}
 
 BluetoothSocketMac::ConnectCallbacks::ConnectCallbacks() {}
 
 BluetoothSocketMac::ConnectCallbacks::~ConnectCallbacks() {}
 
 // static
-scoped_refptr<BluetoothSocketMac> BluetoothSocketMac::CreateBluetoothSocket(
-    IOBluetoothSDPServiceRecord* record) {
-  return new BluetoothSocketMac(record);
+void BluetoothSocketMac::Connect(
+    IOBluetoothSDPServiceRecord* record,
+    const ConnectSuccessCallback& success_callback,
+    const ErrorCompletionCallback& error_callback) {
+  scoped_refptr<BluetoothSocketMac> socket(new BluetoothSocketMac());
+  socket->ConnectImpl(record, success_callback, error_callback);
 }
 
-BluetoothSocketMac::BluetoothSocketMac(
-    IOBluetoothSDPServiceRecord* record)
-    : record_([record retain]),
-      delegate_([[BluetoothRFCOMMChannelDelegate alloc] initWithSocket:this]) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+// static
+void BluetoothSocketMac::AcceptConnection(
+    IOBluetoothRFCOMMChannel* rfcomm_channel,
+    const ConnectSuccessCallback& success_callback,
+    const ErrorCompletionCallback& error_callback) {
+  scoped_refptr<BluetoothSocketMac> socket(new BluetoothSocketMac());
+  socket->AcceptConnectionImpl(
+      rfcomm_channel, success_callback, error_callback);
+}
+
+BluetoothSocketMac::BluetoothSocketMac()
+    : delegate_([[BluetoothRFCOMMChannelDelegate alloc] initWithSocket:this]) {
 }
 
 BluetoothSocketMac::~BluetoothSocketMac() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ReleaseChannel();
 }
 
 void BluetoothSocketMac::ReleaseChannel() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (rfcomm_channel_) {
     [rfcomm_channel_ setDelegate:nil];
     [rfcomm_channel_ closeChannel];
     rfcomm_channel_.reset();
   }
 
   // Closing the channel above prevents the callback delegate from being called
   // so it is now safe to release all callback state.
   connect_callbacks_.reset();
   receive_callbacks_.reset();
   empty_queue(receive_queue_);
   empty_queue(send_queue_);
 }
 
-void BluetoothSocketMac::Connect(
-    const base::Closure& success_callback,
+void BluetoothSocketMac::ConnectImpl(
+    IOBluetoothSDPServiceRecord* record,
+    const ConnectSuccessCallback& success_callback,
     const ErrorCompletionCallback& error_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (connecting()) {
     error_callback.Run(kSocketConnecting);
     return;
   }
 
   if (rfcomm_channel_) {
     error_callback.Run(kSocketAlreadyConnected);
     return;
   }
 
   uint8 rfcomm_channel_id;
-  IOReturn status = [record_ getRFCOMMChannelID:&rfcomm_channel_id];
+  IOReturn status = [record getRFCOMMChannelID:&rfcomm_channel_id];
   if (status != kIOReturnSuccess) {
     // TODO(youngki) add support for L2CAP sockets as well.
     error_callback.Run(kL2CAPNotSupported);
     return;
   }
 
-  IOBluetoothDevice* device = [record_ device];
+  IOBluetoothDevice* device = [record device];
   IOBluetoothRFCOMMChannel* rfcomm_channel;
   status = [device openRFCOMMChannelAsync:&rfcomm_channel
                             withChannelID:rfcomm_channel_id
                                  delegate:delegate_];
   if (status != kIOReturnSuccess) {
     std::stringstream error;
     error << "Failed to connect bluetooth socket ("
           << base::SysNSStringToUTF8([device addressString]) << "): (" << status
           << ")";
     error_callback.Run(error.str());
     return;
   }
 
+  AcceptConnectionImpl(rfcomm_channel, success_callback, error_callback);
+}
+
+void BluetoothSocketMac::AcceptConnectionImpl(
+    IOBluetoothRFCOMMChannel* rfcomm_channel,
+    const ConnectSuccessCallback& success_callback,
+    const ErrorCompletionCallback& error_callback) {
   connect_callbacks_.reset(new ConnectCallbacks());
-  connect_callbacks_->success_callback = success_callback;
+  connect_callbacks_->success_callback =
+      base::Bind(success_callback, scoped_refptr<BluetoothSocketMac>(this));
   connect_callbacks_->error_callback = error_callback;
-  rfcomm_channel_.reset(rfcomm_channel);
+
+  // Note: It's important to set the connect callbacks *prior* to setting the
+  // delegate, as setting the delegate can synchronously call into
+  // OnChannelOpened().
+  rfcomm_channel_.reset([rfcomm_channel retain]);
   [rfcomm_channel_ setDelegate:delegate_];
 }
 
 void BluetoothSocketMac::OnChannelOpened(
     IOBluetoothRFCOMMChannel* rfcomm_channel,
     IOReturn status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(rfcomm_channel_, rfcomm_channel);
   DCHECK(connecting());
 
   scoped_ptr<ConnectCallbacks> temp = connect_callbacks_.Pass();
   if (status != kIOReturnSuccess) {
     ReleaseChannel();
     std::stringstream error;
     error << "Failed to connect bluetooth socket ("
-          << base::SysNSStringToUTF8([[record_ device] addressString]) << "): ("
+          << base::SysNSStringToUTF8(
+                 [[rfcomm_channel_ getDevice] addressString]) << "): ("
           << status << ")";
     temp->error_callback.Run(error.str());
     return;
   }
 
   temp->success_callback.Run();
 }
 
 void BluetoothSocketMac::Close() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 99 matching lines @@
   while (send_buffer->BytesRemaining() > 0) {
     int byte_count = send_buffer->BytesRemaining();
     if (byte_count > mtu)
       byte_count = mtu;
     IOReturn status = [rfcomm_channel_ writeAsync:send_buffer->data()
                                            length:byte_count
                                            refcon:request.get()];
     if (status != kIOReturnSuccess) {
       std::stringstream error;
       error << "Failed to connect bluetooth socket ("
-            << base::SysNSStringToUTF8([[record_ device] addressString])
+            << base::SysNSStringToUTF8(
+                   [[rfcomm_channel_ getDevice] addressString])
             << "): (" << status << ")";
       // Remember the first error only
       if (request->status == kIOReturnSuccess)
         request->status = status;
       request->error_signaled = true;
       request->error_callback.Run(error.str());
       // We may have failed to issue any write operation. In that case, there
       // will be no corresponding completion callback for this particular
       // request, so we must forget about it now.
       if (request->active_async_writes == 0) {
@@ skipping 34 matching lines @@
   if (request->active_async_writes > 0)
     return;
 
   // If this was the last active async write for this request, remove it from
   // the queue and call the appropriate callback associated to the request.
   send_queue_.pop();
   if (request->status != kIOReturnSuccess) {
     if (!request->error_signaled) {
       std::stringstream error;
       error << "Failed to connect bluetooth socket ("
-            << base::SysNSStringToUTF8([[record_ device] addressString])
+            << base::SysNSStringToUTF8(
+                   [[rfcomm_channel_ getDevice] addressString])
             << "): (" << status << ")";
       request->error_signaled = true;
       request->error_callback.Run(error.str());
     }
   } else {
     request->success_callback.Run(request->buffer_size);
   }
 }
 
 void BluetoothSocketMac::OnChannelClosed(
     IOBluetoothRFCOMMChannel* rfcomm_channel) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(rfcomm_channel_, rfcomm_channel);
 
   if (receive_callbacks_) {
     scoped_ptr<ReceiveCallbacks> temp = receive_callbacks_.Pass();
     temp->error_callback.Run(BluetoothSocket::kDisconnected,
                              kSocketNotConnected);
   }
 
   ReleaseChannel();
 }
 
 }  // namespace device