Implemented BluetoothTaskManagerWin class.

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 <BluetoothAPIs.h>
+#if defined(_WIN32_WINNT_WIN8) && _MSC_VER < 1700
+// The Windows 8 SDK defines FACILITY_VISUALCPP in winerror.h.
+#undef FACILITY_VISUALCPP
+#endif
+#include <delayimp.h>
+#include <string>

[brettw, 2013/01/09 20:06:04]

Blank line after this as well as before (separating C includes, C++ includes,
and our includes).

[youngki, 2013/01/09 22:20:14]

Done.

+#include "base/bind.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop.h"
+#include "base/sequenced_task_runner.h"
+#include "base/stringprintf.h"
+#include "base/sys_string_conversions.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread_restrictions.h"
+
+#pragma comment(lib, "Bthprops.lib")
+#pragma comment(lib, "delayimp.lib")

[brettw, 2013/01/09 20:06:04]

Carlos seemed to be of the opinion that this is not necessary. Does it still
work without this line?

[youngki, 2013/01/09 22:20:14]

Done.

[grt (UTC plus 2), 2013/01/10 04:01:47]

Is this not needed for __HrLoadAllImportsForDll?

[youngki, 2013/01/10 18:52:01]

At least this compiles without delayimp.lib and the bluetooth functions are
detecting bluetooth adapters without it...

+
+namespace {
+
+const int kNumThreadsInWorkerPool = 3;
+const char* kBluetoothThreadName = "BluetoothPollingThreadWin";
+const BLUETOOTH_FIND_RADIO_PARAMS adapter_param =
+    { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) };
+
+// A frame-based exception handler filter function for a handler for exceptions
+// generated by the Visual C++ delay loader helper function.
+int FilterVisualCPPExceptions(DWORD exception_code) {
+  return HRESULT_FACILITY(exception_code) == FACILITY_VISUALCPP ?
+      EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
+}
+
+// Returns true if the machine has a bluetooth stack available. The first call
+// to this function will involve file IO, so it should be done on an
+// appropriate thread. This function is not threadsafe.
+bool HasBluetoothStack() {
+  static enum {
+    HBS_UNKNOWN,
+    HBS_YES,
+    HBS_NO,
+  } has_bluetooth_stack = HBS_UNKNOWN;
+
+  if (has_bluetooth_stack == HBS_UNKNOWN) {
+    base::ThreadRestrictions::AssertIOAllowed();
+    HRESULT hr = E_FAIL;
+    __try {
+      hr = __HrLoadAllImportsForDll("bthprops.cpl");
+    } __except(FilterVisualCPPExceptions(::GetExceptionCode())) {

[brettw, 2013/01/09 20:06:04]

It looks like you only need 3 bluetooth functions. Is that right? If so, it
seems more clear to me to just use LoadLibrary/GetProcAddress rather than
dealing with this exception stuff which most people don't have any experience
with.

[youngki, 2013/01/09 22:20:14]

By 3 bluetooth functions, do you mean BluetoothGetRadioInfo,
BluetoothFindFirstRadio, and BluetoothFindRadioClose? Then the answer is no. In
the later CLs we will add more bluetooth functions to implement the rest of
Bluetooth adapter functionalities.

Honestly I am not familiar with this function; it is added by @grt at
https://chromiumcodereview.appspot.com/11299332.

Greg, do you think it is okay to use LoadLibrary/GetProcAddress for this?

[grt (UTC plus 2), 2013/01/10 04:01:47]

If you'll eventually be using the full BT API, I think you'll end up with a lot
of boilerplate (typedefs, casts, a function table somewhere, etc) if you try to
switch from delayloading the dll to using LoadLibrary/GetProcAddress for all
functions.

Another approach, if __HrLoadAllImportsForDll is considered too
ugly/obscure/etc, would be to keep using delayload as now, but replace
_HrLoadAllImportsForDll with a single LoadLibrary/GetProcAddress pair just to
test the waters, so to speak. If you succeed in looking up even one BT function
that way (you don't need to ever call it), then all of the other calls (which go
through the delayload machinery) should succeed.

A part of me likes the fact that the current approach resolves all imports in
one shot at a well-known place in the code so that you don't take a resolution
hit on the first call of each function.

[youngki, 2013/01/10 18:52:01]

I will leave this as is.

+      hr = E_FAIL;
+    }
+    has_bluetooth_stack = SUCCEEDED(hr) ? HBS_YES : HBS_NO;
+  }
+
+  return has_bluetooth_stack == HBS_YES;
+}
+
+// Populates bluetooth adapter state using adapter_handle.
+void GetAdapterState(const HANDLE adapter_handle,
+                     device::BluetoothTaskManagerWin::AdapterState* state) {
+  std::string name;
+  std::string address;
+  bool powered = false;
+  BLUETOOTH_RADIO_INFO adapter_info = { sizeof(BLUETOOTH_RADIO_INFO), 0 };
+  if (adapter_handle &&
+      ERROR_SUCCESS == BluetoothGetRadioInfo(adapter_handle,
+                                             &adapter_info)) {
+    name = base::SysWideToUTF8(adapter_info.szName);
+    address = base::StringPrintf("%02X:%02X:%02X:%02X:%02X:%02X",
+        adapter_info.address.rgBytes[5],
+        adapter_info.address.rgBytes[4],
+        adapter_info.address.rgBytes[3],
+        adapter_info.address.rgBytes[2],
+        adapter_info.address.rgBytes[1],
+        adapter_info.address.rgBytes[0]);
+    powered = !!BluetoothIsConnectable(adapter_handle);
+  }
+  state->name = name;
+  state->address = address;
+  state->powered = powered;
+}
+
+}

