Extensions: Move bluetooth APIs to extensions/.

extensions/browser/api/bluetooth/bluetooth_private_apitest.cc

 // Copyright 2014 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 "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
-#include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 #include "chrome/browser/extensions/extension_apitest.h"
-#include "chrome/common/extensions/api/bluetooth_private.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
+#include "extensions/browser/api/bluetooth/bluetooth_api.h"
+#include "extensions/browser/api/bluetooth/bluetooth_event_router.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/common/api/bluetooth_private.h"
 #include "extensions/common/switches.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using testing::_;
 using testing::InSequence;
 using testing::NiceMock;
 using testing::Return;
 using testing::ReturnPointee;
 using testing::WithArgs;
 using testing::WithoutArgs;
 
-namespace bt = extensions::api::bluetooth;
-namespace bt_private = extensions::api::bluetooth_private;
+namespace bt = extensions::core_api::bluetooth;
+namespace bt_private = extensions::core_api::bluetooth_private;
+
+namespace extensions {
 
 namespace {
 
 const char kTestExtensionId[] = "jofgjdphhceggjecimellaapdjjadibj";
 const char kAdapterName[] = "Helix";
 const char kDeviceName[] = "Red";
 }
 
 class BluetoothPrivateApiTest : public ExtensionApiTest {
  public:
   BluetoothPrivateApiTest()
       : adapter_name_(kAdapterName),
         adapter_powered_(false),
         adapter_discoverable_(false) {}
 
   virtual ~BluetoothPrivateApiTest() {}
 
   virtual void SetUpOnMainThread() OVERRIDE {
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-        extensions::switches::kWhitelistedExtensionID, kTestExtensionId);
+        switches::kWhitelistedExtensionID, kTestExtensionId);
     mock_adapter_ = new NiceMock<MockBluetoothAdapter>();
     event_router()->SetAdapterForTest(mock_adapter_.get());
     mock_device_.reset(new NiceMock<MockBluetoothDevice>(mock_adapter_.get(),
                                                          0,
                                                          kDeviceName,
                                                          "11:12:13:14:15:16",
                                                          false,
                                                          false));
     ON_CALL(*mock_adapter_.get(), GetDevice(mock_device_->GetAddress()))
         .WillByDefault(Return(mock_device_.get()));
     ON_CALL(*mock_adapter_.get(), IsPresent()).WillByDefault(Return(true));
   }
 
   virtual void TearDownOnMainThread() OVERRIDE {}
 
-  extensions::BluetoothEventRouter* event_router() {
-    return extensions::BluetoothAPI::Get(browser()->profile())
-        ->event_router();
+  BluetoothEventRouter* event_router() {
+    return BluetoothAPI::Get(browser()->profile())->event_router();
   }
 
   void SetName(const std::string& name, const base::Closure& callback) {
     adapter_name_ = name;
     callback.Run();
   }
 
   void SetPowered(bool powered, const base::Closure& callback) {
     adapter_powered_ = powered;
     callback.Run();
   }
 
   void SetDiscoverable(bool discoverable, const base::Closure& callback) {
     adapter_discoverable_ = discoverable;
     callback.Run();
   }
 
   void DispatchPairingEvent(bt_private::PairingEventType pairing_event_type) {
     bt_private::PairingEvent pairing_event;
     pairing_event.pairing = pairing_event_type;
     pairing_event.device.name.reset(new std::string(kDeviceName));
     pairing_event.device.address = mock_device_->GetAddress();
     pairing_event.device.vendor_id_source = bt::VENDOR_ID_SOURCE_USB;
     pairing_event.device.type = bt::DEVICE_TYPE_PHONE;
 
     scoped_ptr<base::ListValue> args =
         bt_private::OnPairing::Create(pairing_event);
-    scoped_ptr<extensions::Event> event(
-        new extensions::Event(bt_private::OnPairing::kEventName, args.Pass()));
-    extensions::EventRouter::Get(browser()->profile())
-        ->DispatchEventToExtension(kTestExtensionId, event.Pass());
+    scoped_ptr<Event> event(
+        new Event(bt_private::OnPairing::kEventName, args.Pass()));
+    EventRouter::Get(browser()->profile())->DispatchEventToExtension(
+        kTestExtensionId, event.Pass());
   }
 
   void DispatchAuthorizePairingEvent() {
     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTAUTHORIZATION);
   }
 
   void DispatchPincodePairingEvent() {
     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTPINCODE);
   }
 
@@ skipping 65 matching lines @@
   EXPECT_CALL(*mock_adapter_.get(),
               AddPairingDelegate(
                   _, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH))
       .WillOnce(WithoutArgs(
           Invoke(this, &BluetoothPrivateApiTest::DispatchPasskeyPairingEvent)));
   EXPECT_CALL(*mock_device_, ExpectingPasskey()).WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_device_, SetPasskey(900531));
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/passkey_pairing"))
       << message_;
 }
+
+}  // namespace extensions