Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/power/extension_event_observer.cc

 // Copyright 2015 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.
 
 #include "chrome/browser/chromeos/power/extension_event_observer.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/gcm.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/background_info.h"
@@ skipping 57 matching lines @@
 
   for (const auto& pair : keepalive_sources_) {
     extensions::ExtensionHost* host =
         const_cast<extensions::ExtensionHost*>(pair.first);
     host->RemoveObserver(this);
   }
 
   DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
 }
 
-scoped_ptr<ExtensionEventObserver::TestApi>
+std::unique_ptr<ExtensionEventObserver::TestApi>
 ExtensionEventObserver::CreateTestApi() {
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new ExtensionEventObserver::TestApi(weak_factory_.GetWeakPtr()));
 }
 
 void ExtensionEventObserver::SetShouldDelaySuspend(bool should_delay) {
   should_delay_suspend_ = should_delay;
   if (!should_delay_suspend_ && suspend_is_pending_) {
     // There is a suspend attempt pending but this class should no longer be
     // delaying it.  Immediately report readiness.
     suspend_is_pending_ = false;
     power_manager_callback_.Run();
@@ skipping 23 matching lines @@
 void ExtensionEventObserver::OnBackgroundHostCreated(
     extensions::ExtensionHost* host) {
   // We only care about ExtensionHosts for extensions that use GCM and have a
   // lazy background page.
   if (!host->extension()->permissions_data()->HasAPIPermission(
           extensions::APIPermission::kGcm) ||
       !extensions::BackgroundInfo::HasLazyBackgroundPage(host->extension()))
     return;
 
   auto result =
-      keepalive_sources_.add(host, make_scoped_ptr(new KeepaliveSources()));
+      keepalive_sources_.add(host, base::WrapUnique(new KeepaliveSources()));
 
   if (result.second)
     host->AddObserver(this);
 }
 
 void ExtensionEventObserver::OnExtensionHostDestroyed(
     const extensions::ExtensionHost* host) {
   DCHECK(keepalive_sources_.contains(host));
 
-  scoped_ptr<KeepaliveSources> sources =
+  std::unique_ptr<KeepaliveSources> sources =
       keepalive_sources_.take_and_erase(host);
 
   suspend_keepalive_count_ -= sources->unacked_push_messages.size();
   suspend_keepalive_count_ -= sources->pending_network_requests.size();
   MaybeReportSuspendReadiness();
 }
 
 void ExtensionEventObserver::OnBackgroundEventDispatched(
     const extensions::ExtensionHost* host,
     const std::string& event_name,
@@ skipping 109 matching lines @@
   if (!suspend_is_pending_ || suspend_keepalive_count_ > 0 ||
       power_manager_callback_.is_null())
     return;
 
   suspend_is_pending_ = false;
   power_manager_callback_.Run();
   power_manager_callback_.Reset();
 }
 
 }  // namespace chromeos