win: Implement Bluetooth server.

device/bluetooth/bluetooth_socket_win.cc

 // Copyright (c) 2012 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 "device/bluetooth/bluetooth_socket_win.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ skipping 53 matching lines @@
   result->device_address_ = service_record_win->address();
   if (service_record.SupportsRfcomm()) {
     result->supports_rfcomm_ = true;
     result->rfcomm_channel_ = service_record_win->rfcomm_channel();
     result->bth_addr_ = service_record_win->bth_addr();
   }
 
   return result;
 }
 
+// static
+scoped_refptr<BluetoothSocketWin> BluetoothSocketWin::CreateBluetoothSocket(
+    scoped_ptr<net::TCPSocket> existing,
+    scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+    scoped_refptr<BluetoothSocketThreadWin> socket_thread,
+    net::NetLog* net_log,
+    const net::NetLog::Source& source) {
+  DCHECK(ui_task_runner->RunsTasksOnCurrentThread());
+
+  scoped_refptr<BluetoothSocketWin> result(
+      new BluetoothSocketWin(ui_task_runner, socket_thread, net_log, source));
+  result->tcp_socket_ = existing.Pass();
+
+  return result;
+}
+
 BluetoothSocketWin::BluetoothSocketWin(
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<BluetoothSocketThreadWin> socket_thread,
     net::NetLog* net_log,
     const net::NetLog::Source& source)
     : ui_task_runner_(ui_task_runner),
       socket_thread_(socket_thread),
       net_log_(net_log),
       source_(source),
       supports_rfcomm_(false),
@@ skipping 68 matching lines @@
           &BluetoothSocketWin::DoSend,
           this,
           buffer,
           buffer_size,
           base::Bind(
               &BluetoothSocketWin::PostSendCompletion, this, success_callback),
           base::Bind(
               &BluetoothSocketWin::PostErrorCompletion, this, error_callback)));
 }
 
+void BluetoothSocketWin::Accept(
+    const BluetoothSocketWin::OnAcceptCallback& on_accept_callback) {
+  DCHECK(on_accept_callback_.is_null());
+  on_accept_callback_ = on_accept_callback;
+  socket_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&BluetoothSocketWin::DoAccept, this));
+}
+
 void BluetoothSocketWin::DoClose() {
   DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
   base::ThreadRestrictions::AssertIOAllowed();
 
   if (tcp_socket_) {
     tcp_socket_->Close();
     tcp_socket_.reset(NULL);
   }
 
   // Note: Closing |tcp_socket_| above released all potential pending
@@ skipping 220 matching lines @@
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(callback, reason, error_message));
 }
 
 void BluetoothSocketWin::PostSendCompletion(
     const SendCompletionCallback& callback,
     int bytes_written) {
   ui_task_runner_->PostTask(FROM_HERE, base::Bind(callback, bytes_written));
 }
 
+void BluetoothSocketWin::DoAccept() {
+  DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
+  int result = tcp_socket_->Accept(
+      &accept_socket_,
+      &accept_address_,
+      base::Bind(&BluetoothSocketWin::OnAcceptOnSocketThread, this));
+  if (result != net::OK && result != net::ERR_IO_PENDING)
+    LOG(WARNING) << "Failed to accept, net err=" << result;
+}
+
+void BluetoothSocketWin::OnAcceptOnSocketThread(int accept_result) {
+  DCHECK(socket_thread_->task_runner()->RunsTasksOnCurrentThread());
+  if (accept_result != net::OK) {
+    LOG(WARNING) << "OnAccept error, net err=" << accept_result;
+    return;
+  }
+
+  ui_task_runner_->PostTask(
+    FROM_HERE,
+    base::Bind(&BluetoothSocketWin::OnAcceptOnUI,
+               this,
+               base::Passed(&accept_socket_),
+               accept_address_));
+  DoAccept();
+}
+
+void BluetoothSocketWin::OnAcceptOnUI(
+    scoped_ptr<net::TCPSocket> accept_socket,
+    const net::IPEndPoint& peer_address) {
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+
+  on_accept_callback_.Run(
+      CreateBluetoothSocket(
+          accept_socket.Pass(),
+          ui_task_runner_,
+          socket_thread_,
+          net_log_,
+          source_),
+      peer_address);
+}
+
 }  // namespace device