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

content/browser/tab_contents/tab_contents_unittest.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 "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/mock_content_browser_client.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/test_render_view_host.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/tab_contents/interstitial_page.h"
 #include "content/browser/tab_contents/navigation_entry_impl.h"
 #include "content/browser/tab_contents/test_tab_contents.h"
 #include "content/common/view_messages.h"
+#include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/browser/web_ui_controller_factory.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
 #include "content/test/test_browser_thread.h"
@@ skipping 55 matching lines @@
 
   virtual content::WebUIControllerFactory*
       GetWebUIControllerFactory() OVERRIDE {
     return &factory_;
   }
 
  private:
   TabContentsTestWebUIControllerFactory factory_;
 };
 
+class TestInterstitialPage;
+
+class TestInterstitialPageDelegate : public content::InterstitialPageDelegate {
+ public:
+  TestInterstitialPageDelegate(TestInterstitialPage* interstitial_page)
+      : interstitial_page_(interstitial_page) {}
+  virtual void CommandReceived(const std::string& command) OVERRIDE;
+  virtual std::string GetHTMLContents() OVERRIDE { return std::string(); }
+  virtual void OnDontProceed() OVERRIDE;
+  virtual void OnProceed() OVERRIDE;
+ private:
+  TestInterstitialPage* interstitial_page_;
+};
+
 class TestInterstitialPage : public InterstitialPage {
  public:
   enum InterstitialState {
     UNDECIDED = 0,  // No decision taken yet.
     OKED,           // Proceed was called.
     CANCELED        // DontProceed was called.
   };
 
   class Delegate {
    public:
@@ skipping 11 matching lines @@
   // are cleared when the test finishes.
   // Not doing so will cause stack trashing if your test does not hide the
   // interstitial, as in such a case it will be destroyed in the test TearDown
   // method and will dereference the |deleted| local variable which by then is
   // out of scope.
   TestInterstitialPage(TabContents* tab,
                        bool new_navigation,
                        const GURL& url,
                        InterstitialState* state,
                        bool* deleted)
-      : InterstitialPage(tab, new_navigation, url),
+      : InterstitialPage(
+            tab, new_navigation, url,
+            new TestInterstitialPageDelegate(this)),
         state_(state),
         deleted_(deleted),
         command_received_count_(0),
         delegate_(NULL) {
     *state_ = UNDECIDED;
     *deleted_ = false;
   }
 
   virtual ~TestInterstitialPage() {
     if (deleted_)
       *deleted_ = true;
     if (delegate_)
       delegate_->TestInterstitialPageDeleted(this);
   }
 
-  virtual void DontProceed() {
+  void OnDontProceed() {
     if (state_)
       *state_ = CANCELED;
-    InterstitialPage::DontProceed();
   }
-  virtual void Proceed() {
+  void OnProceed() {
     if (state_)
       *state_ = OKED;
-    InterstitialPage::Proceed();
   }
 
   int command_received_count() const {
     return command_received_count_;
   }
 
   void TestDomOperationResponse(const std::string& json_string) {
     if (enabled())
-      CommandReceived(json_string);
+      CommandReceived();
   }
 
   void TestDidNavigate(int page_id, const GURL& url) {
     ViewHostMsg_FrameNavigate_Params params;
     InitNavigateParams(&params, page_id, url, content::PAGE_TRANSITION_TYPED);
     DidNavigate(render_view_host(), params);
   }
 
   void TestRenderViewGone(base::TerminationStatus status, int error_code) {
     RenderViewGone(render_view_host(), status, error_code);
   }
 
   bool is_showing() const {
     return static_cast<TestRenderWidgetHostView*>(render_view_host()->view())->
         is_showing();
   }
 
   void ClearStates() {
     state_ = NULL;
     deleted_ = NULL;
     delegate_ = NULL;
   }
 
+  void CommandReceived() {
+    command_received_count_++;
+  }
+
   void set_delegate(Delegate* delegate) {
     delegate_ = delegate;
   }
 
  protected:
-  virtual RenderViewHost* CreateRenderViewHost() {
+  virtual RenderViewHost* CreateRenderViewHost() OVERRIDE {
     return new TestRenderViewHost(
         SiteInstance::Create(tab()->GetBrowserContext()),
         this, MSG_ROUTING_NONE);
   }
 
-  virtual content::WebContentsView* CreateWebContentsView() { return NULL; }
-
-
-  virtual void CommandReceived(const std::string& command) {
-    command_received_count_++;
+  virtual content::WebContentsView* CreateWebContentsView() OVERRIDE {
+    return NULL;
   }
 
  private:
   InterstitialState* state_;
   bool* deleted_;
   int command_received_count_;
   Delegate* delegate_;
 };
 
+void TestInterstitialPageDelegate::CommandReceived(const std::string& command) {
+  interstitial_page_->CommandReceived();
+}
+
+void TestInterstitialPageDelegate::OnDontProceed() {
+  interstitial_page_->OnDontProceed();
+}
+
+void TestInterstitialPageDelegate::OnProceed() {
+  interstitial_page_->OnProceed();
+}
+
 class TestInterstitialPageStateGuard : public TestInterstitialPage::Delegate {
  public:
   explicit TestInterstitialPageStateGuard(
       TestInterstitialPage* interstitial_page)
       : interstitial_page_(interstitial_page) {
     DCHECK(interstitial_page_);
     interstitial_page_->set_delegate(this);
   }
   ~TestInterstitialPageStateGuard() {
     if (interstitial_page_)
@@ skipping 1624 matching lines @@
 
   // It should have a transient entry.
   EXPECT_TRUE(other_controller.GetTransientEntry());
 
   // And the interstitial should be showing.
   EXPECT_TRUE(other_contents->ShowingInterstitialPage());
 
   // And the interstitial should do a reload on don't proceed.
   EXPECT_TRUE(other_contents->GetInterstitialPage()->reload_on_dont_proceed());
 }