bluetooth: Refactor device/bluetooth for C++ Style: typedef ordering.

device/bluetooth/bluetooth_adapter.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 DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_H_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 163 matching lines @@
   };
 
   // The ErrorCallback is used for methods that can fail in which case it is
   // called, in the success case the callback is simply not called.
   typedef base::Closure ErrorCallback;
 
   // The InitCallback is used to trigger a callback after asynchronous
   // initialization, if initialization is asynchronous on the platform.
   typedef base::Callback<void()> InitCallback;
 
+  typedef base::Callback<void(scoped_ptr<BluetoothDiscoverySession>)>
+      DiscoverySessionCallback;
+  typedef std::vector<BluetoothDevice*> DeviceList;
+  typedef std::vector<const BluetoothDevice*> ConstDeviceList;
+  typedef base::Callback<void(scoped_refptr<BluetoothSocket>)>
+      CreateServiceCallback;
+  typedef base::Callback<void(const std::string& message)>
+      CreateServiceErrorCallback;
+  typedef base::Callback<void(scoped_refptr<BluetoothAudioSink>)>
+      AcquiredCallback;
+
   // Returns a weak pointer to a new adapter.  For platforms with asynchronous
   // initialization, the returned adapter will run the |init_callback| once
   // asynchronous initialization is complete.
   // Caution: The returned pointer also transfers ownership of the adapter.  The
   // caller is expected to call |AddRef()| on the returned pointer, typically by
   // storing it into a |scoped_refptr|.
   static base::WeakPtr<BluetoothAdapter> CreateAdapter(
       const InitCallback& init_callback);
 
   // Returns a weak pointer to an existing adapter for testing purposes only.
@@ skipping 69 matching lines @@
   // If clients desire device discovery to run, they should always call this
   // method and never make it conditional on the value of IsDiscovering(), as
   // another client might cause discovery to stop unexpectedly. Hence, clients
   // should always obtain a BluetoothDiscoverySession and call
   // BluetoothDiscoverySession::Stop when done. When this method gets called,
   // device discovery may actually be in progress. Clients can call GetDevices()
   // and check for those with IsPaired() as false to obtain the list of devices
   // that have been discovered so far. Otherwise, clients can be notified of all
   // new and lost devices by implementing the Observer methods "DeviceAdded" and
   // "DeviceRemoved".
-  typedef base::Callback<void(scoped_ptr<BluetoothDiscoverySession>)>
-      DiscoverySessionCallback;
   virtual void StartDiscoverySession(const DiscoverySessionCallback& callback,
                                      const ErrorCallback& error_callback);
   virtual void StartDiscoverySessionWithFilter(
       scoped_ptr<BluetoothDiscoveryFilter> discovery_filter,
       const DiscoverySessionCallback& callback,
       const ErrorCallback& error_callback);
 
   // Return all discovery filters assigned to this adapter merged together.
   scoped_ptr<BluetoothDiscoveryFilter> GetMergedDiscoveryFilter() const;
 
   // Works like GetMergedDiscoveryFilter, but doesn't take |masked_filter| into
   // account. |masked_filter| is compared by pointer, and must be a member of
   // active session.
   scoped_ptr<BluetoothDiscoveryFilter> GetMergedDiscoveryFilterMasked(
       BluetoothDiscoveryFilter* masked_filter) const;
 
   // Requests the list of devices from the adapter. All devices are returned,
   // including those currently connected and those paired. Use the returned
   // device pointers to determine which they are.
-  typedef std::vector<BluetoothDevice*> DeviceList;
   virtual DeviceList GetDevices();
