Factor out a BluetoothChannelMac base class and a BluetoothRfcommChannelMac subclass.

device/bluetooth/bluetooth_socket_mac.h

 // 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.
 
 #ifndef DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_MAC_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_MAC_H_
 
 #include <queue>
 #include <string>
 
 #import <IOBluetooth/IOBluetooth.h>
 #import <IOKit/IOReturn.h>
 
 #include "base/mac/scoped_nsobject.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "device/bluetooth/bluetooth_socket.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
-@class BluetoothRfcommChannelDelegate;
 @class BluetoothRfcommConnectionListener;
 
 namespace net {
 class IOBuffer;
 class IOBufferWithSize;
 }
 
 namespace device {
 
 class BluetoothAdapter;
+class BluetoothChannelMac;
 
 // Implements the BluetoothSocket class for the Mac OS X platform.
 class BluetoothSocketMac : public BluetoothSocket {
  public:
   static scoped_refptr<BluetoothSocketMac> CreateSocket();
 
   // Connects this socket to the service on |device| published as UUID |uuid|.
   // The underlying protocol and PSM or Channel is obtained through service
   // discovery. On a successful connection, the socket properties will be
   // updated and |success_callback| called. On failure, |error_callback| will be
@@ skipping 43 matching lines @@
   // |status| is the returned status from the SDP query, |device| is the
   // IOBluetoothDevice for which the query was made. The remaining
   // parameters are those from |Connect()|.
   void OnSDPQueryComplete(
       IOReturn status,
       IOBluetoothDevice* device,
       const base::Closure& success_callback,
       const ErrorCompletionCallback& error_callback);
 
   // Called by BluetoothRfcommConnectionListener.
-  void OnRfcommChannelOpened(IOBluetoothRFCOMMChannel* rfcomm_channel);
+  void OnChannelOpened(scoped_ptr<BluetoothChannelMac> channel);
 
-  // Called by BluetoothRfcommChannelDelegate.
-  void OnRfcommChannelOpenComplete(IOBluetoothRFCOMMChannel* rfcomm_channel,
-                                   IOReturn status);
-  void OnRfcommChannelClosed(IOBluetoothRFCOMMChannel* rfcomm_channel);
-  void OnRfcommChannelDataReceived(IOBluetoothRFCOMMChannel* rfcomm_channel,
-                                   void* data,
-                                   size_t length);
-  void OnRfcommChannelWriteComplete(IOBluetoothRFCOMMChannel* rfcomm_channel,
-                                    void* refcon,
-                                    IOReturn status);
+  // Called by |channel_|.
+  // Note: OnChannelOpenComplete might be called before the |channel_| is set.
+  void OnChannelOpenComplete(const std::string& device_address,
+                             IOReturn status);
+  void OnChannelClosed();
+  void OnChannelDataReceived(void* data, size_t length);
+  void OnChannelWriteComplete(void* refcon, IOReturn status);
 
  private:
   struct AcceptRequest {
     AcceptRequest();
     ~AcceptRequest();
 
     AcceptCompletionCallback success_callback;
     ErrorCompletionCallback error_callback;
   };
 
@@ skipping 41 matching lines @@
   scoped_refptr<BluetoothAdapter> adapter_;
 
   // UUID of the profile being connected to, or that the socket is listening on.
   device::BluetoothUUID uuid_;
 
   // A simple helper that registers for OS notifications and forwards them to
   // |this| profile.
   base::scoped_nsobject<BluetoothRfcommConnectionListener>
       rfcomm_connection_listener_;
 
-  // A simple delegate that forwards RFCOMM channel methods to |this| socket.
-  base::scoped_nsobject<BluetoothRfcommChannelDelegate>
-      rfcomm_channel_delegate_;
-
   // A handle to the service record registered in the system SDP server.
   // Used to eventually unregister the service.
   BluetoothSDPServiceRecordHandle service_record_handle_;
 
-  // The IOBluetooth RFCOMM channel used to issue commands.
-  base::scoped_nsobject<IOBluetoothRFCOMMChannel> rfcomm_channel_;
+  // The channel used to issue commands.
+  scoped_ptr<BluetoothChannelMac> channel_;
 
   // Connection callbacks -- when a pending async connection is active.
   scoped_ptr<ConnectCallbacks> connect_callbacks_;
 
   // Packets received while there is no pending "receive" callback.
   std::queue<scoped_refptr<net::IOBufferWithSize> > receive_queue_;
 
   // Receive callbacks -- when a receive call is active.
   scoped_ptr<ReceiveCallbacks> receive_callbacks_;
 
   // Send queue -- one entry per pending send operation.
   std::queue<linked_ptr<SendRequest>> send_queue_;
 
   // The pending request to an Accept() call, or null if there is no pending
   // request.
   scoped_ptr<AcceptRequest> accept_request_;
 
-  // Queue of incoming RFCOMM connections.
-  std::queue<base::scoped_nsobject<IOBluetoothRFCOMMChannel>> accept_queue_;
+  // Queue of incoming connections.
+  std::queue<linked_ptr<BluetoothChannelMac>> accept_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothSocketMac);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_MAC_H_