Sprinkle some defensiveness into the UI tests so that they don't explode if t...

chrome/browser/tab_restore_uitest.cc

 // Copyright (c) 2006-2009 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/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #if defined(OS_WIN)
 #include "base/win_util.h"
 #endif
@@ skipping 63 matching lines @@
       int new_tab_count = 0;
       ASSERT_TRUE(browser_proxy->GetTabCount(&new_tab_count));
       EXPECT_EQ(++tab_count, new_tab_count);
     }
 
     // Get a handle to the restored tab.
     ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
     ASSERT_GT(tab_count, expected_tabstrip_index);
     scoped_refptr<TabProxy> restored_tab_proxy(
         browser_proxy->GetTab(expected_tabstrip_index));
+    ASSERT_TRUE(restored_tab_proxy.get());
     // Wait for the restored tab to finish loading.
     ASSERT_TRUE(restored_tab_proxy->WaitForTabToBeRestored(
         action_max_timeout_ms()));
 
     // Ensure that the tab and window are active.
     CheckActiveWindow(browser_proxy.get());
     EXPECT_EQ(expected_tabstrip_index,
         GetActiveTabIndex(expected_window_index));
   }
 
@@ skipping 48 matching lines @@
 // in its original position, and active.
 TEST_F(TabRestoreUITest, Basic) {
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
 
   int starting_tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&starting_tab_count));
   int tab_count = AddSomeTabs(browser_proxy.get(), 1);
 
   int closed_tab_index = tab_count - 1;
   scoped_refptr<TabProxy> new_tab(browser_proxy->GetTab(closed_tab_index));
+  ASSERT_TRUE(new_tab.get());
   // Make sure we're at url.
   new_tab->NavigateToURL(url1_);
   // Close the tab.
   new_tab->Close(true);
   new_tab = NULL;
   ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
   EXPECT_EQ(starting_tab_count, tab_count);
 
   RestoreTab(0, closed_tab_index);
 
   // And make sure everything looks right.
   ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
   EXPECT_EQ(starting_tab_count + 1, tab_count);
   EXPECT_EQ(closed_tab_index, GetActiveTabIndex());
   EXPECT_EQ(url1_, GetActiveTabURL());
 }
 
 // Close a tab not at the end of the current window, then restore it. The tab
 // should be in its original position, and active.
 TEST_F(TabRestoreUITest, MiddleTab) {
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
 
   int starting_tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&starting_tab_count));
   int tab_count = AddSomeTabs(browser_proxy.get(), 3);
 
   // Close one in the middle
   int closed_tab_index = starting_tab_count + 1;
   scoped_refptr<TabProxy> new_tab(browser_proxy->GetTab(closed_tab_index));
+  ASSERT_TRUE(new_tab.get());
   // Make sure we're at url.
   new_tab->NavigateToURL(url1_);
   // Close the tab.
   new_tab->Close(true);
   new_tab = NULL;
   ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
   EXPECT_EQ(starting_tab_count + 2, tab_count);
 
   RestoreTab(0, closed_tab_index);
 
@@ skipping 15 matching lines @@
   // CheckActiveWindow(). See comments in that function.
   CheckActiveWindow(browser_proxy.get());
 
   int starting_tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&starting_tab_count));
   int tab_count = AddSomeTabs(browser_proxy.get(), 3);
 
   // Close one in the middle
   int closed_tab_index = starting_tab_count + 1;
   scoped_refptr<TabProxy> new_tab(browser_proxy->GetTab(closed_tab_index));
+  ASSERT_TRUE(new_tab.get());
   // Make sure we're at url.
   new_tab->NavigateToURL(url1_);
   // Close the tab.
   new_tab->Close(true);
   new_tab = NULL;
   ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
   EXPECT_EQ(starting_tab_count + 2, tab_count);
 
   // Create a new browser.
   ASSERT_TRUE(automation()->OpenNewBrowserWindow(false));
