Make pink's TabContentsWrapper change compile on Windows....

chrome/browser/ui/browser_navigator_browsertest.cc

 // Copyright (c) 2010 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 "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
+#include "chrome/browser/tab_contents_wrapper.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "ipc/ipc_message.h"
 
 namespace {
 
 class BrowserNavigatorTest : public InProcessBrowserTest {
@@ skipping 11 matching lines @@
     params.show_window = true;
     return params;
   }
 
   Browser* CreateEmptyBrowserForType(Browser::Type type, Profile* profile) {
     Browser* browser = Browser::CreateForType(type, profile);
     browser->AddBlankTab(true);
     return browser;
   }
 
-  TabContents* CreateTabContents() {
-    return new TabContents(browser()->profile(),
-                           NULL,
-                           MSG_ROUTING_NONE,
-                           browser()->GetSelectedTabContents(),
-                           NULL);
+  TabContentsWrapper* CreateTabContents() {
+    return Browser::TabContentsFactory(
+        browser()->profile(),
+        NULL,
+        MSG_ROUTING_NONE,
+        browser()->GetSelectedTabContents(),
+        NULL);
   }
 
   void RunSuppressTest(WindowOpenDisposition disposition) {
     GURL old_url = browser()->GetSelectedTabContents()->GetURL();
     browser::NavigateParams p(MakeNavigateParams());
     p.disposition = disposition;
     browser::Navigate(&p);
 
     // Nothing should have happened as a result of Navigate();
     EXPECT_EQ(1, browser()->tab_count());
@@ skipping 60 matching lines @@
 
 // This test verifies that when a navigation results in a foreground tab, the
 // tab count of the Browser increases and the selected tab shifts to the new
 // foreground tab.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewForegroundTab) {
   TabContents* old_contents = browser()->GetSelectedTabContents();
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_FOREGROUND_TAB;
   browser::Navigate(&p);
   EXPECT_NE(old_contents, browser()->GetSelectedTabContents());
-  EXPECT_EQ(browser()->GetSelectedTabContents(), p.target_contents);
+  EXPECT_EQ(browser()->GetSelectedTabContentsWrapper(), p.target_contents);
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 // This test verifies that when a navigation results in a background tab, the
 // tab count of the Browser increases but the selected tab remains the same.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewBackgroundTab) {
   TabContents* old_contents = browser()->GetSelectedTabContents();
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_BACKGROUND_TAB;
   browser::Navigate(&p);
@@ skipping 195 matching lines @@
 // This tests adding a foreground tab with a predefined TabContents.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, TargetContents_ForegroundTab) {
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_FOREGROUND_TAB;
   p.target_contents = CreateTabContents();
   browser::Navigate(&p);
 
   // Navigate() should have opened the contents in a new foreground in the
   // current Browser.
   EXPECT_EQ(browser(), p.browser);
-  EXPECT_EQ(browser()->GetSelectedTabContents(), p.target_contents);
+  EXPECT_EQ(browser()->GetSelectedTabContentsWrapper(), p.target_contents);
 
   // We should have one window, with two tabs.
   EXPECT_EQ(1u, BrowserList::size());
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 #if defined(OS_WIN)
 // This tests adding a popup with a predefined TabContents.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, TargetContents_Popup) {
   browser::NavigateParams p(MakeNavigateParams());
@@ skipping 14 matching lines @@
   // p.window_bounds.origin(), but its size will not. We need to match
   // the size against the selected tab's view's container size.
   // Only Windows positions the window according to |p.window_bounds.origin()| -
   // on Mac the window is offset from the opener and on Linux it always opens
   // at 0,0.
   EXPECT_EQ(p.window_bounds.origin(),
             p.browser->window()->GetRestoredBounds().origin());
   // All platforms should respect size however provided width > 400 (Mac has a
   // minimum window width of 400).
   EXPECT_EQ(p.window_bounds.size(),
-            p.target_contents->view()->GetContainerSize());
+            p.target_contents->tab_contents()->view()->GetContainerSize());
 
   // We should have two windows, the new popup and the browser() provided by the
   // framework.
   EXPECT_EQ(2u, BrowserList::size());
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(1, p.browser->tab_count());
 }
 #endif
 
 // This tests adding a tab at a specific index.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Tabstrip_InsertAtIndex) {
   // This is not meant to be a comprehensive test of whether or not the tab
   // implementation of the browser observes the insertion index. That is
   // covered by the unit tests for TabStripModel. This merely verifies that
   // insertion index preference is reflected in common cases.
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_FOREGROUND_TAB;
   p.tabstrip_index = 0;
   p.tabstrip_add_types = TabStripModel::ADD_FORCE_INDEX;
   browser::Navigate(&p);
 
   // Navigate() should have inserted a new tab at slot 0 in the tabstrip.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(0, browser()->tabstrip_model()->GetIndexOfTabContents(
-      static_cast<const TabContents*>(p.target_contents)));
+      static_cast<const TabContentsWrapper*>(p.target_contents)));
 
   // We should have one window - the browser() provided by the framework.
   EXPECT_EQ(1u, BrowserList::size());
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 // This test verifies that constructing params with a NULL browser has
 // the same result as navigating to a new foreground tab in the (only)
 // active browser. Tests are the same as for Disposition_NewForegroundTab.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, NullBrowser_NewForegroundTab) {
   TabContents* old_contents = browser()->GetSelectedTabContents();
   // Navigate with a NULL browser.
   browser::NavigateParams p(MakeNavigateParams(NULL));
   p.disposition = NEW_FOREGROUND_TAB;
   p.profile = browser()->profile();
   browser::Navigate(&p);
 
   // Navigate() should have found browser() and create a new tab.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_NE(old_contents, browser()->GetSelectedTabContents());
-  EXPECT_EQ(browser()->GetSelectedTabContents(), p.target_contents);
+  EXPECT_EQ(browser()->GetSelectedTabContentsWrapper(), p.target_contents);
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 // This test verifies that constructing params with a NULL browser and
 // a specific profile matches the specified profile.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, NullBrowser_MatchProfile) {
   // Create a new browser with using the incognito profile.
   Browser* incognito =
       Browser::Create(browser()->profile()->GetOffTheRecordProfile());
 
   // Navigate with a NULL browser and the incognito profile.
   browser::NavigateParams p(MakeNavigateParams(NULL));
   p.disposition = NEW_FOREGROUND_TAB;
   p.profile = incognito->profile();
   browser::Navigate(&p);
 
   // Navigate() should have found incognito, not browser().
   EXPECT_EQ(incognito, p.browser);
-  EXPECT_EQ(incognito->GetSelectedTabContents(), p.target_contents);
+  EXPECT_EQ(incognito->GetSelectedTabContentsWrapper(), p.target_contents);
   EXPECT_EQ(1, incognito->tab_count());
 }
 
 // This test verifies that constructing params with a NULL browser and
 // disposition = NEW_WINDOW always opens exactly one new window.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, NullBrowser_NewWindow) {
   browser::NavigateParams p(MakeNavigateParams(NULL));
   p.disposition = NEW_WINDOW;
   p.profile = browser()->profile();
   browser::Navigate(&p);
 
   // Navigate() should have created a new browser.
   EXPECT_NE(browser(), p.browser);
   EXPECT_EQ(Browser::TYPE_NORMAL, p.browser->type());
 
   // We should now have two windows, the browser() provided by the framework and
   // the new normal window.
   EXPECT_EQ(2u, BrowserList::size());
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(1, p.browser->tab_count());
 }
 
 
 }  // namespace