Convert //extensions/renderer from scoped_ptr to std::unique_ptr

extensions/renderer/dispatcher.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/renderer/dispatcher.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "content/grit/content_resources.h"
@@ skipping 132 matching lines @@
 // Calls a method |method_name| in a module |module_name| belonging to the
 // module system from |context|. Intended as a callback target from
 // ScriptContextSet::ForEach.
 void CallModuleMethod(const std::string& module_name,
                       const std::string& method_name,
                       const base::ListValue* args,
                       ScriptContext* context) {
   v8::HandleScope handle_scope(context->isolate());
   v8::Context::Scope context_scope(context->v8_context());
 
-  scoped_ptr<content::V8ValueConverter> converter(
+  std::unique_ptr<content::V8ValueConverter> converter(
       content::V8ValueConverter::create());
 
   std::vector<v8::Local<v8::Value>> arguments;
   for (base::ListValue::const_iterator it = args->begin(); it != args->end();
        ++it) {
     arguments.push_back(converter->ToV8Value(*it, context->v8_context()));
   }
 
   context->module_system()->CallModuleMethod(
       module_name, method_name, &arguments);
@@ skipping 129 matching lines @@
 
   ScriptContext* context = script_context_set_->Register(
       frame, v8_context, extension_group, world_id);
 
   // Initialize origin permissions for content scripts, which can't be
   // initialized in |OnActivateExtension|.
   if (context->context_type() == Feature::CONTENT_SCRIPT_CONTEXT)
     InitOriginPermissions(context->extension());
 
   {
-    scoped_ptr<ModuleSystem> module_system(
+    std::unique_ptr<ModuleSystem> module_system(
         new ModuleSystem(context, &source_map_));
     context->set_module_system(std::move(module_system));
   }
   ModuleSystem* module_system = context->module_system();
 
   // Enable natives in startup.
   ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system);
 
   RegisterNativeHandlers(module_system, context);
 
@@ skipping 93 matching lines @@
     // saying that an extension is ready, and documenting that extension APIs
     // won't work before that event has fired?
     return;
   }
 
   ScriptContext* context = new ScriptContext(
       v8_context, nullptr, extension, Feature::SERVICE_WORKER_CONTEXT,
       extension, Feature::SERVICE_WORKER_CONTEXT);
   context->set_url(url);
 
-  g_worker_script_context_set.Get().Insert(make_scoped_ptr(context));
+  g_worker_script_context_set.Get().Insert(base::WrapUnique(context));
 
   v8::Isolate* isolate = context->isolate();
 
   // Fetch the source code for service_worker_bindings.js.
   base::StringPiece script_resource =
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_SERVICE_WORKER_BINDINGS_JS);
   v8::Local<v8::String> script = v8::String::NewExternal(
       isolate, new StaticV8ExternalOneByteStringResource(script_resource));
 
