Moved bluetooth adapter files to device/bluetooth/.

chromeos/dbus/bluetooth_out_of_band_client.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 "chromeos/dbus/bluetooth_out_of_band_client.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "chromeos/dbus/bluetooth_adapter_client.h"
-#include "chromeos/dbus/bluetooth_out_of_band_pairing_data.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
+#include "device/bluetooth/bluetooth_out_of_band_pairing_data.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 // The BluetoothOutOfBandClient implementation used in production.
 class BluetoothOutOfBandClientImpl: public BluetoothOutOfBandClient {
  public:
   explicit BluetoothOutOfBandClientImpl(dbus::Bus* bus)
       : bus_(bus),
         weak_ptr_factory_(this) {}
@@ skipping 14 matching lines @@
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&BluetoothOutOfBandClientImpl::OnReadLocalData,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   // BluetoothOutOfBandClient override.
   virtual void AddRemoteData(
       const dbus::ObjectPath& object_path,
       const std::string& address,
-      const BluetoothOutOfBandPairingData& data,
+      const device::BluetoothOutOfBandPairingData& data,
       const SuccessCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         bluetooth_outofband::kBluetoothOutOfBandInterface,
         bluetooth_outofband::kAddRemoteData);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(address);
-    writer.AppendArrayOfBytes(data.hash, kBluetoothOutOfBandPairingDataSize);
-    writer.AppendArrayOfBytes(data.randomizer,
-        kBluetoothOutOfBandPairingDataSize);
+    writer.AppendArrayOfBytes(
+        data.hash, device::kBluetoothOutOfBandPairingDataSize);
+    writer.AppendArrayOfBytes(
+        data.randomizer, device::kBluetoothOutOfBandPairingDataSize);
 
     dbus::ObjectProxy* object_proxy = GetObjectProxy(object_path);
 
     object_proxy->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&BluetoothOutOfBandClientImpl::ResponseToSuccessCallback,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
@@ skipping 35 matching lines @@
         bluetooth_outofband::kBluetoothOutOfBandServiceName, object_path);
 
     object_map_[object_path] = object_proxy;
     return object_proxy;
   }
 
   // Called when a response from ReadLocalOutOfBandPairingData() is received.
   void OnReadLocalData(const DataCallback& callback,
                        dbus::Response* response) {
     bool success = false;
-    BluetoothOutOfBandPairingData data;
+    device::BluetoothOutOfBandPairingData data;
     if (response != NULL) {
       dbus::MessageReader reader(response);
       uint8_t* bytes = NULL;
-      size_t length = kBluetoothOutOfBandPairingDataSize;
+      size_t length = device::kBluetoothOutOfBandPairingDataSize;
       if (reader.PopArrayOfBytes(&bytes, &length)) {
-        if (length == kBluetoothOutOfBandPairingDataSize) {
+        if (length == device::kBluetoothOutOfBandPairingDataSize) {
           memcpy(&data.hash, bytes, length);
           if (reader.PopArrayOfBytes(&bytes, &length)) {
-            if (length == kBluetoothOutOfBandPairingDataSize) {
+            if (length == device::kBluetoothOutOfBandPairingDataSize) {
               memcpy(&data.randomizer, bytes, length);
               success = true;
             }
           }
         }
       }
     }
     callback.Run(data, success);
   }
 
@@ skipping 17 matching lines @@
 
 // The BluetoothOutOfBandClient implementation used on Linux desktop, which does
 // nothing.
 class BluetoothOutOfBandClientStubImpl : public BluetoothOutOfBandClient {
  public:
   // BluetoothOutOfBandClient override.
   virtual void ReadLocalData(
       const dbus::ObjectPath& object_path,
       const DataCallback& callback) OVERRIDE {
     VLOG(1) << "ReadLocalData: " << object_path.value();
-    BluetoothOutOfBandPairingData data;
+    device::BluetoothOutOfBandPairingData data;
     callback.Run(data, false);
   }
 
   // BluetoothOutOfBandClient override.
   virtual void AddRemoteData(
       const dbus::ObjectPath& object_path,
       const std::string& address,
-      const BluetoothOutOfBandPairingData& data,
+      const device::BluetoothOutOfBandPairingData& data,
       const SuccessCallback& callback) OVERRIDE {
     VLOG(1) << "AddRemoteData: " << object_path.value();
     callback.Run(false);
   }
 
   // BluetoothOutOfBandClient override.
   virtual void RemoveRemoteData(
       const dbus::ObjectPath& object_path,
       const std::string& address,
       const SuccessCallback& callback) OVERRIDE {
     VLOG(1) << "RemoveRemoteData: " << object_path.value();
     callback.Run(false);
   }
 };
 
 BluetoothOutOfBandClient::BluetoothOutOfBandClient() {}
 
 BluetoothOutOfBandClient::~BluetoothOutOfBandClient() {}
 
 BluetoothOutOfBandClient* BluetoothOutOfBandClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new BluetoothOutOfBandClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new BluetoothOutOfBandClientStubImpl();
 }
 
 }  // namespace chromeos