Remove stl_util's STLDeleteContainerPairSecondPointers from extensions.

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>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/stl_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/messaging/extension_message_port.h"
 #include "chrome/browser/extensions/api/messaging/incognito_connectability.h"
 #include "chrome/browser/extensions/api/messaging/native_message_port.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
@@ skipping 197 matching lines @@
 MessageService::MessageService(BrowserContext* context)
     : lazy_background_task_queue_(
           LazyBackgroundTaskQueue::Get(context)),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 MessageService::~MessageService() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  base::STLDeleteContainerPairSecondPointers(channels_.begin(),
-                                             channels_.end());
   channels_.clear();
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<MessageService> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<MessageService>*
 MessageService::GetFactoryInstance() {
   return g_factory.Pointer();
@@ skipping 223 matching lines @@
     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)));
 
   // Keep the opener alive until the channel is closed.
   channel->opener->IncrementLazyKeepaliveCount();
 
-  AddChannel(channel.release(), receiver_port_id);
+  AddChannel(std::move(channel), receiver_port_id);
 #else  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
   const char kNativeMessagingNotSupportedError[] =
       "Native Messaging is not supported on this platform.";
   DispatchOnDisconnect(
       source, receiver_port_id, kNativeMessagingNotSupportedError);
 #endif  // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
 }
 
 void MessageService::OpenChannelToTab(int source_process_id,
                                       int source_routing_id,
@@ skipping 90 matching lines @@
     return;
   opener->OpenPort(params->source_process_id, params->source_routing_id);
   opener->RevalidatePort();
 
   params->receiver->RemoveCommonFrames(*opener);
   if (!params->receiver->IsValidPort()) {
     opener->DispatchOnDisconnect(kReceivingEndDoesntExistError);
     return;
   }
 
-  MessageChannel* channel(new MessageChannel());
+  std::unique_ptr<MessageChannel> channel_ptr =
+      base::MakeUnique<MessageChannel>();
+  MessageChannel* channel = channel_ptr.get();
   channel->opener.reset(opener.release());
   channel->receiver.reset(params->receiver.release());
-  AddChannel(channel, params->receiver_port_id);
+  AddChannel(std::move(channel_ptr), params->receiver_port_id);
 
   // TODO(robwu): Could |guest_process_id| and |guest_render_frame_routing_id|
   // be removed? In the past extension message routing was process-based, but
   // now that extensions are routed from a specific RFH, the special casing for
   // guest views seems no longer necessary, because the ExtensionMessagePort can
   // simply obtain the source process & frame ID directly from the RFH.
   int guest_process_id = content::ChildProcessHost::kInvalidUniqueID;
   int guest_render_frame_routing_id = MSG_ROUTING_NONE;
   if (params->include_guest_process_info) {
     guest_process_id = params->source_process_id;
@@ skipping 40 matching lines @@
     }
     EventRouter::Get(browser_context)
         ->ReportEvent(histogram_value, target_extension, did_enqueue);
   }
 
   // Keep both ends of the channel alive until the channel is closed.
   channel->opener->IncrementLazyKeepaliveCount();
   channel->receiver->IncrementLazyKeepaliveCount();
 }
 
-void MessageService::AddChannel(MessageChannel* channel, int receiver_port_id) {
+void MessageService::AddChannel(std::unique_ptr<MessageChannel> channel,
+                                int receiver_port_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   int channel_id = GET_CHANNEL_ID(receiver_port_id);
   CHECK(channels_.find(channel_id) == channels_.end());
-  channels_[channel_id] = channel;
+  channels_[channel_id] = std::move(channel);
   pending_lazy_background_page_channels_.erase(channel_id);
 }
 
 void MessageService::OpenPort(int port_id, int process_id, int routing_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!IS_OPENER_PORT_ID(port_id));
 
   int channel_id = GET_CHANNEL_ID(port_id);
   MessageChannelMap::iterator it = channels_.find(channel_id);
   if (it == channels_.end())
@@ skipping 48 matching lines @@
   }
 }
 
 void MessageService::CloseChannelImpl(
     MessageChannelMap::iterator channel_iter,
     int closing_port_id,
     const std::string& error_message,
     bool notify_other_port) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  MessageChannel* channel = channel_iter->second;
+  std::unique_ptr<MessageChannel> channel = std::move(channel_iter->second);
   // Remove from map to make sure that it is impossible for CloseChannelImpl to
   // run twice for the same channel.
   channels_.erase(channel_iter);
 
   // Notify the other side.
   if (notify_other_port) {
     MessagePort* port = IS_OPENER_PORT_ID(closing_port_id) ?
         channel->receiver.get() : channel->opener.get();
     port->DispatchOnDisconnect(error_message);
   }
 
   // Balance the IncrementLazyKeepaliveCount() in OpenChannelImpl.
   channel->opener->DecrementLazyKeepaliveCount();
   channel->receiver->DecrementLazyKeepaliveCount();
-
-  delete channel;
 }
 
 void MessageService::PostMessage(int source_port_id, const Message& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   int channel_id = GET_CHANNEL_ID(source_port_id);
   MessageChannelMap::iterator iter = channels_.find(channel_id);
   if (iter == channels_.end()) {
     // If this channel is pending, queue up the PostMessage to run once
     // the channel opens.
     EnqueuePendingMessage(source_port_id, channel_id, message);
     return;
   }
 
-  DispatchMessage(source_port_id, iter->second, message);
+  DispatchMessage(source_port_id, iter->second.get(), message);
 }
 
 void MessageService::EnqueuePendingMessage(int source_port_id,
                                            int channel_id,
                                            const Message& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   PendingChannelMap::iterator pending_for_incognito =
       pending_incognito_channels_.find(channel_id);
   if (pending_for_incognito != pending_incognito_channels_.end()) {
@@ skipping 240 matching lines @@
   port.DispatchOnDisconnect(error_message);
 }
 
 void MessageService::DispatchPendingMessages(const PendingMessagesQueue& queue,
                                              int channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   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);
+      DispatchMessage(message.first, channel_iter->second.get(),
+                      message.second);
     }
   }
 }
 
 }  // namespace extensions