[brettw, 2013/01/09 20:06:04]

Should have a "  // namespace" comment

[youngki, 2013/01/09 22:20:14]

Done.

+
+namespace device {
+
+// static
+const int BluetoothTaskManagerWin::kPollIntervalMs = 500;
+
+BluetoothTaskManagerWin::BluetoothTaskManagerWin()
+    : ui_task_runner_(MessageLoop::current()->message_loop_proxy()),
+      worker_pool_(new base::SequencedWorkerPool(kNumThreadsInWorkerPool,
+                                                 kBluetoothThreadName)),
+      bluetooth_task_runner_(
+          worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
+              worker_pool_->GetSequenceToken(),
+              base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)) {
+}
+
+BluetoothTaskManagerWin::~BluetoothTaskManagerWin() {
+}
+
+void BluetoothTaskManagerWin::AddObserver(Observer* observer) {
+  CHECK(observer);
+  observers_.AddObserver(observer);
+}
+
+void BluetoothTaskManagerWin::RemoveObserver(Observer* observer) {
+  CHECK(observer);
+  observers_.RemoveObserver(observer);
+}
+
+void BluetoothTaskManagerWin::Initialize() {
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  bluetooth_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&BluetoothTaskManagerWin::StartPolling,
+                 this));
+}
+
+void BluetoothTaskManagerWin::StartPolling() {
+  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+
+  // TODO(youngki): Handle this check where BluetoothAdapter is initialized.
+  if (HasBluetoothStack()) {
+    PollAdapter();
+  }
+}
+
+void BluetoothTaskManagerWin::Shutdown() {
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  worker_pool_->Shutdown();
+}
+
+void BluetoothTaskManagerWin::OnAdapterStateChanged(const AdapterState* state) {
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_,
+                    AdapterStateChanged(*state));
+}
+
+void BluetoothTaskManagerWin::PollAdapter() {
+  DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
+
+  HBLUETOOTH_RADIO_FIND adapter_handle = NULL;
+  HBLUETOOTH_RADIO_FIND handle = BluetoothFindFirstRadio(&adapter_param,
+                                                         &adapter_handle);
+
+  if (handle)
+    BluetoothFindRadioClose(handle);
+
+  AdapterState* state = new AdapterState();
+  GetAdapterState(adapter_handle, state);
+
+  // Notify the UI thread of the Bluetooth Adapter state.
+  ui_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged,
+                 this,
+                 base::Owned(state)));
+
+  // Re-poll.
+  bluetooth_task_runner_->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&BluetoothTaskManagerWin::PollAdapter,
+                 this),
+      base::TimeDelta::FromMilliseconds(kPollIntervalMs));
+}
+
+}  // namespace device