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);
+}

[rpaquay, 2014/04/23 22:15:55]

There is little common code between a client and a server socket, which makes
reasoning about this code somewhat tricky. Out of curiosity, why did you decide
to not create a separate class?

[Ilya Sherman, 2014/04/24 06:50:10]

I actually originally planned to create a separate class, but to my surprise, I
found that most of the code does make sense to share between the client and
server socket.  Essentially, the only difference between the two is how the
socket is connected, which is the Connect() vs AcceptConnection() methods. 
Beyond that, the sockets are bi-directional, so all of the code for reading and
writing ends up being shared.

I think all of the code that's BluetoothProfileMac right now will need to end up
in a separate server-type class for registering/unregistering a service, as well
as listening to incoming connections.  That's one level up from the socket
class, though.

+
+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