@@ skipping 143 matching lines @@
       extension_id, base::Bind(&CallModuleMethod, local_event_bindings,
                                kEventDispatchFunction, &args));
 }
 
 void Dispatcher::InvokeModuleSystemMethod(content::RenderFrame* render_frame,
                                           const std::string& extension_id,
                                           const std::string& module_name,
                                           const std::string& function_name,
                                           const base::ListValue& args,
                                           bool user_gesture) {
-  scoped_ptr<WebScopedUserGesture> web_user_gesture;
+  std::unique_ptr<WebScopedUserGesture> web_user_gesture;
   if (user_gesture)
     web_user_gesture.reset(new WebScopedUserGesture);
 
   script_context_set_->ForEach(
       extension_id, render_frame,
       base::Bind(&CallModuleMethod, module_name, function_name, &args));
 
   // Reset the idle handler each time there's any activity like event or message
   // dispatch, for which Invoke is the chokepoint.
   if (set_idle_notifications_) {
@@ skipping 202 matching lines @@
 }
 
 // NOTE: please use the naming convention "foo_natives" for these.
 // static
 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
                                         ScriptContext* context,
                                         Dispatcher* dispatcher,
                                         RequestSender* request_sender,
                                         V8SchemaRegistry* v8_schema_registry) {
   module_system->RegisterNativeHandler(
-      "chrome", scoped_ptr<NativeHandler>(new ChromeNativeHandler(context)));
+      "chrome",
+      std::unique_ptr<NativeHandler>(new ChromeNativeHandler(context)));
   module_system->RegisterNativeHandler(
-      "logging", scoped_ptr<NativeHandler>(new LoggingNativeHandler(context)));
+      "logging",
+      std::unique_ptr<NativeHandler>(new LoggingNativeHandler(context)));
   module_system->RegisterNativeHandler("schema_registry",
                                        v8_schema_registry->AsNativeHandler());
   module_system->RegisterNativeHandler(
       "test_features",
-      scoped_ptr<NativeHandler>(new TestFeaturesNativeHandler(context)));
+      std::unique_ptr<NativeHandler>(new TestFeaturesNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "test_native_handler",
-      scoped_ptr<NativeHandler>(new TestNativeHandler(context)));
+      std::unique_ptr<NativeHandler>(new TestNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "user_gestures",
-      scoped_ptr<NativeHandler>(new UserGesturesNativeHandler(context)));
+      std::unique_ptr<NativeHandler>(new UserGesturesNativeHandler(context)));
   module_system->RegisterNativeHandler(
-      "utils", scoped_ptr<NativeHandler>(new UtilsNativeHandler(context)));
+      "utils", std::unique_ptr<NativeHandler>(new UtilsNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "v8_context",
-      scoped_ptr<NativeHandler>(new V8ContextNativeHandler(context)));
+      std::unique_ptr<NativeHandler>(new V8ContextNativeHandler(context)));
   module_system->RegisterNativeHandler(
-      "event_natives", scoped_ptr<NativeHandler>(new EventBindings(context)));
+      "event_natives",
+      std::unique_ptr<NativeHandler>(new EventBindings(context)));
   module_system->RegisterNativeHandler(
-      "messaging_natives",
-      scoped_ptr<NativeHandler>(MessagingBindings::Get(dispatcher, context)));
+      "messaging_natives", std::unique_ptr<NativeHandler>(
+                               MessagingBindings::Get(dispatcher, context)));
   module_system->RegisterNativeHandler(
-      "apiDefinitions",
-      scoped_ptr<NativeHandler>(
-          new ApiDefinitionsNatives(dispatcher, context)));
+      "apiDefinitions", std::unique_ptr<NativeHandler>(
+                            new ApiDefinitionsNatives(dispatcher, context)));
   module_system->RegisterNativeHandler(
-      "sendRequest",
-      scoped_ptr<NativeHandler>(
-          new SendRequestNatives(request_sender, context)));
+      "sendRequest", std::unique_ptr<NativeHandler>(
+                         new SendRequestNatives(request_sender, context)));
   module_system->RegisterNativeHandler(
-      "setIcon",
-      scoped_ptr<NativeHandler>(new SetIconNatives(context)));
+      "setIcon", std::unique_ptr<NativeHandler>(new SetIconNatives(context)));
   module_system->RegisterNativeHandler(
       "activityLogger",
-      scoped_ptr<NativeHandler>(new APIActivityLogger(context)));
+      std::unique_ptr<NativeHandler>(new APIActivityLogger(context)));
   module_system->RegisterNativeHandler(
       "renderFrameObserverNatives",
-      scoped_ptr<NativeHandler>(new RenderFrameObserverNatives(context)));
+      std::unique_ptr<NativeHandler>(new RenderFrameObserverNatives(context)));
 
   // Natives used by multiple APIs.
   module_system->RegisterNativeHandler(
       "file_system_natives",
-      scoped_ptr<NativeHandler>(new FileSystemNatives(context)));
+      std::unique_ptr<NativeHandler>(new FileSystemNatives(context)));
 
   // Custom bindings.
   module_system->RegisterNativeHandler(
       "app_window_natives",
-      scoped_ptr<NativeHandler>(new AppWindowCustomBindings(context)));
+      std::unique_ptr<NativeHandler>(new AppWindowCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "blob_natives",
-      scoped_ptr<NativeHandler>(new BlobNativeHandler(context)));
+      std::unique_ptr<NativeHandler>(new BlobNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "context_menus",
-      scoped_ptr<NativeHandler>(new ContextMenusCustomBindings(context)));
+      std::unique_ptr<NativeHandler>(new ContextMenusCustomBindings(context)));
   module_system->RegisterNativeHandler(
-      "css_natives", scoped_ptr<NativeHandler>(new CssNativeHandler(context)));
+      "css_natives",
+      std::unique_ptr<NativeHandler>(new CssNativeHandler(context)));
   module_system->RegisterNativeHandler(
       "document_natives",
-      scoped_ptr<NativeHandler>(new DocumentCustomBindings(context)));
+      std::unique_ptr<NativeHandler>(new DocumentCustomBindings(context)));
   module_system->RegisterNativeHandler(
-      "guest_view_internal",
-      scoped_ptr<NativeHandler>(
-          new GuestViewInternalCustomBindings(context)));
+      "guest_view_internal", std::unique_ptr<NativeHandler>(
+                                 new GuestViewInternalCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "id_generator",
-      scoped_ptr<NativeHandler>(new IdGeneratorCustomBindings(context)));
+      std::unique_ptr<NativeHandler>(new IdGeneratorCustomBindings(context)));
   module_system->RegisterNativeHandler(
-      "runtime", scoped_ptr<NativeHandler>(new RuntimeCustomBindings(context)));
+      "runtime",
+      std::unique_ptr<NativeHandler>(new RuntimeCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "display_source",
-      scoped_ptr<NativeHandler>(new DisplaySourceCustomBindings(context)));
+      std::unique_ptr<NativeHandler>(new DisplaySourceCustomBindings(context)));
 }
 
 bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(Dispatcher, message)
   IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
   IPC_MESSAGE_HANDLER(ExtensionMsg_CancelSuspend, OnCancelSuspend)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnConnect, OnDispatchOnConnect)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect, OnDispatchOnDisconnect)
