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

chrome/browser/renderer_host/render_view_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.
 
 #include "chrome/browser/renderer_host/render_view_host.h"
 
 #include <string>
 #include <vector>
 
 #include "base/gfx/native_widget_types.h"
@@ skipping 103 matching lines @@
 RenderViewHost::~RenderViewHost() {
   OnDebugDisconnect();
 
 #ifdef CHROME_PERSONALIZATION
   Personalization::CleanupHostPersonalization(personalization_);
   personalization_ = NULL;
 #endif
 
   // Be sure to clean up any leftover state from cross-site requests.
   Singleton<CrossSiteRequestManager>()->SetHasPendingCrossSiteRequest(
-      process()->host_id(), routing_id(), false);
+      process()->pid(), routing_id(), false);
 
   NotificationService::current()->Notify(
       NotificationType::RENDER_VIEW_HOST_DELETED,
       Source<RenderViewHost>(this),
       NotificationService::NoDetails());
 }
 
 bool RenderViewHost::CreateRenderView() {
   DCHECK(!IsRenderViewLive()) << "Creating view twice";
 
   // The process may (if we're sharing a process with another host that already
   // initialized it) or may not (we have our own process or the old process
   // crashed) have been initialized. Calling Init multiple times will be
   // ignored, so this is safe.
   if (!process()->Init())
     return false;
   DCHECK(process()->channel());
   DCHECK(process()->profile());
 
+  if (enabled_bindings_ & BindingsPolicy::DOM_UI) {
+    RendererSecurityPolicy::GetInstance()->GrantDOMUIBindings(
+        process()->pid());
+  }
+
   renderer_initialized_ = true;
 
 #if defined(OS_WIN)
   HANDLE modal_dialog_event_handle;
   HANDLE renderer_process_handle = process()->process().handle();
   if (renderer_process_handle == NULL)
     renderer_process_handle = GetCurrentProcess();
 
   BOOL result = DuplicateHandle(GetCurrentProcess(),
       modal_dialog_event_->handle(),
@@ skipping 40 matching lines @@
   RenderWidgetHost::Init();
   renderer_initialized_ = true;
 }
 
 void RenderViewHost::NavigateToEntry(const NavigationEntry& entry,
                                      bool is_reload) {
   ViewMsg_Navigate_Params params;
   MakeNavigateParams(entry, is_reload, &params);
 
   RendererSecurityPolicy::GetInstance()->GrantRequestURL(
-      process()->host_id(), params.url);
+      process()->pid(), params.url);
 
   DoNavigate(new ViewMsg_Navigate(routing_id(), params));
 }
 
 void RenderViewHost::NavigateToURL(const GURL& url) {
   ViewMsg_Navigate_Params params;
   params.page_id = -1;
   params.url = url;
   params.transition = PageTransition::LINK;
   params.reload = false;
 
   RendererSecurityPolicy::GetInstance()->GrantRequestURL(
-      process()->host_id(), params.url);
+      process()->pid(), params.url);
 
   DoNavigate(new ViewMsg_Navigate(routing_id(), params));
 }
 
 void RenderViewHost::DoNavigate(ViewMsg_Navigate* nav_message) {
   // Only send the message if we aren't suspended at the start of a cross-site
   // request.
   if (navigations_suspended_) {
     // Shouldn't be possible to have a second navigation while suspended, since
     // navigations will only be suspended during a cross-site request.  If a
@@ skipping 41 matching lines @@
   if (!is_waiting_for_unload_ack_) {
     // Start the hang monitor in case the renderer hangs in the beforeunload
     // handler.
     is_waiting_for_unload_ack_ = true;
     StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kUnloadTimeoutMS));
     Send(new ViewMsg_ShouldClose(routing_id()));
   }
 }
 
 void RenderViewHost::FirePageUnload() {
-  ClosePage(site_instance()->process_host_id(),
-            routing_id());
+  ClosePage(process()->pid(), routing_id());
 }
 
 // static
 void RenderViewHost::ClosePageIgnoringUnloadEvents(int render_process_host_id,
                                                    int request_id) {
   RenderViewHost* rvh = RenderViewHost::FromID(render_process_host_id,
                                                request_id);
   if (!rvh)
     return;
 
@@ skipping 19 matching lines @@
     // the page.  We must notify the ResourceDispatcherHost on the IO thread,
     // which we will do through the RenderProcessHost's widget helper.
     process()->CrossSiteClosePageACK(new_render_process_host_id,
                                      new_request_id);
   }
 }
 
 void RenderViewHost::SetHasPendingCrossSiteRequest(bool has_pending_request,
                                                    int request_id) {
   Singleton<CrossSiteRequestManager>()->SetHasPendingCrossSiteRequest(
-      process()->host_id(), routing_id(), has_pending_request);
+      process()->pid(), routing_id(), has_pending_request);
   pending_request_id_ = request_id;
 }
 
 int RenderViewHost::GetPendingRequestId() {
   return pending_request_id_;
 }
 
 void RenderViewHost::OnCrossSiteResponse(int new_render_process_host_id,
                                          int new_request_id) {
   delegate_->OnCrossSiteResponse(new_render_process_host_id, new_request_id);
@@ skipping 49 matching lines @@
 
 void RenderViewHost::FillPasswordForm(
     const PasswordFormDomManager::FillData& form_data) {
   Send(new ViewMsg_FillPasswordForm(routing_id(), form_data));
 }
 
 void RenderViewHost::DragTargetDragEnter(const WebDropData& drop_data,
     const gfx::Point& client_pt, const gfx::Point& screen_pt) {
   // Grant the renderer the ability to load the drop_data.
   RendererSecurityPolicy* policy = RendererSecurityPolicy::GetInstance();
-  policy->GrantRequestURL(process()->host_id(), drop_data.url);
+  policy->GrantRequestURL(process()->pid(), drop_data.url);
   for (std::vector<std::wstring>::const_iterator
          iter(drop_data.filenames.begin());
        iter != drop_data.filenames.end(); ++iter) {
-    policy->GrantRequestURL(process()->host_id(),
-                            net::FilePathToFileURL(*iter));
-    policy->GrantUploadFile(process()->host_id(), *iter);
+    policy->GrantRequestURL(process()->pid(), net::FilePathToFileURL(*iter));
+    policy->GrantUploadFile(process()->pid(), *iter);
   }
   Send(new ViewMsg_DragTargetDragEnter(routing_id(), drop_data, client_pt,
                                        screen_pt));
 }
 
 void RenderViewHost::DragTargetDragOver(
     const gfx::Point& client_pt, const gfx::Point& screen_pt) {
   Send(new ViewMsg_DragTargetDragOver(routing_id(), client_pt, screen_pt));
 }
 
@@ skipping 130 matching lines @@
 
   ViewHostMsg_ShowModalHTMLDialog::WriteReplyParams(reply_msg, json_retval);
   Send(reply_msg);
 }
 
 void RenderViewHost::CopyImageAt(int x, int y) {
   Send(new ViewMsg_CopyImageAt(routing_id(), x, y));
 }
 
 void RenderViewHost::InspectElementAt(int x, int y) {
-  RendererSecurityPolicy::GetInstance()->GrantInspectElement(
-      process()->host_id());
+  RendererSecurityPolicy::GetInstance()->GrantInspectElement(process()->pid());
   Send(new ViewMsg_InspectElement(routing_id(), x, y));
 }
 
 void RenderViewHost::ShowJavaScriptConsole() {
-  RendererSecurityPolicy::GetInstance()->GrantInspectElement(
-      process()->host_id());
+  RendererSecurityPolicy::GetInstance()->GrantInspectElement(process()->pid());
 
   Send(new ViewMsg_ShowJavaScriptConsole(routing_id()));
 }
 
 void RenderViewHost::DragSourceEndedAt(
     int client_x, int client_y, int screen_x, int screen_y) {
   Send(new ViewMsg_DragSourceEndedOrMoved(
       routing_id(), client_x, client_y, screen_x, screen_y, true));
 }
 
