Moved bluetooth adapter files to device/bluetooth/.

device/bluetooth/bluetooth_device_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 "chrome/browser/chromeos/bluetooth/bluetooth_device_chromeos.h"
+#include "device/bluetooth/bluetooth_device_chromeos.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_adapter_chromeos.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_service_record.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_socket_chromeos.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_utils.h"
 #include "chromeos/dbus/bluetooth_adapter_client.h"
 #include "chromeos/dbus/bluetooth_agent_service_provider.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "chromeos/dbus/bluetooth_input_client.h"
 #include "chromeos/dbus/bluetooth_out_of_band_client.h"
-#include "chromeos/dbus/bluetooth_out_of_band_pairing_data.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/introspectable_client.h"
 #include "dbus/bus.h"
 #include "dbus/object_path.h"
+#include "device/bluetooth/bluetooth_adapter_chromeos.h"
+#include "device/bluetooth/bluetooth_out_of_band_pairing_data.h"
+#include "device/bluetooth/bluetooth_service_record.h"
+#include "device/bluetooth/bluetooth_socket_chromeos.h"
+#include "device/bluetooth/bluetooth_utils.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-namespace chromeos {
+using chromeos::BluetoothDeviceClient;
+using chromeos::DBusThreadManager;
+
+namespace bluetooth {
 
 BluetoothDeviceChromeOs::BluetoothDeviceChromeOs(
     BluetoothAdapterChromeOs* adapter)
   : BluetoothDevice(),
     adapter_(adapter),
     pairing_delegate_(NULL),
     connecting_applications_counter_(0),
     weak_ptr_factory_(this) {
 }
 
@@ skipping 21 matching lines @@
                      callback,
                      error_callback));
 }
 
 bool BluetoothDeviceChromeOs::ProvidesServiceWithUUID(
     const std::string& uuid) const {
   const BluetoothDevice::ServiceList& services = GetServices();
   for (BluetoothDevice::ServiceList::const_iterator iter = services.begin();
        iter != services.end();
        ++iter) {
-    if (bluetooth_utils::CanonicalUuid(*iter) == uuid)
+    if (utils::CanonicalUuid(*iter) == uuid)
       return true;
   }
   return false;
 }
 
 void BluetoothDeviceChromeOs::ProvidesServiceWithName(
     const std::string& name,
     const ProvidesServiceCallback& callback) {
   GetServiceRecords(
       base::Bind(&BluetoothDeviceChromeOs::SearchServicesForNameCallback,
@@ skipping 46 matching lines @@
     // a given bluetooth device.
     DCHECK(agent_.get() == NULL);
 
     std::string agent_path_basename;
     ReplaceChars(address_, ":", "_", &agent_path_basename);
     dbus::ObjectPath agent_path("/org/chromium/bluetooth_agent/" +
                                 agent_path_basename);
 
     dbus::Bus* system_bus = DBusThreadManager::Get()->GetSystemBus();
     if (system_bus) {
-      agent_.reset(BluetoothAgentServiceProvider::Create(system_bus,
-                                                         agent_path,
-                                                         this));
+      agent_.reset(chromeos::BluetoothAgentServiceProvider::Create(system_bus,
+                                                                   agent_path,
+                                                                   this));
     } else {
       agent_.reset(NULL);
     }
 
     DVLOG(1) << "Pairing: " << address_;
     DBusThreadManager::Get()->GetBluetoothAdapterClient()->
         CreatePairedDevice(
             adapter_->object_path_,
             address_,
             agent_path,
@@ skipping 95 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  service_uuid,
                  callback),
       base::Bind(
           &BluetoothDeviceChromeOs::GetServiceRecordsForConnectErrorCallback,
           weak_ptr_factory_.GetWeakPtr(),
           callback));
 }
 
 void BluetoothDeviceChromeOs::SetOutOfBandPairingData(
-    const chromeos::BluetoothOutOfBandPairingData& data,
+    const bluetooth::BluetoothOutOfBandPairingData& data,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DBusThreadManager::Get()->GetBluetoothOutOfBandClient()->
       AddRemoteData(
           object_path_,
           address(),
           data,
           base::Bind(&BluetoothDeviceChromeOs::OnRemoteDataCallback,
                      weak_ptr_factory_.GetWeakPtr(),
                      callback,
@@ skipping 145 matching lines @@
     LOG(WARNING) << "Failed to determine supported applications: " << address_;
     error_callback.Run();
     return;
   }
 
   // The introspection data for the device object may list one or more
   // additional D-Bus interfaces that BlueZ supports for this particular
   // device. Send appropraite Connect calls for each of those interfaces
   // to connect all of the application protocols for this device.
   std::vector<std::string> interfaces =
-      IntrospectableClient::GetInterfacesFromIntrospectResult(xml_data);
+      chromeos::IntrospectableClient::GetInterfacesFromIntrospectResult(
+          xml_data);
 
   DCHECK_EQ(0, connecting_applications_counter_);
   connecting_applications_counter_ = 0;
   for (std::vector<std::string>::iterator iter = interfaces.begin();
        iter != interfaces.end(); ++iter) {
     if (*iter == bluetooth_input::kBluetoothInputInterface) {
       connecting_applications_counter_++;
       // Supports Input interface.
       DBusThreadManager::Get()->GetBluetoothInputClient()->
           Connect(object_path_,
@@ skipping 236 matching lines @@
   pairing_delegate_->DismissDisplayOrConfirm();
 }
 
 
 // static
 BluetoothDeviceChromeOs* BluetoothDeviceChromeOs::Create(
     BluetoothAdapterChromeOs* adapter) {
   return new BluetoothDeviceChromeOs(adapter);
 }
 
-}  // namespace chromeos
+}  // namespace bluetooth