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>
 
@@ skipping 167 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_,
+                                    file_task_runner_,
+                                    net_log_,
+                                    net_log_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_, file_task_runner_, net_log_, net_log_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 27 matching lines @@
 void BluetoothAdapterWin::InitForTest(
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner) {
   ui_task_runner_ = ui_task_runner;
   task_manager_ =
       new BluetoothTaskManagerWin(ui_task_runner_);
   task_manager_->AddObserver(this);
   task_manager_->InitializeWithBluetoothTaskRunner(bluetooth_task_runner);
 }
 
+void BluetoothAdapterWin::PostInit(
+    scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
+    scoped_refptr<base::SequencedTaskRunner> file_task_runner,
+    net::NetLog* net_log,
+    const net::NetLog::Source& net_log_source) {
+  ui_task_runner_ = ui_task_runner;
+  file_task_runner_ = file_task_runner;
+  net_log_ = net_log;
+  net_log_source_ = net_log_source;
+}
+
 void BluetoothAdapterWin::MaybePostStartDiscoveryTask() {
   if (discovery_status_ == NOT_DISCOVERING &&
       !on_start_discovery_callbacks_.empty()) {
     discovery_status_ = DISCOVERY_STARTING;
     task_manager_->PostStartDiscoveryTask();
   }
 }
 
 void BluetoothAdapterWin::MaybePostStopDiscoveryTask() {
   if (discovery_status_ != DISCOVERING)
     return;
 
   if (on_stop_discovery_callbacks_.size() < num_discovery_listeners_) {
     for (std::vector<base::Closure>::const_iterator iter =
              on_stop_discovery_callbacks_.begin();
          iter != on_stop_discovery_callbacks_.end();
          ++iter) {
       ui_task_runner_->PostTask(FROM_HERE, *iter);
     }
     num_discovery_listeners_ -= on_stop_discovery_callbacks_.size();
     on_stop_discovery_callbacks_.clear();
     return;
   }
 
   discovery_status_ = DISCOVERY_STOPPING;
   task_manager_->PostStopDiscoveryTask();
 }
 
 }  // namespace device