-  typedef std::vector<const BluetoothDevice*> ConstDeviceList;
   virtual ConstDeviceList GetDevices() const;
 
   // Returns a pointer to the device with the given address |address| or NULL if
   // no such device is known.
   virtual BluetoothDevice* GetDevice(const std::string& address);
   virtual const BluetoothDevice* GetDevice(const std::string& address) const;
 
   // Possible priorities for AddPairingDelegate(), low is intended for
   // permanent UI and high is intended for interactive UI or applications.
   enum PairingDelegatePriority {
@@ skipping 21 matching lines @@
   // incoming pairing requests.
   virtual BluetoothDevice::PairingDelegate* DefaultPairingDelegate();
 
   // Creates an RFCOMM service on this adapter advertised with UUID |uuid|,
   // listening on channel |options.channel|, which may be left null to
   // automatically allocate one. The service will be advertised with
   // |options.name| as the English name of the service. |callback| will be
   // called on success with a BluetoothSocket instance that is to be owned by
   // the received.  |error_callback| will be called on failure with a message
   // indicating the cause.
-  typedef base::Callback<void(scoped_refptr<BluetoothSocket>)>
-      CreateServiceCallback;
-  typedef base::Callback<void(const std::string& message)>
-      CreateServiceErrorCallback;
   virtual void CreateRfcommService(
       const BluetoothUUID& uuid,
       const ServiceOptions& options,
       const CreateServiceCallback& callback,
       const CreateServiceErrorCallback& error_callback) = 0;
 
   // Creates an L2CAP service on this adapter advertised with UUID |uuid|,
   // listening on PSM |options.psm|, which may be left null to automatically
   // allocate one. The service will be advertised with |options.name| as the
   // English name of the service. |callback| will be called on success with a
   // BluetoothSocket instance that is to be owned by the received.
   // |error_callback| will be called on failure with a message indicating the
   // cause.
   virtual void CreateL2capService(
       const BluetoothUUID& uuid,
       const ServiceOptions& options,
       const CreateServiceCallback& callback,
       const CreateServiceErrorCallback& error_callback) = 0;
 
   // Creates and registers a BluetoothAudioSink with |options|. If the fields in
   // |options| are not specified, the default values will be used. |callback|
   // will be called on success with a BluetoothAudioSink which is to be owned by
   // the caller of this method. |error_callback| will be called on failure with
   // a message indicating the cause.
-  typedef base::Callback<void(scoped_refptr<BluetoothAudioSink>)>
-      AcquiredCallback;
   virtual void RegisterAudioSink(
       const BluetoothAudioSink::Options& options,
       const AcquiredCallback& callback,
       const BluetoothAudioSink::ErrorCallback& error_callback) = 0;
 
  protected:
   friend class base::RefCountedThreadSafe<BluetoothAdapter,
                                           BluetoothAdapterDeleter>;
   friend struct BluetoothAdapterDeleter;
   friend class BluetoothDiscoverySession;
+
+  typedef std::map<const std::string, BluetoothDevice*> DevicesMap;
+  typedef std::pair<BluetoothDevice::PairingDelegate*, PairingDelegatePriority>
+      PairingDelegatePair;
+
   BluetoothAdapter();
   virtual ~BluetoothAdapter();
 
   // Called by RefCountedThreadSafeDeleteOnCorrectThread to destroy this.
   virtual void DeleteOnCorrectThread() const = 0;
 
   // Internal methods for initiating and terminating device discovery sessions.
   // An implementation of BluetoothAdapter keeps an internal reference count to
   // make sure that the underlying controller is constantly searching for nearby
   // devices and retrieving information from them as long as there are clients
@@ skipping 57 matching lines @@
   // Removes |discovery_session| from |discovery_sessions_|, if its in there.
   // Called by DiscoverySession when an instance is destroyed or becomes
   // inactive.
   void DiscoverySessionBecameInactive(
       BluetoothDiscoverySession* discovery_session);
 
   // Devices paired with, connected to, discovered by, or visible to the
   // adapter. The key is the Bluetooth address of the device and the value is
   // the BluetoothDevice object whose lifetime is managed by the adapter
   // instance.
-  typedef std::map<const std::string, BluetoothDevice*> DevicesMap;
   DevicesMap devices_;
 
   // Default pairing delegates registered with the adapter.
-  typedef std::pair<BluetoothDevice::PairingDelegate*,
-                    PairingDelegatePriority> PairingDelegatePair;
   std::list<PairingDelegatePair> pairing_delegates_;
 
  private:
   // Return all discovery filters assigned to this adapter merged together.
   // If |omit| is true, |discovery_filter| will not be processed.
   scoped_ptr<BluetoothDiscoveryFilter> GetMergedDiscoveryFilterHelper(
       const BluetoothDiscoveryFilter* discovery_filter,
       bool omit) const;
 
   // List of active DiscoverySession objects. This is used to notify sessions to
@@ skipping 12 matching lines @@
 // Trait for RefCountedThreadSafe that deletes BluetoothAdapter.
 struct BluetoothAdapterDeleter {
   static void Destruct(const BluetoothAdapter* adapter) {
     adapter->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_H_