Refactor RenderProcessHost to use IPC::Listener instead of RenderWidgetHost

content/browser/renderer_host/render_process_host_impl.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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 87 matching lines @@
 #include "content/common/child_process_messages.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/resource_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host_factory.h"
+#include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
@@ skipping 591 matching lines @@
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableMemoryBenchmarking))
     channel_->AddFilter(new MemoryBenchmarkMessageFilter());
 #endif
 }
 
 int RenderProcessHostImpl::GetNextRoutingID() {
   return widget_helper_->GetNextRoutingID();
 }
 
+void RenderProcessHostImpl::AddRoute(
+    int32 routing_id,
+    IPC::Listener* listener) {
+  listeners_.AddWithID(listener, routing_id);
+}
+
+void RenderProcessHostImpl::RemoveRoute(int32 routing_id) {
+  DCHECK(listeners_.Lookup(routing_id) != NULL);
+  listeners_.Remove(routing_id);
+
+#if defined(OS_WIN)
+  // Dump the handle table if handle auditing is enabled.
+  const CommandLine& browser_command_line =
+      *CommandLine::ForCurrentProcess();
+  if (browser_command_line.HasSwitch(switches::kAuditHandles) ||
+      browser_command_line.HasSwitch(switches::kAuditAllHandles)) {
+    DumpHandles();
+
+    // We wait to close the channels until the child process has finished
+    // dumping handles and sends us ChildProcessHostMsg_DumpHandlesDone.
+    return;
+  }
+#endif
+  // Keep the one renderer thread around forever in single process mode.
+  if (!run_renderer_in_process())
+    Cleanup();
+}
+
 void RenderProcessHostImpl::SimulateSwapOutACK(
     const ViewMsg_SwapOut_Params& params) {
   widget_helper_->SimulateSwapOutACK(params);
 }
 
 bool RenderProcessHostImpl::WaitForBackingStoreMsg(
     int render_widget_id,
     const base::TimeDelta& max_delay,
     IPC::Message* msg) {
   // The post task to this thread with the process id could be in queue, and we
@@ skipping 462 matching lines @@
     if (!msg_is_ok) {
       // The message had a handler, but its de-serialization failed.
       // We consider this a capital crime. Kill the renderer if we have one.
       LOG(ERROR) << "bad message " << msg.type() << " terminating renderer.";
       RecordAction(UserMetricsAction("BadMessageTerminate_BRPH"));
       ReceivedBadMessage();
     }
     return true;
   }
 
-  // Dispatch incoming messages to the appropriate RenderView/WidgetHost.
-  RenderWidgetHost* rwh = render_widget_hosts_.Lookup(msg.routing_id());
-  if (!rwh) {
+  // Dispatch incoming messages to the appropriate IPC::Listener.
+  IPC::Listener* listener = listeners_.Lookup(msg.routing_id());
+  if (!listener) {
     if (msg.is_sync()) {
       // The listener has gone away, so we must respond or else the caller will
       // hang waiting for a reply.
       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&msg);
       reply->set_reply_error();
       Send(reply);
     }
 
     // If this is a SwapBuffers, we need to ack it if we're not going to handle
     // it so that the GPU process doesn't get stuck in unscheduled state.
     bool msg_is_ok = true;
     IPC_BEGIN_MESSAGE_MAP_EX(RenderProcessHostImpl, msg, msg_is_ok)
       IPC_MESSAGE_HANDLER(ViewHostMsg_CompositorSurfaceBuffersSwapped,
                           OnCompositorSurfaceBuffersSwappedNoHost)
     IPC_END_MESSAGE_MAP_EX()
     return true;
   }
