Moved bluetooth adapter files to device/bluetooth/.

chrome/browser/ui/webui/options/chromeos/bluetooth_options_handler.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 "chrome/browser/ui/webui/options/chromeos/bluetooth_options_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter_factory.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
 #include "content/public/browser/web_ui.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/bluetooth_device.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // |UpdateDeviceCallback| takes a variable length list as an argument. The
 // value stored in each list element is indicated by the following constants.
 const int kUpdateDeviceAddressIndex = 0;
@@ skipping 89 matching lines @@
     { "bluetoothDisconnectFailed",
         IDS_OPTIONS_SETTINGS_BLUETOOTH_DISCONNECT_FAILED },
     { "bluetoothForgetFailed",
         IDS_OPTIONS_SETTINGS_BLUETOOTH_FORGET_FAILED }};
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
 }
 
 // TODO(kevers): Reorder methods to match ordering in the header file.
 
-void BluetoothOptionsHandler::AdapterPresentChanged(BluetoothAdapter* adapter,
-                                                    bool present) {
+void BluetoothOptionsHandler::AdapterPresentChanged(
+    device::BluetoothAdapter* adapter,
+    bool present) {
   DCHECK(adapter == adapter_.get());
   if (present) {
     web_ui()->CallJavascriptFunction(
         "options.BrowserOptions.showBluetoothSettings");
 
     // Update the checkbox and visibility based on the powered state of the
     // new adapter.
     AdapterPoweredChanged(adapter_.get(), adapter_->IsPowered());
   } else {
     web_ui()->CallJavascriptFunction(
         "options.BrowserOptions.hideBluetoothSettings");
   }
 }
 
-void BluetoothOptionsHandler::AdapterPoweredChanged(BluetoothAdapter* adapter,
-                                                    bool powered) {
+void BluetoothOptionsHandler::AdapterPoweredChanged(
+    device::BluetoothAdapter* adapter,
+    bool powered) {
   DCHECK(adapter == adapter_.get());
   base::FundamentalValue checked(powered);
   web_ui()->CallJavascriptFunction(
       "options.BrowserOptions.setBluetoothState", checked);
 }
 
 void BluetoothOptionsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("bluetoothEnableChange",
       base::Bind(&BluetoothOptionsHandler::EnableChangeCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("findBluetoothDevices",
       base::Bind(&BluetoothOptionsHandler::FindDevicesCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("updateBluetoothDevice",
       base::Bind(&BluetoothOptionsHandler::UpdateDeviceCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("stopBluetoothDeviceDiscovery",
       base::Bind(&BluetoothOptionsHandler::StopDiscoveryCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getPairedBluetoothDevices",
       base::Bind(&BluetoothOptionsHandler::GetPairedDevicesCallback,
                  base::Unretained(this)));
 }
 
 void BluetoothOptionsHandler::InitializeHandler() {
-  adapter_ = BluetoothAdapterFactory::DefaultAdapter();
+  adapter_ = device::BluetoothAdapterFactory::DefaultAdapter();
+  DCHECK(adapter_.get());
   adapter_->AddObserver(this);
 }
 
 void BluetoothOptionsHandler::InitializePage() {
   // Show or hide the bluetooth settings and update the checkbox based
   // on the current present/powered state.
   AdapterPresentChanged(adapter_.get(), adapter_->IsPresent());
   // Automatically start device discovery if the "Add Bluetooth Device"
   // overlay is visible.
   web_ui()->CallJavascriptFunction(
@@ skipping 28 matching lines @@
 void BluetoothOptionsHandler::FindDevicesError() {
   DVLOG(1) << "Failed to start discovery.";
   ReportError("bluetoothStartDiscoveryFailed", std::string());
 }
 
 void BluetoothOptionsHandler::UpdateDeviceCallback(
     const ListValue* args) {
   std::string address;
   args->GetString(kUpdateDeviceAddressIndex, &address);
 
-  BluetoothDevice* device = adapter_->GetDevice(address);
+  device::BluetoothDevice* device = adapter_->GetDevice(address);
   if (!device)
     return;
 
   std::string command;
   args->GetString(kUpdateDeviceCommandIndex, &command);
 
   if (command == kConnectCommand) {
     int size = args->GetSize();
     if (size > kUpdateDeviceAuthTokenIndex) {
       // PIN code or Passkey entry during the pairing process.
@@ skipping 87 matching lines @@
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothOptionsHandler::StopDiscoveryError() {
   DVLOG(1) << "Failed to stop discovery.";
   ReportError("bluetoothStopDiscoveryFailed", std::string());
 }
 
 void BluetoothOptionsHandler::GetPairedDevicesCallback(
     const ListValue* args) {
-  BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+  device::BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
 
-  for (BluetoothAdapter::DeviceList::iterator iter = devices.begin();
+  for (device::BluetoothAdapter::DeviceList::iterator iter = devices.begin();
        iter != devices.end(); ++iter)
     SendDeviceNotification(*iter, NULL);
 }
 
 void BluetoothOptionsHandler::SendDeviceNotification(
-    const BluetoothDevice* device,
+    const device::BluetoothDevice* device,
     base::DictionaryValue* params) {
   base::DictionaryValue js_properties;
   js_properties.SetString("name", device->GetName());
   js_properties.SetString("address", device->address());
   js_properties.SetBoolean("paired", device->IsPaired());
   js_properties.SetBoolean("bonded", device->IsBonded());
   js_properties.SetBoolean("connected", device->IsConnected());
   if (params) {
     js_properties.MergeDictionary(params);
   }
   web_ui()->CallJavascriptFunction(
       "options.BrowserOptions.addBluetoothDevice",
       js_properties);
 }
 
-void BluetoothOptionsHandler::RequestPinCode(BluetoothDevice* device) {
+void BluetoothOptionsHandler::RequestPinCode(device::BluetoothDevice* device) {
   DictionaryValue params;
   params.SetString("pairing", kEnterPinCode);
   SendDeviceNotification(device, &params);
 }
 
-void BluetoothOptionsHandler::RequestPasskey(BluetoothDevice* device) {
+void BluetoothOptionsHandler::RequestPasskey(device::BluetoothDevice* device) {
   DictionaryValue params;
   params.SetString("pairing", kEnterPasskey);
   SendDeviceNotification(device, &params);
 }
 
-void BluetoothOptionsHandler::DisplayPinCode(BluetoothDevice* device,
+void BluetoothOptionsHandler::DisplayPinCode(device::BluetoothDevice* device,
                                              const std::string& pincode) {
   DictionaryValue params;
   params.SetString("pairing", kRemotePinCode);
   params.SetString("pincode", pincode);
   SendDeviceNotification(device, &params);
 }
 
-void BluetoothOptionsHandler::DisplayPasskey(BluetoothDevice* device,
+void BluetoothOptionsHandler::DisplayPasskey(device::BluetoothDevice* device,
                                              uint32 passkey) {
   DictionaryValue params;
   params.SetString("pairing", kRemotePasskey);
   params.SetInteger("passkey", passkey);
   SendDeviceNotification(device, &params);
 }
 
-void BluetoothOptionsHandler::ConfirmPasskey(BluetoothDevice* device,
+void BluetoothOptionsHandler::ConfirmPasskey(device::BluetoothDevice* device,
                                              uint32 passkey) {
   DictionaryValue params;
   params.SetString("pairing", kConfirmPasskey);
   params.SetInteger("passkey", passkey);
   SendDeviceNotification(device, &params);
 }
 
 void BluetoothOptionsHandler::DismissDisplayOrConfirm() {
   web_ui()->CallJavascriptFunction(
       "options.BluetoothPairing.dismissDialog");
 }
 
 void BluetoothOptionsHandler::ReportError(
     const std::string& error,
     const std::string& address) {
   base::DictionaryValue properties;
   properties.SetString("label", error);
   properties.SetString("address", address);
   web_ui()->CallJavascriptFunction(
       "options.BluetoothPairing.showMessage",
       properties);
 }
 
-void BluetoothOptionsHandler::DeviceAdded(BluetoothAdapter* adapter,
-                                          BluetoothDevice* device) {
+void BluetoothOptionsHandler::DeviceAdded(device::BluetoothAdapter* adapter,
+                                          device::BluetoothDevice* device) {
   DCHECK(adapter == adapter_.get());
   DCHECK(device);
   SendDeviceNotification(device, NULL);
 }
 
-void BluetoothOptionsHandler::DeviceChanged(BluetoothAdapter* adapter,
-                                            BluetoothDevice* device) {
+void BluetoothOptionsHandler::DeviceChanged(device::BluetoothAdapter* adapter,
+                                            device::BluetoothDevice* device) {
   DCHECK(adapter == adapter_.get());
   DCHECK(device);
   SendDeviceNotification(device, NULL);
 }
 
-void BluetoothOptionsHandler::DeviceRemoved(BluetoothAdapter* adapter,
-                                            BluetoothDevice* device) {
+void BluetoothOptionsHandler::DeviceRemoved(device::BluetoothAdapter* adapter,
+                                            device::BluetoothDevice* device) {
   DCHECK(adapter == adapter_.get());
   DCHECK(device);
 
   base::StringValue address(device->address());
   web_ui()->CallJavascriptFunction(
       "options.BrowserOptions.removeBluetoothDevice",
       address);
 }
 
 }  // namespace options
 }  // namespace chromeos