Convert device to std::unique_ptr

BUG=554298

Review URL: https://codereview.chromium.org/1874313002

Cr-Commit-Position: refs/heads/master@{#386398}

chrome/browser/devtools/device/usb/android_usb_device.h

@@ -14,6 +14,7 @@
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "device/usb/usb_device_handle.h"

device/battery/battery_monitor_impl.h

@@ -5,8 +5,9 @@
 #ifndef DEVICE_BATTERY_BATTERY_MONITOR_IMPL_H_
 #define DEVICE_BATTERY_BATTERY_MONITOR_IMPL_H_
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "device/battery/battery_export.h"
 #include "device/battery/battery_monitor.mojom.h"
 #include "device/battery/battery_status_service.h"
@@ -33,7 +34,8 @@ class BatteryMonitorImpl : public BatteryMonitor {
   void ReportStatus();
 
   mojo::StrongBinding<BatteryMonitor> binding_;
-  scoped_ptr<BatteryStatusService::BatteryUpdateSubscription> subscription_;
+  std::unique_ptr<BatteryStatusService::BatteryUpdateSubscription>
+      subscription_;
   BatteryStatusCallback callback_;
   BatteryStatus status_;
   bool status_to_report_;

device/battery/battery_status_manager.h

@@ -5,7 +5,8 @@
 #ifndef DEVICE_BATTERY_BATTERY_STATUS_MANAGER_H_
 #define DEVICE_BATTERY_BATTERY_STATUS_MANAGER_H_
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
 #include "device/battery/battery_status_service.h"
 
 namespace device {
@@ -15,7 +16,7 @@ class BatteryStatusManager {
  public:
   // Creates a BatteryStatusManager object. |callback| should be called when the
   // battery status changes.
-  static scoped_ptr<BatteryStatusManager> Create(
+  static std::unique_ptr<BatteryStatusManager> Create(
       const BatteryStatusService::BatteryUpdateCallback& callback);
 
   virtual ~BatteryStatusManager() {}

device/battery/battery_status_manager_chromeos.cc

@@ -4,6 +4,8 @@
 
 #include "device/battery/battery_status_manager.h"
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ -146,9 +148,9 @@ class BatteryStatusManagerChromeOS
 }  // namespace
 
 // static
-scoped_ptr<BatteryStatusManager> BatteryStatusManager::Create(
+std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
-  return scoped_ptr<BatteryStatusManager>(
+  return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerChromeOS(callback));
 }
 

device/battery/battery_status_manager_default.cc

@@ -4,6 +4,8 @@
 
 #include "device/battery/battery_status_manager.h"
 
+#include <memory>
+
 #include "base/logging.h"
 #include "base/macros.h"
 
@@ -32,9 +34,9 @@ class BatteryStatusManagerDefault : public BatteryStatusManager {
 }  // namespace
 
 // static
-scoped_ptr<BatteryStatusManager> BatteryStatusManager::Create(
+std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
-  return scoped_ptr<BatteryStatusManager>(
+  return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerDefault(callback));
 }
 

device/battery/battery_status_manager_linux.cc

@@ -7,6 +7,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/threading/thread.h"
@@ -60,37 +62,35 @@ bool GetPropertyAsBoolean(const base::DictionaryValue& dictionary,
   return dictionary.GetBoolean(property_name, &value) ? value : default_value;
 }
 
-scoped_ptr<base::DictionaryValue> GetPropertiesAsDictionary(
+std::unique_ptr<base::DictionaryValue> GetPropertiesAsDictionary(
     dbus::ObjectProxy* proxy) {
   dbus::MethodCall method_call(dbus::kPropertiesInterface,
                                dbus::kPropertiesGetAll);
   dbus::MessageWriter builder(&method_call);
   builder.AppendString(kUPowerDeviceName);
 
-  scoped_ptr<dbus::Response> response(
-      proxy->CallMethodAndBlock(&method_call,
-                                dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  std::unique_ptr<dbus::Response> response(proxy->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
   if (response) {
     dbus::MessageReader reader(response.get());
-    scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
+    std::unique_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
     base::DictionaryValue* dictionary_value = NULL;
     if (value && value->GetAsDictionary(&dictionary_value)) {
       ignore_result(value.release());
-      return scoped_ptr<base::DictionaryValue>(dictionary_value);
+      return std::unique_ptr<base::DictionaryValue>(dictionary_value);
     }
   }
-  return scoped_ptr<base::DictionaryValue>();
+  return std::unique_ptr<base::DictionaryValue>();
 }
 
-scoped_ptr<PathsVector> GetPowerSourcesPaths(dbus::ObjectProxy* proxy) {
-  scoped_ptr<PathsVector> paths(new PathsVector());
+std::unique_ptr<PathsVector> GetPowerSourcesPaths(dbus::ObjectProxy* proxy) {
+  std::unique_ptr<PathsVector> paths(new PathsVector());
   if (!proxy)
     return paths;
 
   dbus::MethodCall method_call(kUPowerServiceName, kUPowerEnumerateDevices);
-  scoped_ptr<dbus::Response> response(
-      proxy->CallMethodAndBlock(&method_call,
-                                dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
+  std::unique_ptr<dbus::Response> response(proxy->CallMethodAndBlock(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (response) {
     dbus::MessageReader reader(response.get());
@@ -136,14 +136,15 @@ class BatteryStatusNotificationThread : public base::Thread {
     dbus::ObjectProxy* power_proxy =
         system_bus_->GetObjectProxy(kUPowerServiceName,
                                     dbus::ObjectPath(kUPowerPath));
-    scoped_ptr<PathsVector> device_paths = GetPowerSourcesPaths(power_proxy);
+    std::unique_ptr<PathsVector> device_paths =
+        GetPowerSourcesPaths(power_proxy);
     int num_batteries = 0;
 
     for (size_t i = 0; i < device_paths->size(); ++i) {
       const dbus::ObjectPath& device_path = device_paths->at(i);
       dbus::ObjectProxy* device_proxy = system_bus_->GetObjectProxy(
           kUPowerServiceName, device_path);
-      scoped_ptr<base::DictionaryValue> dictionary =
+      std::unique_ptr<base::DictionaryValue> dictionary =
           GetPropertiesAsDictionary(device_proxy);
 
       if (!dictionary)
@@ -250,7 +251,7 @@ class BatteryStatusNotificationThread : public base::Thread {
     if (!system_bus_.get())
       return;
 
-    scoped_ptr<base::DictionaryValue> dictionary =
+    std::unique_ptr<base::DictionaryValue> dictionary =
         GetPropertiesAsDictionary(battery_proxy_);
     if (dictionary)
       callback_.Run(ComputeWebBatteryStatus(*dictionary));
@@ -315,7 +316,7 @@ class BatteryStatusManagerLinux : public BatteryStatusManager {
   }
 
   BatteryStatusService::BatteryUpdateCallback callback_;
-  scoped_ptr<BatteryStatusNotificationThread> notifier_thread_;
+  std::unique_ptr<BatteryStatusNotificationThread> notifier_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerLinux);
 };
@@ -368,9 +369,9 @@ BatteryStatus ComputeWebBatteryStatus(const base::DictionaryValue& dictionary) {
 }
 
 // static
-scoped_ptr<BatteryStatusManager> BatteryStatusManager::Create(
+std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
-  return scoped_ptr<BatteryStatusManager>(
+  return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerLinux(callback));
 }
 

device/battery/battery_status_manager_mac.cc

@@ -5,14 +5,15 @@
 #include "device/battery/battery_status_manager.h"
 
 #include <CoreFoundation/CoreFoundation.h>
-#include <IOKit/ps/IOPowerSources.h>
 #include <IOKit/ps/IOPSKeys.h>
+#include <IOKit/ps/IOPowerSources.h>
+
+#include <memory>
 #include <vector>
 
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
 
@@ -227,17 +228,17 @@ class BatteryStatusManagerMac : public BatteryStatusManager {
   }
 
  private:
-  scoped_ptr<BatteryStatusObserver> notifier_;
+  std::unique_ptr<BatteryStatusObserver> notifier_;
 
   DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerMac);
 };
 
 } // end namespace
 
 // static
-scoped_ptr<BatteryStatusManager> BatteryStatusManager::Create(
+std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
-  return scoped_ptr<BatteryStatusManager>(
+  return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerMac(callback));
 }
 

device/battery/battery_status_manager_win.cc

@@ -4,9 +4,10 @@
 
 #include "device/battery/battery_status_manager_win.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/win/message_window.h"
@@ -152,7 +153,7 @@ class BatteryStatusObserver {
   HPOWERNOTIFY power_handle_;
   HPOWERNOTIFY battery_change_handle_;
   BatteryCallback callback_;
-  scoped_ptr<base::win::MessageWindow> window_;
+  std::unique_ptr<base::win::MessageWindow> window_;
 
   DISALLOW_COPY_AND_ASSIGN(BatteryStatusObserver);
 };
@@ -173,7 +174,7 @@ class BatteryStatusManagerWin : public BatteryStatusManager {
   void StopListeningBatteryChange() override { battery_observer_->Stop(); }
 
  private:
-  scoped_ptr<BatteryStatusObserver> battery_observer_;
+  std::unique_ptr<BatteryStatusObserver> battery_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerWin);
 };
@@ -206,9 +207,9 @@ BatteryStatus ComputeWebBatteryStatus(const SYSTEM_POWER_STATUS& win_status) {
 }
 
 // static
-scoped_ptr<BatteryStatusManager> BatteryStatusManager::Create(
+std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
     const BatteryStatusService::BatteryUpdateCallback& callback) {
-  return scoped_ptr<BatteryStatusManager>(
+  return std::unique_ptr<BatteryStatusManager>(
       new BatteryStatusManagerWin(callback));
 }
 

device/battery/battery_status_service.cc

@@ -34,7 +34,7 @@ BatteryStatusService* BatteryStatusService::GetInstance() {
       base::LeakySingletonTraits<BatteryStatusService>>::get();
 }
 
-scoped_ptr<BatteryStatusService::BatteryUpdateSubscription>
+std::unique_ptr<BatteryStatusService::BatteryUpdateSubscription>
 BatteryStatusService::AddCallback(const BatteryUpdateCallback& callback) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(!is_shutdown_);
@@ -100,7 +100,7 @@ BatteryStatusService::GetUpdateCallbackForTesting() const {
 }
 
 void BatteryStatusService::SetBatteryManagerForTesting(
-    scoped_ptr<BatteryStatusManager> test_battery_manager) {
+    std::unique_ptr<BatteryStatusManager> test_battery_manager) {
   battery_fetcher_ = std::move(test_battery_manager);
   status_ = BatteryStatus();
   status_updated_ = false;

device/battery/battery_status_service.h

@@ -5,9 +5,10 @@
 #ifndef DEVICE_BATTERY_BATTERY_STATUS_SERVICE_H_
 #define DEVICE_BATTERY_BATTERY_STATUS_SERVICE_H_
 
+#include <memory>
+
 #include "base/callback_list.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "device/battery/battery_export.h"
 #include "device/battery/battery_status.mojom.h"
@@ -32,15 +33,15 @@ class DEVICE_BATTERY_EXPORT BatteryStatusService {
   // Adds a callback to receive battery status updates.  Must be called on the
   // main thread. The callback itself will be called on the main thread as well.
   // NOTE: The callback may be run before AddCallback returns!
-  scoped_ptr<BatteryUpdateSubscription> AddCallback(
+  std::unique_ptr<BatteryUpdateSubscription> AddCallback(
       const BatteryUpdateCallback& callback);
 
   // Gracefully clean-up.
   void Shutdown();
 
   // Injects a custom battery status manager for testing purposes.
   void SetBatteryManagerForTesting(
-      scoped_ptr<BatteryStatusManager> test_battery_manager);
+      std::unique_ptr<BatteryStatusManager> test_battery_manager);
 
   // Returns callback to invoke when battery is changed. Used for testing.
   const BatteryUpdateCallback& GetUpdateCallbackForTesting() const;
@@ -59,7 +60,7 @@ class DEVICE_BATTERY_EXPORT BatteryStatusService {
   void ConsumersChanged();
 
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
-  scoped_ptr<BatteryStatusManager> battery_fetcher_;
+  std::unique_ptr<BatteryStatusManager> battery_fetcher_;
   BatteryUpdateCallbackList callback_list_;
   BatteryUpdateCallback update_callback_;
   BatteryStatus status_;