-  return RenderWidgetHostImpl::From(rwh)->OnMessageReceived(msg);
+  return listener->OnMessageReceived(msg);
 }
 
 void RenderProcessHostImpl::OnChannelConnected(int32 peer_pid) {
 #if defined(IPC_MESSAGE_LOG_ENABLED)
   Send(new ChildProcessMsg_SetIPCLoggingEnabled(
       IPC::Logging::GetInstance()->Enabled()));
 #endif
 
   tracked_objects::ThreadData::Status status =
       tracked_objects::ThreadData::status();
@@ skipping 14 matching lines @@
 }
 
 int RenderProcessHostImpl::GetID() const {
   return id_;
 }
 
 bool RenderProcessHostImpl::HasConnection() const {
   return channel_.get() != NULL;
 }
 
-RenderWidgetHost* RenderProcessHostImpl::GetRenderWidgetHostByID(
-    int routing_id) {
-  return render_widget_hosts_.Lookup(routing_id);
-}
-
 void RenderProcessHostImpl::SetIgnoreInputEvents(bool ignore_input_events) {
   ignore_input_events_ = ignore_input_events;
 }
 
 bool RenderProcessHostImpl::IgnoreInputEvents() const {
   return ignore_input_events_;
 }
 
+/*
 void RenderProcessHostImpl::Attach(RenderWidgetHost* host,
                                    int routing_id) {
   render_widget_hosts_.AddWithID(host, routing_id);
 }
+*/
 
