TabContentsWrapper -> TabContents, part 13.

chrome/browser/ui/tabs/tab_strip_model_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 "chrome/browser/ui/tabs/tab_strip_model.h"
 
 #include <map>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/property_bag.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_order_controller.h"
 #include "chrome/browser/ui/tabs/test_tab_strip_model_delegate.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using content::NavigationController;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 
 namespace {
 
-// Class used to delete a TabContentsWrapper when another TabContentsWrapper is
-// destroyed.
+// Class used to delete a TabContents when another TabContents is destroyed.
 class DeleteTabContentsOnDestroyedObserver
     : public content::NotificationObserver {
  public:
-  DeleteTabContentsOnDestroyedObserver(TabContentsWrapper* source,
-                                       TabContentsWrapper* tab_to_delete)
+  DeleteTabContentsOnDestroyedObserver(TabContents* source,
+                                       TabContents* tab_to_delete)
       : source_(source),
         tab_to_delete_(tab_to_delete) {
     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED,
-                   content::Source<TabContentsWrapper>(source));
+                   content::Source<TabContents>(source));
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) {
-    TabContentsWrapper* tab_to_delete = tab_to_delete_;
+    TabContents* tab_to_delete = tab_to_delete_;
     tab_to_delete_ = NULL;
     delete tab_to_delete;
   }
 
  private:
