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();

[Devlin, 2016/09/16 20:23:19]

optional nit: maybe rename to "raw_channel"?

[Avi (use Gerrit), 2016/09/16 20:41:45]

I'll pass.

That's used for the rest of the function to refer to the channel, while the
owning pointer is passed off to the AddChannel() function immediately.
Therefore, I'm giving the raw pointer the better name.

   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