Stop using renderer specific host ids in ResourceDispatcher. This allows it ...

chrome/browser/renderer_host/render_process_host.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/renderer_host/render_process_host.h"
 
 #include "base/rand_util.h"
 #include "base/sys_info.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/notification_service.h"
@@ skipping 34 matching lines @@
     if (memory_tier >= arraysize(kMaxRenderersByRamTier))
       max_count = chrome::kMaxRendererProcessCount;
     else
       max_count = kMaxRenderersByRamTier[memory_tier];
   }
   return max_count;
 }
 
 // Returns true if the given host is suitable for launching a new view
 // associated with the given profile.
-// TODO(jabdelmalek): do we want to avoid processes with hung renderers
-// or with a large memory consumption?
 static bool IsSuitableHost(Profile* profile, RenderProcessHost* host) {
   return host->profile() == profile;
 }
 
 // the global list of all renderer processes
 IDMap<RenderProcessHost> all_hosts;
 
 }  // namespace
 
 bool RenderProcessHost::run_renderer_in_process_ = false;
 
 RenderProcessHost::RenderProcessHost(Profile* profile)
     : max_page_id_(-1),
       notified_termination_(false),
+      pid_(-1),
       profile_(profile) {
-  host_id_ = all_hosts.Add(this);
 }
 
 RenderProcessHost::~RenderProcessHost() {
 }
 
 void RenderProcessHost::Attach(IPC::Channel::Listener* listener,
                                int routing_id) {
   listeners_.AddWithID(listener, routing_id);
 }
 
 void RenderProcessHost::Release(int listener_id) {
   DCHECK(listeners_.Lookup(listener_id) != NULL);
   listeners_.Remove(listener_id);
 
   // Make sure that all associated resource requests are stopped.
   CancelResourceRequests(listener_id);
 
   // When no other owners of this object, we can delete ourselves
   if (listeners_.IsEmpty()) {
     if (!notified_termination_) {
       bool close_expected = true;
       NotificationService::current()->Notify(
           NotificationType::RENDERER_PROCESS_TERMINATED,
           Source<RenderProcessHost>(this),
           Details<bool>(&close_expected));
       notified_termination_ = true;
     }
-    Unregister();
+    if (pid_ >= 0) {
+      all_hosts.Remove(pid_);
+      pid_ = -1;
+    }
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 }
 
 void RenderProcessHost::ReportExpectingClose(int32 listener_id) {
   listeners_expecting_close_.insert(listener_id);
 }
 
 void RenderProcessHost::UpdateMaxPageID(int32 page_id) {
   if (page_id > max_page_id_)
@@ skipping 49 matching lines @@
   // Now pick a random suitable renderer, if we have any.
   if (!suitable_renderers.empty()) {
     int suitable_count = static_cast<int>(suitable_renderers.size());
     int random_index = base::RandInt(0, suitable_count - 1);
     return suitable_renderers[random_index];
   }
 
   return NULL;
 }
 
-void RenderProcessHost::Unregister() {
-  if (host_id_ >= 0) {
-    all_hosts.Remove(host_id_);
-    host_id_ = -1;
+void RenderProcessHost::SetProcessID(int pid) {
+  if (pid_ != -1) {
+    // This object is being reused after a renderer crash.  Remove the old pid.
+    all_hosts.Remove(pid_);
   }
+
+  pid_ = pid;
+  all_hosts.AddWithID(this, pid);
 }