chrome.bluetooth API improvements.

device/bluetooth/bluetooth_adapter_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_adapter_win.h"
 
 #include <hash_set>
 #include <string>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/bluetooth/bluetooth_device_win.h"
+#include "device/bluetooth/bluetooth_socket_thread_win.h"
 #include "device/bluetooth/bluetooth_task_manager_win.h"
 
 namespace device {
 
 BluetoothAdapterWin::BluetoothAdapterWin(const InitCallback& init_callback)
     : BluetoothAdapter(),
       init_callback_(init_callback),
       initialized_(false),
       powered_(false),
       discovery_status_(NOT_DISCOVERING),
@@ skipping 151 matching lines @@
 
 void BluetoothAdapterWin::DevicesDiscovered(
     const ScopedVector<BluetoothTaskManagerWin::DeviceState>& devices) {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (ScopedVector<BluetoothTaskManagerWin::DeviceState>::const_iterator iter =
            devices.begin();
        iter != devices.end();
        ++iter) {
     if (discovered_devices_.find((*iter)->address) ==
         discovered_devices_.end()) {
-      BluetoothDeviceWin device_win(**iter);
+      BluetoothDeviceWin device_win(
+          **iter, ui_task_runner_, socket_thread_, NULL, net::NetLog::Source());
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         DeviceAdded(this, &device_win));
       discovered_devices_.insert((*iter)->address);
     }
   }
 }
 
 void BluetoothAdapterWin::DevicesUpdated(
     const ScopedVector<BluetoothTaskManagerWin::DeviceState>& devices) {
   STLDeleteValues(&devices_);
   for (ScopedVector<BluetoothTaskManagerWin::DeviceState>::const_iterator iter =
            devices.begin();
        iter != devices.end();
        ++iter) {
-    devices_[(*iter)->address] = new BluetoothDeviceWin(**iter);
+    devices_[(*iter)->address] = new BluetoothDeviceWin(
+        **iter, ui_task_runner_, socket_thread_, NULL, net::NetLog::Source());
   }
 }
 
 // If the method is called when |discovery_status_| is DISCOVERY_STOPPING,
 // starting again is handled by BluetoothAdapterWin::DiscoveryStopped().
 void BluetoothAdapterWin::AddDiscoverySession(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (discovery_status_ == DISCOVERING) {
     num_discovery_listeners_++;
@@ skipping 11 matching lines @@
   if (discovery_status_ == NOT_DISCOVERING) {
     error_callback.Run();
     return;
   }
   on_stop_discovery_callbacks_.push_back(callback);
   MaybePostStopDiscoveryTask();
 }
 
 void BluetoothAdapterWin::Init() {
   ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+  socket_thread_ = BluetoothSocketThreadWin::Get();
   task_manager_ =
       new BluetoothTaskManagerWin(ui_task_runner_);
   task_manager_->AddObserver(this);
   task_manager_->Initialize();
 }
 
 void BluetoothAdapterWin::InitForTest(
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner) {
   ui_task_runner_ = ui_task_runner;
@@ skipping 25 matching lines @@
     num_discovery_listeners_ -= on_stop_discovery_callbacks_.size();
     on_stop_discovery_callbacks_.clear();
     return;
   }
 
   discovery_status_ = DISCOVERY_STOPPING;
   task_manager_->PostStopDiscoveryTask();
 }
 
 }  // namespace device