Implement chrome.bluetoothSocket.listenUsing*()

chrome/browser/extensions/api/bluetooth/bluetooth_api_socket.cc

 // Copyright 2014 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 "chrome/browser/extensions/api/bluetooth/bluetooth_api_socket.h"
 
 #include "device/bluetooth/bluetooth_socket.h"
 #include "net/base/io_buffer.h"
 
 namespace {
 
 const char kSocketNotConnectedError[] = "Socket not connected";
+const char kSocketNotListeningError[] = "Socket not listening";
 
 }  // namespace
 
 namespace extensions {
 
 // static
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<ApiResourceManager<BluetoothApiSocket> > >
     g_server_factory = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 43 matching lines @@
 
   if (socket_.get())
     socket_->Close();
 
   socket_ = socket;
   device_address_ = device_address;
   uuid_ = uuid;
   connected_ = true;
 }
 
-void BluetoothApiSocket::Disconnect(const base::Closure& success_callback) {
+void BluetoothApiSocket::AdoptListeningSocket(
+    scoped_refptr<device::BluetoothSocket> socket,
+    const device::BluetoothUUID& uuid) {
   DCHECK(content::BrowserThread::CurrentlyOn(kThreadId));
 
-  if (!socket_.get() || !IsConnected()) {
-    success_callback.Run();
+  if (socket_.get())
+    socket_->Close();
+
+  socket_ = socket;
+  device_address_ = "";
+  uuid_ = uuid;
+  connected_ = false;
+}
+
+void BluetoothApiSocket::Disconnect(const base::Closure& callback) {
+  DCHECK(content::BrowserThread::CurrentlyOn(kThreadId));
+
+  if (!socket_.get()) {
+    callback.Run();
     return;
   }
 
-  socket_->Disconnect(success_callback);
+  connected_ = false;
+  socket_->Disconnect(callback);
 }
 
 bool BluetoothApiSocket::IsPersistent() const {
   DCHECK(content::BrowserThread::CurrentlyOn(kThreadId));
   return persistent_;
 }
 
 void BluetoothApiSocket::Receive(
     int count,
     const ReceiveCompletionCallback& success_callback,
@@ skipping 51 matching lines @@
                 success_callback,
                 base::Bind(&OnSocketSendError, error_callback));
 }
 
 // static
 void BluetoothApiSocket::OnSocketSendError(
     const ErrorCompletionCallback& error_callback,
     const std::string& message) {
   DCHECK(content::BrowserThread::CurrentlyOn(kThreadId));
   error_callback.Run(BluetoothApiSocket::kSystemError, message);
+}
 
+void BluetoothApiSocket::Accept(
+    const AcceptCompletionCallback& success_callback,
+    const ErrorCompletionCallback& error_callback) {
+  DCHECK(content::BrowserThread::CurrentlyOn(kThreadId));
+
+  if (!socket_.get() || IsConnected()) {
+    error_callback.Run(BluetoothApiSocket::kNotListening,
+                       kSocketNotListeningError);
+    return;
+  }
+
+  socket_->Accept(success_callback,
+                  base::Bind(&OnSocketAcceptError, error_callback));
+}
+
+// static
+void BluetoothApiSocket::OnSocketAcceptError(
+    const ErrorCompletionCallback& error_callback,
+    const std::string& message) {
+  DCHECK(content::BrowserThread::CurrentlyOn(kThreadId));
+  error_callback.Run(BluetoothApiSocket::kSystemError, message);
 }
 
 }  // namespace extensions