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

chrome/browser/extensions/api/messaging/message_service.cc

 // 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.
 
 #include "chrome/browser/extensions/api/messaging/message_service.h"
 
 #include <stdint.h>
 #include <limits>
 #include <utility>
 
@@ skipping 109 matching lines @@
     "Could not establish connection. Receiving end does not exist.";
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
 const char kMissingPermissionError[] =
     "Access to native messaging requires nativeMessaging permission.";
 const char kProhibitedByPoliciesError[] =
     "Access to the native messaging host was disabled by the system "
     "administrator.";
 #endif
 
 struct MessageService::MessageChannel {
-  scoped_ptr<MessagePort> opener;
-  scoped_ptr<MessagePort> receiver;
+  std::unique_ptr<MessagePort> opener;
+  std::unique_ptr<MessagePort> receiver;
 };
 
 struct MessageService::OpenChannelParams {
   int source_process_id;
   int source_routing_id;
-  scoped_ptr<base::DictionaryValue> source_tab;
+  std::unique_ptr<base::DictionaryValue> source_tab;
   int source_frame_id;
-  scoped_ptr<MessagePort> receiver;
+  std::unique_ptr<MessagePort> receiver;
   int receiver_port_id;
   std::string source_extension_id;
   std::string target_extension_id;
   GURL source_url;
   std::string channel_name;
   bool include_tls_channel_id;
   std::string tls_channel_id;
   bool include_guest_process_info;
 
   // Takes ownership of receiver.
   OpenChannelParams(int source_process_id,
                     int source_routing_id,
-                    scoped_ptr<base::DictionaryValue> source_tab,
+                    std::unique_ptr<base::DictionaryValue> source_tab,
                     int source_frame_id,
                     MessagePort* receiver,
                     int receiver_port_id,
                     const std::string& source_extension_id,
                     const std::string& target_extension_id,
                     const GURL& source_url,
                     const std::string& channel_name,
                     bool include_tls_channel_id,
                     bool include_guest_process_info)
       : source_process_id(source_process_id),
@@ skipping 154 matching lines @@
       return;
     }
   }
 
   WebContents* source_contents = tab_util::GetWebContentsByFrameID(
       source_process_id, source_routing_id);
 
   bool include_guest_process_info = false;
 
   // Include info about the opener's tab (if it was a tab).
-  scoped_ptr<base::DictionaryValue> source_tab;
+  std::unique_ptr<base::DictionaryValue> source_tab;
   int source_frame_id = -1;
   if (source_contents && ExtensionTabUtil::GetTabId(source_contents) >= 0) {
     // Only the tab id is useful to platform apps for internal use. The
     // unnecessary bits will be stripped out in
     // MessagingBindings::DispatchOnConnect().
     source_tab.reset(ExtensionTabUtil::CreateTabObject(source_contents)
                          ->ToValue()
                          .release());
 
     content::RenderFrameHost* rfh =
         content::RenderFrameHost::FromID(source_process_id, source_routing_id);
     if (rfh)
       source_frame_id = ExtensionApiFrameIdMap::GetFrameId(rfh);
   } else {
     // Check to see if it was a WebView making the request.
     // Sending messages from WebViews to extensions breaks webview isolation,
     // so only allow component extensions to receive messages from WebViews.
     bool is_web_view = !!WebViewGuest::FromWebContents(source_contents);
     if (is_web_view && extensions::Manifest::IsComponentLocation(
                            target_extension->location())) {
       include_guest_process_info = true;
     }
   }
 
