Use InterstitialPage through a delegate interface instead of deriving from it.

content/browser/tab_contents/interstitial_page.cc

 // Copyright (c) 2012 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 "content/browser/tab_contents/interstitial_page.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/tab_contents/navigation_controller_impl.h"
 #include "content/browser/tab_contents/navigation_entry_impl.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/dom_storage_common.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/dom_operation_notification_details.h"
+#include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/view_type.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 using content::DomOperationNotificationDetails;
+using content::InterstitialPageDelegate;
 using content::NavigationController;
 using content::NavigationEntry;
 using content::NavigationEntryImpl;
 using content::RenderViewHostDelegate;
 using content::SiteInstance;
 using content::WebContents;
 using content::WebContentsView;
 using WebKit::WebDragOperation;
 using WebKit::WebDragOperationsMask;
 
@@ skipping 61 matching lines @@
                            const gfx::Rect& selection_rect,
                            int active_match_ordinal,
                            bool final_update);
 
  private:
   InterstitialPage* interstitial_page_;
 
   DISALLOW_COPY_AND_ASSIGN(InterstitialPageRVHViewDelegate);
 };
 
+InterstitialPage* InterstitialPage::Create(WebContents* tab,
+                                           bool new_navigation,
+                                           const GURL& url,
+                                           InterstitialPageDelegate* delegate) {
+  return new InterstitialPage(tab, new_navigation, url, delegate);
+}
+
 // static
 InterstitialPage::InterstitialPageMap*
     InterstitialPage::tab_to_interstitial_page_ =  NULL;
 
 InterstitialPage::InterstitialPage(WebContents* tab,
                                    bool new_navigation,
-                                   const GURL& url)
+                                   const GURL& url,
+                                   InterstitialPageDelegate* delegate)
     : tab_(static_cast<TabContents*>(tab)),
       url_(url),
       new_navigation_(new_navigation),
       should_discard_pending_nav_entry_(new_navigation),
       reload_on_dont_proceed_(false),
       enabled_(true),
       action_taken_(NO_ACTION),
       render_view_host_(NULL),
       original_child_id_(tab->GetRenderProcessHost()->GetID()),
       original_rvh_id_(tab->GetRenderViewHost()->routing_id()),
       should_revert_tab_title_(false),
       tab_was_loading_(false),
       resource_dispatcher_host_notified_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(rvh_view_delegate_(
-          new InterstitialPageRVHViewDelegate(this))) {
+          new InterstitialPageRVHViewDelegate(this))),
+      create_view_(true),
+      delegate_(delegate) {
   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->GetController().GetPendingEntry());
 }
 
 InterstitialPage::~InterstitialPage() {
-  InterstitialPageMap::iterator iter = tab_to_interstitial_page_->find(tab_);
-  DCHECK(iter != tab_to_interstitial_page_->end());
-  if (iter != tab_to_interstitial_page_->end())
-    tab_to_interstitial_page_->erase(iter);
-  DCHECK(!render_view_host_);
 }
 
 void InterstitialPage::Show() {
   // If an interstitial is already showing or about to be shown, close it before
   // showing the new one.
   // Be careful not to take an action on the old interstitial more than once.
   InterstitialPageMap::const_iterator iter =
       tab_to_interstitial_page_->find(tab_);
   if (iter != tab_to_interstitial_page_->end()) {
     InterstitialPage* interstitial = iter->second;
     if (interstitial->action_taken_ != NO_ACTION) {
       interstitial->Hide();
+      delete interstitial;
     } else {
       // If we are currently showing an interstitial page for which we created
       // a transient entry and a new interstitial is shown as the result of a
       // new browser initiated navigation, then that transient entry has already
       // been discarded and a new pending navigation entry created.
       // So we should not discard that new pending navigation entry.
       // See http://crbug.com/9791
       if (new_navigation_ && interstitial->new_navigation_)
         interstitial->should_discard_pending_nav_entry_= false;
       interstitial->DontProceed();
@@ skipping 14 matching lines @@
   iter = tab_to_interstitial_page_->find(tab_);
   DCHECK(iter == tab_to_interstitial_page_->end());
   (*tab_to_interstitial_page_)[tab_] = this;
 
   if (new_navigation_) {
     NavigationEntryImpl* entry = new NavigationEntryImpl;
     entry->SetURL(url_);
     entry->SetVirtualURL(url_);
     entry->set_page_type(content::PAGE_TYPE_INTERSTITIAL);
 
-    // Give sub-classes a chance to set some states on the navigation entry.
-    UpdateEntry(entry);
+    // Give delegates a chance to set some states on the navigation entry.
+    delegate_->OverrideEntry(entry);
 
     tab_->GetControllerImpl().AddTransientEntry(entry);
   }
 
   DCHECK(!render_view_host_);
   render_view_host_ = CreateRenderViewHost();
   CreateWebContentsView();
 
   std::string data_url = "data:text/html;charset=utf-8," +
-                         net::EscapePath(GetHTMLContents());
+                         net::EscapePath(delegate_->GetHTMLContents());
   render_view_host_->NavigateToURL(GURL(data_url));
 
   notification_registrar_.Add(this,
                               content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                               content::Source<WebContents>(tab_));
   notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(&tab_->GetController()));
   notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_PENDING,
       content::Source<NavigationController>(&tab_->GetController()));
   notification_registrar_.Add(
@@ skipping 29 matching lines @@
   if (!new_navigation_ && should_revert_tab_title_) {
     entry->SetTitle(original_tab_title_);
     tab_->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
   }
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_INTERSTITIAL_DETACHED,
       content::Source<WebContents>(tab_),
       content::NotificationService::NoDetails());
 
-  delete this;
+  InterstitialPageMap::iterator iter = tab_to_interstitial_page_->find(tab_);
+  DCHECK(iter != tab_to_interstitial_page_->end());
+  if (iter != tab_to_interstitial_page_->end())
+    tab_to_interstitial_page_->erase(iter);
 }
 
 void InterstitialPage::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_NAV_ENTRY_PENDING:
       // 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