@@ skipping 19 matching lines @@
 TEST_F(TabRestoreUITest, MAYBE_BasicRestoreFromClosedWindow) {
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   CheckActiveWindow(browser_proxy.get());
 
   int tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
 
   // Close tabs until we only have one open.
   while (tab_count > 1) {
     scoped_refptr<TabProxy> tab_to_close(browser_proxy->GetTab(0));
+    ASSERT_TRUE(tab_to_close.get());
     tab_to_close->Close(true);
     ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
   }
 
   // Navigate to url1 then url2.
   scoped_refptr<TabProxy> tab_proxy(browser_proxy->GetTab(0));
+  ASSERT_TRUE(tab_proxy.get());
   tab_proxy->NavigateToURL(url1_);
   tab_proxy->NavigateToURL(url2_);
 
   // Create a new browser.
   ASSERT_TRUE(automation()->OpenNewBrowserWindow(false));
   int window_count;
   ASSERT_TRUE(automation()->GetBrowserWindowCount(&window_count));
   EXPECT_EQ(2, window_count);
   CheckActiveWindow(automation()->GetBrowserWindow(1));
 
   // Close the final tab in the first browser.
   EXPECT_TRUE(tab_proxy->Close(true));
   ASSERT_TRUE(automation()->WaitForWindowCountToBecome(
       1, action_max_timeout_ms()));
 
   // Tab and browser are no longer valid.
   tab_proxy = NULL;
   browser_proxy = NULL;
 
   RestoreTab(1, 0);
 
   // Tab should be in a new window.
   browser_proxy = automation()->GetBrowserWindow(1);
   CheckActiveWindow(browser_proxy.get());
   tab_proxy = browser_proxy->GetActiveTab();
+  ASSERT_TRUE(tab_proxy.get());
   // And make sure the URLs matches.
   EXPECT_EQ(url2_, GetActiveTabURL(1));
   EXPECT_TRUE(tab_proxy->GoBack());
   EXPECT_EQ(url1_, GetActiveTabURL(1));
 }
 
 // Restore a tab then make sure it doesn't restore again.
 // Disabled because the command updater doesn't know the proper state of
 // the tab restore command. http://crbug.com/14428.
 TEST_F(TabRestoreUITest, DISABLED_DontLoadRestoredTab) {
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   CheckActiveWindow(browser_proxy.get());
 
   // Add two tabs
   int starting_tab_count = 0;
   ASSERT_TRUE(browser_proxy->GetTabCount(&starting_tab_count));
   AddSomeTabs(browser_proxy.get(), 2);
   int current_tab_count = 0;
   ASSERT_TRUE(browser_proxy->GetTabCount(&current_tab_count));
   ASSERT_EQ(current_tab_count, starting_tab_count + 2);
 
   // Close one of them.
   scoped_refptr<TabProxy> tab_to_close(browser_proxy->GetTab(0));
+  ASSERT_TRUE(tab_to_close.get());
   tab_to_close->Close(true);
   ASSERT_TRUE(browser_proxy->GetTabCount(&current_tab_count));
   ASSERT_EQ(current_tab_count, starting_tab_count + 1);
 
   // Restore it.
   RestoreTab(0, 0);
   ASSERT_TRUE(browser_proxy->GetTabCount(&current_tab_count));
   ASSERT_EQ(current_tab_count, starting_tab_count + 2);
 
   // Make sure that there's nothing else to restore.
@@ skipping 14 matching lines @@
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   CheckActiveWindow(browser_proxy.get());
 
   int starting_tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&starting_tab_count));
   int tab_count = AddSomeTabs(browser_proxy.get(), 3);
 
   // Close one in the middle
   int closed_tab_index = starting_tab_count + 1;
   scoped_refptr<TabProxy> new_tab(browser_proxy->GetTab(closed_tab_index));
+  ASSERT_TRUE(new_tab.get());
   // Make sure we're at url.
   new_tab->NavigateToURL(url1_);
   // Close the tab.
   new_tab->Close(true);
   new_tab = NULL;
   ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
   EXPECT_EQ(starting_tab_count + 2, tab_count);
 
   // Create a new browser.
   ASSERT_TRUE(automation()->OpenNewBrowserWindow(false));
