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

chrome/browser/extensions/api/messaging/extension_message_port.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/extension_message_port.h"
 
+#include "base/memory/ptr_util.h"
 #include "base/scoped_observer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/process_manager.h"
@@ skipping 156 matching lines @@
 bool ExtensionMessagePort::HasFrame(content::RenderFrameHost* rfh) const {
   return frames_.find(rfh) != frames_.end();
 }
 
 bool ExtensionMessagePort::IsValidPort() {
   return !frames_.empty();
 }
 
 void ExtensionMessagePort::DispatchOnConnect(
     const std::string& channel_name,
-    scoped_ptr<base::DictionaryValue> source_tab,
+    std::unique_ptr<base::DictionaryValue> source_tab,
     int source_frame_id,
     int guest_process_id,
     int guest_render_frame_routing_id,
     const std::string& source_extension_id,
     const std::string& target_extension_id,
     const GURL& source_url,
     const std::string& tls_channel_id) {
   ExtensionMsg_TabConnectionInfo source;
   if (source_tab)
     source.tab.Swap(source_tab.get());
   source.frame_id = source_frame_id;
 
   ExtensionMsg_ExternalConnectionInfo info;
   info.target_id = target_extension_id;
   info.source_id = source_extension_id;
   info.source_url = source_url;
   info.guest_process_id = guest_process_id;
   info.guest_render_frame_routing_id = guest_render_frame_routing_id;
 
-  SendToPort(make_scoped_ptr(new ExtensionMsg_DispatchOnConnect(
+  SendToPort(base::WrapUnique(new ExtensionMsg_DispatchOnConnect(
       MSG_ROUTING_NONE, port_id_, channel_name, source, info, tls_channel_id)));
 }
 
 void ExtensionMessagePort::DispatchOnDisconnect(
     const std::string& error_message) {
-  SendToPort(make_scoped_ptr(new ExtensionMsg_DispatchOnDisconnect(
+  SendToPort(base::WrapUnique(new ExtensionMsg_DispatchOnDisconnect(
       MSG_ROUTING_NONE, port_id_, error_message)));
 }
 
 void ExtensionMessagePort::DispatchOnMessage(const Message& message) {
-  SendToPort(make_scoped_ptr(new ExtensionMsg_DeliverMessage(
-      MSG_ROUTING_NONE, port_id_, message)));
+  SendToPort(base::WrapUnique(
+      new ExtensionMsg_DeliverMessage(MSG_ROUTING_NONE, port_id_, message)));
 }
 
 void ExtensionMessagePort::IncrementLazyKeepaliveCount() {
   ProcessManager* pm = ProcessManager::Get(browser_context_);
   ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id_);
   if (host && BackgroundInfo::HasLazyBackgroundPage(host->extension()))
     pm->IncrementLazyKeepaliveCount(host->extension());
 
   // Keep track of the background host, so when we decrement, we only do so if
   // the host hasn't reloaded.
@@ skipping 43 matching lines @@
   // is not triggered for |rfh|.
   if (rfh->IsRenderFrameLive())
     frames_.insert(rfh);
 }
 
 void ExtensionMessagePort::UnregisterFrame(content::RenderFrameHost* rfh) {
   if (frames_.erase(rfh) != 0 && frames_.empty())
     CloseChannel();
 }
 
-void ExtensionMessagePort::SendToPort(scoped_ptr<IPC::Message> msg) {
+void ExtensionMessagePort::SendToPort(std::unique_ptr<IPC::Message> msg) {
   DCHECK_GT(frames_.size(), 0UL);
   if (extension_process_) {
     // All extension frames reside in the same process, so we can just send a
     // single IPC message to the extension process as an optimization.
     // The frame tracking is then only used to make sure that the port gets
     // closed when all frames have closed / reloaded.
     msg->set_routing_id(MSG_ROUTING_CONTROL);
     extension_process_->Send(msg.release());
     return;
   }
   for (content::RenderFrameHost* rfh : frames_) {
     IPC::Message* msg_copy = new IPC::Message(*msg.get());
     msg_copy->set_routing_id(rfh->GetRoutingID());
     rfh->Send(msg_copy);
   }
 }
 
 }  // namespace extensions