Fix a memory leak in ExtensionMessageService.

chrome/browser/extensions/extension_message_service.cc

 // Copyright (c) 2009 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/extension_message_service.h"
 
 #include "base/json/json_writer.h"
 #include "base/singleton.h"
 #include "base/stl_util-inl.h"
 #include "base/values.h"
@@ skipping 108 matching lines @@
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::RENDERER_PROCESS_CLOSED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::RENDER_VIEW_HOST_DELETED,
                  NotificationService::AllSources());
 
   extension_devtools_manager_ = profile_->GetExtensionDevToolsManager();
 }
 
 ExtensionMessageService::~ExtensionMessageService() {
+  STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
+  channels_.clear();
 }
 
 void ExtensionMessageService::ProfileDestroyed() {
   profile_ = NULL;
 
   // We remove notifications here because our destructor might be called on
   // a non-UI thread.
   registrar_.RemoveAll();
 }
 
@@ skipping 156 matching lines @@
     // Treat it as a disconnect.
     DispatchOnDisconnect(MessagePort(source, MSG_ROUTING_CONTROL),
                          GET_OPPOSITE_PORT_ID(receiver_port_id));
     return false;
   }
 
   // Add extra paranoid CHECKs, since we have crash reports of this being NULL.
   // http://code.google.com/p/chromium/issues/detail?id=19067
   CHECK(receiver.sender);
 
-  linked_ptr<MessageChannel> channel(new MessageChannel);
+  MessageChannel* channel(new MessageChannel);
   channel->opener = MessagePort(source, MSG_ROUTING_CONTROL);
   channel->receiver = receiver;
 
   CHECK(receiver.sender);
 
+  CHECK(channels_.find(GET_CHANNEL_ID(receiver_port_id)) == channels_.end());
   channels_[GET_CHANNEL_ID(receiver_port_id)] = channel;
 
   CHECK(receiver.sender);

[Erik does not do reviews, 2009/11/04 17:00:33]

remove redundant CHECK

 
   // Include info about the opener's tab (if it was a tab).
   std::string tab_json = "null";
   if (source_contents) {
-    DictionaryValue* tab_value =
-        ExtensionTabUtil::CreateTabValue(source_contents);
-    base::JSONWriter::Write(tab_value, false, &tab_json);
+    scoped_ptr<DictionaryValue> tab_value(
+        ExtensionTabUtil::CreateTabValue(source_contents));
+    base::JSONWriter::Write(tab_value.get(), false, &tab_json);
   }
 
   CHECK(receiver.sender);
 
   // Send the connect event to the receiver.  Give it the opener's port ID (the
   // opener has the opposite port ID).
   DispatchOnConnect(receiver, receiver_port_id, channel_name, tab_json,
                     source_extension_id, target_extension_id);
 
   return true;
 }
 
 int ExtensionMessageService::OpenSpecialChannelToExtension(
     const std::string& extension_id, const std::string& channel_name,
     IPC::Message::Sender* source) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
   DCHECK(profile_);
 
   int port1_id = -1;
   int port2_id = -1;
   // Create a channel ID for both sides of the channel.
   AllocatePortIdPair(&port1_id, &port2_id);
 
   MessagePort receiver(
       profile_->GetExtensionProcessManager()->
-      GetExtensionProcess(extension_id),
+          GetExtensionProcess(extension_id),
       MSG_ROUTING_CONTROL);
   receiver.debug_info = 4;
   if (!OpenChannelOnUIThreadImpl(
       source, NULL, receiver, port2_id, extension_id, extension_id,
       channel_name))
     return -1;
 
   return port1_id;
 }
 
@@ skipping 33 matching lines @@
     MessageChannelMap::iterator channel_iter, int closing_port_id,
     bool notify_other_port) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   // Notify the other side.
   const MessagePort& port = IS_OPENER_PORT_ID(closing_port_id) ?
       channel_iter->second->receiver : channel_iter->second->opener;
 
   if (notify_other_port)
     DispatchOnDisconnect(port, GET_OPPOSITE_PORT_ID(closing_port_id));
+  delete channel_iter->second;
   channels_.erase(channel_iter);
 }
 
 void ExtensionMessageService::PostMessageFromRenderer(
     int source_port_id, const std::string& message) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   MessageChannelMap::iterator iter =
       channels_.find(GET_CHANNEL_ID(source_port_id));
   if (iter == channels_.end())
@@ skipping 93 matching lines @@
 
     if (current->second->opener.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_OPENER_ID(current->first),
                        notify_other_port);
     } else if (current->second->receiver.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_RECEIVERS_ID(current->first),
                        notify_other_port);
     }
   }
 }