device/bluetooth/bluetooth_socket_net.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_NET_H_
   6 #define DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_NET_H_
   7
   8 #include <queue>
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/memory/linked_ptr.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/sequenced_task_runner.h"
  16 #include "device/bluetooth/bluetooth_socket.h"
  17 #include "device/bluetooth/bluetooth_socket_thread.h"
  18 #include "net/base/net_log.h"
  19 #include "net/socket/tcp_socket.h"
  20
  21 namespace net {
  22 class IOBuffer;
  23 class IOBufferWithSize;
  24 }  // namespace net
  25
  26 namespace device {
  27
  28 // This class is a base-class for implementations of BluetoothSocket that can
  29 // use net::TCPSocket. All public methods (including the factory method) must
  30 // be called on the UI thread, while underlying socket operations are
  31 // performed on a separate thread.
  32 class BluetoothSocketNet : public BluetoothSocket {
  33  public:
  34   // BluetoothSocket:
  35   virtual void Close() OVERRIDE;
  36   virtual void Disconnect(const base::Closure& callback) OVERRIDE;
  37   virtual void Receive(int buffer_size,
  38                        const ReceiveCompletionCallback& success_callback,
  39                        const ReceiveErrorCompletionCallback& error_callback)
  40       OVERRIDE;
  41   virtual void Send(scoped_refptr<net::IOBuffer> buffer,
  42                     int buffer_size,
  43                     const SendCompletionCallback& success_callback,
  44                     const ErrorCompletionCallback& error_callback) OVERRIDE;
  45
  46  protected:
  47   BluetoothSocketNet(scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
  48                      scoped_refptr<BluetoothSocketThread> socket_thread,
  49                      net::NetLog* net_log,
  50                      const net::NetLog::Source& source);
  51   virtual ~BluetoothSocketNet();
  52
  53   // Resets locally held data after a socket is closed. Default implementation
  54   // does nothing, subclasses may override.
  55   virtual void ResetData();
  56
  57   // Methods for subclasses to obtain the members.
  58   scoped_refptr<base::SequencedTaskRunner> ui_task_runner() const {
  59     return ui_task_runner_;
  60   }
  61
  62   scoped_refptr<BluetoothSocketThread> socket_thread() const {
  63     return socket_thread_;
  64   }
  65
  66   net::NetLog* net_log() const { return net_log_; }
  67   const net::NetLog::Source& source() const { return source_; }
  68
  69   net::TCPSocket* tcp_socket() { return tcp_socket_.get(); }
  70
  71   void ResetTCPSocket();
  72   void SetTCPSocket(scoped_ptr<net::TCPSocket> tcp_socket);
  73
  74   void PostSuccess(const base::Closure& callback);
  75   void PostErrorCompletion(const ErrorCompletionCallback& callback,
  76                            const std::string& error);
  77
  78  private:
  79   struct WriteRequest {
  80     WriteRequest();
  81     ~WriteRequest();
  82
  83     scoped_refptr<net::IOBuffer> buffer;
  84     int buffer_size;
  85     SendCompletionCallback success_callback;
  86     ErrorCompletionCallback error_callback;
  87   };
  88
  89   void DoClose();
  90   void DoDisconnect(const base::Closure& callback);
  91   void DoReceive(int buffer_size,
  92                  const ReceiveCompletionCallback& success_callback,
  93                  const ReceiveErrorCompletionCallback& error_callback);
  94   void OnSocketReadComplete(
  95       const ReceiveCompletionCallback& success_callback,
  96       const ReceiveErrorCompletionCallback& error_callback,
  97       int read_result);
  98   void DoSend(scoped_refptr<net::IOBuffer> buffer,
  99               int buffer_size,
 100               const SendCompletionCallback& success_callback,
 101               const ErrorCompletionCallback& error_callback);
 102   void SendFrontWriteRequest();
 103   void OnSocketWriteComplete(const SendCompletionCallback& success_callback,
 104                              const ErrorCompletionCallback& error_callback,
 105                              int send_result);
 106
 107   void PostReceiveCompletion(const ReceiveCompletionCallback& callback,
 108                              int io_buffer_size,
 109                              scoped_refptr<net::IOBuffer> io_buffer);
 110   void PostReceiveErrorCompletion(
 111       const ReceiveErrorCompletionCallback& callback,
 112       ErrorReason reason,
 113       const std::string& error_message);
 114   void PostSendCompletion(const SendCompletionCallback& callback,
 115                           int bytes_written);
 116
 117   scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
 118   scoped_refptr<BluetoothSocketThread> socket_thread_;
 119   net::NetLog* net_log_;
 120   const net::NetLog::Source source_;
 121
 122   scoped_ptr<net::TCPSocket> tcp_socket_;
 123   scoped_refptr<net::IOBufferWithSize> read_buffer_;
 124   std::queue<linked_ptr<WriteRequest> > write_queue_;
 125
 126   DISALLOW_COPY_AND_ASSIGN(BluetoothSocketNet);
 127 };
 128
 129 }  // namespace device
 130
 131 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_SOCKET_NET_H_