Replace ScopedVector/ScopedPtrHashMap with std::vector and std::unordered_map

device/bluetooth/bluetooth_device.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_DEVICE_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/optional.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_export.h"
+#include "device/bluetooth/bluetooth_remote_gatt_service.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace device {
 
 class BluetoothAdapter;
 class BluetoothGattConnection;
-class BluetoothRemoteGattService;
 class BluetoothSocket;
 class BluetoothUUID;
 
 // BluetoothDevice represents a remote Bluetooth device, both its properties and
 // capabilities as discovered by a local adapter and actions that may be
 // performed on the remove device such as pairing, connection and disconnection.
 //
 // The class is instantiated and managed by the BluetoothAdapter class
 // and pointers should only be obtained from that class and not cached,
 // instead use the GetAddress() method as a unique key for a device.
@@ skipping 42 matching lines @@
     ERROR_INSUFFICIENT_ENCRYPTION,
     ERROR_OFFSET_INVALID,
     ERROR_READ_NOT_PERMITTED,
     ERROR_REQUEST_NOT_SUPPORTED,
     ERROR_UNKNOWN,
     ERROR_UNSUPPORTED_DEVICE,
     ERROR_WRITE_NOT_PERMITTED,
     NUM_CONNECT_ERROR_CODES  // Keep as last enum.
   };
 
-  typedef std::vector<BluetoothUUID> UUIDList;
-  typedef std::unordered_set<BluetoothUUID, BluetoothUUIDHash> UUIDSet;
-  typedef std::unordered_map<BluetoothUUID,
-                             std::vector<uint8_t>,
-                             BluetoothUUIDHash>
-      ServiceDataMap;
-  typedef uint16_t ManufacturerId;
-  typedef std::unordered_map<ManufacturerId, std::vector<uint8_t>>
-      ManufacturerDataMap;
-  typedef std::unordered_set<ManufacturerId> ManufacturerIDSet;
+  using UUIDList = std::vector<BluetoothUUID>;
+  using UUIDSet = std::unordered_set<BluetoothUUID, BluetoothUUIDHash>;
+  using ServiceDataMap = std::
+      unordered_map<BluetoothUUID, std::vector<uint8_t>, BluetoothUUIDHash>;
+  using ManufacturerId = uint16_t;
+  using ManufacturerDataMap =
+      std::unordered_map<ManufacturerId, std::vector<uint8_t>>;
+  using ManufacturerIDSet = std::unordered_set<ManufacturerId>;
 
   // Mapping from the platform-specific GATT service identifiers to
   // BluetoothRemoteGattService objects.
-  typedef base::ScopedPtrHashMap<std::string,
-                                 std::unique_ptr<BluetoothRemoteGattService>>
-      GattServiceMap;
+  using GattServiceMap =
+      std::unordered_map<std::string,
+                         std::unique_ptr<BluetoothRemoteGattService>>;
 
   // Interface for negotiating pairing of bluetooth devices.
   class PairingDelegate {
    public:
     virtual ~PairingDelegate() {}
 
     // This method will be called when the Bluetooth daemon requires a
     // PIN Code for authentication of the device |device|, the delegate should
     // obtain the code from the user and call SetPinCode() on the device to
     // provide it, or RejectPairing() or CancelPairing() to reject or cancel
@@ skipping 518 matching lines @@
 
   // Callbacks for pending success and error result of CreateGattConnection.
   std::vector<GattConnectionCallback> create_gatt_connection_success_callbacks_;
   std::vector<ConnectErrorCallback> create_gatt_connection_error_callbacks_;
 
   // BluetoothGattConnection objects keeping the GATT connection alive.
   std::set<BluetoothGattConnection*> gatt_connections_;
 
   GattServiceMap gatt_services_;
   bool gatt_services_discovery_complete_;
+  bool gatt_services_shutting_down_;
 
   // Received Signal Strength Indicator of the advertisement received.
   base::Optional<int8_t> inquiry_rssi_;
 
   // Tx Power advertised by the device.
   base::Optional<int8_t> inquiry_tx_power_;
 
   // Advertising Data flags of the device.
   base::Optional<uint8_t> advertising_data_flags_;
 
   // Class that holds the union of Advertised UUIDs and Service UUIDs.
   DeviceUUIDs device_uuids_;
 
   // Map of BluetoothUUIDs to their advertised Service Data.
   ServiceDataMap service_data_;
 
   // Map of Manufacturer IDs to their advertised Manufacturer Data.
   ManufacturerDataMap manufacturer_data_;
 
   // Timestamp for when an advertisement was last seen.
   base::Time last_update_time_;
 
  private:
   // Returns a localized string containing the device's bluetooth address and
   // a device type for display when |name_| is empty.
   base::string16 GetAddressWithLocalizedDeviceTypeName() const;
+
+  DISALLOW_COPY_AND_ASSIGN(BluetoothDevice);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_