Implemented BluetoothTaskManagerWin class.

device/bluetooth/bluetooth_polling_thread_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_polling_thread_win.h"
+
+#include <BluetoothAPIs.h>
+#include "base/message_loop.h"
+#include "base/stringprintf.h"
+#include "base/sys_string_conversions.h"
+#include "content/public/browser/browser_thread.h"
+#include "device/bluetooth/bluetooth_adapter_win.h"
+
+# pragma comment(lib, "Bthprops.lib")
+
+namespace {
+
+const char* kBluetoothManagerThreadName = "BluetoothPollingThreadWin";
+const BLUETOOTH_FIND_RADIO_PARAMS adapter_param =
+    { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) };
+
+// Populates bluetooth adapter state using adapter_handle.
+void GetAdapterState(const HANDLE adapter_handle,
+                     device::BluetoothPollingThreadWin::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;
+}
+
+}  // namespace
+
+namespace device {
+
+// static
+const int BluetoothPollingThreadWin::kPollIntervalMs = 500;
+
+BluetoothPollingThreadWin::BluetoothPollingThreadWin()
+    : Thread(kBluetoothManagerThreadName),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+  thread_checker_.DetachFromThread();
+}
+
+// Stop() waits until all the pending tasks in BluetoothPollingThread finish.
+// Also this class will be destroyed after Stop() returns, having all the
+// pending tasks completed. Setting |cancellation_flag_| will effectively
+// cancel all the pending tasks.
+BluetoothPollingThreadWin::~BluetoothPollingThreadWin() {
+  cancellation_flag_.Set();
+  Stop();
+}
+
+void BluetoothPollingThreadWin::AddObserver(Observer* observer) {
+  CHECK(observer);
+  observers_.AddObserver(observer);
+}
+
+void BluetoothPollingThreadWin::RemoveObserver(Observer* observer) {
+  CHECK(observer);
+  observers_.RemoveObserver(observer);
+}
+
+void BluetoothPollingThreadWin::Init() {

[bryeung, 2012/12/10 19:15:35]

CHECK that you're on the UI thread here

+  if (!message_loop()) {

[bryeung, 2012/12/10 19:15:35]

// WeakPtrs are bound to the thread that creates the first WeakPtr for the
object.  Try to check that the WeakPtr below will be bound to the this (the UI)
thread.  This should be the ONLY place where GetWeakPtr() is called on this
weak_ptr_factory_.
CHECK(!weak_ptr_factory_.HasWeakPtrs());
base::WeakPtr<BluetoothPollingThreadWin>
weak_ptr(weak_ptr_factory_.GetWeakPtr());

+    Start();
+    message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&BluetoothPollingThreadWin::PollAdapter,
+                   base::Unretained(this),
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+void BluetoothPollingThreadWin::PollAdapter(
+    base::WeakPtr<BluetoothPollingThreadWin> weak_ptr) {

[bryeung, 2012/12/10 19:15:35]

rename this to weak_ptr_for_ui_thread

+  if (cancellation_flag_.IsSet())
+    return;
+
+  CHECK(thread_checker_.CalledOnValidThread());
+
+  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);
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&BluetoothPollingThreadWin::OnAdapterStateChanged,
+                 weak_ptr,
+                 base::Owned(state)));
+
+  // Re-poll.
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&BluetoothPollingThreadWin::PollAdapter,
+                 base::Unretained(this),
+                 weak_ptr),
+      base::TimeDelta::FromMilliseconds(kPollIntervalMs));
+}
+
+void BluetoothPollingThreadWin::OnAdapterStateChanged(
+    const AdapterState* state) {
+  CHECK(thread_checker_.CalledOnValidThread());

[bryeung, 2012/12/10 19:15:35]

use a separate, ui_thread_checker_ here

+  FOR_EACH_OBSERVER(BluetoothPollingThreadWin::Observer, observers_,
+                    AdapterStateChanged(*state));
+}
+
+}  // namespace device