Implement chrome.bluetoothSocket.listenUsing*()

chrome/browser/extensions/api/bluetooth_socket/bluetooth_socket_api.cc

Index: chrome/browser/extensions/api/bluetooth_socket/bluetooth_socket_api.cc
diff --git a/chrome/browser/extensions/api/bluetooth_socket/bluetooth_socket_api.cc b/chrome/browser/extensions/api/bluetooth_socket/bluetooth_socket_api.cc
index 12213598455d054db6ed1fe2a83d6c51d3abf887..184311bd7ee6577aab59e39f8105026f07fe0752 100644
--- a/chrome/browser/extensions/api/bluetooth_socket/bluetooth_socket_api.cc
+++ b/chrome/browser/extensions/api/bluetooth_socket/bluetooth_socket_api.cc
@@ -45,9 +45,8 @@ linked_ptr<SocketInfo> CreateSocketInfo(int socket_id,
   socket_info->paused = socket->paused();
   socket_info->connected = socket->IsConnected();
 
-  // TODO(keybuk): These should not be present if socket isn't connected or
-  // listening.
-  socket_info->address.reset(new std::string(socket->device_address()));
+  if (socket->IsConnected())

[armansito, 2014/05/08 22:00:16]

Does IsConnected imply listening?

[keybuk, 2014/05/08 22:02:46]

A BluetoothApiSocket can be:
 - created
 - connected
 - listening
 - disconnected

IsConnected() only matches the second one - that's also the only state for which
the address member would be valid.

[armansito, 2014/05/08 22:25:14]

OK. I commented on this because your previous comment said "isn't connected or
listening". So the removed comment was incorrect or do we want to check for
listening as well? Does listening mean that it's listening for incoming
connections and hence there is no address associated with it?

+    socket_info->address.reset(new std::string(socket->device_address()));
   socket_info->uuid.reset(new std::string(socket->uuid().canonical_value()));
 
   return socket_info;
@@ -223,22 +222,195 @@ void BluetoothSocketSetPausedFunction::Work() {
   results_ = bluetooth_socket::SetPaused::Results::Create();
 }
 
-bool BluetoothSocketListenUsingRfcommFunction::RunAsync() {
-  // TODO(keybuk): Implement.
-  SetError("Not yet implemented.");
-  return false;
+BluetoothSocketListenFunction::BluetoothSocketListenFunction() {}
+
+BluetoothSocketListenFunction::~BluetoothSocketListenFunction() {}
+
+bool BluetoothSocketListenFunction::Prepare() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!CreateParams())
+    return false;
+  socket_event_dispatcher_ = GetSocketEventDispatcher(browser_context());
+  return socket_event_dispatcher_ != NULL;
+}
+
+void BluetoothSocketListenFunction::AsyncWorkStart() {
+  DCHECK(BrowserThread::CurrentlyOn(work_thread_id()));
+  device::BluetoothAdapterFactory::GetAdapter(
+      base::Bind(&BluetoothSocketListenFunction::OnGetAdapter, this));
+}
+
+void BluetoothSocketListenFunction::OnGetAdapter(
+    scoped_refptr<device::BluetoothAdapter> adapter) {
+  DCHECK(BrowserThread::CurrentlyOn(work_thread_id()));
+  BluetoothApiSocket* socket = GetSocket(socket_id());
+  if (!socket) {
+    error_ = kSocketNotFoundError;
+    AsyncWorkCompleted();
+    return;
+  }
+
+  device::BluetoothUUID bluetooth_uuid(uuid());
+  if (!bluetooth_uuid.IsValid()) {
+    error_ = kInvalidUuidError;
+    AsyncWorkCompleted();
+    return;
+  }
+
+  BluetoothPermissionRequest param(uuid());
+  if (!BluetoothManifestData::CheckRequest(GetExtension(), param)) {
+    error_ = kPermissionDeniedError;
+    AsyncWorkCompleted();
+    return;
+  }
+
+  CreateService(
+      adapter,
+      bluetooth_uuid,
+      base::Bind(&BluetoothSocketListenFunction::OnCreateService, this),
+      base::Bind(&BluetoothSocketListenFunction::OnCreateServiceError, this));
+}
+
+
+void BluetoothSocketListenFunction::OnCreateService(
+    scoped_refptr<device::BluetoothSocket> socket) {
+  DCHECK(BrowserThread::CurrentlyOn(work_thread_id()));
+
+  // Fetch the socket again since this is not a reference-counted object, and
+  // it may have gone away in the meantime (we check earlier to avoid making
+  // a connection in the case of an obvious programming error).
+  BluetoothApiSocket* api_socket = GetSocket(socket_id());
+  if (!api_socket) {
+    error_ = kSocketNotFoundError;
+    AsyncWorkCompleted();
+    return;
+  }
+
+  api_socket->AdoptListeningSocket(socket,
+                                   device::BluetoothUUID(uuid()));
+  socket_event_dispatcher_->OnSocketListen(extension_id(), socket_id());
+
+  CreateResults();
+  AsyncWorkCompleted();
 }
 
