Adds support for multiple malware/phishing resources in a page

chrome/browser/tab_contents/interstitial_page.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/tab_contents/interstitial_page.h"
 
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_resources.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_win.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/web_contents.h"
 #include "chrome/browser/tab_contents/web_contents_view_win.h"
 #include "chrome/views/window.h"
 #include "chrome/views/window_delegate.h"
 #include "net/base/escape.h"
 
+enum ResourceRequestAction {
+  BLOCK,
+  RESUME,
+  CANCEL
+};
+
 namespace {
 
 class ResourceRequestTask : public Task {
  public:
-  ResourceRequestTask(RenderViewHost* render_view_host,
+  ResourceRequestTask(int process_id,
+                      int render_view_host_id,
                       ResourceRequestAction action)
       : action_(action),
-        process_id_(render_view_host->process()->host_id()),
-        render_view_host_id_(render_view_host->routing_id()),
+        process_id_(process_id),
+        render_view_host_id_(render_view_host_id),
         resource_dispatcher_host_(
             g_browser_process->resource_dispatcher_host()) {
   }
 
   virtual void Run() {
     switch (action_) {
       case BLOCK:
         resource_dispatcher_host_->BlockRequestsForRenderView(
             process_id_, render_view_host_id_);
         break;
@@ skipping 26 matching lines @@
     InterstitialPage::tab_to_interstitial_page_ =  NULL;
 
 InterstitialPage::InterstitialPage(WebContents* tab,
                                    bool new_navigation,
                                    const GURL& url)
     : tab_(tab),
       url_(url),
       action_taken_(false),
       enabled_(true),
       new_navigation_(new_navigation),
+      original_rvh_process_id_(tab->render_view_host()->process()->host_id()),
+      original_rvh_id_(tab->render_view_host()->routing_id()),
       render_view_host_(NULL),
+      resource_dispatcher_host_notified_(false),
       should_revert_tab_title_(false),
       ui_loop_(MessageLoop::current()) {
   InitInterstitialPageMap();
   // It would be inconsistent to create an interstitial with no new navigation
   // (which is the case when the interstitial was triggered by a sub-resource on
   // a page) when we have a pending entry (in the process of loading a new top
   // frame).
   DCHECK(new_navigation || !tab->controller()->GetPendingEntry());
 }
 
@@ skipping 64 matching lines @@
     tab_->NotifyNavigationStateChanged(TabContents::INVALIDATE_TITLE);
   }
   delete this;
 }
 
 void InterstitialPage::Observe(NotificationType type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
   switch (type) {
     case NOTIFY_NAV_ENTRY_PENDING:
-      // We are navigating away from the interstitial.  Make sure clicking on
-      // the interstitial will have no effect.
+      // We are navigating away from the interstitial (the user has typed a URL
+      // in the location bar or clicked a bookmark).  Make sure clicking on the
+      // interstitial will have no effect.  Also cancel any blocked requests
+      // on the ResourceDispatcherHost.  Note that when we get this notification
+      // the RenderViewHost has not yet navigated so we'll unblock the
+      // RenderViewHost before the resource request for the new page we are
+      // navigating arrives in the ResourceDispatcherHost.  This ensures that
+      // request won't be blocked if the same RenderViewHost was used for the
+      // new navigation.
       Disable();
+      DCHECK(!resource_dispatcher_host_notified_);
+      TakeActionOnResourceDispatcher(CANCEL);
       break;
     case NOTIFY_RENDER_WIDGET_HOST_DESTROYED:
       if (!action_taken_) {
         // The RenderViewHost is being destroyed (as part of the tab being
         // closed), make sure we clear the blocked requests.
-        DCHECK(Source<RenderViewHost>(source).ptr() ==
-               tab_->render_view_host());
+        RenderViewHost* rvh = Source<RenderViewHost>(source).ptr();
+        DCHECK(rvh->process()->host_id() == original_rvh_process_id_ &&
+               rvh->routing_id() == original_rvh_id_);
         TakeActionOnResourceDispatcher(CANCEL);
       }
       break;
     case NOTIFY_TAB_CONTENTS_DESTROYED:
     case NOTIFY_NAV_ENTRY_COMMITTED:
       if (!action_taken_) {
         // We are navigating away from the interstitial or closing a tab with an
         // interstitial.  Default to DontProceed(). We don't just call Hide as
         // subclasses will almost certainly override DontProceed to do some work
         // (ex: close pending connections).
@@ skipping 23 matching lines @@
       static_cast<WebContentsViewWin*>(tab_->view());
   render_view_host->CreateRenderView();
   // SetSize must be called after CreateRenderView or the HWND won't show.
   view->SetSize(web_contents_view->GetContainerSize());
 
   render_view_host->AllowDomAutomationBindings();
   return render_view_host;
 }
 
 void InterstitialPage::Proceed() {
-  DCHECK(!action_taken_);
+  if (action_taken_) {
+    NOTREACHED();
+    return;
+  }
   Disable();
   action_taken_ = true;
 
   // Resumes the throbber.
   tab_->SetIsLoading(true, NULL);
 
   // If this is a new navigation, the old page is going away, so we cancel any
   // blocked requests for it.  If it is not a new navigation, then it means the
   // interstitial was shown as a result of a resource loading in the page.
   // Since the user wants to proceed, we'll let any blocked request go through.
   if (new_navigation_)
     TakeActionOnResourceDispatcher(CANCEL);
   else
     TakeActionOnResourceDispatcher(RESUME);
 
   // No need to hide if we are a new navigation, we'll get hidden when the
   // navigation is committed.
   if (!new_navigation_) {
     Hide();
     // WARNING: we are now deleted!
   }
 }
 
 void InterstitialPage::DontProceed() {
-  DCHECK(!action_taken_);
+  if (action_taken_) {
+    NOTREACHED();
+    return;
+  }
   Disable();
   action_taken_ = true;
 
   // If this is a new navigation, we are returning to the original page, so we
   // resume blocked requests for it.  If it is not a new navigation, then it
   // means the interstitial was shown as a result of a resource loading in the
   // page and we won't return to the original page, so we cancel blocked
   // requests in that case.
   if (new_navigation_)
     TakeActionOnResourceDispatcher(RESUME);
@@ skipping 70 matching lines @@
 }
 
 void InterstitialPage::Disable() {
   enabled_ = false;
 }
 
 void InterstitialPage::TakeActionOnResourceDispatcher(
     ResourceRequestAction action) {
   DCHECK(MessageLoop::current() == ui_loop_) << 
       "TakeActionOnResourceDispatcher should be called on the main thread.";
+
+  if (action == CANCEL || action == RESUME) {
+    if (resource_dispatcher_host_notified_)
+      return;
+    resource_dispatcher_host_notified_ = true;
+  }
+
   // The tab might not have a render_view_host if it was closed (in which case,
   // we have taken care of the blocked requests when processing
   // NOTIFY_RENDER_WIDGET_HOST_DESTROYED.
   // Also we need to test there is an IO thread, as when unit-tests we don't
   // have one.
-  if (tab_->render_view_host() && g_browser_process->io_thread()) {
+  RenderViewHost* rvh = RenderViewHost::FromID(original_rvh_process_id_,
+                                               original_rvh_id_);
+  if (rvh && g_browser_process->io_thread()) {
     g_browser_process->io_thread()->message_loop()->PostTask(
-        FROM_HERE, new ResourceRequestTask(tab_->render_view_host(), action));
+        FROM_HERE, new ResourceRequestTask(original_rvh_process_id_,
+                                           original_rvh_id_,
+                                           action));
   }
 }
 
 // static
 void InterstitialPage::InitInterstitialPageMap() {
   if (!tab_to_interstitial_page_)
     tab_to_interstitial_page_ = new InterstitialPageMap;
 }
 
 // static
 InterstitialPage* InterstitialPage::GetInterstitialPage(
     WebContents* web_contents) {
   InitInterstitialPageMap();
   InterstitialPageMap::const_iterator iter =
       tab_to_interstitial_page_->find(web_contents);
   if (iter == tab_to_interstitial_page_->end())
     return NULL;
 
   return iter->second;
 }
+