Remove base::ScopedPtrHashMap from device/.

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/macros.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 55 matching lines @@
                              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;
 
   // Mapping from the platform-specific GATT service identifiers to
   // BluetoothRemoteGattService objects.
-  typedef base::ScopedPtrHashMap<std::string,
-                                 std::unique_ptr<BluetoothRemoteGattService>>
+  typedef std::unordered_map<std::string,
+                             std::unique_ptr<BluetoothRemoteGattService>>
       GattServiceMap;
 
   // 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
@@ skipping 451 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(BluetoothTest, RemoveOutdatedDevices);
   FRIEND_TEST_ALL_PREFIXES(BluetoothTest, RemoveOutdatedDeviceGattConnect);
 
   // Helper class to easily update the sets of UUIDs and keep them in sync with
   // the set of all the device's UUIDs.
   class DeviceUUIDs {
    public:
     DeviceUUIDs();
     ~DeviceUUIDs();
 
+    DeviceUUIDs(const DeviceUUIDs& other);
+    DeviceUUIDs& operator=(const DeviceUUIDs& other);
+
     // Advertised Service UUIDs functions
     void ReplaceAdvertisedUUIDs(UUIDList new_advertised_uuids);
 
     void ClearAdvertisedUUIDs();
 
     // Service UUIDs functions
     void ReplaceServiceUUIDs(
         const BluetoothDevice::GattServiceMap& gatt_services);
 
     void ClearServiceUUIDs();
 
     // Returns the union of Advertised UUIDs and Service UUIDs.
     const UUIDSet& GetUUIDs() const;
 
    private:
     void UpdateDeviceUUIDs();
 
     BluetoothDevice::UUIDSet advertised_uuids_;
     BluetoothDevice::UUIDSet service_uuids_;
     BluetoothDevice::UUIDSet device_uuids_;
   };
 
-  BluetoothDevice(BluetoothAdapter* adapter);
+  explicit BluetoothDevice(BluetoothAdapter* adapter);
 
   // Implements platform specific operations to initiate a GATT connection.
   // Subclasses must also call DidConnectGatt, DidFailToConnectGatt, or
   // DidDisconnectGatt immediately or asynchronously as the connection state
   // changes.
   virtual void CreateGattConnectionImpl() = 0;
 
   // Disconnects GATT connection on platforms that maintain a specific GATT
   // connection.
   virtual void DisconnectGatt() = 0;
@@ skipping 51 matching lines @@
   // 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_