device/bluetooth/bluetooth_socket_net.cc

   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 #include "device/bluetooth/bluetooth_socket_net.h"
   6
   7 #include <queue>
   8 #include <string>
   9
  10 #include "base/logging.h"
  11 #include "base/memory/linked_ptr.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/sequenced_task_runner.h"
  15 #include "base/threading/thread_restrictions.h"
  16 #include "device/bluetooth/bluetooth_socket.h"
  17 #include "device/bluetooth/bluetooth_socket_thread.h"
  18 #include "net/base/io_buffer.h"
  19 #include "net/base/net_errors.h"
  20
  21 namespace {
  22
  23 const char kSocketNotConnected[] = "Socket is not connected.";
  24
  25 static void DeactivateSocket(
  26     const scoped_refptr<device::BluetoothSocketThread>& socket_thread) {
  27   socket_thread->OnSocketDeactivate();
  28 }
  29
  30 }  // namespace
  31
  32 namespace device {
  33
  34 BluetoothSocketNet::WriteRequest::WriteRequest()
  35     : buffer_size(0) {}
  36
  37 BluetoothSocketNet::WriteRequest::~WriteRequest() {}
  38
  39 BluetoothSocketNet::BluetoothSocketNet(
  40     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
  41     scoped_refptr<BluetoothSocketThread> socket_thread,
  42     net::NetLog* net_log,
  43     const net::NetLog::Source& source)
  44     : ui_task_runner_(ui_task_runner),
  45       socket_thread_(socket_thread),
  46       net_log_(net_log),
  47       source_(source) {
  48   DCHECK(ui_task_runner->RunsTasksOnCurrentThread());
  49   socket_thread_->OnSocketActivate();
  50 }
  51
  52 BluetoothSocketNet::~BluetoothSocketNet() {
  53   DCHECK(tcp_socket_.get() == NULL);
  54   ui_task_runner_->PostTask(FROM_HERE,
  55                             base::Bind(&DeactivateSocket, socket_thread_));
  56 }
  57
  58 void BluetoothSocketNet::Close() {
  59   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
  60   socket_thread_->task_runner()->PostTask(
  61       FROM_HERE, base::Bind(&BluetoothSocketNet::DoClose, this));
  62 }
  63
  64 void BluetoothSocketNet::Disconnect(
  65     const base::Closure& success_callback) {
  66   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
  67   socket_thread_->task_runner()->PostTask(
  68       FROM_HERE,
  69       base::Bind(
  70           &BluetoothSocketNet::DoDisconnect,
  71           this,
  72           base::Bind(&BluetoothSocketNet::PostSuccess,
  73                      this,
  74                      success_callback)));
  75 }
  76
  77 void BluetoothSocketNet::Receive(
  78     int buffer_size,
  79     const ReceiveCompletionCallback& success_callback,
  80     const ReceiveErrorCompletionCallback& error_callback) {
  81   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
  82   socket_thread_->task_runner()->PostTask(
  83       FROM_HERE,
  84       base::Bind(
  85           &BluetoothSocketNet::DoReceive,
  86           this,
  87           buffer_size,
  88           base::Bind(&BluetoothSocketNet::PostReceiveCompletion,
  89                      this,
  90                      success_callback),
  91           base::Bind(&BluetoothSocketNet::PostReceiveErrorCompletion,
  92                      this,
  93                      error_callback)));
  94 }
  95
  96 void BluetoothSocketNet::Send(
  97     scoped_refptr<net::IOBuffer> buffer,
  98     int buffer_size,
  99     const SendCompletionCallback& success_callback,
 100     const ErrorCompletionCallback& error_callback) {
 101   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 102   socket_thread_->task_runner()->PostTask(
 103       FROM_HERE,
 104       base::Bind(
 105           &BluetoothSocketNet::DoSend,
 106           this,
 107           buffer,
 108           buffer_size,
 109           base::Bind(&BluetoothSocketNet::PostSendCompletion,
 110                      this,
 111                      success_callback),
 112           base::Bind(&BluetoothSocketNet::PostErrorCompletion,
 113                      this,
 114                      error_callback)));
 115 }
 116
 117 void BluetoothSocketNet::ResetData() {
 118 }
 119
 120 void BluetoothSocketNet::ResetTCPSocket() {
 121   tcp_socket_.reset(new net::TCPSocket(net_log_, source_));
 122 }
 123
 124 void BluetoothSocketNet::SetTCPSocket(scoped_ptr<net::TCPSocket> tcp_socket) {
 125   tcp_socket_ = tcp_socket.Pass();
 126 }
 127
 128 void BluetoothSocketNet::PostSuccess(const base::Closure& callback) {
 129   ui_task_runner_->PostTask(FROM_HERE, callback);
 130 }
 131
 132 void BluetoothSocketNet::PostErrorCompletion(
 133     const ErrorCompletionCallback& callback,
 134     const std::string& error) {
 135   ui_task_runner_->PostTask(FROM_HERE, base::Bind(callback, error));
 136 }
 137
 138 void BluetoothSocketNet::DoClose() {
 139   DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
 140   base::ThreadRestrictions::AssertIOAllowed();
 141
 142   if (tcp_socket_) {
 143     tcp_socket_->Close();
 144     tcp_socket_.reset(NULL);
 145   }
 146
 147   // Note: Closing |tcp_socket_| above released all potential pending
 148   // Send/Receive operations, so we can no safely release the state associated
 149   // to those pending operations.
 150   read_buffer_ = NULL;
 151   std::queue<linked_ptr<WriteRequest> > empty;
 152   std::swap(write_queue_, empty);
 153
 154   ResetData();
 155 }
 156
 157 void BluetoothSocketNet::DoDisconnect(const base::Closure& callback) {
 158   DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
 159   base::ThreadRestrictions::AssertIOAllowed();
 160
 161   DoClose();
 162   callback.Run();
 163 }
 164
 165 void BluetoothSocketNet::DoReceive(
 166     int buffer_size,
 167     const ReceiveCompletionCallback& success_callback,
 168     const ReceiveErrorCompletionCallback& error_callback) {
 169   DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
 170   base::ThreadRestrictions::AssertIOAllowed();
 171
 172   if (!tcp_socket_) {
 173     error_callback.Run(BluetoothSocket::kDisconnected, kSocketNotConnected);
 174     return;
 175   }
 176
 177   // Only one pending read at a time
 178   if (read_buffer_.get()) {
 179     error_callback.Run(BluetoothSocket::kIOPending,
 180                        net::ErrorToString(net::ERR_IO_PENDING));
 181     return;
 182   }
 183
 184   scoped_refptr<net::IOBufferWithSize> buffer(
 185       new net::IOBufferWithSize(buffer_size));
 186   int read_result =
 187       tcp_socket_->Read(buffer.get(),
 188                         buffer->size(),
 189                         base::Bind(&BluetoothSocketNet::OnSocketReadComplete,
 190                                    this,
 191                                    success_callback,
 192                                    error_callback));
 193
 194   read_buffer_ = buffer;
 195   if (read_result != net::ERR_IO_PENDING)
 196     OnSocketReadComplete(success_callback, error_callback, read_result);
 197 }
 198
 199 void BluetoothSocketNet::OnSocketReadComplete(
 200     const ReceiveCompletionCallback& success_callback,
 201     const ReceiveErrorCompletionCallback& error_callback,
 202     int read_result) {
 203   DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
 204   base::ThreadRestrictions::AssertIOAllowed();
 205
 206   scoped_refptr<net::IOBufferWithSize> buffer;
 207   buffer.swap(read_buffer_);
 208   if (read_result > 0) {
 209     success_callback.Run(read_result, buffer);
 210   } else if (read_result == net::OK ||
 211              read_result == net::ERR_CONNECTION_CLOSED ||
 212              read_result == net::ERR_CONNECTION_RESET) {
 213     error_callback.Run(BluetoothSocket::kDisconnected,
 214                        net::ErrorToString(read_result));
 215   } else {
 216     error_callback.Run(BluetoothSocket::kSystemError,
 217                        net::ErrorToString(read_result));
 218   }
 219 }
 220
 221 void BluetoothSocketNet::DoSend(
 222     scoped_refptr<net::IOBuffer> buffer,
 223     int buffer_size,
 224     const SendCompletionCallback& success_callback,
 225     const ErrorCompletionCallback& error_callback) {
 226   DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
 227   base::ThreadRestrictions::AssertIOAllowed();
 228
 229   if (!tcp_socket_) {
 230     error_callback.Run(kSocketNotConnected);
 231     return;
 232   }
 233
 234   linked_ptr<WriteRequest> request(new WriteRequest());
 235   request->buffer = buffer;
 236   request->buffer_size = buffer_size;
 237   request->success_callback = success_callback;
 238   request->error_callback = error_callback;
 239
 240   write_queue_.push(request);
 241   if (write_queue_.size() == 1) {
 242     SendFrontWriteRequest();
 243   }
 244 }
 245
 246 void BluetoothSocketNet::SendFrontWriteRequest() {
 247   DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
 248   base::ThreadRestrictions::AssertIOAllowed();
 249
 250   if (!tcp_socket_)
 251     return;
 252
 253   if (write_queue_.size() == 0)
 254     return;
 255
 256   linked_ptr<WriteRequest> request = write_queue_.front();
 257   net::CompletionCallback callback =
 258       base::Bind(&BluetoothSocketNet::OnSocketWriteComplete,
 259                  this,
 260                  request->success_callback,
 261                  request->error_callback);
 262   int send_result =
 263       tcp_socket_->Write(request->buffer, request->buffer_size, callback);
 264   if (send_result != net::ERR_IO_PENDING) {
 265     callback.Run(send_result);
 266   }
 267 }
 268
 269 void BluetoothSocketNet::OnSocketWriteComplete(
 270     const SendCompletionCallback& success_callback,
 271     const ErrorCompletionCallback& error_callback,
 272     int send_result) {
 273   DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
 274   base::ThreadRestrictions::AssertIOAllowed();
 275
 276   write_queue_.pop();
 277
 278   if (send_result >= net::OK) {
 279     success_callback.Run(send_result);
 280   } else {
 281     error_callback.Run(net::ErrorToString(send_result));
 282   }
 283
 284   // Don't call directly to avoid potentail large recursion.
 285   socket_thread_->task_runner()->PostNonNestableTask(
 286       FROM_HERE,
 287       base::Bind(&BluetoothSocketNet::SendFrontWriteRequest, this));
 288 }
 289
 290 void BluetoothSocketNet::PostReceiveCompletion(
 291     const ReceiveCompletionCallback& callback,
 292     int io_buffer_size,
 293     scoped_refptr<net::IOBuffer> io_buffer) {
 294   ui_task_runner_->PostTask(FROM_HERE,
 295                             base::Bind(callback, io_buffer_size, io_buffer));
 296 }
 297
 298 void BluetoothSocketNet::PostReceiveErrorCompletion(
 299     const ReceiveErrorCompletionCallback& callback,
 300     ErrorReason reason,
 301     const std::string& error_message) {
 302   ui_task_runner_->PostTask(FROM_HERE,
 303                             base::Bind(callback, reason, error_message));
 304 }
 305
 306 void BluetoothSocketNet::PostSendCompletion(
 307     const SendCompletionCallback& callback,
 308     int bytes_written) {
 309   ui_task_runner_->PostTask(FROM_HERE, base::Bind(callback, bytes_written));
 310 }
 311
 312 }  // namespace device