Implemented BluetoothTaskManagerWin class.

device/bluetooth/bluetooth_adapter_win_unittest.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 <string>
 
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
-#include "base/stringprintf.h"
-#include "base/time.h"
 #include "content/public/test/test_browser_thread.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_adapter_win.h"
-#include "device/bluetooth/test/mock_bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_task_manager_win.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-const char* kAdapterAddress = "bluetooth adapter address";
+const char* kAdapterAddress = "Bluetooth Adapter Address";
+const char* kAdapterName = "Bluetooth Adapter Name";
 
 }  // namespace
 
 namespace device {
 
-class FakeBluetoothAdapterWin : public BluetoothAdapterWin {
- public:
-  FakeBluetoothAdapterWin() : BluetoothAdapterWin() {}
-
-  virtual void UpdateAdapterState() {
-    address_ = adapter_address_;
-  }
-
-  void SetAdapterAddressForTest(const std::string& adapter_address) {
-    adapter_address_ = adapter_address;
-  }
-
- private:
-  virtual ~FakeBluetoothAdapterWin() {}
-  std::string adapter_address_;
-  DISALLOW_COPY_AND_ASSIGN(FakeBluetoothAdapterWin);
-};
-
 class BluetoothAdapterWinTest : public testing::Test {
  public:
   BluetoothAdapterWinTest()
-      : ui_thread_(content::BrowserThread::UI, &loop_),
-        ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
+      : ui_thread_(content::BrowserThread::UI, &ui_loop_),
+        adapter_(NULL),
+        adapter_win_(NULL) {
   }
 
   virtual void SetUp() {
-    adapter_ = new FakeBluetoothAdapterWin();
-    adapter_->TrackDefaultAdapter();
+    adapter_ = BluetoothAdapterFactory::DefaultAdapter();
+    adapter_win_ = static_cast<BluetoothAdapterWin*>(adapter_.get());
   }
 
-  void SetAdapterAddressForTest() {
-    adapter_->SetAdapterAddressForTest(kAdapterAddress);
+  virtual void TearDown() {
+    ReleaseAdapter();
   }
 
-  int GetPollIntervalMs() const {
-    return BluetoothAdapterWin::kPollIntervalMs;
+  void ReleaseAdapter() {
+    adapter_ = NULL;
+    adapter_win_ = NULL;
   }
 
  protected:
-  scoped_refptr<FakeBluetoothAdapterWin> adapter_;
-
-  // Main message loop for the test.
-  MessageLoopForUI loop_;
-
-  // Main thread for the test.
+  MessageLoopForUI ui_loop_;
   content::TestBrowserThread ui_thread_;
-
-  // NOTE: This should remain the last member so it'll be destroyed and
-  // invalidate its weak pointers before any other members are destroyed.
-  base::WeakPtrFactory<BluetoothAdapterWinTest> weak_ptr_factory_;
+  scoped_refptr<BluetoothAdapter> adapter_;
+  BluetoothAdapterWin* adapter_win_;
 };
 
-TEST_F(BluetoothAdapterWinTest, Polling) {
+TEST_F(BluetoothAdapterWinTest, AdapterNotPresent) {
+  BluetoothTaskManagerWin::AdapterState state;
+  adapter_win_->AdapterStateChanged(state);
+  EXPECT_FALSE(adapter_win_->IsPresent());
+}
+
+TEST_F(BluetoothAdapterWinTest, AdapterPresent) {
+  BluetoothTaskManagerWin::AdapterState state;
+  state.address = kAdapterAddress;
+  state.name = kAdapterName;
+  adapter_win_->AdapterStateChanged(state);
+  EXPECT_TRUE(adapter_win_->IsPresent());
+}
+
+TEST_F(BluetoothAdapterWinTest, AdapterDestroyed) {
+  base::RunLoop run_loop;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
-          &BluetoothAdapterWinTest::SetAdapterAddressForTest,
-          weak_ptr_factory_.GetWeakPtr()),
-      base::TimeDelta::FromMilliseconds(GetPollIntervalMs() - 1));
-  EXPECT_STRNE(kAdapterAddress, adapter_->address().c_str());
-  base::RunLoop run_loop;
-
+          &BluetoothAdapterWinTest::ReleaseAdapter,
+          base::Unretained(this)),
+      base::TimeDelta::FromMilliseconds(1));
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       run_loop.QuitClosure(),
-      base::TimeDelta::FromMilliseconds(GetPollIntervalMs() + 1));
+      base::TimeDelta::FromMilliseconds(2));
 
   run_loop.Run();
 
-  EXPECT_STREQ(kAdapterAddress, adapter_->address().c_str());
+  // Adapter has been destroyed gracefully.
+  SUCCEED();
 }
 
-TEST_F(BluetoothAdapterWinTest, IsPresent) {
-  EXPECT_FALSE(adapter_->IsPresent());
-  SetAdapterAddressForTest();
-  base::RunLoop run_loop;
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      run_loop.QuitClosure(),
-      base::TimeDelta::FromMilliseconds(GetPollIntervalMs()));
-  run_loop.Run();
-
-  EXPECT_TRUE(adapter_->IsPresent());
-}
 
 }  // namespace device