@@ skipping 13 matching lines @@
 }
 
 void RenderViewHost::AllowExternalHostBindings() {
   DCHECK(!renderer_initialized_);
   enabled_bindings_ |= BindingsPolicy::EXTERNAL_HOST;
 }
 
 void RenderViewHost::AllowDOMUIBindings() {
   DCHECK(!renderer_initialized_);
   enabled_bindings_ |= BindingsPolicy::DOM_UI;
-  RendererSecurityPolicy::GetInstance()->GrantDOMUIBindings(
-      process()->host_id());
 }
 
 void RenderViewHost::AllowExtensionBindings() {
   DCHECK(!renderer_initialized_);
   enabled_bindings_ |= BindingsPolicy::EXTENSION;
 }
 
 void RenderViewHost::SetDOMUIProperty(const std::string& name,
                                       const std::string& value) {
   DCHECK(BindingsPolicy::is_dom_ui_enabled(enabled_bindings_));
@@ skipping 22 matching lines @@
 
 void RenderViewHost::UpdateWebPreferences(const WebPreferences& prefs) {
   Send(new ViewMsg_UpdateWebPreferences(routing_id(), prefs));
 }
 
 void RenderViewHost::InstallMissingPlugin() {
   Send(new ViewMsg_InstallMissingPlugin(routing_id()));
 }
 
 void RenderViewHost::FileSelected(const std::wstring& path) {
-  RendererSecurityPolicy::GetInstance()->GrantUploadFile(process()->host_id(),
+  RendererSecurityPolicy::GetInstance()->GrantUploadFile(process()->pid(),
                                                          path);
   std::vector<std::wstring> files;
   files.push_back(path);
   Send(new ViewMsg_RunFileChooserResponse(routing_id(), files));
 }
 
 void RenderViewHost::MultiFilesSelected(
          const std::vector<std::wstring>& files) {
   for (std::vector<std::wstring>::const_iterator file = files.begin();
        file != files.end(); ++file) {
     RendererSecurityPolicy::GetInstance()->GrantUploadFile(
-      process()->host_id(), *file);
+      process()->pid(), *file);
   }
   Send(new ViewMsg_RunFileChooserResponse(routing_id(), files));
 }
 
 void RenderViewHost::LoadStateChanged(const GURL& url,
                                       net::LoadState load_state) {
   delegate_->LoadStateChanged(url, load_state);
 }
 
 bool RenderViewHost::CanTerminate() const {
@@ skipping 202 matching lines @@
 // action.
 void RenderViewHost::OnMsgNavigate(const IPC::Message& msg) {
   // Read the parameters out of the IPC message directly to avoid making another
   // copy when we filter the URLs.
   void* iter = NULL;
   ViewHostMsg_FrameNavigate_Params validated_params;
   if (!IPC::ParamTraits<ViewHostMsg_FrameNavigate_Params>::
       Read(&msg, &iter, &validated_params))
     return;
 
-  const int renderer_id = process()->host_id();
+  const int renderer_id = process()->pid();
   RendererSecurityPolicy* policy = RendererSecurityPolicy::GetInstance();
   // Without this check, an evil renderer can trick the browser into creating
   // a navigation entry for a banned URL.  If the user clicks the back button
   // followed by the forward button (or clicks reload, or round-trips through
   // session restore, etc), we'll think that the browser commanded the
   // renderer to load the URL and grant the renderer the privileges to request
   // the URL.  To prevent this attack, we block the renderer from inserting
   // banned URLs into the navigation controller in the first place.
   FilterURL(policy, renderer_id, &validated_params.url);
   FilterURL(policy, renderer_id, &validated_params.referrer);
@@ skipping 68 matching lines @@
 void RenderViewHost::OnMsgDidLoadResourceFromMemoryCache(
     const GURL& url,
     const std::string& security_info) {
   delegate_->DidLoadResourceFromMemoryCache(url, security_info);
 }
 
 void RenderViewHost::OnMsgDidStartProvisionalLoadForFrame(bool is_main_frame,
                                                           const GURL& url) {
   GURL validated_url(url);
   FilterURL(RendererSecurityPolicy::GetInstance(),
-            process()->host_id(), &validated_url);
+            process()->pid(), &validated_url);
 
   delegate_->DidStartProvisionalLoadForFrame(this, is_main_frame,
                                              validated_url);
 }
 
 void RenderViewHost::OnMsgDidFailProvisionalLoadWithError(
     bool is_main_frame,
     int error_code,
     const GURL& url,
     bool showing_repost_interstitial) {
   GURL validated_url(url);
   FilterURL(RendererSecurityPolicy::GetInstance(),
-            process()->host_id(), &validated_url);
+            process()->pid(), &validated_url);
 
   delegate_->DidFailProvisionalLoadWithError(this, is_main_frame,
                                              error_code, validated_url,
                                              showing_repost_interstitial);
 }
 
 void RenderViewHost::OnMsgFindReply(int request_id,
                                     int number_of_matches,
                                     const gfx::Rect& selection_rect,
                                     int active_match_ordinal,
@@ skipping 24 matching lines @@
 }
 
 void RenderViewHost::OnMsgContextMenu(const ContextMenuParams& params) {
   RenderViewHostDelegate::View* view = delegate_->GetViewDelegate();
   if (!view)
     return;
 
   // Validate the URLs in |params|.  If the renderer can't request the URLs
   // directly, don't show them in the context menu.
   ContextMenuParams validated_params(params);
-  const int renderer_id = process()->host_id();
+  const int renderer_id = process()->pid();
   RendererSecurityPolicy* policy = RendererSecurityPolicy::GetInstance();
 
   FilterURL(policy, renderer_id, &validated_params.link_url);
   FilterURL(policy, renderer_id, &validated_params.image_url);
   FilterURL(policy, renderer_id, &validated_params.page_url);
   FilterURL(policy, renderer_id, &validated_params.frame_url);
 
   view->ShowContextMenu(validated_params);
 }
 
 void RenderViewHost::OnMsgOpenURL(const GURL& url,
                                   const GURL& referrer,
                                   WindowOpenDisposition disposition) {
   GURL validated_url(url);
   FilterURL(RendererSecurityPolicy::GetInstance(),
-            process()->host_id(), &validated_url);
+            process()->pid(), &validated_url);
 
   delegate_->RequestOpenURL(validated_url, referrer, disposition);
 }
 
 void RenderViewHost::OnMsgDomOperationResponse(
     const std::string& json_string, int automation_id) {
   delegate_->DomOperationResponse(json_string, automation_id);
 }
 
 void RenderViewHost::OnMsgDOMUISend(
     const std::string& message, const std::string& content) {
   if (!RendererSecurityPolicy::GetInstance()->
-          HasDOMUIBindings(process()->host_id())) {
+          HasDOMUIBindings(process()->pid())) {
     NOTREACHED() << "Blocked unauthorized use of DOMUIBindings.";
     return;
   }
   delegate_->ProcessDOMUIMessage(message, content);
 }
 
 void RenderViewHost::OnMsgForwardMessageToExternalHost(
     const std::string& message, const std::string& origin,
     const std::string& target) {
   delegate_->ProcessExternalHostMessage(message, origin, target);
@@ skipping 283 matching lines @@
   Send(new ViewMsg_PersonalizationEvent(routing_id(), event_name, event_arg));
 }
 #endif
 
 void RenderViewHost::ForwardMessageFromExternalHost(const std::string& message,
                                                     const std::string& origin,
                                                     const std::string& target) {
   Send(new ViewMsg_HandleMessageFromExternalHost(routing_id(), message, origin,
                                                  target));
 }