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

chrome/browser/renderer_host/render_process_host.h

 // 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.
 
 #ifndef CHROME_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_H_
 #define CHROME_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_H_
 
 #include <set>
 
 #include "base/id_map.h"
@@ skipping 15 matching lines @@
                           public IPC::Channel::Listener {
  public:
   typedef IDMap<RenderProcessHost>::const_iterator iterator;
 
   RenderProcessHost(Profile* profile);
   virtual ~RenderProcessHost();
 
   // Returns the user profile associated with this renderer process.
   Profile* profile() const { return profile_; }
 
-  // Returns the unique identifier for this host. This can be used later in
+  // Returns the process id for this host. This can be used later in
   // a call to FromID() to get back to this object (this is used to avoid
   // sending non-threadsafe pointers to other threads).
-  int host_id() const { return host_id_; }
+  int pid() const { return pid_; }
 
   // Returns the process object associated with the child process. In certain
   // tests or single-process mode, this will actually represent the current
   // process.
   const base::Process& process() const { return process_; }
 
   // May return NULL if there is no connection.
   IPC::SyncChannel* channel() { return channel_.get(); }
 
   // Used for refcounting, each holder of this object must Attach and Release
@@ skipping 115 matching lines @@
   // RenderProcessHost rather than creating a new one.
   static bool ShouldTryToUseExistingProcessHost();
 
   // Get an existing RenderProcessHost associated with the given profile, if
   // possible.  The renderer process is chosen randomly from the
   // processes associated with the given profile.
   // Returns NULL if no suitable renderer process is available.
   static RenderProcessHost* GetExistingProcessHost(Profile* profile);
 
  protected:
-  // Unregister this object from all globals that reference it.
-  // This would naturally be part of the destructor, but we destruct
-  // asynchronously.
-  //
-  // This can be overridden by derived classes to add their own unregister code,
-  // but you should be sure to always call this one AT THE END of your own.
-  virtual void Unregister();
+  // Sets the process  of this object, so that others access it using FromID.
+  void SetProcessID(int pid);
 
   base::Process process_;
 
   // A proxy for our IPC::Channel that lives on the IO thread (see
   // browser_process.h)
   scoped_ptr<IPC::SyncChannel> channel_;
 
   // the registered listeners. When this list is empty or all NULL, we should
   // delete ourselves
   IDMap<IPC::Channel::Listener> listeners_;
 
   // The maximum page ID we've ever seen from the renderer process.
   int32 max_page_id_;
 
   // Indicates whether we have notified that the process has terminated. We
   // only want to send this out once.
   bool notified_termination_;
 
  private:
-  int host_id_;
+  int pid_;
 
   Profile* profile_;
 
   // set of listeners that expect the renderer process to close
   std::set<int> listeners_expecting_close_;
 
   // See getter above.
   static bool run_renderer_in_process_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderProcessHost);
 };
 
 // Factory object for RenderProcessHosts. Using this factory allows tests to
 // swap out a different one to use a TestRenderProcessHost.
 class RenderProcessHostFactory {
  public:
   virtual ~RenderProcessHostFactory() {}
   virtual RenderProcessHost* CreateRenderProcessHost(
       Profile* profile) const = 0;
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_H_