Moved bluetooth adapter files to device/bluetooth/.

device/bluetooth/bluetooth_device_chromeos.h

 // 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.
 
-#ifndef CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_
-#define CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_
+#ifndef DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_
+#define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string16.h"
-#include "chrome/browser/chromeos/bluetooth/bluetooth_device.h"
 #include "chromeos/dbus/bluetooth_agent_service_provider.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "dbus/object_path.h"
+#include "device/bluetooth/bluetooth_device.h"
 
-namespace chromeos {
+namespace bluetooth {

[keybuk, 2012/10/12 00:13:18]

namespace?

[youngki, 2012/10/12 01:50:12]

Done.

 
 class BluetoothAdapterChromeOs;
 class BluetoothServiceRecord;
 
 struct BluetoothOutOfBandPairingData;
 
 // The BluetoothDeviceChromeOs class is an implementation of BluetoothDevice
 // for Chrome OS platform.
-class BluetoothDeviceChromeOs : public BluetoothDevice,
-                                public BluetoothDeviceClient::Observer,
-                                public BluetoothAgentServiceProvider::Delegate {
+class BluetoothDeviceChromeOs
+    : public BluetoothDevice,
+      public chromeos::BluetoothDeviceClient::Observer,
+      public chromeos::BluetoothAgentServiceProvider::Delegate {
  public:
   virtual ~BluetoothDeviceChromeOs();
 
   // BluetoothDevice override
   virtual bool IsPaired() const OVERRIDE;
   virtual const ServiceList& GetServices() const OVERRIDE;
   virtual void GetServiceRecords(
       const ServiceRecordsCallback& callback,
       const ErrorCallback& error_callback) OVERRIDE;
   virtual bool ProvidesServiceWithUUID(const std::string& uuid) const OVERRIDE;
@@ skipping 13 matching lines @@
   virtual void RejectPairing() OVERRIDE;
   virtual void CancelPairing() OVERRIDE;
   virtual void Disconnect(
       const base::Closure& callback,
       const ErrorCallback& error_callback) OVERRIDE;
   virtual void Forget(const ErrorCallback& error_callback) OVERRIDE;
   virtual void ConnectToService(
       const std::string& service_uuid,
       const SocketCallback& callback) OVERRIDE;
   virtual void SetOutOfBandPairingData(
-      const chromeos::BluetoothOutOfBandPairingData& data,
+      const bluetooth::BluetoothOutOfBandPairingData& data,
       const base::Closure& callback,
       const ErrorCallback& error_callback) OVERRIDE;
   virtual void ClearOutOfBandPairingData(
       const base::Closure& callback,
       const ErrorCallback& error_callback) OVERRIDE;
 
  private:
   friend class BluetoothAdapterChromeOs;
   friend class MockBluetoothDevice;
 
   explicit BluetoothDeviceChromeOs(BluetoothAdapterChromeOs* adapter);
 
   // Sets the dbus object path for the device to |object_path|, indicating
   // that the device has gone from being discovered to paired or bonded.
   void SetObjectPath(const dbus::ObjectPath& object_path);
 
   // Removes the dbus object path from the device, indicating that the
   // device is no longer paired or bonded, but perhaps still visible.
   void RemoveObjectPath();
 
   // Sets whether the device is visible to the owning adapter to |visible|.
   void SetVisible(bool visible) { visible_ = visible; }
 
   // Updates device information from the properties in |properties|, device
   // state properties such as |paired_| and |connected_| are ignored unless
   // |update_state| is true.
-  void Update(const BluetoothDeviceClient::Properties* properties,
+  void Update(const chromeos::BluetoothDeviceClient::Properties* properties,
               bool update_state);
 
   // Called by BluetoothAdapterClient when a call to CreateDevice() or
   // CreatePairedDevice() succeeds, provides the new object path for the remote
   // device in |device_path|. |callback| and |error_callback| are the callbacks
   // provided to Connect().
   void ConnectCallback(const base::Closure& callback,
                        const ErrorCallback& error_callback,
                        const dbus::ObjectPath& device_path);
 
   // Called by BluetoothAdapterClient when a call to CreateDevice() or
   // CreatePairedDevice() fails with the error named |error_name| and
   // optional message |error_message|, |error_callback| is the callback
   // provided to Connect().
   void ConnectErrorCallback(const ErrorCallback& error_callback,
                             const std::string& error_name,
                             const std::string& error_message);
 
   // Called by BluetoothAdapterClient when a call to DiscoverServices()
   // completes.  |callback| and |error_callback| are the callbacks provided to
   // GetServiceRecords.
   void CollectServiceRecordsCallback(
       const ServiceRecordsCallback& callback,
       const ErrorCallback& error_callback,
       const dbus::ObjectPath& device_path,
-      const BluetoothDeviceClient::ServiceMap& service_map,
+      const chromeos::BluetoothDeviceClient::ServiceMap& service_map,
       bool success);
 
   // Called by BluetoothProperty when the call to Set() for the Trusted
   // property completes. |success| indicates whether or not the request
   // succeeded, |callback| and |error_callback| are the callbacks provided to
   // Connect().
   void OnSetTrusted(const base::Closure& callback,
                     const ErrorCallback& error_callback,
                     bool success);
 
@@ skipping 208 matching lines @@
   // The services (identified by UUIDs) that this device provides.
   std::vector<std::string> service_uuids_;
 
   // During pairing this is set to an object that we don't own, but on which
   // we can make method calls to request, display or confirm PIN Codes and
   // Passkeys. Generally it is the object that owns this one.
   BluetoothDevice::PairingDelegate* pairing_delegate_;
 
   // During pairing this is set to an instance of a D-Bus agent object
   // intialized with our own class as its delegate.
-  scoped_ptr<BluetoothAgentServiceProvider> agent_;
+  scoped_ptr<chromeos::BluetoothAgentServiceProvider> agent_;
 
   // During pairing these callbacks are set to those provided by method calls
   // made on us by |agent_| and are called by our own method calls such as
   // SetPinCode() and SetPasskey().
   PinCodeCallback pincode_callback_;
   PasskeyCallback passkey_callback_;
   ConfirmationCallback confirmation_callback_;
 
   // Used to keep track of pending application connection requests.
   int connecting_applications_counter_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<BluetoothDeviceChromeOs> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothDeviceChromeOs);
 };
 
-}  // namespace chromeos
+}  // namespace bluetooth
 
-#endif  // CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_
+#endif  // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H_