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

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/renderer_host/browser_render_process_host.h"
 
 #include "build/build_config.h"
@@ skipping 110 matching lines @@
 
 const wchar_t* const kDesktopName = L"ChromeRendererDesktop";
 
 BrowserRenderProcessHost::BrowserRenderProcessHost(Profile* profile)
     : RenderProcessHost(profile),
       visible_widgets_(0),
       backgrounded_(true),
       ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
             base::TimeDelta::FromSeconds(5),
             this, &BrowserRenderProcessHost::ClearTransportDIBCache)) {
-  DCHECK(host_id() >= 0);  // We use a negative host_id_ in destruction.
-  widget_helper_ = new RenderWidgetHelper(
-      host_id(), g_browser_process->resource_dispatcher_host());
-
-  CacheManagerHost::GetInstance()->Add(host_id());
-  RendererSecurityPolicy::GetInstance()->Add(host_id());
+  widget_helper_ = new RenderWidgetHelper();
 
   PrefService* prefs = profile->GetPrefs();
   prefs->AddPrefObserver(prefs::kBlockPopups, this);
   widget_helper_->set_block_popups(
       profile->GetPrefs()->GetBoolean(prefs::kBlockPopups));
 
   NotificationService::current()->AddObserver(this,
       NotificationType::USER_SCRIPTS_LOADED,
       NotificationService::AllSources());
 
   // Note: When we create the BrowserRenderProcessHost, it's technically
   //       backgrounded, because it has no visible listeners.  But the process
   //       doesn't actually exist yet, so we'll Background it later, after
   //       creation.
 }
 
 BrowserRenderProcessHost::~BrowserRenderProcessHost() {
-  // Some tests hold BrowserRenderProcessHost in a scoped_ptr, so we must call
-  // Unregister here as well as in response to Release().
-  Unregister();
+  if (pid() >= 0) {
+    CacheManagerHost::GetInstance()->Remove(pid());
+    RendererSecurityPolicy::GetInstance()->Remove(pid());
+  }
 
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
 
   // Destroy the AudioRendererHost properly.
   if (audio_renderer_host_.get())
     audio_renderer_host_->Destroy();
 
   if (process_.handle() && !run_renderer_in_process()) {
     ProcessWatcher::EnsureProcessTerminated(process_.handle());
@@ skipping 18 matching lines @@
 
   // Construct the AudioRendererHost with the IO thread.
   audio_renderer_host_ =
       new AudioRendererHost(io_thread->message_loop());
 
   scoped_refptr<ResourceMessageFilter> resource_message_filter =
       new ResourceMessageFilter(g_browser_process->resource_dispatcher_host(),
                                 audio_renderer_host_.get(),
                                 PluginService::GetInstance(),
                                 g_browser_process->print_job_manager(),
-                                host_id(),
                                 profile(),
                                 widget_helper_,
                                 profile()->GetSpellChecker());
 
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
 
   // setup IPC channel
   const std::wstring channel_id =
       ChildProcessInfo::GenerateRandomChannelID(this);
   channel_.reset(
@@ skipping 93 matching lines @@
 
   cmd_line.AppendSwitchWithValue(switches::kProcessChannelID,
                                  channel_id);
 
   const std::wstring& profile_path =
       browser_command_line.GetSwitchValue(switches::kUserDataDir);
   if (!profile_path.empty())
     cmd_line.AppendSwitchWithValue(switches::kUserDataDir,
                                    profile_path);
 
+  int process_id;
   bool run_in_process = run_renderer_in_process();
   if (run_in_process) {
     // Crank up a thread and run the initialization there.  With the way that
     // messages flow between the browser and renderer, this thread is required
     // to prevent a deadlock in single-process mode.  When using multiple
     // processes, the primordial thread in the renderer process has a message
     // loop which is used for sending messages asynchronously to the io thread
     // in the browser process.  If we don't create this thread, then the
     // RenderThread is both responsible for rendering and also for
     // communicating IO.  This can lead to deadlocks where the RenderThread is
     // waiting for the IO to complete, while the browsermain is trying to pass
     // an event to the RenderThread.
     in_process_renderer_.reset(new RendererMainThread(channel_id));
 
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_IO;
     in_process_renderer_->StartWithOptions(options);
+
+    // We need a "renderer pid", but we don't have one when there's no renderer
+    // process.  So pick a value that won't clash with other child process pids.
+    // Linux has PID_MAX_LIMIT which is 2^22.  Windows always uses pids that are
+    // divisible by 4.  So...
+    static int next_pid = 4 * 1024 * 1024;
+    next_pid += 3;
+    process_id = next_pid;
   } else {
 #if defined(OS_WIN)
     if (in_sandbox) {
       // spawn the child process in the sandbox
       sandbox::BrokerServices* broker_service =
           g_browser_process->broker_services();
 
       sandbox::ResultCode result;
       PROCESS_INFORMATION target = {0};
       sandbox::TargetPolicy* policy = broker_service->CreatePolicy();
@@ skipping 62 matching lines @@
         DebugUtil::SpawnDebuggerOnProcess(target.dwProcessId);
     } else
 #endif  // OS_WIN and sandbox
     {
       // spawn child process
       base::ProcessHandle process = 0;
       if (!SpawnChild(cmd_line, channel_.get(), &process))
         return false;
       process_.set_handle(process);
     }
+
+    process_id = process_.pid();
   }
 
+  SetProcessID(process_id);
+  resource_message_filter->Init(pid());
+  CacheManagerHost::GetInstance()->Add(pid());
+  RendererSecurityPolicy::GetInstance()->Add(pid());
+
   // Now that the process is created, set it's backgrounding accordingly.
   SetBackgrounded(backgrounded_);
 
   InitVisitedLinks();
   InitUserScripts();
 
   if (max_page_id_ != -1)
     channel_->Send(new ViewMsg_SetNextPageID(max_page_id_ + 1));
 
   return true;
@@ skipping 344 matching lines @@
        i != local_listeners.end(); ++i) {
     i->second->OnMessageReceived(ViewHostMsg_RenderViewGone(i->first));
   }
 
   ClearTransportDIBCache();
 
   // this object is not deleted at this point and may be reused later.
   // TODO(darin): clean this up
 }
 
-void BrowserRenderProcessHost::Unregister() {
-  // RenderProcessHost::Unregister will clean up the host_id_, so we must
-  // do our cleanup that uses that variable before we call it.
-  if (host_id() >= 0) {
-    CacheManagerHost::GetInstance()->Remove(host_id());
-    RendererSecurityPolicy::GetInstance()->Remove(host_id());
-  }
-
-  RenderProcessHost::Unregister();
-}
-
 void BrowserRenderProcessHost::OnPageContents(const GURL& url,
                                        int32 page_id,
                                        const std::wstring& contents) {
   Profile* p = profile();
   if (!p || p->IsOffTheRecord())
     return;
 
   HistoryService* hs = p->GetHistoryService(Profile::IMPLICIT_ACCESS);
   if (hs)
     hs->SetPageContents(url, contents);
 }
 
 void BrowserRenderProcessHost::OnUpdatedCacheStats(
     const CacheManager::UsageStats& stats) {
-  CacheManagerHost::GetInstance()->ObserveStats(host_id(), stats);
+  CacheManagerHost::GetInstance()->ObserveStats(pid(), stats);
 }
 
 void BrowserRenderProcessHost::SetBackgrounded(bool backgrounded) {
   // If the process_ is NULL, the process hasn't been created yet.
   if (process_.handle()) {
     bool should_set_backgrounded = true;
 
 #if defined(OS_WIN)
     // The cbstext.dll loads as a global GetMessage hook in the browser process
     // and intercepts/unintercepts the kernel32 API SetPriorityClass in a
@@ skipping 56 matching lines @@
         SendUserScriptsUpdate(shared_memory);
       }
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }