extensions/browser/api/bluetooth_socket/bluetooth_api_socket.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 "extensions/browser/api/bluetooth_socket/bluetooth_api_socket.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "device/bluetooth/bluetooth_socket.h"
   9 #include "net/base/io_buffer.h"
  10
  11 namespace {
  12
  13 const char kSocketNotConnectedError[] = "Socket not connected";
  14 const char kSocketNotListeningError[] = "Socket not listening";
  15
  16 }  // namespace
  17
  18 namespace extensions {
  19
  20 // static
  21 static base::LazyInstance<
  22     BrowserContextKeyedAPIFactory<ApiResourceManager<BluetoothApiSocket> > >
  23     g_server_factory = LAZY_INSTANCE_INITIALIZER;
  24
  25 // static
  26 template <>
  27 BrowserContextKeyedAPIFactory<ApiResourceManager<BluetoothApiSocket> >*
  28 ApiResourceManager<BluetoothApiSocket>::GetFactoryInstance() {
  29   return g_server_factory.Pointer();
  30 }
  31
  32 BluetoothApiSocket::BluetoothApiSocket(const std::string& owner_extension_id)
  33     : ApiResource(owner_extension_id),
  34       persistent_(false),
  35       buffer_size_(0),
  36       paused_(false),
  37       connected_(false) {
  38   DCHECK_CURRENTLY_ON(kThreadId);
  39 }
  40
  41 BluetoothApiSocket::BluetoothApiSocket(
  42     const std::string& owner_extension_id,
  43     scoped_refptr<device::BluetoothSocket> socket,
  44     const std::string& device_address,
  45     const device::BluetoothUUID& uuid)
  46     : ApiResource(owner_extension_id),
  47       socket_(socket),
  48       device_address_(device_address),
  49       uuid_(uuid),
  50       persistent_(false),
  51       buffer_size_(0),
  52       paused_(true),
  53       connected_(true) {
  54   DCHECK_CURRENTLY_ON(kThreadId);
  55 }
  56
  57 BluetoothApiSocket::~BluetoothApiSocket() {
  58   DCHECK_CURRENTLY_ON(kThreadId);
  59   if (socket_.get())
  60     socket_->Close();
  61 }
  62
  63 void BluetoothApiSocket::AdoptConnectedSocket(
  64     scoped_refptr<device::BluetoothSocket> socket,
  65     const std::string& device_address,
  66     const device::BluetoothUUID& uuid) {
  67   DCHECK_CURRENTLY_ON(kThreadId);
  68
  69   if (socket_.get())
  70     socket_->Close();
  71
  72   socket_ = socket;
  73   device_address_ = device_address;
  74   uuid_ = uuid;
  75   connected_ = true;
  76 }
  77
  78 void BluetoothApiSocket::AdoptListeningSocket(
  79     scoped_refptr<device::BluetoothSocket> socket,
  80     const device::BluetoothUUID& uuid) {
  81   DCHECK_CURRENTLY_ON(kThreadId);
  82
  83   if (socket_.get())
  84     socket_->Close();
  85
  86   socket_ = socket;
  87   device_address_ = "";
  88   uuid_ = uuid;
  89   connected_ = false;
  90 }
  91
  92 void BluetoothApiSocket::Disconnect(const base::Closure& callback) {
  93   DCHECK_CURRENTLY_ON(kThreadId);
  94
  95   if (!socket_.get()) {
  96     callback.Run();
  97     return;
  98   }
  99
 100   connected_ = false;
 101   socket_->Disconnect(callback);
 102 }
 103
 104 bool BluetoothApiSocket::IsPersistent() const {
 105   DCHECK_CURRENTLY_ON(kThreadId);
 106   return persistent_;
 107 }
 108
 109 void BluetoothApiSocket::Receive(
 110     int count,
 111     const ReceiveCompletionCallback& success_callback,
 112     const ErrorCompletionCallback& error_callback) {
 113   DCHECK_CURRENTLY_ON(kThreadId);
 114
 115   if (!socket_.get() || !IsConnected()) {
 116     error_callback.Run(BluetoothApiSocket::kNotConnected,
 117                        kSocketNotConnectedError);
 118     return;
 119   }
 120
 121   socket_->Receive(count,
 122                    success_callback,
 123                    base::Bind(&OnSocketReceiveError, error_callback));
 124 }
 125
 126 // static
 127 void BluetoothApiSocket::OnSocketReceiveError(
 128     const ErrorCompletionCallback& error_callback,
 129     device::BluetoothSocket::ErrorReason reason,
 130     const std::string& message) {
 131   DCHECK_CURRENTLY_ON(kThreadId);
 132   BluetoothApiSocket::ErrorReason error_reason;
 133   switch (reason) {
 134     case device::BluetoothSocket::kIOPending:
 135       error_reason = BluetoothApiSocket::kIOPending;
 136       break;
 137     case device::BluetoothSocket::kDisconnected:
 138       error_reason = BluetoothApiSocket::kDisconnected;
 139       break;
 140     case device::BluetoothSocket::kSystemError:
 141       error_reason = BluetoothApiSocket::kSystemError;
 142       break;
 143   }
 144   error_callback.Run(error_reason, message);
 145 }
 146
 147 void BluetoothApiSocket::Send(scoped_refptr<net::IOBuffer> buffer,
 148                               int buffer_size,
 149                               const SendCompletionCallback& success_callback,
 150                               const ErrorCompletionCallback& error_callback) {
 151   DCHECK_CURRENTLY_ON(kThreadId);
 152
 153   if (!socket_.get() || !IsConnected()) {
 154     error_callback.Run(BluetoothApiSocket::kNotConnected,
 155                        kSocketNotConnectedError);
 156     return;
 157   }
 158
 159   socket_->Send(buffer,
 160                 buffer_size,
 161                 success_callback,
 162                 base::Bind(&OnSocketSendError, error_callback));
 163 }
 164
 165 // static
 166 void BluetoothApiSocket::OnSocketSendError(
 167     const ErrorCompletionCallback& error_callback,
 168     const std::string& message) {
 169   DCHECK_CURRENTLY_ON(kThreadId);
 170   error_callback.Run(BluetoothApiSocket::kSystemError, message);
 171 }
 172
 173 void BluetoothApiSocket::Accept(
 174     const AcceptCompletionCallback& success_callback,
 175     const ErrorCompletionCallback& error_callback) {
 176   DCHECK_CURRENTLY_ON(kThreadId);
 177
 178   if (!socket_.get() || IsConnected()) {
 179     error_callback.Run(BluetoothApiSocket::kNotListening,
 180                        kSocketNotListeningError);
 181     return;
 182   }
 183
 184   socket_->Accept(success_callback,
 185                   base::Bind(&OnSocketAcceptError, error_callback));
 186 }
 187
 188 // static
 189 void BluetoothApiSocket::OnSocketAcceptError(
 190     const ErrorCompletionCallback& error_callback,
 191     const std::string& message) {
 192   DCHECK_CURRENTLY_ON(kThreadId);
 193   error_callback.Run(BluetoothApiSocket::kSystemError, message);
 194 }
 195
 196 }  // namespace extensions