Fix for WebContents unit tests memory trashing

chrome/browser/web_contents_unittest.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 "base/logging.h"
 #include "chrome/browser/interstitial_page.h"
 #include "chrome/browser/navigation_controller.h"
 #include "chrome/browser/navigation_entry.h"
 #include "chrome/browser/render_view_host.h"
 #include "chrome/browser/render_widget_host_view.h"
@@ skipping 240 matching lines @@
 };
 
 class TestInterstitialPage : public InterstitialPage {
  public:
   enum InterstitialState {
     UNDECIDED = 0, // No decision taken yet.
     OKED,          // Proceed was called.
     CANCELED       // DontProceed was called.
   };
 
+  class Delegate {
+   public:
+    virtual void TestInterstitialPageDeleted(
+        TestInterstitialPage* interstitial) = 0;
+  };
+
   // IMPORTANT NOTE: if you pass stack allocated values for |state| and
   // |deleted| (like all interstitial related tests do at this point), make sure
   // to create an instance of the TestInterstitialPageStateGuard class on the
   // stack in your test.  This will ensure that the TestInterstitialPage states
   // 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(WebContents* tab,
                        bool new_navigation,
                        const GURL& url,
                        InterstitialState* state,
                        bool* deleted)
       : InterstitialPage(tab, new_navigation, url),
         state_(state),
         deleted_(deleted),
-        command_received_count_(0) {
+        command_received_count_(0),
+        delegate_(NULL) {
     *state_ = UNDECIDED;
     *deleted_ = false;
   }
 
   virtual ~TestInterstitialPage() {
     if (deleted_)
       *deleted_ = true;
+    if (delegate_)
+      delegate_->TestInterstitialPageDeleted(this);
   }
 
   virtual void DontProceed() {
     if (state_)
       *state_ = CANCELED;
     InterstitialPage::DontProceed();
   }
   virtual void Proceed() {
     if (state_)
       *state_ = OKED;
@@ skipping 19 matching lines @@
   }
 
   bool is_showing() const {
     return static_cast<TestRenderWidgetHostView*>(render_view_host()->view())->
         is_showing();
   }
 
   void ClearStates() {
     state_ = NULL;
     deleted_ = NULL;
+    delegate_ = NULL;
+  }
+
+  void set_delegate(Delegate* delegate) {
+    delegate_ = delegate;
   }
 
  protected:
   virtual RenderViewHost* CreateRenderViewHost() {
     return new TestRenderViewHost(
         SiteInstance::CreateSiteInstance(tab()->profile()),
         this, MSG_ROUTING_NONE, NULL);
   }
  
   virtual void CommandReceived(const std::string& command) {
     command_received_count_++;
   }
 
  private:
   InterstitialState* state_;
   bool* deleted_;
   int command_received_count_;
+  Delegate* delegate_;
 };
 
