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

device/bluetooth/bluetooth_task_manager_win.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_TASK_MANAGER_WIN_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 32 matching lines @@
     : public base::RefCountedThreadSafe<BluetoothTaskManagerWin> {
  public:
   struct DEVICE_BLUETOOTH_EXPORT AdapterState {
     AdapterState();
     ~AdapterState();
     std::string name;
     std::string address;
     bool powered;
   };
 
-  struct DEVICE_BLUETOOTH_EXPORT ServiceRecordState {
+  class DEVICE_BLUETOOTH_EXPORT ServiceRecordState {
+   public:
     ServiceRecordState();
-    ~ServiceRecordState();
+    virtual ~ServiceRecordState();

[Reilly Grant (use Gerrit), 2016/12/21 22:25:15]

Perhaps declare this class final and skip the virtual destructor.

[dougt, 2016/12/22 01:18:03]

Acknowledged.

     // Properties common to Bluetooth Classic and LE devices.
     std::string name;
     // Properties specific to Bluetooth Classic devices.
     std::vector<uint8_t> sdp_bytes;
     // Properties specific to Bluetooth LE devices.
     BluetoothUUID gatt_uuid;
     uint16_t attribute_handle;
     // GATT service device path.
     // Note: Operation of the included characteristics and descriptors of this
     // service must use service device path instead of resident device device
     // path.
     base::FilePath path;
   };

[Reilly Grant (use Gerrit), 2016/12/21 22:25:15]

Maybe DISALLOW_COPY_AND_ASSIGN(ServiceRecordState).

[dougt, 2016/12/22 01:18:03]

Done.

 
-  struct DEVICE_BLUETOOTH_EXPORT DeviceState {
+  using ServiceRecordStateList =
+      std::vector<std::unique_ptr<ServiceRecordState>>;
+
+  class DEVICE_BLUETOOTH_EXPORT DeviceState {
+   public:
     DeviceState();
     ~DeviceState();
 
     bool is_bluetooth_classic() const { return path.empty(); }
 
     // Properties common to Bluetooth Classic and LE devices.
     std::string address;  // This uniquely identifies the device.
     base::Optional<std::string> name;  // Friendly name
     bool visible;
     bool connected;
     bool authenticated;
-    ScopedVector<ServiceRecordState> service_record_states;
+    ServiceRecordStateList service_record_states;
     // Properties specific to Bluetooth Classic devices.
     uint32_t bluetooth_class;
     // Properties specific to Bluetooth LE devices.
     base::FilePath path;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(DeviceState);
   };
 
   class DEVICE_BLUETOOTH_EXPORT Observer {
    public:
      virtual ~Observer() {}
 
      virtual void AdapterStateChanged(const AdapterState& state) {}
      virtual void DiscoveryStarted(bool success) {}
      virtual void DiscoveryStopped() {}
      // Called when the adapter has just been polled for the list of *all* known
      // devices. This includes devices previously paired, devices paired using
      // the underlying Operating System UI, and devices discovered recently due
      // to an active discovery session. Note that for a given device (address),
      // the associated state can change over time. For example, during a
      // discovery session, the "friendly" name may initially be "unknown" before
      // the actual name is retrieved in subsequent poll events.
-     virtual void DevicesPolled(const ScopedVector<DeviceState>& devices) {}
+     virtual void DevicesPolled(
+         const std::vector<std::unique_ptr<DeviceState>>& devices) {}
   };
 
   explicit BluetoothTaskManagerWin(
       scoped_refptr<base::SequencedTaskRunner> ui_task_runner);
 
   static BluetoothUUID BluetoothLowEnergyUuidToBluetoothUuid(
       const BTH_LE_UUID& bth_le_uuid);
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   void Initialize();
   void InitializeWithBluetoothTaskRunner(
       scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner);
   void Shutdown();
 
   void PostSetPoweredBluetoothTask(
       bool powered,
       const base::Closure& callback,
       const BluetoothAdapter::ErrorCallback& error_callback);
   void PostStartDiscoveryTask();
   void PostStopDiscoveryTask();
 
   // Callbacks of asynchronous operations of GATT service.
-  typedef base::Callback<void(HRESULT)> HResultCallback;
-  typedef base::Callback<
-      void(std::unique_ptr<BTH_LE_GATT_CHARACTERISTIC>, uint16_t, HRESULT)>
-      GetGattIncludedCharacteristicsCallback;
-  typedef base::Callback<
-      void(std::unique_ptr<BTH_LE_GATT_DESCRIPTOR>, uint16_t, HRESULT)>
-      GetGattIncludedDescriptorsCallback;
-  typedef base::Callback<void(std::unique_ptr<BTH_LE_GATT_CHARACTERISTIC_VALUE>,
-                              HRESULT)>
-      ReadGattCharacteristicValueCallback;
-  typedef base::Callback<void(std::unique_ptr<std::vector<uint8_t>>)>
-      GattCharacteristicValueChangedCallback;
-  typedef base::Callback<void(PVOID, HRESULT)> GattEventRegistrationCallback;
+  using HResultCallback = base::Callback<void(HRESULT)>;
+  using GetGattIncludedCharacteristicsCallback = base::Callback<
+      void(std::unique_ptr<BTH_LE_GATT_CHARACTERISTIC>, uint16_t, HRESULT)>;
+  using GetGattIncludedDescriptorsCallback = base::Callback<
+      void(std::unique_ptr<BTH_LE_GATT_DESCRIPTOR>, uint16_t, HRESULT)>;
+  using ReadGattCharacteristicValueCallback =
+      base::Callback<void(std::unique_ptr<BTH_LE_GATT_CHARACTERISTIC_VALUE>,
+                          HRESULT)>;
+  using GattCharacteristicValueChangedCallback =
+      base::Callback<void(std::unique_ptr<std::vector<uint8_t>>)>;
+  using GattEventRegistrationCallback = base::Callback<void(PVOID, HRESULT)>;
 
   // Get all included characteristics of a given service. The service is
   // uniquely identified by its |uuid| and |attribute_handle| with service
   // device |service_path|. The result is returned asynchronously through
   // |callback|.
   void PostGetGattIncludedCharacteristics(
       const base::FilePath& service_path,
       const BluetoothUUID& uuid,
       uint16_t attribute_handle,
       const GetGattIncludedCharacteristicsCallback& callback);
@@ skipping 48 matching lines @@
 
   // Logs Win32 errors occurring during polling on the worker thread. The method
   // may discard messages to avoid logging being too verbose.
   void LogPollingError(const char* message, int win32_error);
 
   // Notify all Observers of updated AdapterState. Should only be called on the
   // UI thread.
   void OnAdapterStateChanged(const AdapterState* state);
   void OnDiscoveryStarted(bool success);
   void OnDiscoveryStopped();
-  void OnDevicesPolled(const ScopedVector<DeviceState>* devices);
+  void OnDevicesPolled(
+      const std::vector<std::unique_ptr<DeviceState>>* devices);

[Reilly Grant (use Gerrit), 2016/12/21 22:25:15]

Pass const& since this function DCHECKS that devices != nullptr.

[dougt, 2016/12/22 01:18:03]

Done.

 
   // Called on BluetoothTaskRunner.
   void StartPolling();
   void PollAdapter();
   void PostAdapterStateToUi();
   void SetPowered(bool powered,
                   const base::Closure& callback,
                   const BluetoothAdapter::ErrorCallback& error_callback);
 
   // Starts discovery. Once the discovery starts, it issues a discovery inquiry
@@ skipping 11 matching lines @@
 
   // Fetch already known device information. Similar to |StartDiscovery|, except
   // this function does not issue a discovery inquiry. Instead it gets the
   // device info cached in the adapter.
   void GetKnownDevices();
 
   // Looks for Bluetooth Classic and Low Energy devices, as well as the services
   // exposed by those devices.
   bool SearchDevices(int timeout_multiplier,
                      bool search_cached_devices_only,
-                     ScopedVector<DeviceState>* device_list);
+                     std::vector<std::unique_ptr<DeviceState>>* device_list);
 
   // Sends a device search API call to the adapter to look for Bluetooth Classic
   // devices.
-  bool SearchClassicDevices(int timeout_multiplier,
-                            bool search_cached_devices_only,
-                            ScopedVector<DeviceState>* device_list);
+  bool SearchClassicDevices(
+      int timeout_multiplier,
+      bool search_cached_devices_only,
+      std::vector<std::unique_ptr<DeviceState>>* device_list);
 
   // Enumerate Bluetooth Low Energy devices.
-  bool SearchLowEnergyDevices(ScopedVector<DeviceState>* device_list);
+  bool SearchLowEnergyDevices(
+      std::vector<std::unique_ptr<DeviceState>>* device_list);
 
   // Discover services for the devices in |device_list|.
-  bool DiscoverServices(ScopedVector<DeviceState>* device_list,
+  bool DiscoverServices(std::vector<std::unique_ptr<DeviceState>>* device_list,
                         bool search_cached_services_only);
 
   // Discover Bluetooth Classic services for the given |device_address|.
   bool DiscoverClassicDeviceServices(
       const std::string& device_address,
       const GUID& protocol_uuid,
       bool search_cached_services_only,
-      ScopedVector<ServiceRecordState>* service_record_states);
+      std::vector<std::unique_ptr<ServiceRecordState>>* service_record_states);
 
   // Discover Bluetooth Classic services for the given |device_address|.
   // Returns a Win32 error code.
   int DiscoverClassicDeviceServicesWorker(
       const std::string& device_address,
       const GUID& protocol_uuid,
       bool search_cached_services_only,
-      ScopedVector<ServiceRecordState>* service_record_states);
+      std::vector<std::unique_ptr<ServiceRecordState>>* service_record_states);
 
   // Discover Bluetooth Low Energy services for the given |device_path|.
   bool DiscoverLowEnergyDeviceServices(
       const base::FilePath& device_path,
-      ScopedVector<ServiceRecordState>* service_record_states);
+      std::vector<std::unique_ptr<ServiceRecordState>>* service_record_states);
 
   // Search for device paths of the GATT services in |*service_record_states|
   // from |device_address|.
   bool SearchForGattServiceDevicePaths(
       const std::string device_address,
-      ScopedVector<ServiceRecordState>* service_record_states);
+      std::vector<std::unique_ptr<ServiceRecordState>>* service_record_states);
 
   // GATT service related functions.
   void GetGattIncludedCharacteristics(
       base::FilePath device_path,
       BluetoothUUID uuid,
       uint16_t attribute_handle,
       const GetGattIncludedCharacteristicsCallback& callback);
   void GetGattIncludedDescriptors(
       base::FilePath service_path,
       BTH_LE_GATT_CHARACTERISTIC characteristic,
@@ skipping 33 matching lines @@
   // Use for discarding too many log messages.
   base::TimeTicks current_logging_batch_ticks_;
   int current_logging_batch_count_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothTaskManagerWin);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_