Implement fake Bluetooth adapter for BluetoothTest.ConstructFakeAdapter

device/bluetooth/bluetooth_task_manager_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_task_manager_win.h"
 
 #include <stddef.h>
 #include <winsock2.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "base/win/scoped_handle.h"
 #include "device/bluetooth/bluetooth_classic_win.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_init_win.h"
 #include "device/bluetooth/bluetooth_low_energy_win.h"
 #include "device/bluetooth/bluetooth_service_record_win.h"
 #include "net/base/winsock_init.h"
 
 namespace {
 
 const int kNumThreadsInWorkerPool = 3;
@@ skipping 105 matching lines @@
       bluetooth_class(0) {
 }
 
 BluetoothTaskManagerWin::DeviceState::~DeviceState() {
 }
 
 BluetoothTaskManagerWin::BluetoothTaskManagerWin(
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner)
     : ui_task_runner_(ui_task_runner),
       discovering_(false),
-      current_logging_batch_count_(0) {
-}
+      current_logging_batch_count_(0),
+      adapter_handle_(NULL) {}
 
 BluetoothTaskManagerWin::~BluetoothTaskManagerWin() {
   win::BluetoothLowEnergyWrapper::DeleteInstance();
   win::BluetoothClassicWrapper::DeleteInstance();
 }
 
 void BluetoothTaskManagerWin::AddObserver(Observer* observer) {
   DCHECK(observer);
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   observers_.AddObserver(observer);
@@ skipping 133 matching lines @@
       BluetoothTaskManagerWin::Observer, observers_, DevicesPolled(*devices));
 }
 
 void BluetoothTaskManagerWin::PollAdapter() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 
   // Skips updating the adapter info if the adapter is in discovery mode.
   if (!discovering_) {
     const BLUETOOTH_FIND_RADIO_PARAMS adapter_param =
         { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) };
-    if (adapter_handle_.IsValid())
-      adapter_handle_.Close();
     HANDLE temp_adapter_handle;
     HBLUETOOTH_RADIO_FIND handle =
         win::BluetoothClassicWrapper::GetInstance()->FindFirstRadio(
             &adapter_param, &temp_adapter_handle);
 
     if (handle) {
-      adapter_handle_.Set(temp_adapter_handle);
+      adapter_handle_ = temp_adapter_handle;
       GetKnownDevices();
       win::BluetoothClassicWrapper::GetInstance()->FindRadioClose(handle);
     }
 
     PostAdapterStateToUi();
   }
 
   // Re-poll.
   bluetooth_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::PollAdapter,
                  this),
       base::TimeDelta::FromMilliseconds(kPollIntervalMs));
 }
 
 void BluetoothTaskManagerWin::PostAdapterStateToUi() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   AdapterState* state = new AdapterState();
-  GetAdapterState(adapter_handle_.Get(), state);
+  GetAdapterState(adapter_handle_, state);
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged,
                  this,
                  base::Owned(state)));
 }
 
 void BluetoothTaskManagerWin::SetPowered(
     bool powered,
     const base::Closure& callback,
     const BluetoothAdapter::ErrorCallback& error_callback) {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   bool success = false;
-  if (adapter_handle_.IsValid()) {
+  if (adapter_handle_) {
     if (!powered) {
       win::BluetoothClassicWrapper::GetInstance()->EnableDiscovery(
-          adapter_handle_.Get(), false);
+          adapter_handle_, false);
     }
     success = !!win::BluetoothClassicWrapper::GetInstance()
-                    ->EnableIncomingConnections(adapter_handle_.Get(), powered);
+                    ->EnableIncomingConnections(adapter_handle_, powered);
   }
 
   if (success) {
     PostAdapterStateToUi();
     ui_task_runner_->PostTask(FROM_HERE, callback);
   } else {
     ui_task_runner_->PostTask(FROM_HERE, error_callback);
   }
 }
 
 void BluetoothTaskManagerWin::StartDiscovery() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   ui_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStarted,
-                 this,
-                 adapter_handle_.IsValid()));
-  if (!adapter_handle_.IsValid())
+      FROM_HERE, base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStarted, this,
+                            !!adapter_handle_));
+  if (!adapter_handle_)
     return;
   discovering_ = true;
 
   DiscoverDevices(1);
 }
 
 void BluetoothTaskManagerWin::StopDiscovery() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   discovering_ = false;
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
 }
 
 void BluetoothTaskManagerWin::DiscoverDevices(int timeout_multiplier) {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
-  if (!discovering_ || !adapter_handle_.IsValid()) {
+  if (!discovering_ || !adapter_handle_) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
     return;
   }
 
   scoped_ptr<ScopedVector<DeviceState> > device_list(
       new ScopedVector<DeviceState>());
   if (SearchDevices(timeout_multiplier, false, device_list.get())) {
     ui_task_runner_->PostTask(
@@ skipping 48 matching lines @@
   device_search_params.fIssueInquiry = (search_cached_devices_only ? 0 : 1);
   device_search_params.cTimeoutMultiplier = timeout_multiplier;
 
   BLUETOOTH_DEVICE_INFO device_info;
   ZeroMemory(&device_info, sizeof(device_info));
   device_info.dwSize = sizeof(BLUETOOTH_DEVICE_INFO);
   HBLUETOOTH_DEVICE_FIND handle =
       win::BluetoothClassicWrapper::GetInstance()->FindFirstDevice(
           &device_search_params, &device_info);
   if (!handle) {
-    int last_error = GetLastError();
+    int last_error = win::BluetoothClassicWrapper::GetInstance()->LastError();
     if (last_error == ERROR_NO_MORE_ITEMS) {
       return true;  // No devices is not an error.
     }
     LogPollingError("Error calling BluetoothFindFirstDevice", last_error);
     return false;
   }
 
   while (true) {
     DeviceState* device_state = new DeviceState();
     GetDeviceState(device_info, device_state);
     device_list->push_back(device_state);
 
     // Reset device info before next call (as a safety precaution).
     ZeroMemory(&device_info, sizeof(device_info));
     device_info.dwSize = sizeof(BLUETOOTH_DEVICE_INFO);
     if (!win::BluetoothClassicWrapper::GetInstance()->FindNextDevice(
             handle, &device_info)) {
-      int last_error = GetLastError();
+      int last_error = win::BluetoothClassicWrapper::GetInstance()->LastError();
       if (last_error == ERROR_NO_MORE_ITEMS) {
         break;  // No more items is expected error when done enumerating.
       }
       LogPollingError("Error calling BluetoothFindNextDevice", last_error);
       win::BluetoothClassicWrapper::GetInstance()->FindDeviceClose(handle);
       return false;
     }
   }
 
   if (!win::BluetoothClassicWrapper::GetInstance()->FindDeviceClose(handle)) {
-    LogPollingError("Error calling BluetoothFindDeviceClose", GetLastError());
+    LogPollingError("Error calling BluetoothFindDeviceClose",
+                    win::BluetoothClassicWrapper::GetInstance()->LastError());
     return false;
   }
   return true;
 }
 
 bool BluetoothTaskManagerWin::SearchLowEnergyDevices(
     ScopedVector<DeviceState>* device_list) {
   if (!win::IsBluetoothLowEnergySupported())
     return true;  // Bluetooth LE not supported is not an error.
 
@@ skipping 231 matching lines @@
           break;
         }
       }
     }
   }
 
   return true;
 }
 
 }  // namespace device