Implements extensions devtools API

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_writer.h"
 #include "base/singleton.h"
 #include "base/stl_util-inl.h"
 #include "base/values.h"
@@ skipping 87 matching lines @@
 const char ExtensionMessageService::kDispatchOnConnect[] =
     "Port.dispatchOnConnect";
 const char ExtensionMessageService::kDispatchOnDisconnect[] =
     "Port.dispatchOnDisconnect";
 const char ExtensionMessageService::kDispatchOnMessage[] =
     "Port.dispatchOnMessage";
 const char ExtensionMessageService::kDispatchEvent[] =
     "Event.dispatchJSON";
 
 ExtensionMessageService::ExtensionMessageService(Profile* profile)
-    : ui_loop_(MessageLoop::current()), profile_(profile), next_port_id_(0) {
+    : ui_loop_(MessageLoop::current()),
+      profile_(profile),
+      extension_devtools_manager_(NULL),
+      next_port_id_(0) {
   DCHECK_EQ(ui_loop_->type(), MessageLoop::TYPE_UI);
 
   registrar_.Add(this, NotificationType::RENDERER_PROCESS_TERMINATED,
                  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() {
 }
 
 void ExtensionMessageService::ProfileDestroyed() {
   DCHECK_EQ(ui_loop_->type(), MessageLoop::TYPE_UI);
 
   profile_ = NULL;
 
   // We remove notifications here because our destructor might be called on
   // a non-UI thread.
   registrar_.RemoveAll();
 }
 
 void ExtensionMessageService::AddEventListener(const std::string& event_name,
                                                int render_process_id) {
   DCHECK(RenderProcessHost::FromID(render_process_id)) <<
       "Adding event listener to a non-existant RenderProcessHost.";
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
   DCHECK_EQ(listeners_[event_name].count(render_process_id), 0u) << event_name;
   listeners_[event_name].insert(render_process_id);
+
+  if (extension_devtools_manager_.get()) {
+    extension_devtools_manager_->AddEventListener(event_name,
+                                                  render_process_id);
+  }
 }
 
 void ExtensionMessageService::RemoveEventListener(const std::string& event_name,
                                                   int render_process_id) {
   // It is possible that this RenderProcessHost is being destroyed.  If that is
   // the case, we'll have already removed his listeners, so do nothing here.
   RenderProcessHost* rph = RenderProcessHost::FromID(render_process_id);
   if (!rph)
     return;
 
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
   DCHECK_EQ(listeners_[event_name].count(render_process_id), 1u) << event_name;
   listeners_[event_name].erase(render_process_id);
+
+  if (extension_devtools_manager_.get()) {
+    extension_devtools_manager_->RemoveEventListener(event_name,
+                                                     render_process_id);
+  }
 }
 
 void ExtensionMessageService::AllocatePortIdPair(int* port1, int* port2) {
   AutoLock lock(next_port_id_lock_);
 
   // TODO(mpcomplete): what happens when this wraps?
   int port1_id = next_port_id_++;
   int port2_id = next_port_id_++;
 
   DCHECK(IS_OPENER_PORT_ID(port1_id));
@@ skipping 176 matching lines @@
   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;
 
   DispatchOnDisconnect(port, GET_OPPOSITE_PORT_ID(closing_port_id));
   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())
     return;
 
   // Figure out which port the ID corresponds to.
@@ skipping 29 matching lines @@
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   switch (type.value) {
     case NotificationType::RENDERER_PROCESS_TERMINATED:
     case NotificationType::RENDERER_PROCESS_CLOSED: {
       RenderProcessHost* renderer = Source<RenderProcessHost>(source).ptr();
       OnSenderClosed(renderer);
 
-      // Remove this renderer from our listener maps.
+      // Remove all event listeners associated with this renderer
       for (ListenerMap::iterator it = listeners_.begin();
            it != listeners_.end(); ) {
         ListenerMap::iterator current = it++;
-        current->second.erase(renderer->pid());
-        if (current->second.empty())
-          listeners_.erase(current);
+        if (current->second.count(renderer->pid()) != 0)
+          RemoveEventListener(current->first, renderer->pid());
       }
       break;
     }
     case NotificationType::RENDER_VIEW_HOST_DELETED:
       OnSenderClosed(Details<RenderViewHost>(details).ptr());
       break;
     default:
       NOTREACHED();
       return;
   }
 }
 
 void ExtensionMessageService::OnSenderClosed(IPC::Message::Sender* sender) {
   // Close any channels that share this renderer.  We notify the opposite
   // port that his pair has closed.
   for (MessageChannelMap::iterator it = channels_.begin();
        it != channels_.end(); ) {
     MessageChannelMap::iterator current = it++;
     if (current->second->opener.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_OPENER_ID(current->first));
     } else if (current->second->receiver.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_RECEIVERS_ID(current->first));
     }
   }
 }