-  scoped_ptr<OpenChannelParams> params(new OpenChannelParams(
+  std::unique_ptr<OpenChannelParams> params(new OpenChannelParams(
       source_process_id, source_routing_id, std::move(source_tab),
       source_frame_id, nullptr, receiver_port_id, source_extension_id,
       target_extension_id, source_url, channel_name, include_tls_channel_id,
       include_guest_process_info));
 
   pending_incognito_channels_[GET_CHANNEL_ID(params->receiver_port_id)] =
       PendingMessagesQueue();
   if (context->IsOffTheRecord() &&
       !util::IsIncognitoEnabled(target_extension_id, context)) {
     // Give the user a chance to accept an incognito connection from the web if
@@ skipping 74 matching lines @@
   PrefService* pref_service = profile->GetPrefs();
 
   // Verify that the host is not blocked by policies.
   PolicyPermission policy_permission =
       IsNativeMessagingHostAllowed(pref_service, native_app_name);
   if (policy_permission == DISALLOW) {
     DispatchOnDisconnect(source, receiver_port_id, kProhibitedByPoliciesError);
     return;
   }
 
-  scoped_ptr<MessageChannel> channel(new MessageChannel());
+  std::unique_ptr<MessageChannel> channel(new MessageChannel());
   channel->opener.reset(
       new ExtensionMessagePort(weak_factory_.GetWeakPtr(),
                                GET_OPPOSITE_PORT_ID(receiver_port_id),
                                source_extension_id, source, false));
   if (!channel->opener->IsValidPort())
     return;
   channel->opener->OpenPort(source_process_id, source_routing_id);
 
   // Get handle of the native view and pass it to the native messaging host.
   gfx::NativeView native_view = source ? source->GetNativeView() : nullptr;
 
   std::string error = kReceivingEndDoesntExistError;
-  scoped_ptr<NativeMessageHost> native_host = NativeMessageHost::Create(
-      native_view,
-      source_extension_id,
-      native_app_name,
-      policy_permission == ALLOW_ALL,
-      &error);
+  std::unique_ptr<NativeMessageHost> native_host = NativeMessageHost::Create(
+      native_view, source_extension_id, native_app_name,
+      policy_permission == ALLOW_ALL, &error);
 
   // Abandon the channel.
   if (!native_host.get()) {
     LOG(ERROR) << "Failed to create native process.";
     DispatchOnDisconnect(source, receiver_port_id, error);
     return;
   }
   channel->receiver.reset(new NativeMessagePort(
       weak_factory_.GetWeakPtr(), receiver_port_id, std::move(native_host)));
 
@@ skipping 20 matching lines @@
   DCHECK_GE(frame_id, -1);
 
   content::RenderFrameHost* source =
       content::RenderFrameHost::FromID(source_process_id, source_routing_id);
   if (!source)
     return;
   Profile* profile =
       Profile::FromBrowserContext(source->GetProcess()->GetBrowserContext());
 
   WebContents* contents = NULL;
-  scoped_ptr<MessagePort> receiver;
+  std::unique_ptr<MessagePort> receiver;
   if (!ExtensionTabUtil::GetTabById(tab_id, profile, true, NULL, NULL,
                                     &contents, NULL) ||
       contents->GetController().NeedsReload()) {
     // The tab isn't loaded yet. Don't attempt to connect.
     DispatchOnDisconnect(
         source, receiver_port_id, kReceivingEndDoesntExistError);
     return;
   }
 
   // Frame ID -1 is every frame in the tab.
@@ skipping 14 matching lines @@
 
   const Extension* extension = nullptr;
   if (!extension_id.empty()) {
     // Source extension == target extension so the extension must exist, or
     // where did the IPC come from?
     extension = ExtensionRegistry::Get(profile)->enabled_extensions().GetByID(
         extension_id);
     DCHECK(extension);
   }
 
-  scoped_ptr<OpenChannelParams> params(new OpenChannelParams(
-      source_process_id,
-      source_routing_id,
-      scoped_ptr<base::DictionaryValue>(),  // Source tab doesn't make sense
-                                            // for opening to tabs.
+  std::unique_ptr<OpenChannelParams> params(new OpenChannelParams(
+      source_process_id, source_routing_id,
+      std::unique_ptr<base::DictionaryValue>(),  // Source tab doesn't make
+                                                 // sense
+                                                 // for opening to tabs.
       -1,  // If there is no tab, then there is no frame either.
       receiver.release(), receiver_port_id, extension_id, extension_id,
       GURL(),  // Source URL doesn't make sense for opening to tabs.
       channel_name,
       false,    // Connections to tabs don't get TLS channel IDs.
       false));  // Connections to tabs aren't webview guests.
   OpenChannelImpl(contents->GetBrowserContext(), std::move(params), extension,
                   false /* did_enqueue */);
 }
 
 void MessageService::OpenChannelImpl(BrowserContext* browser_context,
-                                     scoped_ptr<OpenChannelParams> params,
+                                     std::unique_ptr<OpenChannelParams> params,
                                      const Extension* target_extension,
                                      bool did_enqueue) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(target_extension != nullptr, !params->target_extension_id.empty());
 
   content::RenderFrameHost* source =
       content::RenderFrameHost::FromID(params->source_process_id,
                                        params->source_routing_id);
   if (!source)
     return;  // Closed while in flight.
 
   if (!params->receiver || !params->receiver->IsValidPort()) {
     DispatchOnDisconnect(source, params->receiver_port_id,
                          kReceivingEndDoesntExistError);
     return;
   }
 
-  scoped_ptr<MessagePort> opener(
+  std::unique_ptr<MessagePort> opener(
       new ExtensionMessagePort(weak_factory_.GetWeakPtr(),
                                GET_OPPOSITE_PORT_ID(params->receiver_port_id),
                                params->source_extension_id, source, false));
   if (!opener->IsValidPort())
     return;
   opener->OpenPort(params->source_process_id, params->source_routing_id);
 
   params->receiver->RemoveCommonFrames(*opener);
   if (!params->receiver->IsValidPort()) {
     opener->DispatchOnDisconnect(kReceivingEndDoesntExistError);
@@ skipping 228 matching lines @@
   int dest_port_id = GET_OPPOSITE_PORT_ID(source_port_id);
   MessagePort* port = IS_OPENER_PORT_ID(dest_port_id) ?
       channel->opener.get() : channel->receiver.get();
 
   port->DispatchOnMessage(message);
 }
 
 bool MessageService::MaybeAddPendingLazyBackgroundPageOpenChannelTask(
     BrowserContext* context,
     const Extension* extension,
-    scoped_ptr<OpenChannelParams>* params,
+    std::unique_ptr<OpenChannelParams>* params,
     const PendingMessagesQueue& pending_messages) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!BackgroundInfo::HasLazyBackgroundPage(extension))
     return false;
 
   // If the extension uses spanning incognito mode, make sure we're always
   // using the original profile since that is what the extension process
   // will use.
   if (!IncognitoInfo::IsSplitMode(extension))
@@ skipping 11 matching lines @@
       base::Bind(&MessageService::PendingLazyBackgroundPageOpenChannel,
                  weak_factory_.GetWeakPtr(), base::Passed(params), source_id));
 
   for (const PendingMessage& message : pending_messages) {
     EnqueuePendingMessageForLazyBackgroundLoad(message.first, channel_id,
                                                message.second);
   }
   return true;
 }
 
-void MessageService::OnOpenChannelAllowed(scoped_ptr<OpenChannelParams> params,
-                                          bool allowed) {
+void MessageService::OnOpenChannelAllowed(
+    std::unique_ptr<OpenChannelParams> params,
+    bool allowed) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   int channel_id = GET_CHANNEL_ID(params->receiver_port_id);
 
   PendingChannelMap::iterator pending_for_incognito =
       pending_incognito_channels_.find(channel_id);
   if (pending_for_incognito == pending_incognito_channels_.end()) {
     NOTREACHED();
     return;
   }
@@ skipping 59 matching lines @@
   // if it is loaded and ready, and if not, queue up the task and load the
   // page.
   if (!MaybeAddPendingLazyBackgroundPageOpenChannelTask(
           context, target_extension, &params, pending_messages)) {
     OpenChannelImpl(context, std::move(params), target_extension,
                     false /* did_enqueue */);
     DispatchPendingMessages(pending_messages, channel_id);
   }
 }
 
-void MessageService::GotChannelID(scoped_ptr<OpenChannelParams> params,
+void MessageService::GotChannelID(std::unique_ptr<OpenChannelParams> params,
                                   const std::string& tls_channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   params->tls_channel_id.assign(tls_channel_id);
   int channel_id = GET_CHANNEL_ID(params->receiver_port_id);
 
   PendingChannelMap::iterator pending_for_tls_channel_id =
       pending_tls_channel_id_channels_.find(channel_id);
   if (pending_for_tls_channel_id == pending_tls_channel_id_channels_.end()) {
     NOTREACHED();
@@ skipping 23 matching lines @@
 
   if (!MaybeAddPendingLazyBackgroundPageOpenChannelTask(
           context, target_extension, &params, pending_messages)) {
     OpenChannelImpl(context, std::move(params), target_extension,
                     false /* did_enqueue */);
     DispatchPendingMessages(pending_messages, channel_id);
   }
 }
 
 void MessageService::PendingLazyBackgroundPageOpenChannel(
-    scoped_ptr<OpenChannelParams> params,
+    std::unique_ptr<OpenChannelParams> params,
     int source_process_id,
     ExtensionHost* host) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!host)
     return;  // TODO(mpcomplete): notify source of disconnect?
 
   params->receiver.reset(
       new ExtensionMessagePort(
           weak_factory_.GetWeakPtr(), params->receiver_port_id,
@@ skipping 20 matching lines @@
 
   MessageChannelMap::iterator channel_iter = channels_.find(channel_id);
   if (channel_iter != channels_.end()) {
     for (const PendingMessage& message : queue) {
       DispatchMessage(message.first, channel_iter->second, message.second);
     }
   }
 }
 
 }  // namespace extensions