Moved bluetooth adapter files to device/bluetooth/.

chrome/browser/extensions/api/bluetooth/bluetooth_apitest_chromeos.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.h>
 
-#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
-#include "chrome/browser/chromeos/bluetooth/test/mock_bluetooth_adapter.h"
-#include "chrome/browser/chromeos/bluetooth/test/mock_bluetooth_device.h"
-#include "chrome/browser/chromeos/extensions/bluetooth_event_router.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
+#include "chrome/browser/extensions/bluetooth_event_router.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/ui/browser.h"
-#include "chromeos/dbus/bluetooth_out_of_band_client.h"
-#include "chromeos/dbus/bluetooth_out_of_band_pairing_data.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_out_of_band_pairing_data.h"
+#include "device/bluetooth/test/mock_bluetooth_adapter.h"
+#include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
+using bluetooth::BluetoothAdapter;
+using bluetooth::BluetoothDevice;
+using bluetooth::BluetoothOutOfBandPairingData;
+using bluetooth::MockBluetoothAdapter;
+using bluetooth::MockBluetoothDevice;
 using extensions::Extension;
 
 namespace utils = extension_function_test_utils;
 namespace api = extensions::api;
 
 namespace {
 
 static const char* kAdapterAddress = "A1:A2:A3:A4:A5:A6";
 static const char* kName = "whatsinaname";
 
 class BluetoothApiTest : public PlatformAppApiTest {
  public:
   BluetoothApiTest() : empty_extension_(utils::CreateEmptyExtension()) {}
 
   virtual void SetUpOnMainThread() OVERRIDE {
     // The browser will clean this up when it is torn down
-    mock_adapter_ = new testing::StrictMock<chromeos::MockBluetoothAdapter>(
-        kAdapterAddress, kName);
+    mock_adapter_ =
+        new testing::StrictMock<MockBluetoothAdapter>(kAdapterAddress, kName);

[bryeung, 2012/10/11 15:15:39]

why the wrapping change?

[youngki, 2012/10/11 16:21:18]

Done.

     event_router()->SetAdapterForTest(mock_adapter_);
 
-    device1_.reset(new testing::NiceMock<chromeos::MockBluetoothDevice>(
+    device1_.reset(new testing::NiceMock<MockBluetoothDevice>(
         mock_adapter_, "d1", "11:12:13:14:15:16",
         true /* paired */, false /* bonded */, true /* connected */));
-    device2_.reset(new testing::NiceMock<chromeos::MockBluetoothDevice>(
+    device2_.reset(new testing::NiceMock<MockBluetoothDevice>(
         mock_adapter_, "d2", "21:22:23:24:25:26",
         false /* paired */, true /* bonded */, false /* connected */));
   }
 
   virtual void CleanUpOnMainThread() OVERRIDE {
     EXPECT_CALL(*mock_adapter_, RemoveObserver(testing::_));
   }
 
   void expectBooleanResult(bool expected,
                            UIThreadExtensionFunction* function) {
@@ skipping 18 matching lines @@
   }
 
   template <class T>
   T* setupFunction(T* function) {
     function->set_extension(empty_extension_.get());
     function->set_has_callback(true);
     return function;
   }
 
  protected:
-  testing::StrictMock<chromeos::MockBluetoothAdapter>* mock_adapter_;
-  scoped_ptr<testing::NiceMock<chromeos::MockBluetoothDevice> > device1_;
-  scoped_ptr<testing::NiceMock<chromeos::MockBluetoothDevice> > device2_;
+  testing::StrictMock<MockBluetoothAdapter>* mock_adapter_;
+  scoped_ptr<testing::NiceMock<MockBluetoothDevice> > device1_;
+  scoped_ptr<testing::NiceMock<MockBluetoothDevice> > device2_;
 
-  chromeos::ExtensionBluetoothEventRouter* event_router() {
+  extensions::ExtensionBluetoothEventRouter* event_router() {
     return browser()->profile()->GetExtensionService()->
         bluetooth_event_router();
   }
 
  private:
   scoped_refptr<Extension> empty_extension_;
 };
 
 // This is the canonical UUID for the short UUID 0010.
 static const char kOutOfBandPairingDataHash[] = "0123456789ABCDEh";
 static const char kOutOfBandPairingDataRandomizer[] = "0123456789ABCDEr";
 
-static chromeos::BluetoothOutOfBandPairingData GetOutOfBandPairingData() {
-  chromeos::BluetoothOutOfBandPairingData data;
+static BluetoothOutOfBandPairingData GetOutOfBandPairingData() {
+  BluetoothOutOfBandPairingData data;
   memcpy(&(data.hash), kOutOfBandPairingDataHash,
-      chromeos::kBluetoothOutOfBandPairingDataSize);
+      bluetooth::kBluetoothOutOfBandPairingDataSize);
   memcpy(&(data.randomizer), kOutOfBandPairingDataRandomizer,
-      chromeos::kBluetoothOutOfBandPairingDataSize);
+      bluetooth::kBluetoothOutOfBandPairingDataSize);
   return data;
 }
 
 static bool CallClosure(const base::Closure& callback) {
   callback.Run();
   return true;
 }
 
 static void CallOutOfBandPairingDataCallback(
-    const chromeos::BluetoothAdapter::BluetoothOutOfBandPairingDataCallback&
-        callback,
-    const chromeos::BluetoothAdapter::ErrorCallback& error_callback) {
+    const BluetoothAdapter::BluetoothOutOfBandPairingDataCallback& callback,
+    const BluetoothAdapter::ErrorCallback& error_callback) {
   callback.Run(GetOutOfBandPairingData());
 }
 
 template <bool Value>
 static void CallProvidesServiceCallback(
-      const std::string& name,
-      const chromeos::BluetoothDevice::ProvidesServiceCallback& callback) {
+    const std::string& name,
+    const BluetoothDevice::ProvidesServiceCallback& callback) {
   callback.Run(Value);
 }
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, IsAvailable) {
   EXPECT_CALL(*mock_adapter_, IsPresent())
       .WillOnce(testing::Return(false));
 
   scoped_refptr<api::BluetoothIsAvailableFunction> is_available;
@@ skipping 165 matching lines @@
   EXPECT_CALL(*mock_adapter_, IsDiscovering()).WillOnce(testing::Return(false));
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(true, testing::Truly(CallClosure), testing::_));
   EXPECT_CALL(*mock_adapter_,
               SetDiscovering(false, testing::Truly(CallClosure), testing::_));
 
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   ExtensionTestMessageListener discovery_started("ready", true);
-  const extensions::Extension* extension =
+  const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("bluetooth"));
   GURL page_url = extension->GetResourceURL("test_discovery.html");
   ui_test_utils::NavigateToURL(browser(), page_url);
   EXPECT_TRUE(discovery_started.WaitUntilSatisfied());
 
   event_router()->DeviceAdded(mock_adapter_, device1_.get());
 
   discovery_started.Reply("go");
   ExtensionTestMessageListener discovery_stopped("ready", true);
   EXPECT_TRUE(discovery_stopped.WaitUntilSatisfied());
 
   event_router()->DeviceAdded(mock_adapter_, device2_.get());
   discovery_stopped.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, DiscoveryInProgress) {
   // Fake that the adapter is discovering
   EXPECT_CALL(*mock_adapter_, IsDiscovering()).WillOnce(testing::Return(true));
   event_router()->AdapterDiscoveringChanged(mock_adapter_, true);
 
   // Cache a device before the extension starts discovering
   event_router()->DeviceAdded(mock_adapter_, device1_.get());
 
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   ExtensionTestMessageListener discovery_started("ready", true);
-  const extensions::Extension* extension =
+  const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("bluetooth"));
   GURL page_url = extension->GetResourceURL("test_discovery_in_progress.html");
   ui_test_utils::NavigateToURL(browser(), page_url);
   EXPECT_TRUE(discovery_started.WaitUntilSatisfied());
 
   // This should be received in addition to the cached device above.
   event_router()->DeviceAdded(mock_adapter_, device2_.get());
 
   discovery_started.Reply("go");
   ExtensionTestMessageListener discovery_stopped("ready", true);
   EXPECT_TRUE(discovery_stopped.WaitUntilSatisfied());
 
   event_router()->DeviceAdded(mock_adapter_, device2_.get());
   discovery_stopped.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Events) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   // Load and wait for setup
   ExtensionTestMessageListener listener("ready", true);
-  const extensions::Extension* extension =
+  const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("bluetooth"));
   GURL page_url = extension->GetResourceURL("test_events.html");
   ui_test_utils::NavigateToURL(browser(), page_url);
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   event_router()->AdapterPoweredChanged(mock_adapter_, true);
   event_router()->AdapterPoweredChanged(mock_adapter_, false);
   event_router()->AdapterPresentChanged(mock_adapter_, true);
   event_router()->AdapterPresentChanged(mock_adapter_, false);
   event_router()->AdapterDiscoveringChanged(mock_adapter_, true);
   event_router()->AdapterDiscoveringChanged(mock_adapter_, false);
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetDevices) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
-  chromeos::BluetoothAdapter::ConstDeviceList devices;
+  BluetoothAdapter::ConstDeviceList devices;
   devices.push_back(device1_.get());
   devices.push_back(device2_.get());
 
   EXPECT_CALL(*device1_, ProvidesServiceWithUUID(testing::_))
       .WillOnce(testing::Return(false));
   EXPECT_CALL(*device1_, ProvidesServiceWithName(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallProvidesServiceCallback<true>));
 
   EXPECT_CALL(*device2_, ProvidesServiceWithUUID(testing::_))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(*device2_, ProvidesServiceWithName(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallProvidesServiceCallback<false>));
 
   EXPECT_CALL(*mock_adapter_, GetDevices())
       .Times(3)
       .WillRepeatedly(testing::Return(devices));
 
   // Load and wait for setup
   ExtensionTestMessageListener listener("ready", true);