+/*
 void RenderProcessHostImpl::Release(int routing_id) {
   DCHECK(render_widget_hosts_.Lookup(routing_id) != NULL);
   render_widget_hosts_.Remove(routing_id);
 
 #if defined(OS_WIN)
   // Dump the handle table if handle auditing is enabled.
   const CommandLine& browser_command_line =
       *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kAuditHandles) ||
       browser_command_line.HasSwitch(switches::kAuditAllHandles)) {
     DumpHandles();
 
     // We wait to close the channels until the child process has finished
     // dumping handles and sends us ChildProcessHostMsg_DumpHandlesDone.
     return;
   }
 #endif
   // Keep the one renderer thread around forever in single process mode.
   if (!run_renderer_in_process())
     Cleanup();
 }
+*/
 
 void RenderProcessHostImpl::Cleanup() {
   // When no other owners of this object, we can delete ourselves
-  if (render_widget_hosts_.IsEmpty()) {
+  if (listeners_.IsEmpty()) {
     DCHECK_EQ(0, pending_views_);
     NotificationService::current()->Notify(
         NOTIFICATION_RENDERER_PROCESS_TERMINATED,
         Source<RenderProcessHost>(this),
         NotificationService::NoDetails());
 
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
     deleting_soon_ = true;
     // It's important not to wait for the DeleteTask to delete the channel
     // proxy. Kill it off now. That way, in case the profile is going away, the
@@ skipping 40 matching lines @@
 }
 
 void RenderProcessHostImpl::ResumeRequestsForView(int route_id) {
   widget_helper_->ResumeRequestsForView(route_id);
 }
 
 IPC::ChannelProxy* RenderProcessHostImpl::GetChannel() {
   return channel_.get();
 }
 
-RenderProcessHost::RenderWidgetHostsIterator
-    RenderProcessHostImpl::GetRenderWidgetHostsIterator() {
-  return RenderWidgetHostsIterator(&render_widget_hosts_);
-}
-
 bool RenderProcessHostImpl::FastShutdownForPageCount(size_t count) {
-  if (render_widget_hosts_.size() == count)
+  if (listeners_.size() == count)
     return FastShutdownIfPossible();
   return false;
 }
 
 bool RenderProcessHostImpl::FastShutdownStarted() const {
   return fast_shutdown_started_;
 }
 
 // static
 void RenderProcessHostImpl::RegisterHost(int host_id, RenderProcessHost* host) {
@@ skipping 240 matching lines @@
   RendererClosedDetails details(GetHandle(), status, exit_code);
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_CLOSED,
       Source<RenderProcessHost>(this),
       Details<RendererClosedDetails>(&details));
 
   child_process_launcher_.reset();
   channel_.reset();
   gpu_message_filter_ = NULL;
 
-  IDMap<RenderWidgetHost>::iterator iter(&render_widget_hosts_);
-  while (!iter.IsAtEnd()) {
-    RenderWidgetHostImpl::From(iter.GetCurrentValue())->OnMessageReceived(
-        ViewHostMsg_RenderViewGone(iter.GetCurrentKey(),
-                                   static_cast<int>(status),
-                                   exit_code));
-    iter.Advance();
+  scoped_ptr<RenderWidgetHost::List> hosts =
+      RenderWidgetHost::GetRenderWidgetHosts();
+  for (RenderWidgetHost::List::const_iterator it = hosts->begin();
+      it != hosts->end();
+      ++it) {
+    const RenderWidgetHost* widget = *it;
+    if (widget->GetProcess()->GetID() != GetID())
+      continue;
+    RenderWidgetHostImpl::From(
+        const_cast<RenderWidgetHost*>(widget))->OnMessageReceived(
+            ViewHostMsg_RenderViewGone(widget->GetRoutingID(),
+                                       static_cast<int>(status),
+                                       exit_code));
+
   }
 
   ClearTransportDIBCache();
 
   // this object is not deleted at this point and may be reused later.
   // TODO(darin): clean this up
 }
 
 int RenderProcessHostImpl::GetActiveViewCount() {
   int num_active_views = 0;
-  for (RenderWidgetHostsIterator iter = GetRenderWidgetHostsIterator();
-       !iter.IsAtEnd();
-       iter.Advance()) {
-    const RenderWidgetHost* widget = iter.GetCurrentValue();
+
+  //typedef std::vector<RenderWidgetHost*> RenderWidgetHostList;
+  scoped_ptr<RenderWidgetHost::List> hosts =
+      RenderWidgetHost::GetRenderWidgetHosts();
+
+  for (RenderWidgetHost::List::const_iterator it = hosts->begin();
+       it != hosts->end();
+       ++it) {
+    const RenderWidgetHost* widget = *it;
     DCHECK(widget);
     if (!widget)
       continue;
 
+    // Count only RenderWidgetHosts in this process.
+    if (widget->GetProcess()->GetID() != GetID())
+      continue;
+
     // All RenderWidgetHosts are swapped in.
     if (!widget->IsRenderView()) {
       num_active_views++;
       continue;
     }
 
     // Don't count swapped out views.
     RenderViewHost* rvh =
         RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
     if (!static_cast<RenderViewHostImpl*>(rvh)->is_swapped_out())
       num_active_views++;
   }
+
   return num_active_views;
 }
 
 // Frame subscription API for this class is for accelerated composited path
 // only. These calls are redirected to GpuMessageFilter.
 void RenderProcessHostImpl::BeginFrameSubscription(
     int route_id,
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
   if (!gpu_message_filter_)
     return;
@@ skipping 109 matching lines @@
   TRACE_EVENT0("renderer_host",
                "RenderWidgetHostImpl::OnCompositorSurfaceBuffersSwappedNoHost");
   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
   ack_params.sync_point = 0;
   RenderWidgetHostImpl::AcknowledgeBufferPresent(params.route_id,
                                                  params.gpu_process_host_id,
                                                  ack_params);
 }
 
 void RenderProcessHostImpl::OnGpuSwitching() {
-  for (RenderWidgetHostsIterator iter = GetRenderWidgetHostsIterator();
-       !iter.IsAtEnd();
-       iter.Advance()) {
-    const RenderWidgetHost* widget = iter.GetCurrentValue();
+  scoped_ptr<RenderWidgetHost::List> hosts =
+      RenderWidgetHost::GetRenderWidgetHosts();
+
+  for (RenderWidgetHost::List::const_iterator it = hosts->begin();
+       it != hosts->end();
+       ++it) {
+    const RenderWidgetHost* widget = *it;
     DCHECK(widget);
     if (!widget || !widget->IsRenderView())
       continue;
 
+    // Skip widgest in other processes.
+    if (widget->GetProcess()->GetID() != GetID())
+      continue;
+
     RenderViewHost* rvh =
         RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
 
     rvh->UpdateWebkitPreferences(rvh->GetWebkitPreferences());
   }
 }
 
 }  // namespace content