@@ skipping 22 matching lines @@
       if (action_taken_ == NO_ACTION) {
         // 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).
         DontProceed();
       } else {
         // User decided to proceed and either the navigation was committed or
         // the tab was closed before that.
         Hide();
-        // WARNING: we are now deleted!
+        delete this;
       }
       break;
     case content::NOTIFICATION_DOM_OPERATION_RESPONSE:
       if (enabled()) {
         content::Details<DomOperationNotificationDetails> dom_op_details(
             details);
-        CommandReceived(dom_op_details->json);
+        delegate_->CommandReceived(dom_op_details->json);
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 RenderViewHostDelegate::View* InterstitialPage::GetViewDelegate() {
   return rvh_view_delegate_.get();
 }
@@ skipping 85 matching lines @@
     should_revert_tab_title_ = true;
   }
   // TODO(evan): make use of title_direction.
   // http://code.google.com/p/chromium/issues/detail?id=27094
   entry->SetTitle(title);
   tab_->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
 }
 
 content::RendererPreferences InterstitialPage::GetRendererPrefs(
     content::BrowserContext* browser_context) const {
+  delegate_->OverrideRendererPrefs(&renderer_preferences_);
   return renderer_preferences_;
 }
 
 WebPreferences InterstitialPage::GetWebkitPrefs() {
   return tab_->GetWebkitPrefs(render_view_host(), url_);
 }
 
 bool InterstitialPage::PreHandleKeyboardEvent(
     const NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
@@ skipping 10 matching lines @@
 }
 
 RenderViewHost* InterstitialPage::CreateRenderViewHost() {
   RenderViewHost* render_view_host = new RenderViewHost(
       SiteInstance::Create(tab()->GetBrowserContext()),
       this, MSG_ROUTING_NONE, kInvalidSessionStorageNamespaceId);
   return render_view_host;
 }
 
 WebContentsView* InterstitialPage::CreateWebContentsView() {
+  if (!create_view_)
+    return NULL;
   WebContentsView* web_contents_view = tab()->GetView();
   RenderWidgetHostView* view =
       web_contents_view->CreateViewForWidget(render_view_host_);
   render_view_host_->SetView(view);
   render_view_host_->AllowBindings(content::BINDINGS_POLICY_DOM_AUTOMATION);
 
   int32 max_page_id =
       tab()->GetMaxPageIDForSiteInstance(render_view_host_->site_instance());
   render_view_host_->CreateRenderView(string16(), max_page_id);
   view->SetSize(web_contents_view->GetContainerSize());
@@ skipping 20 matching lines @@
   // 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!
+    delegate_->OnProceed();
+    delete this;
+    return;
   }
-}
 
-std::string InterstitialPage::GetHTMLContents() {
-  return std::string();
+  delegate_->OnProceed();
 }
 
 void InterstitialPage::DontProceed() {
   DCHECK(action_taken_ != DONT_PROCEED_ACTION);
 
   Disable();
   action_taken_ = DONT_PROCEED_ACTION;
 
   // 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
@@ skipping 10 matching lines @@
     // explicitely.  Note that by calling DiscardNonCommittedEntries() we also
     // discard the pending entry, which is what we want, since the navigation is
     // cancelled.
     tab_->GetController().DiscardNonCommittedEntries();
   }
 
   if (reload_on_dont_proceed_)
     tab_->GetController().Reload(true);
 
   Hide();
-  // WARNING: we are now deleted!
+  delegate_->OnDontProceed();
+  delete this;
 }
 
 void InterstitialPage::CancelForNavigation() {
   // The user is trying to navigate away.  We should unblock the renderer and
   // disable the interstitial, but keep it visible until the navigation
   // completes.
   Disable();
   // If this interstitial was shown for a new navigation, allow any navigations
   // on the original page to resume (e.g., subresource requests, XHRs, etc).
   // Otherwise, cancel the pending, possibly dangerous navigations.
@@ skipping 17 matching lines @@
 
 void InterstitialPage::Focus() {
   // Focus the native window.
   render_view_host_->view()->Focus();
 }
 
 void InterstitialPage::FocusThroughTabTraversal(bool reverse) {
   render_view_host_->SetInitialFocus(reverse);
 }
 
+content::InterstitialPageDelegate* InterstitialPage::GetDelegateForTesting() {
+  return delegate_.get();
+}
+
+void InterstitialPage::DontCreateViewForTesting() {
+  create_view_ = false;
+}
+
 content::ViewType InterstitialPage::GetRenderViewType() const {
   return content::VIEW_TYPE_INTERSTITIAL_PAGE;
 }
 
 gfx::Rect InterstitialPage::GetRootWindowResizerRect() const {
   return gfx::Rect();
 }
 
 void InterstitialPage::Disable() {
   enabled_ = false;
@@ skipping 128 matching lines @@
   if (!tab->GetViewDelegate())
     return;
 
   tab->GetViewDelegate()->TakeFocus(reverse);
 }
 
 void InterstitialPage::InterstitialPageRVHViewDelegate::OnFindReply(
     int request_id, int number_of_matches, const gfx::Rect& selection_rect,
     int active_match_ordinal, bool final_update) {
 }