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

content/browser/tab_contents/interstitial_page.h

 // 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.
 
 #ifndef CONTENT_BROWSER_TAB_CONTENTS_INTERSTITIAL_PAGE_H_
 #define CONTENT_BROWSER_TAB_CONTENTS_INTERSTITIAL_PAGE_H_
 #pragma once
 
 #include <map>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/common/renderer_preferences.h"
 #include "googleurl/src/gurl.h"
 #include "ui/gfx/size.h"
 
 class TabContents;
 
 namespace content {
+class InterstitialPageDelegate;
 class NavigationEntry;
 class WebContents;
 class WebContentsView;
 }
 
 // This class is a base class for interstitial pages, pages that show some
 // informative message asking for user validation before reaching the target
 // page. (Navigating to a page served over bad HTTPS or a page containing
 // malware are typical cases where an interstitial is required.)
 //
@@ skipping 19 matching lines @@
     PROCEED_ACTION,      // "Proceed" was selected.
     DONT_PROCEED_ACTION  // "Don't proceed" was selected.
   };
 
   // Creates an interstitial page to show in |tab|. |new_navigation| should be
   // set to true when the interstitial is caused by loading a new page, in which
   // case a temporary navigation entry is created with the URL |url| and
   // added to the navigation controller (so the interstitial page appears as a
   // new navigation entry). |new_navigation| should be false when the
   // interstitial was triggered by a loading a sub-resource in a page.
+  // Takes ownership of |delegate|.
+  static InterstitialPage* Create(content::WebContents* tab,
+                                  bool new_navigation,
+                                  const GURL& url,
+                                  content::InterstitialPageDelegate* delegate);
+
   InterstitialPage(content::WebContents* tab,
                    bool new_navigation,
-                   const GURL& url);
+                   const GURL& url,
+                   content::InterstitialPageDelegate* delegate);
   virtual ~InterstitialPage();
 
   // Shows the interstitial page in the tab.
-  virtual void Show();
+  void Show();
 
-  // Hides the interstitial page. Warning: this deletes the InterstitialPage.
+  // Hides the interstitial page.
   void Hide();
 
   // Retrieves the InterstitialPage if any associated with the specified
   // |web_contents| (used by ui tests).
   static InterstitialPage* GetInterstitialPage(
       content::WebContents* web_contents);
 
-  // Sub-classes should return the HTML that should be displayed in the page.
-  virtual std::string GetHTMLContents();
-
-  // Invoked when the page sent a command through DOMAutomation.
-  virtual void CommandReceived(const std::string& command) {}
-
   // Reverts to the page showing before the interstitial.
   // Sub-classes should call this method when the user has chosen NOT to proceed
   // to the target URL.
   // Warning: if |new_navigation| was set to true in the constructor, 'this'
   //          will be deleted when this method returns.
   virtual void DontProceed();
 
   // Sub-classes should call this method when the user has chosen to proceed to
   // the target URL.
   // Warning: 'this' has been deleted when this method returns.
   virtual void Proceed();
 
   // Allows the user to navigate away by disabling the interstitial, canceling
   // the pending request, and unblocking the hidden renderer.  The interstitial
   // will stay visible until the navigation completes.
   void CancelForNavigation();
 
   // Sizes the RenderViewHost showing the actual interstitial page contents.
   void SetSize(const gfx::Size& size);
 
   ActionState action_taken() const { return action_taken_; }
 
   // Sets the focus to the interstitial.
   void Focus();
 
   // Focus the first (last if reverse is true) element in the interstitial page.
   // Called when tab traversing.
   void FocusThroughTabTraversal(bool reverse);
 
-  virtual content::ViewType GetRenderViewType() const OVERRIDE;
-
-  virtual gfx::Rect GetRootWindowResizerRect() const OVERRIDE;
-
   // See description above field.
   void set_reload_on_dont_proceed(bool value) {
     reload_on_dont_proceed_ = value;
   }
   bool reload_on_dont_proceed() const { return reload_on_dont_proceed_; }
 
+  RenderViewHost* render_view_host() const { return render_view_host_; }
+
+  content::InterstitialPageDelegate* GetDelegateForTesting();
+  void DontCreateViewForTesting();
+
  protected:
   // content::NotificationObserver method:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // RenderViewHostDelegate implementation:
   virtual View* GetViewDelegate() OVERRIDE;
   virtual const GURL& GetURL() const OVERRIDE;
   virtual void RenderViewGone(RenderViewHost* render_view_host,
                               base::TerminationStatus status,
                               int error_code) OVERRIDE;
   virtual void DidNavigate(
       RenderViewHost* render_view_host,
       const ViewHostMsg_FrameNavigate_Params& params) OVERRIDE;
   virtual void UpdateTitle(RenderViewHost* render_view_host,
                            int32 page_id,
                            const string16& title,
                            base::i18n::TextDirection title_direction) OVERRIDE;
   virtual content::RendererPreferences GetRendererPrefs(
       content::BrowserContext* browser_context) const OVERRIDE;
   virtual WebPreferences GetWebkitPrefs() OVERRIDE;
   virtual bool PreHandleKeyboardEvent(const NativeWebKeyboardEvent& event,
                                       bool* is_keyboard_shortcut) OVERRIDE;
   virtual void HandleKeyboardEvent(
       const NativeWebKeyboardEvent& event) OVERRIDE;
-
-  // Invoked with the NavigationEntry that is going to be added to the
-  // navigation controller.
-  // Gives an opportunity to sub-classes to set states on the |entry|.
-  // Note that this is only called if the InterstitialPage was constructed with
-  // |create_navigation_entry| set to true.
-  virtual void UpdateEntry(content::NavigationEntry* entry) {}
+  virtual content::ViewType GetRenderViewType() const OVERRIDE;
+  virtual gfx::Rect GetRootWindowResizerRect() const OVERRIDE;
 
   bool enabled() const { return enabled_; }
   content::WebContents* tab() const;
   const GURL& url() const { return url_; }
-  RenderViewHost* render_view_host() const { return render_view_host_; }
-  void set_renderer_preferences(const content::RendererPreferences& prefs) {
-    renderer_preferences_ = prefs;
-  }
 
   // Creates the RenderViewHost containing the interstitial content.
   // Overriden in unit tests.
   virtual RenderViewHost* CreateRenderViewHost();
 
   // Creates the WebContentsView that shows the interstitial RVH.
   // Overriden in unit tests.
   virtual content::WebContentsView* CreateWebContentsView();
 
   // Notification magic.
@@ skipping 73 matching lines @@
 
   // Our RenderViewHostViewDelegate, necessary for accelerators to work.
   scoped_ptr<InterstitialPageRVHViewDelegate> rvh_view_delegate_;
 
   // We keep a map of the various blocking pages shown as the UI tests need to
   // be able to retrieve them.
   typedef std::map<TabContents*, InterstitialPage*> InterstitialPageMap;
   static InterstitialPageMap* tab_to_interstitial_page_;
 
   // Settings passed to the renderer.
-  content::RendererPreferences renderer_preferences_;
+  mutable content::RendererPreferences renderer_preferences_;
+
+  bool create_view_;
+
+  scoped_ptr<content::InterstitialPageDelegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(InterstitialPage);
 };
 
 #endif  // CONTENT_BROWSER_TAB_CONTENTS_INTERSTITIAL_PAGE_H_