-bool BluetoothSocketListenUsingInsecureRfcommFunction::RunAsync() {
-  // TODO(keybuk): Implement.
-  SetError("Not yet implemented.");
-  return false;
+void BluetoothSocketListenFunction::OnCreateServiceError(
+    const std::string& message) {
+  DCHECK(BrowserThread::CurrentlyOn(work_thread_id()));
+  error_ = message;
+  AsyncWorkCompleted();
+}
+
+BluetoothSocketListenUsingRfcommFunction::
+    BluetoothSocketListenUsingRfcommFunction() {}
+
+BluetoothSocketListenUsingRfcommFunction::
+    ~BluetoothSocketListenUsingRfcommFunction() {}
+
+int BluetoothSocketListenUsingRfcommFunction::socket_id() const {
+  return params_->socket_id;
+}
+
+const std::string& BluetoothSocketListenUsingRfcommFunction::uuid() const {
+  return params_->uuid;
+}
+
+bool BluetoothSocketListenUsingRfcommFunction::CreateParams() {
+  params_ = bluetooth_socket::ListenUsingRfcomm::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void BluetoothSocketListenUsingRfcommFunction::CreateService(
+    scoped_refptr<device::BluetoothAdapter> adapter,
+    const device::BluetoothUUID& uuid,
+    const device::BluetoothAdapter::CreateServiceCallback& callback,
+    const device::BluetoothAdapter::CreateServiceErrorCallback&
+        error_callback) {
+  int channel = params_->channel;
+  if (!channel)
+    channel = device::BluetoothAdapter::kChannelAuto;
+
+  adapter->CreateRfcommService(uuid, channel, false, callback, error_callback);
+}
+
+void BluetoothSocketListenUsingRfcommFunction::CreateResults() {
+  results_ = bluetooth_socket::ListenUsingRfcomm::Results::Create();
+}
+
+BluetoothSocketListenUsingInsecureRfcommFunction::
+    BluetoothSocketListenUsingInsecureRfcommFunction() {}
+
+BluetoothSocketListenUsingInsecureRfcommFunction::
+    ~BluetoothSocketListenUsingInsecureRfcommFunction() {}
+
+int BluetoothSocketListenUsingInsecureRfcommFunction::socket_id() const {
+  return params_->socket_id;
+}
+
+const std::string&
+BluetoothSocketListenUsingInsecureRfcommFunction::uuid() const {
+  return params_->uuid;
+}
+
+bool BluetoothSocketListenUsingInsecureRfcommFunction::CreateParams() {
+  params_ = bluetooth_socket::ListenUsingInsecureRfcomm::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void BluetoothSocketListenUsingInsecureRfcommFunction::CreateService(
+    scoped_refptr<device::BluetoothAdapter> adapter,
+    const device::BluetoothUUID& uuid,
+    const device::BluetoothAdapter::CreateServiceCallback& callback,
+    const device::BluetoothAdapter::CreateServiceErrorCallback&
+        error_callback) {
+  int channel = params_->channel;
+  if (!channel)
+    channel = device::BluetoothAdapter::kChannelAuto;
+
+  adapter->CreateRfcommService(uuid, channel, true, callback, error_callback);
+}
+
+void BluetoothSocketListenUsingInsecureRfcommFunction::CreateResults() {
+  results_ = bluetooth_socket::ListenUsingInsecureRfcomm::Results::Create();
+}
+
+BluetoothSocketListenUsingL2capFunction::
+    BluetoothSocketListenUsingL2capFunction() {}
+
+BluetoothSocketListenUsingL2capFunction::
+    ~BluetoothSocketListenUsingL2capFunction() {}
+
+int BluetoothSocketListenUsingL2capFunction::socket_id() const {
+  return params_->socket_id;
+}
+
+const std::string& BluetoothSocketListenUsingL2capFunction::uuid() const {
+  return params_->uuid;
+}
+
+bool BluetoothSocketListenUsingL2capFunction::CreateParams() {
+  params_ = bluetooth_socket::ListenUsingL2cap::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void BluetoothSocketListenUsingL2capFunction::CreateService(
+    scoped_refptr<device::BluetoothAdapter> adapter,
+    const device::BluetoothUUID& uuid,
+    const device::BluetoothAdapter::CreateServiceCallback& callback,
+    const device::BluetoothAdapter::CreateServiceErrorCallback&
+        error_callback) {
+  int psm = params_->psm;
+  if (!psm)
+    psm = device::BluetoothAdapter::kPsmAuto;
+
+  adapter->CreateL2capService(uuid, psm, callback, error_callback);
 }
 
-bool BluetoothSocketListenUsingL2capFunction::RunAsync() {
-  // TODO(keybuk): Implement.
-  SetError("Not yet implemented.");
-  return false;
+void BluetoothSocketListenUsingL2capFunction::CreateResults() {
+  results_ = bluetooth_socket::ListenUsingL2cap::Results::Create();
 }
 
 BluetoothSocketConnectFunction::BluetoothSocketConnectFunction() {}