-  TabContentsWrapper* source_;
-  TabContentsWrapper* tab_to_delete_;
+  TabContents* source_;
+  TabContents* tab_to_delete_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteTabContentsOnDestroyedObserver);
 };
 
 }  // namespace
 
 class TabStripDummyDelegate : public TestTabStripModelDelegate {
  public:
-  explicit TabStripDummyDelegate(TabContentsWrapper* dummy)
+  explicit TabStripDummyDelegate(TabContents* dummy)
       : dummy_contents_(dummy),
         can_close_(true),
         run_unload_(false) {}
   virtual ~TabStripDummyDelegate() {}
 
   void set_can_close(bool value) { can_close_ = value; }
   void set_run_unload_listener(bool value) { run_unload_ = value; }
 
   // Overridden from TabStripModelDelegate:
-  virtual TabContentsWrapper* CreateTabContentsForURL(
+  virtual TabContents* CreateTabContentsForURL(
       const GURL& url,
       const content::Referrer& referrer,
       Profile* profile,
       content::PageTransition transition,
       bool defer_load,
       SiteInstance* instance) const OVERRIDE {
     if (url == GURL(chrome::kChromeUINewTabURL))
       return dummy_contents_;
     return NULL;
   }
-  virtual bool RunUnloadListenerBeforeClosing(
-      TabContentsWrapper* contents) OVERRIDE {
+  virtual bool RunUnloadListenerBeforeClosing(TabContents* contents) OVERRIDE {
     return run_unload_;
   }
   virtual bool CanCloseContents(std::vector<int>* indices) OVERRIDE {
     if (!can_close_)
       indices->clear();
     return can_close_;
   }
 
  private:
-  // A dummy TabContentsWrapper we give to callers that expect us to actually
+  // A dummy TabContents we give to callers that expect us to actually
   // build a Destinations tab for them.
-  TabContentsWrapper* dummy_contents_;
+  TabContents* dummy_contents_;
 
   // Whether tabs can be closed.
   bool can_close_;
 
   // Whether to report that we need to run an unload listener before closing.
   bool run_unload_;
 
   DISALLOW_COPY_AND_ASSIGN(TabStripDummyDelegate);
 };
 
 class TabStripModelTest : public ChromeRenderViewHostTestHarness {
  public:
   TabStripModelTest() : browser_thread_(BrowserThread::UI, &message_loop_) {
   }
 
-  TabContentsWrapper* CreateTabContents() {
+  TabContents* CreateTabContents() {
     return Browser::TabContentsFactory(
         profile(), NULL, MSG_ROUTING_NONE, NULL, NULL);
   }
 
-  TabContentsWrapper* CreateTabContentsWithSharedRPH(
+  TabContents* CreateTabContentsWithSharedRPH(
       WebContents* web_contents) {
-    TabContentsWrapper* retval = Browser::TabContentsFactory(profile(),
+    TabContents* retval = Browser::TabContentsFactory(profile(),
         web_contents->GetRenderViewHost()->GetSiteInstance(), MSG_ROUTING_NONE,
         NULL, NULL);
     EXPECT_EQ(retval->web_contents()->GetRenderProcessHost(),
               web_contents->GetRenderProcessHost());
     return retval;
   }
 
-  // Forwards a URL "load" request through to our dummy TabContentsWrapper
+  // Forwards a URL "load" request through to our dummy TabContents
   // implementation.
   void LoadURL(WebContents* con, const std::wstring& url) {
     controller().LoadURL(GURL(WideToUTF16(url)), content::Referrer(),
                          content::PAGE_TRANSITION_LINK, std::string());
   }
 
   void GoBack(WebContents* contents) {
     controller().GoBack();
   }
 
@@ skipping 49 matching lines @@
       result += base::IntToString(indices[i]);
     }
     return result;
   }
 
   void PrepareTabstripForSelectionTest(TabStripModel* model,
                                        int tab_count,
                                        int pinned_count,
                                        const std::string& selected_tabs) {
     for (int i = 0; i < tab_count; ++i) {
-      TabContentsWrapper* contents = CreateTabContents();
+      TabContents* contents = CreateTabContents();
       SetID(contents->web_contents(), i);
       model->AppendTabContents(contents, true);
     }
     for (int i = 0; i < pinned_count; ++i)
       model->SetTabPinned(i, true);
 
     TabStripSelectionModel selection_model;
     std::vector<std::string> selection;
     base::SplitStringAlongWhitespace(selected_tabs, &selection);
     for (size_t i = 0; i < selection.size(); ++i) {
@@ skipping 36 matching lines @@
     ACTIVATE,
     DEACTIVATE,
     SELECT,
     MOVE,
     CHANGE,
     PINNED,
     REPLACED
   };
 
   struct State {
-    State(TabContentsWrapper* a_dst_contents,
+    State(TabContents* a_dst_contents,
           int a_dst_index,
           TabStripModelObserverAction a_action)
         : src_contents(NULL),
           dst_contents(a_dst_contents),
           src_index(-1),
           dst_index(a_dst_index),
           user_gesture(false),
           foreground(false),
           action(a_action) {
     }
 
-    TabContentsWrapper* src_contents;
-    TabContentsWrapper* dst_contents;
+    TabContents* src_contents;
+    TabContents* dst_contents;
     int src_index;
     int dst_index;
     bool user_gesture;
     bool foreground;
     TabStripModelObserverAction action;
   };
 
   int GetStateCount() const {
     return static_cast<int>(states_.size());
   }
@@ skipping 15 matching lines @@
     return (s->src_contents == state.src_contents &&
             s->dst_contents == state.dst_contents &&
             s->src_index == state.src_index &&
             s->dst_index == state.dst_index &&
             s->user_gesture == state.user_gesture &&
             s->foreground == state.foreground &&
             s->action == state.action);
   }
 
   // TabStripModelObserver implementation:
-  virtual void TabInsertedAt(TabContentsWrapper* contents,
+  virtual void TabInsertedAt(TabContents* contents,
                              int index,
                              bool foreground) {
     empty_ = false;
     State* s = new State(contents, index, INSERT);
     s->foreground = foreground;
     states_.push_back(s);
   }
-  virtual void ActiveTabChanged(TabContentsWrapper* old_contents,
-                                TabContentsWrapper* new_contents,
+  virtual void ActiveTabChanged(TabContents* old_contents,
+                                TabContents* new_contents,
                                 int index,
                                 bool user_gesture) {
     State* s = new State(new_contents, index, ACTIVATE);
     s->src_contents = old_contents;
     s->user_gesture = user_gesture;
     states_.push_back(s);
   }
   virtual void TabSelectionChanged(TabStripModel* tab_strip_model,
                                    const TabStripSelectionModel& old_model) {
     State* s = new State(model()->GetActiveTabContents(),
                          model()->active_index(),
                          SELECT);
     s->src_contents = model()->GetTabContentsAt(old_model.active());
     s->src_index = old_model.active();
     states_.push_back(s);
   }
-  virtual void TabMoved(
-      TabContentsWrapper* contents, int from_index, int to_index) {
+  virtual void TabMoved(TabContents* contents, int from_index, int to_index) {
     State* s = new State(contents, to_index, MOVE);
     s->src_index = from_index;
     states_.push_back(s);
   }
 
   virtual void TabClosingAt(TabStripModel* tab_strip_model,
-                            TabContentsWrapper* contents,
+                            TabContents* contents,
                             int index) {
     states_.push_back(new State(contents, index, CLOSE));
   }
-  virtual void TabDetachedAt(TabContentsWrapper* contents, int index) {
+  virtual void TabDetachedAt(TabContents* contents, int index) {
     states_.push_back(new State(contents, index, DETACH));
   }
-  virtual void TabDeactivated(TabContentsWrapper* contents) {
+  virtual void TabDeactivated(TabContents* contents) {
     states_.push_back(new State(contents, model()->active_index(), DEACTIVATE));
   }
-  virtual void TabChangedAt(TabContentsWrapper* contents, int index,
+  virtual void TabChangedAt(TabContents* contents, int index,
                             TabChangeType change_type) {
     states_.push_back(new State(contents, index, CHANGE));
   }
   virtual void TabReplacedAt(TabStripModel* tab_strip_model,
-                             TabContentsWrapper* old_contents,
-                             TabContentsWrapper* new_contents,
+                             TabContents* old_contents,
+                             TabContents* new_contents,
                              int index) {
     State* s = new State(new_contents, index, REPLACED);
     s ->src_contents = old_contents;
     states_.push_back(s);
   }
-  virtual void TabPinnedStateChanged(TabContentsWrapper* contents, int index) {
+  virtual void TabPinnedStateChanged(TabContents* contents, int index) {
     states_.push_back(new State(contents, index, PINNED));
   }
   virtual void TabStripEmpty() {
     empty_ = true;
   }
 
   void ClearStates() {
     STLDeleteContainerPointers(states_.begin(), states_.end());
     states_.clear();
   }
@@ skipping 13 matching lines @@
 TEST_F(TabStripModelTest, TestBasicAPI) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   MockTabStripModelObserver observer(&tabstrip);
   tabstrip.AddObserver(&observer);
 
   EXPECT_TRUE(tabstrip.empty());
 
   typedef MockTabStripModelObserver::State State;
 
-  TabContentsWrapper* contents1 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
 
   // Note! The ordering of these tests is important, each subsequent test
   // builds on the state established in the previous. This is important if you
   // ever insert tests rather than append.
 
   // Test AppendTabContents, ContainsIndex
   {
     EXPECT_FALSE(tabstrip.ContainsIndex(0));
     tabstrip.AppendTabContents(contents1, true);
     EXPECT_TRUE(tabstrip.ContainsIndex(0));
     EXPECT_EQ(1, tabstrip.count());
     EXPECT_EQ(3, observer.GetStateCount());
     State s1(contents1, 0, MockTabStripModelObserver::INSERT);
     s1.foreground = true;
     EXPECT_TRUE(observer.StateEquals(0, s1));
     State s2(contents1, 0, MockTabStripModelObserver::ACTIVATE);
     EXPECT_TRUE(observer.StateEquals(1, s2));
     State s3(contents1, 0, MockTabStripModelObserver::SELECT);
     s3.src_contents = NULL;
     s3.src_index = TabStripSelectionModel::kUnselectedIndex;
     EXPECT_TRUE(observer.StateEquals(2, s3));
     observer.ClearStates();
   }
 
   // Test InsertTabContentsAt, foreground tab.
-  TabContentsWrapper* contents2 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
   {
     tabstrip.InsertTabContentsAt(1, contents2, TabStripModel::ADD_ACTIVE);
 
     EXPECT_EQ(2, tabstrip.count());
     EXPECT_EQ(4, observer.GetStateCount());
     State s1(contents2, 1, MockTabStripModelObserver::INSERT);
     s1.foreground = true;
     EXPECT_TRUE(observer.StateEquals(0, s1));
     State s2(contents1, 0, MockTabStripModelObserver::DEACTIVATE);
     EXPECT_TRUE(observer.StateEquals(1, s2));
     State s3(contents2, 1, MockTabStripModelObserver::ACTIVATE);
     s3.src_contents = contents1;
     EXPECT_TRUE(observer.StateEquals(2, s3));
     State s4(contents2, 1, MockTabStripModelObserver::SELECT);
     s4.src_contents = contents1;
     s4.src_index = 0;
     EXPECT_TRUE(observer.StateEquals(3, s4));
     observer.ClearStates();
   }
 
   // Test InsertTabContentsAt, background tab.
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
   {
     tabstrip.InsertTabContentsAt(2, contents3, TabStripModel::ADD_NONE);
 
     EXPECT_EQ(3, tabstrip.count());
     EXPECT_EQ(1, observer.GetStateCount());
     State s1(contents3, 2, MockTabStripModelObserver::INSERT);
     s1.foreground = false;
     EXPECT_TRUE(observer.StateEquals(0, s1));
     observer.ClearStates();
   }
@@ skipping 11 matching lines @@
     State s3(contents3, 2, MockTabStripModelObserver::SELECT);
     s3.src_contents = contents2;
     s3.src_index = 1;
     EXPECT_TRUE(observer.StateEquals(2, s3));
     observer.ClearStates();
   }
 
   // Test DetachTabContentsAt
   {
     // Detach
-    TabContentsWrapper* detached = tabstrip.DetachTabContentsAt(2);
+    TabContents* detached = tabstrip.DetachTabContentsAt(2);
     // ... and append again because we want this for later.
     tabstrip.AppendTabContents(detached, true);
     EXPECT_EQ(8, observer.GetStateCount());
     State s1(detached, 2, MockTabStripModelObserver::DETACH);
     EXPECT_TRUE(observer.StateEquals(0, s1));
     State s2(detached, TabStripSelectionModel::kUnselectedIndex,
         MockTabStripModelObserver::DEACTIVATE);
     EXPECT_TRUE(observer.StateEquals(1, s2));
     State s3(contents2, 1, MockTabStripModelObserver::ACTIVATE);
     s3.src_contents = contents3;
@@ skipping 131 matching lines @@
 
 TEST_F(TabStripModelTest, TestBasicOpenerAPI) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // This is a basic test of opener functionality. opener_contents is created
   // as the first tab in the strip and then we create 5 other tabs in the
   // background with opener_contents set as their opener.
 
-  TabContentsWrapper* opener_contents = CreateTabContents();
+  TabContents* opener_contents = CreateTabContents();
   NavigationController* opener =
       &opener_contents->web_contents()->GetController();
   tabstrip.AppendTabContents(opener_contents, true);
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
-  TabContentsWrapper* contents4 = CreateTabContents();
-  TabContentsWrapper* contents5 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
+  TabContents* contents4 = CreateTabContents();
+  TabContents* contents5 = CreateTabContents();
 
   // We use |InsertTabContentsAt| here instead of AppendTabContents so that
   // openership relationships are preserved.
   tabstrip.InsertTabContentsAt(tabstrip.count(), contents1,
                                TabStripModel::ADD_INHERIT_GROUP);
   tabstrip.InsertTabContentsAt(tabstrip.count(), contents2,
                                TabStripModel::ADD_INHERIT_GROUP);
   tabstrip.InsertTabContentsAt(tabstrip.count(), contents3,
                                TabStripModel::ADD_INHERIT_GROUP);
   tabstrip.InsertTabContentsAt(tabstrip.count(), contents4,
@@ skipping 41 matching lines @@
 
   // If the last tab in the group is closed, the preceding tab in the same
   // group should be selected.
   EXPECT_EQ(3, tabstrip.GetIndexOfNextTabContentsOpenedBy(o5, 4, false));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 static int GetInsertionIndex(TabStripModel* tabstrip,
-                             TabContentsWrapper* contents) {
+                             TabContents* contents) {
   return tabstrip->order_controller()->DetermineInsertionIndex(
       contents, content::PAGE_TRANSITION_LINK, false);
 }
 
 static void InsertTabContentses(TabStripModel* tabstrip,
-                                TabContentsWrapper* contents1,
-                                TabContentsWrapper* contents2,
-                                TabContentsWrapper* contents3) {
+                                TabContents* contents1,
+                                TabContents* contents2,
+                                TabContents* contents3) {
   tabstrip->InsertTabContentsAt(GetInsertionIndex(tabstrip, contents1),
                                 contents1, TabStripModel::ADD_INHERIT_GROUP);
   tabstrip->InsertTabContentsAt(GetInsertionIndex(tabstrip, contents2),
                                 contents2, TabStripModel::ADD_INHERIT_GROUP);
   tabstrip->InsertTabContentsAt(GetInsertionIndex(tabstrip, contents3),
                                 contents3, TabStripModel::ADD_INHERIT_GROUP);
 }
 
 // Tests opening background tabs.
 TEST_F(TabStripModelTest, TestLTRInsertionOptions) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
-  TabContentsWrapper* opener_contents = CreateTabContents();
+  TabContents* opener_contents = CreateTabContents();
   tabstrip.AppendTabContents(opener_contents, true);
 
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
 
   // Test LTR
   InsertTabContentses(&tabstrip, contents1, contents2, contents3);
   EXPECT_EQ(contents1, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(contents2, tabstrip.GetTabContentsAt(2));
   EXPECT_EQ(contents3, tabstrip.GetTabContentsAt(3));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 // Tests inserting tabs with InsertAfter set to false.
 TEST_F(TabStripModelTest, InsertBefore) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   tabstrip.SetInsertionPolicy(TabStripModel::INSERT_BEFORE);
   EXPECT_TRUE(tabstrip.empty());
 
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
 
   InsertTabContentses(&tabstrip, contents1, contents2, contents3);
 
   // The order should be reversed.
   EXPECT_EQ(contents3, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(contents2, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(contents1, tabstrip.GetTabContentsAt(2));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 // Tests opening background tabs with InsertAfter set to false.
 TEST_F(TabStripModelTest, InsertBeforeOpeners) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   tabstrip.SetInsertionPolicy(TabStripModel::INSERT_BEFORE);
   EXPECT_TRUE(tabstrip.empty());
-  TabContentsWrapper* opener_contents = CreateTabContents();
+  TabContents* opener_contents = CreateTabContents();
   tabstrip.AppendTabContents(opener_contents, true);
 
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
 
   InsertTabContentses(&tabstrip, contents1, contents2, contents3);
 
   // The order should be reversed.
   EXPECT_EQ(contents3, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(contents2, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(contents1, tabstrip.GetTabContentsAt(2));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 // This test constructs a tabstrip, and then simulates loading several tabs in
 // the background from link clicks on the first tab. Then it simulates opening
 // a new tab from the first tab in the foreground via a link click, verifies
 // that this tab is opened adjacent to the opener, then closes it.
 // Finally it tests that a tab opened for some non-link purpose openes at the
 // end of the strip, not bundled to any existing context.
 TEST_F(TabStripModelTest, TestInsertionIndexDetermination) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
-  TabContentsWrapper* opener_contents = CreateTabContents();
+  TabContents* opener_contents = CreateTabContents();
   NavigationController* opener =
       &opener_contents->web_contents()->GetController();
   tabstrip.AppendTabContents(opener_contents, true);
 
   // Open some other random unrelated tab in the background to monkey with our
   // insertion index.
-  TabContentsWrapper* other_contents = CreateTabContents();
+  TabContents* other_contents = CreateTabContents();
   tabstrip.AppendTabContents(other_contents, false);
 
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
 
   // Start by testing LTR
   InsertTabContentses(&tabstrip, contents1, contents2, contents3);
   EXPECT_EQ(opener_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(contents1, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(contents2, tabstrip.GetTabContentsAt(2));
   EXPECT_EQ(contents3, tabstrip.GetTabContentsAt(3));
   EXPECT_EQ(other_contents, tabstrip.GetTabContentsAt(4));
 
   // The opener API should work...
   EXPECT_EQ(3, tabstrip.GetIndexOfNextTabContentsOpenedBy(opener, 2, false));
   EXPECT_EQ(2, tabstrip.GetIndexOfNextTabContentsOpenedBy(opener, 3, false));
   EXPECT_EQ(3, tabstrip.GetIndexOfLastTabContentsOpenedBy(opener, 1));
 
   // Now open a foreground tab from a link. It should be opened adjacent to the
   // opener tab.
-  TabContentsWrapper* fg_link_contents = CreateTabContents();
+  TabContents* fg_link_contents = CreateTabContents();
   int insert_index = tabstrip.order_controller()->DetermineInsertionIndex(
       fg_link_contents, content::PAGE_TRANSITION_LINK, true);
   EXPECT_EQ(1, insert_index);
   tabstrip.InsertTabContentsAt(insert_index, fg_link_contents,
                                TabStripModel::ADD_ACTIVE |
                                TabStripModel::ADD_INHERIT_GROUP);
   EXPECT_EQ(1, tabstrip.active_index());
   EXPECT_EQ(fg_link_contents, tabstrip.GetActiveTabContents());
 
   // Now close this contents. The selection should move to the opener contents.
   tabstrip.CloseSelectedTabs();
   EXPECT_EQ(0, tabstrip.active_index());
 
   // Now open a new empty tab. It should open at the end of the strip.
-  TabContentsWrapper* fg_nonlink_contents = CreateTabContents();
+  TabContents* fg_nonlink_contents = CreateTabContents();
   insert_index = tabstrip.order_controller()->DetermineInsertionIndex(
       fg_nonlink_contents, content::PAGE_TRANSITION_AUTO_BOOKMARK, true);
   EXPECT_EQ(tabstrip.count(), insert_index);
   // We break the opener relationship...
   tabstrip.InsertTabContentsAt(insert_index, fg_nonlink_contents,
                                TabStripModel::ADD_NONE);
   // Now select it, so that user_gesture == true causes the opener relationship
   // to be forgotten...
   tabstrip.ActivateTabAt(tabstrip.count() - 1, true);
   EXPECT_EQ(tabstrip.count() - 1, tabstrip.active_index());
@@ skipping 18 matching lines @@
 //     The next tab (scanning LTR) in the entire strip that has the same opener
 //     is selected
 //     If there are no other tabs that have the same opener,
 //       The opener is selected
 //
 TEST_F(TabStripModelTest, TestSelectOnClose) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
-  TabContentsWrapper* opener_contents = CreateTabContents();
+  TabContents* opener_contents = CreateTabContents();
   tabstrip.AppendTabContents(opener_contents, true);
 
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
 
   // Note that we use Detach instead of Close throughout this test to avoid
   // having to keep reconstructing these TabContentses.
 
   // First test that closing tabs that are in the background doesn't adjust the
   // current selection.
   InsertTabContentses(&tabstrip, contents1, contents2, contents3);
   EXPECT_EQ(0, tabstrip.active_index());
 
   tabstrip.DetachTabContentsAt(1);
@@ skipping 27 matching lines @@
   tabstrip.ActivateTabAt(2, false);
   EXPECT_EQ(2, tabstrip.active_index());
   tabstrip.CloseTabContentsAt(2, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(2, tabstrip.active_index());
   tabstrip.CloseTabContentsAt(2, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(1, tabstrip.active_index());
   tabstrip.CloseTabContentsAt(1, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(0, tabstrip.active_index());
   // Finally test that when a tab has no "siblings" that the opener is
   // selected.
-  TabContentsWrapper* other_contents = CreateTabContents();
+  TabContents* other_contents = CreateTabContents();
   tabstrip.InsertTabContentsAt(1, other_contents, TabStripModel::ADD_NONE);
   EXPECT_EQ(2, tabstrip.count());
-  TabContentsWrapper* opened_contents = CreateTabContents();
+  TabContents* opened_contents = CreateTabContents();
   tabstrip.InsertTabContentsAt(2, opened_contents,
                                TabStripModel::ADD_ACTIVE |
                                TabStripModel::ADD_INHERIT_GROUP);
   EXPECT_EQ(2, tabstrip.active_index());
   tabstrip.CloseTabContentsAt(2, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(0, tabstrip.active_index());
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
@@ skipping 171 matching lines @@
 
 // Tests the following context menu commands:
 //  - Close Tab
 //  - Close Other Tabs
 //  - Close Tabs To Right
 TEST_F(TabStripModelTest, TestContextMenuCloseCommands) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
-  TabContentsWrapper* opener_contents = CreateTabContents();
+  TabContents* opener_contents = CreateTabContents();
   tabstrip.AppendTabContents(opener_contents, true);
 
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
 
   InsertTabContentses(&tabstrip, contents1, contents2, contents3);
   EXPECT_EQ(0, tabstrip.active_index());
 
   tabstrip.ExecuteContextMenuCommand(2, TabStripModel::CommandCloseTab);
   EXPECT_EQ(3, tabstrip.count());
 
   tabstrip.ExecuteContextMenuCommand(0, TabStripModel::CommandCloseTabsToRight);
   EXPECT_EQ(1, tabstrip.count());
   EXPECT_EQ(opener_contents, tabstrip.GetActiveTabContents());
 
-  TabContentsWrapper* dummy_contents = CreateTabContents();
+  TabContents* dummy_contents = CreateTabContents();
   tabstrip.AppendTabContents(dummy_contents, false);
 
   contents1 = CreateTabContents();
   contents2 = CreateTabContents();
   contents3 = CreateTabContents();
   InsertTabContentses(&tabstrip, contents1, contents2, contents3);
   EXPECT_EQ(5, tabstrip.count());
 
   int dummy_index = tabstrip.count() - 1;
   tabstrip.ActivateTabAt(dummy_index, true);
   EXPECT_EQ(dummy_contents, tabstrip.GetActiveTabContents());
 
   tabstrip.ExecuteContextMenuCommand(dummy_index,
                                      TabStripModel::CommandCloseOtherTabs);
   EXPECT_EQ(1, tabstrip.count());
   EXPECT_EQ(dummy_contents, tabstrip.GetActiveTabContents());
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 // Tests GetIndicesClosedByCommand.
 TEST_F(TabStripModelTest, GetIndicesClosedByCommand) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
-  TabContentsWrapper* contents4 = CreateTabContents();
-  TabContentsWrapper* contents5 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
+  TabContents* contents4 = CreateTabContents();
+  TabContents* contents5 = CreateTabContents();
 
   tabstrip.AppendTabContents(contents1, true);
   tabstrip.AppendTabContents(contents2, true);
   tabstrip.AppendTabContents(contents3, true);
   tabstrip.AppendTabContents(contents4, true);
   tabstrip.AppendTabContents(contents5, true);
 
   EXPECT_EQ("4 3 2 1", GetIndicesClosedByCommandAsString(
                 tabstrip, 0, TabStripModel::CommandCloseTabsToRight));
   EXPECT_EQ("4 3 2", GetIndicesClosedByCommandAsString(
@@ skipping 25 matching lines @@
 
 // Tests whether or not TabContentses are inserted in the correct position
 // using this "smart" function with a simulated middle click action on a series
 // of links on the home page.
 TEST_F(TabStripModelTest, AddTabContents_MiddleClickLinksAndClose) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
-  TabContentsWrapper* homepage_contents = CreateTabContents();
+  TabContents* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
       homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
-  TabContentsWrapper* typed_page_contents = CreateTabContents();
+  TabContents* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
       typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(2, tabstrip.count());
 
   // Re-select the home page.
   tabstrip.ActivateTabAt(0, true);
 
   // Open a bunch of tabs by simulating middle clicking on links on the home
   // page.
-  TabContentsWrapper* middle_click_contents1 = CreateTabContents();
+  TabContents* middle_click_contents1 = CreateTabContents();
   tabstrip.AddTabContents(
       middle_click_contents1, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
-  TabContentsWrapper* middle_click_contents2 = CreateTabContents();
+  TabContents* middle_click_contents2 = CreateTabContents();
   tabstrip.AddTabContents(
       middle_click_contents2, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
-  TabContentsWrapper* middle_click_contents3 = CreateTabContents();
+  TabContents* middle_click_contents3 = CreateTabContents();
   tabstrip.AddTabContents(
       middle_click_contents3, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
 
   EXPECT_EQ(5, tabstrip.count());
 
   EXPECT_EQ(homepage_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(middle_click_contents1, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(middle_click_contents2, tabstrip.GetTabContentsAt(2));
   EXPECT_EQ(middle_click_contents3, tabstrip.GetTabContentsAt(3));
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(4));
 
   // Now simulate seleting a tab in the middle of the group of tabs opened from
-  // the home page and start closing them. Each TabContentsWrapper in the group
+  // the home page and start closing them. Each TabContents in the group
   // should be closed, right to left. This test is constructed to start at the
-  // middle TabContentsWrapper in the group to make sure the cursor wraps around
-  // to the first TabContentsWrapper in the group before closing the opener or
-  // any other TabContentsWrapper.
+  // middle TabContents in the group to make sure the cursor wraps around
+  // to the first TabContents in the group before closing the opener or
+  // any other TabContents.
   tabstrip.ActivateTabAt(2, true);
   tabstrip.CloseSelectedTabs();
   EXPECT_EQ(middle_click_contents3, tabstrip.GetActiveTabContents());
   tabstrip.CloseSelectedTabs();
   EXPECT_EQ(middle_click_contents1, tabstrip.GetActiveTabContents());
   tabstrip.CloseSelectedTabs();
   EXPECT_EQ(homepage_contents, tabstrip.GetActiveTabContents());
   tabstrip.CloseSelectedTabs();
   EXPECT_EQ(typed_page_contents, tabstrip.GetActiveTabContents());
 
   EXPECT_EQ(1, tabstrip.count());
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
-// Tests whether or not a TabContentsWrapper created by a left click on a link
+// Tests whether or not a TabContents created by a left click on a link
 // that opens a new tab is inserted correctly adjacent to the tab that spawned
 // it.
 TEST_F(TabStripModelTest, AddTabContents_LeftClickPopup) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
-  TabContentsWrapper* homepage_contents = CreateTabContents();
+  TabContents* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
       homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
-  TabContentsWrapper* typed_page_contents = CreateTabContents();
+  TabContents* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
       typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(2, tabstrip.count());
 
   // Re-select the home page.
   tabstrip.ActivateTabAt(0, true);
 
   // Open a tab by simulating a left click on a link that opens in a new tab.
-  TabContentsWrapper* left_click_contents = CreateTabContents();
+  TabContents* left_click_contents = CreateTabContents();
   tabstrip.AddTabContents(left_click_contents, -1,
                           content::PAGE_TRANSITION_LINK,
                           TabStripModel::ADD_ACTIVE);
 
   // Verify the state meets our expectations.
   EXPECT_EQ(3, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(left_click_contents, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(2));
 
@@ skipping 13 matching lines @@
 
 // Tests whether or not new tabs that should split context (typed pages,
 // generated urls, also blank tabs) open at the end of the tabstrip instead of
 // in the middle.
 TEST_F(TabStripModelTest, AddTabContents_CreateNewBlankTab) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
-  TabContentsWrapper* homepage_contents = CreateTabContents();
+  TabContents* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
       homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
-  TabContentsWrapper* typed_page_contents = CreateTabContents();
+  TabContents* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
       typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(2, tabstrip.count());
 
   // Re-select the home page.
   tabstrip.ActivateTabAt(0, true);
 
   // Open a new blank tab in the foreground.
-  TabContentsWrapper* new_blank_contents = CreateTabContents();
+  TabContents* new_blank_contents = CreateTabContents();
   tabstrip.AddTabContents(new_blank_contents, -1,
                           content::PAGE_TRANSITION_TYPED,
                           TabStripModel::ADD_ACTIVE);
 
   // Verify the state of the tabstrip.
   EXPECT_EQ(3, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(new_blank_contents, tabstrip.GetTabContentsAt(2));
 
   // Now open a couple more blank tabs in the background.
-  TabContentsWrapper* background_blank_contents1 = CreateTabContents();
+  TabContents* background_blank_contents1 = CreateTabContents();
   tabstrip.AddTabContents(
       background_blank_contents1, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_NONE);
-  TabContentsWrapper* background_blank_contents2 = CreateTabContents();
+  TabContents* background_blank_contents2 = CreateTabContents();
   tabstrip.AddTabContents(
       background_blank_contents2, -1, content::PAGE_TRANSITION_GENERATED,
       TabStripModel::ADD_NONE);
   EXPECT_EQ(5, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(new_blank_contents, tabstrip.GetTabContentsAt(2));
   EXPECT_EQ(background_blank_contents1, tabstrip.GetTabContentsAt(3));
   EXPECT_EQ(background_blank_contents2, tabstrip.GetTabContentsAt(4));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 // Tests whether opener state is correctly forgotten when the user switches
 // context.
 TEST_F(TabStripModelTest, AddTabContents_ForgetOpeners) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
-  TabContentsWrapper* homepage_contents = CreateTabContents();
+  TabContents* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
       homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
-  TabContentsWrapper* typed_page_contents = CreateTabContents();
+  TabContents* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
       typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(2, tabstrip.count());
 
   // Re-select the home page.
   tabstrip.ActivateTabAt(0, true);
 
   // Open a bunch of tabs by simulating middle clicking on links on the home
   // page.
-  TabContentsWrapper* middle_click_contents1 = CreateTabContents();
+  TabContents* middle_click_contents1 = CreateTabContents();
   tabstrip.AddTabContents(
       middle_click_contents1, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
-  TabContentsWrapper* middle_click_contents2 = CreateTabContents();
+  TabContents* middle_click_contents2 = CreateTabContents();
   tabstrip.AddTabContents(
       middle_click_contents2, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
-  TabContentsWrapper* middle_click_contents3 = CreateTabContents();
+  TabContents* middle_click_contents3 = CreateTabContents();
   tabstrip.AddTabContents(
       middle_click_contents3, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
 
   // Break out of the context by selecting a tab in a different context.
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(4));
   tabstrip.SelectLastTab();
   EXPECT_EQ(typed_page_contents, tabstrip.GetActiveTabContents());
 
   // Step back into the context by selecting a tab inside it.
@@ skipping 15 matching lines @@
   EXPECT_EQ(1, tabstrip.count());
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 // Added for http://b/issue?id=958960
 TEST_F(TabStripModelTest, AppendContentsReselectionTest) {
   WebContents* fake_destinations_tab =
       WebContents::Create(profile(), NULL, MSG_ROUTING_NONE, NULL, NULL);
-  TabContentsWrapper wrapper(fake_destinations_tab);
-  TabStripDummyDelegate delegate(&wrapper);
+  TabContents tab_contents(fake_destinations_tab);
+  TabStripDummyDelegate delegate(&tab_contents);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
-  TabContentsWrapper* homepage_contents = CreateTabContents();
+  TabContents* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
       homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
-  TabContentsWrapper* typed_page_contents = CreateTabContents();
+  TabContents* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
       typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_NONE);
 
   // The selected tab should still be the first.
   EXPECT_EQ(0, tabstrip.active_index());
 
   // Now simulate a link click that opens a new tab (by virtue of target=_blank)
   // and make sure the right tab gets selected when the new tab is closed.
-  TabContentsWrapper* target_blank_contents = CreateTabContents();
+  TabContents* target_blank_contents = CreateTabContents();
   tabstrip.AppendTabContents(target_blank_contents, true);
   EXPECT_EQ(2, tabstrip.active_index());
   tabstrip.CloseTabContentsAt(2, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(0, tabstrip.active_index());
 
   // clean up after ourselves
   tabstrip.CloseAllTabs();
 }
 
 // Added for http://b/issue?id=1027661
 TEST_F(TabStripModelTest, ReselectionConsidersChildrenTest) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   // Open page A
-  TabContentsWrapper* page_a_contents = CreateTabContents();
+  TabContents* page_a_contents = CreateTabContents();
   strip.AddTabContents(
       page_a_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Simulate middle click to open page A.A and A.B
-  TabContentsWrapper* page_a_a_contents = CreateTabContents();
+  TabContents* page_a_a_contents = CreateTabContents();
   strip.AddTabContents(page_a_a_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  TabContentsWrapper* page_a_b_contents = CreateTabContents();
+  TabContents* page_a_b_contents = CreateTabContents();
   strip.AddTabContents(page_a_b_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Select page A.A
   strip.ActivateTabAt(1, true);
   EXPECT_EQ(page_a_a_contents, strip.GetActiveTabContents());
 
   // Simulate a middle click to open page A.A.A
-  TabContentsWrapper* page_a_a_a_contents = CreateTabContents();
+  TabContents* page_a_a_a_contents = CreateTabContents();
   strip.AddTabContents(page_a_a_a_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   EXPECT_EQ(page_a_a_a_contents, strip.GetTabContentsAt(2));
 
   // Close page A.A
   strip.CloseTabContentsAt(strip.active_index(), TabStripModel::CLOSE_NONE);
 
   // Page A.A.A should be selected, NOT A.B
   EXPECT_EQ(page_a_a_a_contents, strip.GetActiveTabContents());
@@ skipping 12 matching lines @@
 
   // Clean up.
   strip.CloseAllTabs();
 }
 
 TEST_F(TabStripModelTest, AddTabContents_NewTabAtEndOfStripInheritsGroup) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   // Open page A
-  TabContentsWrapper* page_a_contents = CreateTabContents();
+  TabContents* page_a_contents = CreateTabContents();
   strip.AddTabContents(page_a_contents, -1, content::PAGE_TRANSITION_START_PAGE,
                        TabStripModel::ADD_ACTIVE);
 
   // Open pages B, C and D in the background from links on page A...
-  TabContentsWrapper* page_b_contents = CreateTabContents();
-  TabContentsWrapper* page_c_contents = CreateTabContents();
-  TabContentsWrapper* page_d_contents = CreateTabContents();
+  TabContents* page_b_contents = CreateTabContents();
+  TabContents* page_c_contents = CreateTabContents();
+  TabContents* page_d_contents = CreateTabContents();
   strip.AddTabContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   strip.AddTabContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   strip.AddTabContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Switch to page B's tab.
   strip.ActivateTabAt(1, true);
 
   // Open a New Tab at the end of the strip (simulate Ctrl+T)
-  TabContentsWrapper* new_tab_contents = CreateTabContents();
+  TabContents* new_tab_contents = CreateTabContents();
   strip.AddTabContents(new_tab_contents, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfTabContents(new_tab_contents));
   EXPECT_EQ(4, strip.active_index());
 
   // Close the New Tab that was just opened. We should be returned to page B's
   // Tab...
   strip.CloseTabContentsAt(4, TabStripModel::CLOSE_NONE);
 
   EXPECT_EQ(1, strip.active_index());
 
   // Open a non-New Tab tab at the end of the strip, with a TYPED transition.
   // This is like typing a URL in the address bar and pressing Alt+Enter. The
   // behavior should be the same as above.
-  TabContentsWrapper* page_e_contents = CreateTabContents();
+  TabContents* page_e_contents = CreateTabContents();
   strip.AddTabContents(page_e_contents, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfTabContents(page_e_contents));
   EXPECT_EQ(4, strip.active_index());
 
   // Close the Tab. Selection should shift back to page B's Tab.
   strip.CloseTabContentsAt(4, TabStripModel::CLOSE_NONE);
 
   EXPECT_EQ(1, strip.active_index());
 
   // Open a non-New Tab tab at the end of the strip, with some other
   // transition. This is like right clicking on a bookmark and choosing "Open
   // in New Tab". No opener relationship should be preserved between this Tab
   // and the one that was active when the gesture was performed.
-  TabContentsWrapper* page_f_contents = CreateTabContents();
+  TabContents* page_f_contents = CreateTabContents();
   strip.AddTabContents(page_f_contents, -1,
                        content::PAGE_TRANSITION_AUTO_BOOKMARK,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfTabContents(page_f_contents));
   EXPECT_EQ(4, strip.active_index());
 
   // Close the Tab. The next-adjacent should be selected.
   strip.CloseTabContentsAt(4, TabStripModel::CLOSE_NONE);
 
   EXPECT_EQ(3, strip.active_index());
 
   // Clean up.
   strip.CloseAllTabs();
 }
 
 // A test of navigations in a tab that is part of a group of opened from some
 // parent tab. If the navigations are link clicks, the group relationship of
 // the tab to its parent are preserved. If they are of any other type, they are
 // not preserved.
 TEST_F(TabStripModelTest, NavigationForgetsOpeners) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   // Open page A
-  TabContentsWrapper* page_a_contents = CreateTabContents();
+  TabContents* page_a_contents = CreateTabContents();
   strip.AddTabContents(page_a_contents, -1, content::PAGE_TRANSITION_START_PAGE,
                        TabStripModel::ADD_ACTIVE);
 
   // Open pages B, C and D in the background from links on page A...
-  TabContentsWrapper* page_b_contents = CreateTabContents();
-  TabContentsWrapper* page_c_contents = CreateTabContents();
-  TabContentsWrapper* page_d_contents = CreateTabContents();
+  TabContents* page_b_contents = CreateTabContents();
+  TabContents* page_c_contents = CreateTabContents();
+  TabContents* page_d_contents = CreateTabContents();
   strip.AddTabContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   strip.AddTabContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   strip.AddTabContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Open page E in a different opener group from page A.
-  TabContentsWrapper* page_e_contents = CreateTabContents();
+  TabContents* page_e_contents = CreateTabContents();
   strip.AddTabContents(page_e_contents, -1, content::PAGE_TRANSITION_START_PAGE,
                        TabStripModel::ADD_NONE);
 
   // Tell the TabStripModel that we are navigating page D via a link click.
   strip.ActivateTabAt(3, true);
   strip.TabNavigating(page_d_contents, content::PAGE_TRANSITION_LINK);
 
   // Close page D, page C should be selected. (part of same group).
   strip.CloseTabContentsAt(3, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(2, strip.active_index());
@@ skipping 12 matching lines @@
 // A test that the forgetting behavior tested in NavigationForgetsOpeners above
 // doesn't cause the opener relationship for a New Tab opened at the end of the
 // TabStrip to be reset (Test 1 below), unless another any other tab is
 // seelcted (Test 2 below).
 TEST_F(TabStripModelTest, NavigationForgettingDoesntAffectNewTab) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   // Open a tab and several tabs from it, then select one of the tabs that was
   // opened.
-  TabContentsWrapper* page_a_contents = CreateTabContents();
+  TabContents* page_a_contents = CreateTabContents();
   strip.AddTabContents(page_a_contents, -1, content::PAGE_TRANSITION_START_PAGE,
                        TabStripModel::ADD_ACTIVE);
 
-  TabContentsWrapper* page_b_contents = CreateTabContents();
-  TabContentsWrapper* page_c_contents = CreateTabContents();
-  TabContentsWrapper* page_d_contents = CreateTabContents();
+  TabContents* page_b_contents = CreateTabContents();
+  TabContents* page_c_contents = CreateTabContents();
+  TabContents* page_d_contents = CreateTabContents();
   strip.AddTabContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   strip.AddTabContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   strip.AddTabContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   strip.ActivateTabAt(2, true);
 
   // TEST 1: If the user is in a group of tabs and opens a new tab at the end
   // of the strip, closing that new tab will select the tab that they were
   // last on.
 
   // Now simulate opening a new tab at the end of the TabStrip.
-  TabContentsWrapper* new_tab_contents1 = CreateTabContents();
+  TabContents* new_tab_contents1 = CreateTabContents();
   strip.AddTabContents(new_tab_contents1, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   // At this point, if we close this tab the last selected one should be
   // re-selected.
   strip.CloseTabContentsAt(strip.count() - 1, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(page_c_contents, strip.GetTabContentsAt(strip.active_index()));
 
   // TEST 2: If the user is in a group of tabs and opens a new tab at the end
   // of the strip, selecting any other tab in the strip will cause that new
   // tab's opener relationship to be forgotten.
 
   // Open a new tab again.
-  TabContentsWrapper* new_tab_contents2 = CreateTabContents();
+  TabContents* new_tab_contents2 = CreateTabContents();
   strip.AddTabContents(new_tab_contents2, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   // Now select the first tab.
   strip.ActivateTabAt(0, true);
 
   // Now select the last tab.
   strip.ActivateTabAt(strip.count() - 1, true);
 
   // Now close the last tab. The next adjacent should be selected.
   strip.CloseTabContentsAt(strip.count() - 1, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(page_d_contents, strip.GetTabContentsAt(strip.active_index()));
 
   strip.CloseAllTabs();
 }
 
 // Tests that fast shutdown is attempted appropriately.
 TEST_F(TabStripModelTest, FastShutdown) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   MockTabStripModelObserver observer(&tabstrip);
   tabstrip.AddObserver(&observer);
 
   EXPECT_TRUE(tabstrip.empty());
 
   // Make sure fast shutdown is attempted when tabs that share a RPH are shut
   // down.
   {
-    TabContentsWrapper* contents1 = CreateTabContents();
-    TabContentsWrapper* contents2 =
+    TabContents* contents1 = CreateTabContents();
+    TabContents* contents2 =
         CreateTabContentsWithSharedRPH(contents1->web_contents());
 
     SetID(contents1->web_contents(), 1);
     SetID(contents2->web_contents(), 2);
 
     tabstrip.AppendTabContents(contents1, true);
     tabstrip.AppendTabContents(contents2, true);
 
     // Turn on the fake unload listener so the tabs don't actually get shut
     // down when we call CloseAllTabs()---we need to be able to check that
     // fast shutdown was attempted.
     delegate.set_run_unload_listener(true);
     tabstrip.CloseAllTabs();
     // On a mock RPH this checks whether we *attempted* fast shutdown.
     // A real RPH would reject our attempt since there is an unload handler.
     EXPECT_TRUE(contents1->web_contents()->
       GetRenderProcessHost()->FastShutdownStarted());
     EXPECT_EQ(2, tabstrip.count());
 
     delegate.set_run_unload_listener(false);
     tabstrip.CloseAllTabs();
     EXPECT_TRUE(tabstrip.empty());
   }
 
   // Make sure fast shutdown is not attempted when only some tabs that share a
   // RPH are shut down.
   {
-    TabContentsWrapper* contents1 = CreateTabContents();
-    TabContentsWrapper* contents2 =
+    TabContents* contents1 = CreateTabContents();
+    TabContents* contents2 =
         CreateTabContentsWithSharedRPH(contents1->web_contents());
 
     SetID(contents1->web_contents(), 1);
     SetID(contents2->web_contents(), 2);
 
     tabstrip.AppendTabContents(contents1, true);
     tabstrip.AppendTabContents(contents2, true);
 
     tabstrip.CloseTabContentsAt(1, TabStripModel::CLOSE_NONE);
     EXPECT_FALSE(contents1->web_contents()->
@@ skipping 23 matching lines @@
 #endif
 
   DictionaryValue manifest;
   manifest.SetString("name", "hi!");
   manifest.SetString("version", "1");
   std::string error;
   scoped_refptr<Extension> extension_app(
       Extension::Create(path, Extension::INVALID, manifest, Extension::NO_FLAGS,
                         &error));
   extension_app->launch_web_url_ = "http://www.google.com";
-  TabContentsWrapper* contents1 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
   contents1->extension_tab_helper()->SetExtensionApp(extension_app);
-  TabContentsWrapper* contents2 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
   contents2->extension_tab_helper()->SetExtensionApp(extension_app);
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
 
   SetID(contents1->web_contents(), 1);
   SetID(contents2->web_contents(), 2);
   SetID(contents3->web_contents(), 3);
 
   // Note! The ordering of these tests is important, each subsequent test
   // builds on the state established in the previous. This is important if you
   // ever insert tests rather than append.
 
   // Initial state, tab3 only and selected.
@@ skipping 93 matching lines @@
 TEST_F(TabStripModelTest, Pinning) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   MockTabStripModelObserver observer(&tabstrip);
   tabstrip.AddObserver(&observer);
 
   EXPECT_TRUE(tabstrip.empty());
 
   typedef MockTabStripModelObserver::State State;
 
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
 
   SetID(contents1->web_contents(), 1);
   SetID(contents2->web_contents(), 2);
   SetID(contents3->web_contents(), 3);
 
   // Note! The ordering of these tests is important, each subsequent test
   // builds on the state established in the previous. This is important if you
   // ever insert tests rather than append.
 
   // Initial state, three tabs, first selected.
@@ skipping 112 matching lines @@
   // Pin "3" and "1".
   {
     tabstrip.SetTabPinned(0, true);
     tabstrip.SetTabPinned(1, true);
 
     EXPECT_EQ("1p 3p 2", GetPinnedState(tabstrip));
 
     observer.ClearStates();
   }
 
-  TabContentsWrapper* contents4 = CreateTabContents();
+  TabContents* contents4 = CreateTabContents();
   SetID(contents4->web_contents(), 4);
 
   // Insert "4" between "1" and "3". As "1" and "4" are pinned, "4" should end
   // up after them.
   {
     tabstrip.InsertTabContentsAt(1, contents4, TabStripModel::ADD_NONE);
 
     ASSERT_EQ(1, observer.GetStateCount());
     State state(contents4, 2, MockTabStripModelObserver::INSERT);
     EXPECT_TRUE(observer.StateEquals(0, state));
 
     EXPECT_EQ("1p 3p 4 2", GetPinnedState(tabstrip));
   }
 
   tabstrip.CloseAllTabs();
 }
 
 // Makes sure the TabStripModel calls the right observer methods during a
 // replace.
 TEST_F(TabStripModelTest, ReplaceSendsSelected) {
   typedef MockTabStripModelObserver::State State;
 
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
-  TabContentsWrapper* first_contents = CreateTabContents();
+  TabContents* first_contents = CreateTabContents();
   strip.AddTabContents(first_contents, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   MockTabStripModelObserver tabstrip_observer(&strip);
   strip.AddObserver(&tabstrip_observer);
 
-  TabContentsWrapper* new_contents = CreateTabContents();
+  TabContents* new_contents = CreateTabContents();
   delete strip.ReplaceTabContentsAt(0, new_contents);
 
   ASSERT_EQ(2, tabstrip_observer.GetStateCount());
 
   // First event should be for replaced.
   State state(new_contents, 0, MockTabStripModelObserver::REPLACED);
   state.src_contents = first_contents;
   EXPECT_TRUE(tabstrip_observer.StateEquals(0, state));
 
   // And the second for selected.
   state = State(new_contents, 0, MockTabStripModelObserver::ACTIVATE);
   state.src_contents = first_contents;
   EXPECT_TRUE(tabstrip_observer.StateEquals(1, state));
 
   // Now add another tab and replace it, making sure we don't get a selected
   // event this time.
-  TabContentsWrapper* third_contents = CreateTabContents();
+  TabContents* third_contents = CreateTabContents();
   strip.AddTabContents(third_contents, 1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_NONE);
 
   tabstrip_observer.ClearStates();
 
   // And replace it.
   new_contents = CreateTabContents();
   delete strip.ReplaceTabContentsAt(1, new_contents);
 
   ASSERT_EQ(1, tabstrip_observer.GetStateCount());
 
   state = State(new_contents, 1, MockTabStripModelObserver::REPLACED);
   state.src_contents = third_contents;
   EXPECT_TRUE(tabstrip_observer.StateEquals(0, state));
 
   strip.CloseAllTabs();
 }
 
 // Ensures discarding tabs leaves TabStripModel in a good state.
 TEST_F(TabStripModelTest, DiscardTabContentsAt) {
   typedef MockTabStripModelObserver::State State;
 
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
 
   // Fill it with some tabs.
-  TabContentsWrapper* contents1 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
   tabstrip.AppendTabContents(contents1, true);
-  TabContentsWrapper* contents2 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
   tabstrip.AppendTabContents(contents2, true);
 
   // Start watching for events after the appends to avoid observing state
   // transitions that aren't relevant to this test.
   MockTabStripModelObserver tabstrip_observer(&tabstrip);
   tabstrip.AddObserver(&tabstrip_observer);
 
   // Discard one of the tabs.
-  TabContentsWrapper* null_contents1 = tabstrip.DiscardTabContentsAt(0);
+  TabContents* null_contents1 = tabstrip.DiscardTabContentsAt(0);
   ASSERT_EQ(2, tabstrip.count());
   EXPECT_TRUE(tabstrip.IsTabDiscarded(0));
   EXPECT_FALSE(tabstrip.IsTabDiscarded(1));
   ASSERT_EQ(null_contents1, tabstrip.GetTabContentsAt(0));
   ASSERT_EQ(contents2, tabstrip.GetTabContentsAt(1));
   ASSERT_EQ(1, tabstrip_observer.GetStateCount());
   State state1(null_contents1, 0, MockTabStripModelObserver::REPLACED);
   state1.src_contents = contents1;
   EXPECT_TRUE(tabstrip_observer.StateEquals(0, state1));
   tabstrip_observer.ClearStates();
 
   // Discard the same tab again.
-  TabContentsWrapper* null_contents2 = tabstrip.DiscardTabContentsAt(0);
+  TabContents* null_contents2 = tabstrip.DiscardTabContentsAt(0);
   ASSERT_EQ(2, tabstrip.count());
   EXPECT_TRUE(tabstrip.IsTabDiscarded(0));
   EXPECT_FALSE(tabstrip.IsTabDiscarded(1));
   ASSERT_EQ(null_contents2, tabstrip.GetTabContentsAt(0));
   ASSERT_EQ(contents2, tabstrip.GetTabContentsAt(1));
   ASSERT_EQ(1, tabstrip_observer.GetStateCount());
   State state2(null_contents2, 0, MockTabStripModelObserver::REPLACED);
   state2.src_contents = null_contents1;
   EXPECT_TRUE(tabstrip_observer.StateEquals(0, state2));
   tabstrip_observer.ClearStates();
 
   // Activating the tab should clear its discard state.
   tabstrip.ActivateTabAt(0, true /* user_gesture */);
   ASSERT_EQ(2, tabstrip.count());
   EXPECT_FALSE(tabstrip.IsTabDiscarded(0));
   EXPECT_FALSE(tabstrip.IsTabDiscarded(1));
 
   // Discarding the active tab should not crash.
-  TabContentsWrapper* null_contents3 = tabstrip.DiscardTabContentsAt(0);
+  TabContents* null_contents3 = tabstrip.DiscardTabContentsAt(0);
   ASSERT_EQ(2, tabstrip.count());
   EXPECT_TRUE(tabstrip.IsTabDiscarded(0));
   EXPECT_FALSE(tabstrip.IsTabDiscarded(1));
   ASSERT_EQ(null_contents3, tabstrip.GetTabContentsAt(0));
 
   tabstrip.CloseAllTabs();
 }
 
 // Makes sure TabStripModel handles the case of deleting a tab while removing
 // another tab.
 TEST_F(TabStripModelTest, DeleteFromDestroy) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
   strip.AppendTabContents(contents1, true);
   strip.AppendTabContents(contents2, true);
   // DeleteTabContentsOnDestroyedObserver deletes contents1 when contents2 sends
   // out notification that it is being destroyed.
   DeleteTabContentsOnDestroyedObserver observer(contents2, contents1);
   strip.CloseAllTabs();
 }
 
 TEST_F(TabStripModelTest, MoveSelectedTabsTo) {
   struct TestData {
@@ skipping 54 matching lines @@
                                         test_data[i].selected_tabs));
     strip.MoveSelectedTabsTo(test_data[i].target_index);
     EXPECT_EQ(test_data[i].state_after_move, GetPinnedState(strip)) << i;
     strip.CloseAllTabs();
   }
 }
 
 TEST_F(TabStripModelTest, CloseSelectedTabs) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
   strip.AppendTabContents(contents1, true);
   strip.AppendTabContents(contents2, true);
   strip.AppendTabContents(contents3, true);
   strip.ToggleSelectionAt(1);
   strip.CloseSelectedTabs();
   EXPECT_EQ(1, strip.count());
   EXPECT_EQ(0, strip.active_index());
   strip.CloseAllTabs();
 }
 
 TEST_F(TabStripModelTest, MultipleSelection) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
   MockTabStripModelObserver observer(&strip);
-  TabContentsWrapper* contents0 = CreateTabContents();
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
-  TabContentsWrapper* contents3 = CreateTabContents();
+  TabContents* contents0 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
+  TabContents* contents3 = CreateTabContents();
   strip.AppendTabContents(contents0, false);
   strip.AppendTabContents(contents1, false);
   strip.AppendTabContents(contents2, false);
   strip.AppendTabContents(contents3, false);
   strip.AddObserver(&observer);
 
   // Selection and active tab change.
   strip.ActivateTabAt(3, true);
   ASSERT_EQ(2, observer.GetStateCount());
   ASSERT_EQ(observer.GetStateAt(0)->action,
@@ skipping 89 matching lines @@
   strip.RemoveObserver(&observer);
   strip.CloseAllTabs();
 }
 
 // Verifies that if we change the selection from a multi selection to a single
 // selection, but not in a way that changes the selected_index that
 // TabSelectionChanged is invoked.
 TEST_F(TabStripModelTest, MultipleToSingle) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
-  TabContentsWrapper* contents1 = CreateTabContents();
-  TabContentsWrapper* contents2 = CreateTabContents();
+  TabContents* contents1 = CreateTabContents();
+  TabContents* contents2 = CreateTabContents();
   strip.AppendTabContents(contents1, false);
   strip.AppendTabContents(contents2, false);
   strip.ToggleSelectionAt(0);
   strip.ToggleSelectionAt(1);
 
   MockTabStripModelObserver observer(&strip);
   strip.AddObserver(&observer);
   // This changes the selection (0 is no longer selected) but the selected_index
   // still remains at 1.
   strip.ActivateTabAt(1, true);
   ASSERT_EQ(1, observer.GetStateCount());
   MockTabStripModelObserver::State s(
       contents2, 1, MockTabStripModelObserver::SELECT);
   s.src_contents = contents2;
   s.src_index = 1;
   s.user_gesture = false;
   EXPECT_TRUE(observer.StateEquals(0, s));
   strip.RemoveObserver(&observer);
   strip.CloseAllTabs();
 }