@@ skipping 33 matching lines @@
 TEST_F(TabRestoreUITest, RestoreIntoSameWindow) {
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   CheckActiveWindow(browser_proxy.get());
 
   int starting_tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&starting_tab_count));
   int tab_count = AddSomeTabs(browser_proxy.get(), 2);
 
   // Navigate the rightmost one to url2_ for easier identification.
   scoped_refptr<TabProxy> tab_proxy(browser_proxy->GetTab(tab_count - 1));
+  ASSERT_TRUE(tab_proxy.get());
   tab_proxy->NavigateToURL(url2_);
 
   // Create a new browser.
   ASSERT_TRUE(automation()->OpenNewBrowserWindow(false));
   int window_count;
   ASSERT_TRUE(automation()->GetBrowserWindowCount(&window_count));
   EXPECT_EQ(2, window_count);
   CheckActiveWindow(automation()->GetBrowserWindow(1));
 
   // Close all but one tab in the first browser, left to right.
   while (tab_count > 1) {
     scoped_refptr<TabProxy> tab_to_close(browser_proxy->GetTab(0));
+    ASSERT_TRUE(tab_to_close.get());
     tab_to_close->Close(true);
     ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
   }
 
   // Close the last tab, closing the browser.
   tab_proxy = browser_proxy->GetTab(0);
+  ASSERT_TRUE(tab_proxy.get());
   EXPECT_TRUE(tab_proxy->Close(true));
   ASSERT_TRUE(automation()->WaitForWindowCountToBecome(
       1, action_max_timeout_ms()));
   browser_proxy = NULL;
   tab_proxy = NULL;
 
   // Restore the last-closed tab into a new window.
   RestoreTab(1, 0);
   browser_proxy = automation()->GetBrowserWindow(1);
   CheckActiveWindow(browser_proxy.get());
@@ skipping 22 matching lines @@
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   int tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
 
   // Add a tab
   browser_proxy->AppendTab(http_url1);
   int new_tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&new_tab_count));
   EXPECT_EQ(++tab_count, new_tab_count);
   scoped_refptr<TabProxy> tab(browser_proxy->GetTab(tab_count - 1));
+  ASSERT_TRUE(tab.get());
 
   // Navigate to another same-site URL.
   tab->NavigateToURL(http_url2);
 
   // Close the tab.
   tab->Close(true);
   tab = NULL;
 
   // Create a new tab to the original site.  Assuming process-per-site is
   // enabled, this will ensure that the SiteInstance used by the restored tab
   // will already exist when the restore happens.
   browser_proxy->AppendTab(http_url2);
 
   // Restore the closed tab.
   RestoreTab(0, tab_count - 1);
   tab = browser_proxy->GetActiveTab();
+  ASSERT_TRUE(tab.get());
 
   // And make sure the URLs match.
   EXPECT_EQ(http_url2, GetActiveTabURL());
   EXPECT_TRUE(tab->GoBack());
   EXPECT_EQ(http_url1, GetActiveTabURL());
 }
 
 // Tests that the SiteInstances used for entries in a restored tab's history
 // are given appropriate max page IDs, even if the renderer for the entry
 // already exists.  (Bug 1204135)
 TEST_F(TabRestoreUITest, RestoreCrossSiteWithExistingSiteInstance) {
   const wchar_t kDocRoot[] = L"chrome/test/data";
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(kDocRoot, NULL);
   ASSERT_TRUE(NULL != server.get());
   GURL http_url1(server->TestServerPageW(L"files/title1.html"));
   GURL http_url2(server->TestServerPageW(L"files/title2.html"));
 
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   int tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&tab_count));
 
   // Add a tab
   browser_proxy->AppendTab(http_url1);
   int new_tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&new_tab_count));
   EXPECT_EQ(++tab_count, new_tab_count);
   scoped_refptr<TabProxy> tab(browser_proxy->GetTab(tab_count - 1));
+  ASSERT_TRUE(tab.get());
 
   // Navigate to more URLs, then a cross-site URL.
   tab->NavigateToURL(http_url2);
   tab->NavigateToURL(http_url1);
   tab->NavigateToURL(url1_);
 
   // Close the tab.
   tab->Close(true);
   tab = NULL;
 
   // Create a new tab to the original site.  Assuming process-per-site is
   // enabled, this will ensure that the SiteInstance will already exist when
   // the user clicks Back in the restored tab.
   browser_proxy->AppendTab(http_url2);
 
   // Restore the closed tab.
   RestoreTab(0, tab_count - 1);
   tab = browser_proxy->GetActiveTab();
+  ASSERT_TRUE(tab.get());
 
   // And make sure the URLs match.
   EXPECT_EQ(url1_, GetActiveTabURL());
   EXPECT_TRUE(tab->GoBack());
   EXPECT_EQ(http_url1, GetActiveTabURL());
 
   // Navigating to a new URL should clear the forward list, because the max
   // page ID of the renderer should have been updated when we restored the tab.
   tab->NavigateToURL(http_url2);
   EXPECT_FALSE(tab->GoForward());
@@ skipping 10 matching lines @@
   EXPECT_EQ(++window_count, new_window_count);
 
   // Create two more tabs, one with url1, the other url2.
   scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   int initial_tab_count;
   ASSERT_TRUE(browser_proxy->GetTabCount(&initial_tab_count));
   browser_proxy->AppendTab(url1_);
   ASSERT_TRUE(browser_proxy->WaitForTabCountToBecome(initial_tab_count + 1,
                                                      action_max_timeout_ms()));
   scoped_refptr<TabProxy> new_tab(browser_proxy->GetTab(initial_tab_count));
+  ASSERT_TRUE(new_tab.get());
   new_tab->NavigateToURL(url1_);
   browser_proxy->AppendTab(url2_);
   ASSERT_TRUE(browser_proxy->WaitForTabCountToBecome(initial_tab_count + 2,
                                                      action_max_timeout_ms()));
   new_tab = browser_proxy->GetTab(initial_tab_count + 1);
+  ASSERT_TRUE(new_tab.get());
   new_tab->NavigateToURL(url2_);
 
   // Close the window.
   ASSERT_TRUE(browser_proxy->RunCommand(IDC_CLOSE_WINDOW));
   browser_proxy = NULL;
   new_tab = NULL;
   ASSERT_TRUE(automation()->GetBrowserWindowCount(&new_window_count));
   EXPECT_EQ(window_count - 1, new_window_count);
 
   // Restore the window.
   browser_proxy = automation()->GetBrowserWindow(0);
   ASSERT_TRUE(browser_proxy->RunCommand(IDC_RESTORE_TAB));
   ASSERT_TRUE(automation()->GetBrowserWindowCount(&new_window_count));
   EXPECT_EQ(window_count, new_window_count);
 
   browser_proxy = automation()->GetBrowserWindow(1);
   int tab_count;
   EXPECT_TRUE(browser_proxy->GetTabCount(&tab_count));
   EXPECT_EQ(initial_tab_count + 2, tab_count);
 
   scoped_refptr<TabProxy> restored_tab_proxy(
         browser_proxy->GetTab(initial_tab_count));
+  ASSERT_TRUE(restored_tab_proxy.get());
   ASSERT_TRUE(restored_tab_proxy->WaitForTabToBeRestored(action_timeout_ms()));
   GURL url;
   ASSERT_TRUE(restored_tab_proxy->GetCurrentURL(&url));
   EXPECT_TRUE(url == url1_);
 
   restored_tab_proxy = browser_proxy->GetTab(initial_tab_count + 1);
+  ASSERT_TRUE(restored_tab_proxy.get());
   ASSERT_TRUE(restored_tab_proxy->WaitForTabToBeRestored(action_timeout_ms()));
   ASSERT_TRUE(restored_tab_proxy->GetCurrentURL(&url));
   EXPECT_TRUE(url == url2_);
 }