-  const extensions::Extension* extension =
+  const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("bluetooth"));
   GURL page_url = extension->GetResourceURL("test_getdevices.html");
   ui_test_utils::NavigateToURL(browser(), page_url);
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetDevicesConcurrently) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
-  chromeos::BluetoothAdapter::ConstDeviceList devices;
+  BluetoothAdapter::ConstDeviceList devices;
   devices.push_back(device1_.get());
 
   // Save the callback to delay execution so that we can force the calls to
   // happen concurrently.  This will be called after the listener is satisfied.
-  chromeos::BluetoothDevice::ProvidesServiceCallback callback;
+  BluetoothDevice::ProvidesServiceCallback callback;
   EXPECT_CALL(*device1_, ProvidesServiceWithName(testing::_, testing::_))
       .WillOnce(testing::SaveArg<1>(&callback));
 
   EXPECT_CALL(*mock_adapter_, GetDevices())
       .WillOnce(testing::Return(devices));
 
   // Load and wait for setup
   ExtensionTestMessageListener listener("ready", true);
-  const extensions::Extension* extension =
+  const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("bluetooth"));
   GURL page_url =
       extension->GetResourceURL("test_getdevices_concurrently.html");
   ui_test_utils::NavigateToURL(browser(), page_url);
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   callback.Run(false);
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }