Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/runtime/runtime_api.cc

 // Copyright 2014 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 "extensions/browser/api/runtime/runtime_api.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/api/runtime/runtime_api_delegate.h"
 #include "extensions/browser/event_router.h"
@@ skipping 84 matching lines @@
       first_call &&
       LazyBackgroundTaskQueue::Get(browser_context)
           ->ShouldEnqueueTask(browser_context, extension)) {
     LazyBackgroundTaskQueue::Get(browser_context)
         ->AddPendingTask(browser_context, extension_id,
                          base::Bind(&DispatchOnStartupEventImpl,
                                     browser_context, extension_id, false));
     return;
   }
 
-  scoped_ptr<base::ListValue> event_args(new base::ListValue());
-  scoped_ptr<Event> event(new Event(events::RUNTIME_ON_STARTUP,
-                                    runtime::OnStartup::kEventName,
-                                    std::move(event_args)));
+  std::unique_ptr<base::ListValue> event_args(new base::ListValue());
+  std::unique_ptr<Event> event(new Event(events::RUNTIME_ON_STARTUP,
+                                         runtime::OnStartup::kEventName,
+                                         std::move(event_args)));
   EventRouter::Get(browser_context)
       ->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 void SetUninstallURL(ExtensionPrefs* prefs,
                      const std::string& extension_id,
                      const std::string& url_string) {
   prefs->UpdateExtensionPref(
       extension_id, kUninstallUrl, new base::StringValue(url_string));
 }
@@ skipping 150 matching lines @@
                              kPrefPendingOnInstalledEventDispatchInfo, nullptr);
 }
 
 void RuntimeAPI::StorePendingOnInstallInfoToPref(const Extension* extension) {
   ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context_);
   DCHECK(prefs);
 
   // |pending_on_install_info| currently only contains a version string. Instead
   // of making the pref hold a plain string, we store it as a dictionary value
   // so that we can add more stuff to it in the future if necessary.
-  scoped_ptr<base::DictionaryValue> pending_on_install_info(
+  std::unique_ptr<base::DictionaryValue> pending_on_install_info(
       new base::DictionaryValue());
   base::Version previous_version =
       delegate_->GetPreviousExtensionVersion(extension);
   pending_on_install_info->SetString(
       kPrefPreviousVersion,
       previous_version.IsValid() ? previous_version.GetString() : "");
   prefs->UpdateExtensionPref(extension->id(),
                              kPrefPendingOnInstalledEventDispatchInfo,
                              pending_on_install_info.release());
 }
@@ skipping 38 matching lines @@
     content::BrowserContext* context,
     const std::string& extension_id,
     const Version& old_version,
     bool chrome_updated) {
   if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
     return;
   ExtensionSystem* system = ExtensionSystem::Get(context);
   if (!system)
     return;
 
-  scoped_ptr<base::ListValue> event_args(new base::ListValue());
+  std::unique_ptr<base::ListValue> event_args(new base::ListValue());
   base::DictionaryValue* info = new base::DictionaryValue();
   event_args->Append(info);
   if (old_version.IsValid()) {
     info->SetString(kInstallReason, kInstallReasonUpdate);
     info->SetString(kInstallPreviousVersion, old_version.GetString());
   } else if (chrome_updated) {
     info->SetString(kInstallReason, kInstallReasonChromeUpdate);
   } else {
     info->SetString(kInstallReason, kInstallReasonInstall);
   }
   EventRouter* event_router = EventRouter::Get(context);
   DCHECK(event_router);
-  scoped_ptr<Event> event(new Event(events::RUNTIME_ON_INSTALLED,
-                                    runtime::OnInstalled::kEventName,
-                                    std::move(event_args)));
+  std::unique_ptr<Event> event(new Event(events::RUNTIME_ON_INSTALLED,
+                                         runtime::OnInstalled::kEventName,
+                                         std::move(event_args)));
   event_router->DispatchEventWithLazyListener(extension_id, std::move(event));
 
   if (old_version.IsValid()) {
     const Extension* extension =
         ExtensionRegistry::Get(context)->enabled_extensions().GetByID(
             extension_id);
     if (extension && SharedModuleInfo::IsSharedModule(extension)) {
-      scoped_ptr<ExtensionSet> dependents =
+      std::unique_ptr<ExtensionSet> dependents =
           system->GetDependentExtensions(extension);
       for (ExtensionSet::const_iterator i = dependents->begin();
            i != dependents->end();
            i++) {
-        scoped_ptr<base::ListValue> sm_event_args(new base::ListValue());
+        std::unique_ptr<base::ListValue> sm_event_args(new base::ListValue());
         base::DictionaryValue* sm_info = new base::DictionaryValue();
         sm_event_args->Append(sm_info);
         sm_info->SetString(kInstallReason, kInstallReasonSharedModuleUpdate);
         sm_info->SetString(kInstallPreviousVersion, old_version.GetString());
         sm_info->SetString(kInstallId, extension_id);
-        scoped_ptr<Event> sm_event(new Event(events::RUNTIME_ON_INSTALLED,
-                                             runtime::OnInstalled::kEventName,
-                                             std::move(sm_event_args)));
+        std::unique_ptr<Event> sm_event(new Event(
+            events::RUNTIME_ON_INSTALLED, runtime::OnInstalled::kEventName,
+            std::move(sm_event_args)));
         event_router->DispatchEventWithLazyListener((*i)->id(),
                                                     std::move(sm_event));
       }
     }
   }
 }
 
 // static
 void RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
     content::BrowserContext* context,
     const std::string& extension_id,
     const base::DictionaryValue* manifest) {
   ExtensionSystem* system = ExtensionSystem::Get(context);
   if (!system)
     return;
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(manifest->DeepCopy());
   EventRouter* event_router = EventRouter::Get(context);
   DCHECK(event_router);
-  scoped_ptr<Event> event(new Event(events::RUNTIME_ON_UPDATE_AVAILABLE,
-                                    runtime::OnUpdateAvailable::kEventName,
-                                    std::move(args)));
+  std::unique_ptr<Event> event(new Event(events::RUNTIME_ON_UPDATE_AVAILABLE,
+                                         runtime::OnUpdateAvailable::kEventName,
+                                         std::move(args)));
   event_router->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 // static
 void RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(
     content::BrowserContext* context) {
   ExtensionSystem* system = ExtensionSystem::Get(context);
   if (!system)
     return;
 
-  scoped_ptr<base::ListValue> args(new base::ListValue);
+  std::unique_ptr<base::ListValue> args(new base::ListValue);
   EventRouter* event_router = EventRouter::Get(context);
   DCHECK(event_router);
-  scoped_ptr<Event> event(new Event(
+  std::unique_ptr<Event> event(new Event(
       events::RUNTIME_ON_BROWSER_UPDATE_AVAILABLE,
       runtime::OnBrowserUpdateAvailable::kEventName, std::move(args)));
   event_router->BroadcastEvent(std::move(event));
 }
 
 // static
 void RuntimeEventRouter::DispatchOnRestartRequiredEvent(
     content::BrowserContext* context,
     const std::string& app_id,
     api::runtime::OnRestartRequiredReason reason) {
   ExtensionSystem* system = ExtensionSystem::Get(context);
   if (!system)
     return;
 
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::RUNTIME_ON_RESTART_REQUIRED,
                 runtime::OnRestartRequired::kEventName,
                 api::runtime::OnRestartRequired::Create(reason)));
   EventRouter* event_router = EventRouter::Get(context);
   DCHECK(event_router);
   event_router->DispatchEventToExtension(app_id, std::move(event));
 }
 
 // static
 void RuntimeEventRouter::OnExtensionUninstalled(
@@ skipping 129 matching lines @@
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   policy->GrantReadFileSystem(renderer_id, filesystem_id);
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("fileSystemId", filesystem_id);
   dict->SetString("baseName", relative_path);
   return RespondNow(OneArgument(dict));
 }
 
 }  // namespace extensions