-class TestInterstitialPageStateGuard {
+class TestInterstitialPageStateGuard : public TestInterstitialPage::Delegate {
  public:
   explicit TestInterstitialPageStateGuard(
       TestInterstitialPage* interstitial_page)
       : interstitial_page_(interstitial_page) {
     DCHECK(interstitial_page_);
+    interstitial_page_->set_delegate(this);
   }
   ~TestInterstitialPageStateGuard() {
-    interstitial_page_->ClearStates();
+    if (interstitial_page_)
+      interstitial_page_->ClearStates();
+  }
+
+  virtual void TestInterstitialPageDeleted(TestInterstitialPage* interstitial) {
+    DCHECK(interstitial_page_ == interstitial);
+    interstitial_page_ = NULL;
   }
 
  private:
   TestInterstitialPage* interstitial_page_;
 };
 
 class WebContentsTest : public testing::Test {
  public:
   WebContentsTest() : contents(NULL) {}
 
@@ skipping 397 matching lines @@
 
   // These should still be the default values.
   EXPECT_EQ(L"Times New Roman", webkit_prefs.standard_font_family);
   EXPECT_EQ(true, webkit_prefs.javascript_enabled);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Interstitial Tests
 ////////////////////////////////////////////////////////////////////////////////
 
-// All the tests have been temporarily disabled while investigating a heap
-// corruption problem showing up on the build bot.
-// TODO(jcampan): bug #5789 Fix and reenable these tests.
-
 // Test navigating to a page (with the navigation initiated from the browser,
 // as when a URL is typed in the location bar) that shows an interstitial and
 // creates a new navigation entry, then hiding it without proceeding.
 TEST_F(WebContentsTest,
-       DISABLED_ShowInterstitialFromBrowserWithNewNavigationDontProceed) {
+       ShowInterstitialFromBrowserWithNewNavigationDontProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
   Navigate(1, url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 
   // Initiate a browser navigation that will trigger the interstitial
   contents->controller()->LoadURL(GURL("http://www.evil.com"), GURL(),
                                   PageTransition::TYPED);
 
   // Show an interstitial.
@@ skipping 27 matching lines @@
   entry = contents->controller()->GetActiveEntry();
   ASSERT_TRUE(entry != NULL);
   EXPECT_TRUE(entry->url() == url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 }
 
 // Test navigating to a page (with the navigation initiated from the renderer,
 // as when clicking on a link in the page) that shows an interstitial and
 // creates a new navigation entry, then hiding it without proceeding.
 TEST_F(WebContentsTest,
-       DISABLED_ShowInterstitiaFromRendererlWithNewNavigationDontProceed) {
+       ShowInterstitiaFromRendererlWithNewNavigationDontProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
   Navigate(1, url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 
   // Show an interstitial (no pending entry, the interstitial would have been
   // triggered by clicking on a link).
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
@@ skipping 23 matching lines @@
   EXPECT_TRUE(contents->interstitial_page() == NULL);
   entry = contents->controller()->GetActiveEntry();
   ASSERT_TRUE(entry != NULL);
   EXPECT_TRUE(entry->url() == url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 }
 
 // Test navigating to a page that shows an interstitial without creating a new
 // navigation entry (this happens when the interstitial is triggered by a
 // sub-resource in the page), then hiding it without proceeding.
-TEST_F(WebContentsTest,
-       DISABLED_ShowInterstitialNoNewNavigationDontProceed) {
+TEST_F(WebContentsTest, ShowInterstitialNoNewNavigationDontProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
   Navigate(1, url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url2("http://interstitial");
@@ skipping 24 matching lines @@
   entry = contents->controller()->GetActiveEntry();
   ASSERT_TRUE(entry != NULL);
   EXPECT_TRUE(entry->url() == url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 }
 
 // Test navigating to a page (with the navigation initiated from the browser,
 // as when a URL is typed in the location bar) that shows an interstitial and
 // creates a new navigation entry, then proceeding.
 TEST_F(WebContentsTest,
-       DISABLED_ShowInterstitialFromBrowserNewNavigationProceed) {
+       ShowInterstitialFromBrowserNewNavigationProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
   Navigate(1, url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 
   // Initiate a browser navigation that will trigger the interstitial
   contents->controller()->LoadURL(GURL("http://www.evil.com"), GURL(),
                                   PageTransition::TYPED);
 
   // Show an interstitial.
@@ skipping 38 matching lines @@
   ASSERT_TRUE(entry != NULL);
   EXPECT_TRUE(entry->url() == url3);
 
   EXPECT_EQ(2, contents->controller()->GetEntryCount());
 }
 
 // Test navigating to a page (with the navigation initiated from the renderer,
 // as when clicking on a link in the page) that shows an interstitial and
 // creates a new navigation entry, then proceeding.
 TEST_F(WebContentsTest,
-       DISABLED_ShowInterstitialFromRendererNewNavigationProceed) {
+       ShowInterstitialFromRendererNewNavigationProceed) {
   // Navigate to a page.
   GURL url1("http://www.google.com");
   Navigate(1, url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url2("http://interstitial");
@@ skipping 33 matching lines @@
   entry = contents->controller()->GetActiveEntry();
   ASSERT_TRUE(entry != NULL);
   EXPECT_TRUE(entry->url() == url3);
 
   EXPECT_EQ(2, contents->controller()->GetEntryCount());
 }
 
 // Test navigating to a page that shows an interstitial without creating a new
 // navigation entry (this happens when the interstitial is triggered by a
 // sub-resource in the page), then proceeding.
-TEST_F(WebContentsTest, DISABLED_ShowInterstitialNoNewNavigationProceed) {
+TEST_F(WebContentsTest, ShowInterstitialNoNewNavigationProceed) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL url1("http://www.google.com");
   Navigate(1, url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url2("http://interstitial");
@@ skipping 24 matching lines @@
   EXPECT_FALSE(contents->showing_interstitial_page());
   EXPECT_TRUE(contents->interstitial_page() == NULL);
   entry = contents->controller()->GetActiveEntry();
   ASSERT_TRUE(entry != NULL);
   EXPECT_TRUE(entry->url() == url1);
 
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 }
 
 // Test navigating to a page that shows an interstitial, then navigating away.
-TEST_F(WebContentsTest, DISABLED_ShowInterstitialThenNavigate) {
+TEST_F(WebContentsTest, ShowInterstitialThenNavigate) {
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents, true, url, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   interstitial->TestDidNavigate(1, url);
 
   // While interstitial showing, navigate to a new URL.
   const GURL url2("http://www.yahoo.com");
   Navigate(1, url2);
 
   EXPECT_TRUE(deleted);
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 }
 
 // Test navigating to a page that shows an interstitial, then close the tab.
-TEST_F(WebContentsTest, DISABLED_ShowInterstitialThenCloseTab) {
+TEST_F(WebContentsTest, ShowInterstitialThenCloseTab) {
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents, true, url, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   interstitial->TestDidNavigate(1, url);
 
   // Now close the tab.
   contents->CloseContents();
   contents = NULL;  // So we don't detroy it again on TearDown.
   EXPECT_TRUE(deleted);
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 }
 
 // Test that after Proceed is called and an interstitial is still shown, no more
 // commands get executed.
-TEST_F(WebContentsTest, DISABLED_ShowInterstitialProceedMultipleCommands) {
+TEST_F(WebContentsTest, ShowInterstitialProceedMultipleCommands) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL url1("http://www.google.com");
   Navigate(1, url1);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url2("http://interstitial");
@@ skipping 13 matching lines @@
   ASSERT_FALSE(deleted);
 
   // While the navigation to the new page is pending, send other commands, they
   // should be ignored.
   interstitial->TestDomOperationResponse("hello");
   interstitial->TestDomOperationResponse("hi");
   EXPECT_EQ(1, interstitial->command_received_count());
 }
 
 // Test showing an interstitial while another interstitial is already showing.
-TEST_F(WebContentsTest, DISABLED_ShowInterstitialOnInterstitial) {
+TEST_F(WebContentsTest, ShowInterstitialOnInterstitial) {
   // Navigate to a page so we have a navigation entry in the controller.
   GURL start_url("http://www.google.com");
   Navigate(1, start_url);
   EXPECT_EQ(1, contents->controller()->GetEntryCount());
 
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state1 =
       TestInterstitialPage::UNDECIDED;
   bool deleted1 = false;
   GURL url1("http://interstitial1");
@@ skipping 29 matching lines @@
   EXPECT_FALSE(contents->showing_interstitial_page());
   EXPECT_TRUE(contents->interstitial_page() == NULL);
   NavigationEntry* entry = contents->controller()->GetActiveEntry();
   ASSERT_TRUE(entry != NULL);
   EXPECT_TRUE(entry->url() == landing_url);
   EXPECT_EQ(2, contents->controller()->GetEntryCount());
 }
 
 // Test that navigating away from an interstitial while it's loading cause it
 // not to show.
-TEST_F(WebContentsTest, DISABLED_NavigateBeforeInterstitialShows) {
+TEST_F(WebContentsTest, NavigateBeforeInterstitialShows) {
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL interstitial_url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents, true, interstitial_url,
                                &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
 
   // Let's simulate a navigation initiated from the browser before the
   // interstitial finishes loading.
   const GURL url("http://www.google.com");
   contents->controller()->LoadURL(url, GURL(), PageTransition::TYPED);
   ASSERT_FALSE(deleted);
   EXPECT_FALSE(interstitial->is_showing());
 
   // Now let's make the interstitial navigation commit.
   interstitial->TestDidNavigate(1, interstitial_url);
 
   // After it loaded the interstitial should be gone.
   EXPECT_TRUE(deleted);
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 }
 
 // Test showing an interstitial and have its renderer crash.
-TEST_F(WebContentsTest, DISABLED_InterstitialCrasher) {
+TEST_F(WebContentsTest, InterstitialCrasher) {
   // Show an interstitial.
   TestInterstitialPage::InterstitialState state =
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents, true, url, &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   // Simulate a renderer crash before the interstitial is shown.
   interstitial->TestRendererGone();
   // The interstitial should have been dismissed.
   EXPECT_TRUE(deleted);
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 
   // Now try again but this time crash the intersitial after it was shown.
   interstitial =
       new TestInterstitialPage(contents, true, url, &state, &deleted);
   interstitial->Show();
   interstitial->TestDidNavigate(1, url);
   // Simulate a renderer crash.
   interstitial->TestRendererGone();
   // The interstitial should have been dismissed.
   EXPECT_TRUE(deleted);
   EXPECT_EQ(TestInterstitialPage::CANCELED, state);
 }