@@ skipping 82 matching lines @@
   InitOriginPermissions(extension);
 
   UpdateActiveExtensions();
 }
 
 void Dispatcher::OnCancelSuspend(const std::string& extension_id) {
   DispatchEvent(extension_id, kOnSuspendCanceledEvent);
 }
 
 void Dispatcher::OnDeliverMessage(int target_port_id, const Message& message) {
-  scoped_ptr<RequestSender::ScopedTabID> scoped_tab_id;
+  std::unique_ptr<RequestSender::ScopedTabID> scoped_tab_id;
   std::map<int, int>::const_iterator it =
       port_to_tab_id_map_.find(target_port_id);
   if (it != port_to_tab_id_map_.end()) {
     scoped_tab_id.reset(
         new RequestSender::ScopedTabID(request_sender(), it->second));
   }
 
   MessagingBindings::DeliverMessage(*script_context_set_, target_port_id,
                                     message,
                                     NULL);  // All render frames.
@@ skipping 145 matching lines @@
   // extension's URL just won't match anything anymore.
 }
 
 void Dispatcher::OnUpdatePermissions(
     const ExtensionMsg_UpdatePermissions_Params& params) {
   const Extension* extension =
       RendererExtensionRegistry::Get()->GetByID(params.extension_id);
   if (!extension)
     return;
 
-  scoped_ptr<const PermissionSet> active =
+  std::unique_ptr<const PermissionSet> active =
       params.active_permissions.ToPermissionSet();
-  scoped_ptr<const PermissionSet> withheld =
+  std::unique_ptr<const PermissionSet> withheld =
       params.withheld_permissions.ToPermissionSet();
 
   UpdateOriginPermissions(
       extension->url(),
       extension->permissions_data()->GetEffectiveHostPermissions(),
       active->effective_hosts());
 
   extension->permissions_data()->SetPermissions(std::move(active),
                                                 std::move(withheld));
   UpdateBindings(extension->id());
@@ skipping 217 matching lines @@
     if (bind_object->HasRealNamedCallbackProperty(v8_bind_name))
       return;  // lazy binding still there, nothing to do
     if (bind_object->Get(v8_bind_name)->IsObject())
       return;  // binding has already been fully installed
   }
 
   ModuleSystem* module_system = context->module_system();
   if (!source_map_.Contains(api_name)) {
     module_system->RegisterNativeHandler(
         api_name,
-        scoped_ptr<NativeHandler>(new BindingGeneratingNativeHandler(
-            context, api_name, "binding")));
+        std::unique_ptr<NativeHandler>(
+            new BindingGeneratingNativeHandler(context, api_name, "binding")));
     module_system->SetNativeLazyField(
         bind_object, bind_name, api_name, "binding");
   } else {
     module_system->SetLazyField(bind_object, bind_name, api_name, "binding");
   }
 }
 
 // NOTE: please use the naming convention "foo_natives" for these.
 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
                                         ScriptContext* context) {
   RegisterNativeHandlers(module_system,
                          context,
                          this,
                          request_sender_.get(),
                          v8_schema_registry_.get());
   const Extension* extension = context->extension();
   int manifest_version = extension ? extension->manifest_version() : 1;
   bool is_component_extension =
       extension && Manifest::IsComponentLocation(extension->location());
   bool send_request_disabled =
       (extension && Manifest::IsUnpackedLocation(extension->location()) &&
        BackgroundInfo::HasLazyBackgroundPage(extension));
   module_system->RegisterNativeHandler(
       "process",
-      scoped_ptr<NativeHandler>(new ProcessInfoNativeHandler(
-          context,
-          context->GetExtensionID(),
+      std::unique_ptr<NativeHandler>(new ProcessInfoNativeHandler(
+          context, context->GetExtensionID(),
           context->GetContextTypeDescription(),
           ExtensionsRendererClient::Get()->IsIncognitoProcess(),
-          is_component_extension,
-          manifest_version,
-          send_request_disabled)));
+          is_component_extension, manifest_version, send_request_disabled)));
 
   delegate_->RegisterNativeHandlers(this, module_system, context);
 }
 
 bool Dispatcher::IsRuntimeAvailableToContext(ScriptContext* context) {
   for (const auto& extension :
        *RendererExtensionRegistry::Get()->GetMainThreadExtensionSet()) {
     ExternallyConnectableInfo* info = static_cast<ExternallyConnectableInfo*>(
         extension->GetManifestData(manifest_keys::kExternallyConnectable));
     if (info && info->matches.MatchesURL(context->url()))
@@ skipping 153 matching lines @@
   // The "guestViewDeny" module must always be loaded last. It registers
   // error-providing custom elements for the GuestView types that are not
   // available, and thus all of those types must have been checked and loaded
   // (or not loaded) beforehand.
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("guestViewDeny");
   }
 }
 
 }  // namespace extensions