Add abstractions that let embedders drive tests of WebContents.

chrome/browser/ui/views/ash/launcher/launcher_updater_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/views/ash/launcher/launcher_updater.h"
 
 #include <map>
 #include <string>
 
 #include "ash/launcher/launcher_model.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/views/ash/launcher/chrome_launcher_delegate.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/tabs/test_tab_strip_model_delegate.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
-#include "content/browser/tab_contents/test_tab_contents.h"
 #include "content/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/client/activation_delegate.h"
 #include "ui/aura/test/test_activation_client.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 
@@ skipping 160 matching lines @@
   content::TestBrowserThread browser_thread_;
   std::vector<State*> states;
 
   DISALLOW_COPY_AND_ASSIGN(LauncherUpdaterTest);
 };
 
 // Verifies a new launcher item is added for TYPE_TABBED.
 TEST_F(LauncherUpdaterTest, TabbedSetup) {
   size_t initial_size = launcher_model_->items().size();
   {
-    TabContentsWrapper wrapper(CreateTestTabContents());
+    TabContentsWrapper wrapper(CreateTestWebContents());
     State state(this, std::string(), LauncherUpdater::TYPE_TABBED);
 
     // Since the type is tabbed and there is nothing in the tabstrip an item
     // should not have been added.
     EXPECT_EQ(initial_size, launcher_model_->items().size());
 
     // Add a tab.
     state.tab_strip.InsertTabContentsAt(0, &wrapper, TabStripModel::ADD_ACTIVE);
 
     // There should be one more item.
     ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
     // New item should be added at the end.
     EXPECT_EQ(ash::TYPE_TABBED, launcher_model_->items()[initial_size].type);
   }
   // Deleting the LauncherUpdater should have removed the item.
   ASSERT_EQ(initial_size, launcher_model_->items().size());
 
   // Do the same, but this time add the tab first.
   {
-    TabContentsWrapper wrapper(CreateTestTabContents());
+    TabContentsWrapper wrapper(CreateTestWebContents());
 
     TestTabStripModelDelegate tab_strip_delegate;
     TabStripModel tab_strip(&tab_strip_delegate, profile());
     tab_strip.InsertTabContentsAt(0, &wrapper, TabStripModel::ADD_ACTIVE);
     aura::Window window(NULL);
     window.Init(ui::Layer::LAYER_NOT_DRAWN);
     root_window()->AddChild(&window);
     LauncherUpdater updater(&window, &tab_strip, launcher_delegate_.get(),
                             LauncherUpdater::TYPE_TABBED, std::string());
     updater.Init();
@@ skipping 17 matching lines @@
   }
   // Deleting the LauncherUpdater should have removed the item.
   ASSERT_EQ(initial_size, launcher_model_->items().size());
 }
 
 // Various assertions when adding/removing a tab that has an app associated with
 // it.
 TEST_F(LauncherUpdaterTest, TabbedWithApp) {
   size_t initial_size = launcher_model_->items().size();
   {
-    TabContentsWrapper initial_tab(CreateTestTabContents());
+    TabContentsWrapper initial_tab(CreateTestWebContents());
     State state(this, std::string(), LauncherUpdater::TYPE_TABBED);
     // Add a tab.
     state.tab_strip.InsertTabContentsAt(0, &initial_tab,
                                         TabStripModel::ADD_ACTIVE);
 
     // There should be one more item.
     ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
     // New item should be added at the end.
     EXPECT_EQ(ash::TYPE_TABBED, launcher_model_->items()[initial_size].type);
     ash::LauncherID tabbed_id = launcher_model_->items()[initial_size].id;
 
     // Add another tab, configure it so that the launcher thinks it's an app.
-    TabContentsWrapper app_tab(CreateTestTabContents());
+    TabContentsWrapper app_tab(CreateTestWebContents());
     app_icon_loader_->SetAppID(&app_tab, "1");
     state.tab_strip.InsertTabContentsAt(1, &app_tab, TabStripModel::ADD_NONE);
 
     // There should be one more item.
     ASSERT_EQ(initial_size + 2, launcher_model_->items().size());
     // New item should be added at the end.
     EXPECT_EQ(ash::TYPE_APP, launcher_model_->items()[initial_size + 1].type);
 
     // Remove the first tab, this should trigger removing the tabbed item.
     state.tab_strip.DetachTabContentsAt(0);
@@ skipping 13 matching lines @@
   ASSERT_EQ(initial_size, launcher_model_->items().size());
 }
 
 TEST_F(LauncherUpdaterTest, TabbedWithAppOnCreate) {
   size_t initial_size = launcher_model_->items().size();
   aura::Window window(NULL);
   window.Init(ui::Layer::LAYER_NOT_DRAWN);
   root_window()->AddChild(&window);
   TestTabStripModelDelegate tab_strip_delegate;
   TabStripModel tab_strip(&tab_strip_delegate, profile());
-  TabContentsWrapper app_tab(CreateTestTabContents());
+  TabContentsWrapper app_tab(CreateTestWebContents());
   app_icon_loader_->SetAppID(&app_tab, "1");
   tab_strip.InsertTabContentsAt(0, &app_tab, TabStripModel::ADD_ACTIVE);
   LauncherUpdater updater(&window, &tab_strip, launcher_delegate_.get(),
                           LauncherUpdater::TYPE_TABBED, std::string());
   updater.Init();
   ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
   EXPECT_EQ(ash::TYPE_APP, launcher_model_->items()[initial_size].type);
 }
 
 // Verifies transitioning from a normal tab to app tab and back works.
 TEST_F(LauncherUpdaterTest, ChangeToApp) {
   size_t initial_size = launcher_model_->items().size();
   {
-    TabContentsWrapper initial_tab(CreateTestTabContents());
+    TabContentsWrapper initial_tab(CreateTestWebContents());
     State state(this, std::string(), LauncherUpdater::TYPE_TABBED);
     // Add a tab.
     state.tab_strip.InsertTabContentsAt(0, &initial_tab,
                                         TabStripModel::ADD_ACTIVE);
 
     // There should be one more item.
     ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
     // New item should be added at the end.
     EXPECT_EQ(ash::TYPE_TABBED, launcher_model_->items()[initial_size].type);
     ash::LauncherID tabbed_id = launcher_model_->items()[initial_size].id;
@@ skipping 13 matching lines @@
     EXPECT_EQ(tabbed_id, launcher_model_->items()[initial_size].id);
   }
   // Deleting the LauncherUpdater should have removed the item.
   ASSERT_EQ(initial_size, launcher_model_->items().size());
 }
 
 // Verifies AppIconLoader is queried appropriately.
 TEST_F(LauncherUpdaterTest, QueryAppIconLoader) {
   size_t initial_size = launcher_model_->items().size();
   {
-    TabContentsWrapper initial_tab(CreateTestTabContents());
+    TabContentsWrapper initial_tab(CreateTestWebContents());
     State state(this, std::string(), LauncherUpdater::TYPE_TABBED);
     // Configure the tab as an app.
     app_icon_loader_->SetAppID(&initial_tab, "1");
     // Add a tab.
     state.tab_strip.InsertTabContentsAt(0, &initial_tab,
                                         TabStripModel::ADD_ACTIVE);
     // AppIconLoader should have been queried.
     EXPECT_GT(app_icon_loader_->GetAndClearFetchCount(), 0);
     // Remove the tab.
     state.tab_strip.DetachTabContentsAt(0);
   }
   // Deleting the LauncherUpdater should have removed the item.
   ASSERT_EQ(initial_size, launcher_model_->items().size());
 }
 
 // Verifies SetAppImage works.
 TEST_F(LauncherUpdaterTest, SetAppImage) {
   size_t initial_size = launcher_model_->items().size();
-  TabContentsWrapper initial_tab(CreateTestTabContents());
+  TabContentsWrapper initial_tab(CreateTestWebContents());
   State state(this, std::string(), LauncherUpdater::TYPE_TABBED);
   // Configure the tab as an app.
   app_icon_loader_->SetAppID(&initial_tab, "1");
   // Add a tab.
   state.tab_strip.InsertTabContentsAt(0, &initial_tab,
                                       TabStripModel::ADD_ACTIVE);
   SkBitmap image;
   image.setConfig(SkBitmap::kARGB_8888_Config, 2, 3);
   image.allocPixels();
   launcher_delegate_->SetAppImage("1", &image);
   ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
   EXPECT_EQ(2, launcher_model_->items()[initial_size].image.width());
   EXPECT_EQ(3, launcher_model_->items()[initial_size].image.height());
 }
 
 // Verifies Panels items work.
 TEST_F(LauncherUpdaterTest, PanelItem) {
   size_t initial_size = launcher_model_->items().size();
   aura::Window window(NULL);
   TestTabStripModelDelegate tab_strip_delegate;
   TabStripModel tab_strip(&tab_strip_delegate, profile());
-  TabContentsWrapper panel_tab(CreateTestTabContents());
+  TabContentsWrapper panel_tab(CreateTestWebContents());
   app_icon_loader_->SetAppID(&panel_tab, "1");  // Panels are apps.
   tab_strip.InsertTabContentsAt(0, &panel_tab, TabStripModel::ADD_ACTIVE);
   LauncherUpdater updater(&window, &tab_strip, launcher_delegate_.get(),
                           LauncherUpdater::TYPE_PANEL, std::string());
   updater.Init();
   ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
   EXPECT_EQ(ash::TYPE_APP, launcher_model_->items()[initial_size].type);
   EXPECT_NE(static_cast<void*>(NULL), updater.favicon_loader_.get());
 }
 
 // Verifies app tabs are added right after the existing tabbed item.
 TEST_F(LauncherUpdaterTest, AddAppAfterTabbed) {
   size_t initial_size = launcher_model_->items().size();
-  TabContentsWrapper tab1(CreateTestTabContents());
+  TabContentsWrapper tab1(CreateTestWebContents());
   State state1(this, std::string(), LauncherUpdater::TYPE_TABBED);
   // Add a tab.
   state1.tab_strip.InsertTabContentsAt(0, &tab1, TabStripModel::ADD_ACTIVE);
   ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
   ash::LauncherID tabbed_id = launcher_model_->items()[initial_size].id;
 
   // Create another LauncherUpdater.
   State state2(this, std::string(), LauncherUpdater::TYPE_APP);
 
   // Should be two extra items.
   EXPECT_EQ(initial_size + 2, launcher_model_->items().size());
 
   // Add an app tab to state1, it should go after the item for state1 but
   // before the item for state2.
   int next_id = launcher_model_->next_id();
-  TabContentsWrapper app_tab(CreateTestTabContents());
+  TabContentsWrapper app_tab(CreateTestWebContents());
   app_icon_loader_->SetAppID(&app_tab, "1");
   state1.tab_strip.InsertTabContentsAt(1, &app_tab, TabStripModel::ADD_ACTIVE);
 
   ASSERT_EQ(initial_size + 3, launcher_model_->items().size());
   EXPECT_EQ(next_id, launcher_model_->items()[initial_size + 1].id);
   EXPECT_EQ(ash::TYPE_APP, launcher_model_->items()[initial_size + 1].type);
 
   // Remove the non-app tab.
   state1.tab_strip.DetachTabContentsAt(0);
   // Should have removed one item.
   EXPECT_EQ(initial_size + 2, launcher_model_->items().size());
   EXPECT_EQ(-1, launcher_model_->ItemIndexByID(tabbed_id));
   next_id = launcher_model_->next_id();
   // Add the non-app tab back. It should go to the original position (but get a
   // new id).
   state1.tab_strip.InsertTabContentsAt(0, &tab1, TabStripModel::ADD_NONE);
   ASSERT_EQ(initial_size + 3, launcher_model_->items().size());
   EXPECT_EQ(next_id, launcher_model_->items()[initial_size].id);
 }
 
 // Verifies GetWindowAndTabByID works.
 TEST_F(LauncherUpdaterTest, GetUpdaterByID) {
   size_t initial_size = launcher_model_->items().size();
-  TabContentsWrapper tab1(CreateTestTabContents());
-  TabContentsWrapper tab2(CreateTestTabContents());
-  TabContentsWrapper tab3(CreateTestTabContents());
+  TabContentsWrapper tab1(CreateTestWebContents());
+  TabContentsWrapper tab2(CreateTestWebContents());
+  TabContentsWrapper tab3(CreateTestWebContents());
 
   // Create 3 states:
   // . tabbed with an app tab and normal tab.
   // . tabbed with a normal tab.
   // . app.
   State state1(this, std::string(), LauncherUpdater::TYPE_TABBED);
   state1.tab_strip.InsertTabContentsAt(0, &tab1, TabStripModel::ADD_ACTIVE);
   app_icon_loader_->SetAppID(&tab2, "1");
   state1.tab_strip.InsertTabContentsAt(0, &tab2, TabStripModel::ADD_NONE);
   State state2(this, std::string(), LauncherUpdater::TYPE_TABBED);
@@ skipping 27 matching lines @@
   updater = GetUpdaterByID(id);
   EXPECT_EQ(&(state3.updater), updater);
   ASSERT_TRUE(updater);
   EXPECT_TRUE(updater->GetTab(id) == NULL);
 }
 
 // Various assertions around pinning. In particular verifies destroying a
 // LauncherUpdater doesn't remove the entry for a pinned app.
 TEST_F(LauncherUpdaterTest, Pin) {
   size_t initial_size = launcher_model_->items().size();
-  TabContentsWrapper tab1(CreateTestTabContents());
-  TabContentsWrapper tab2(CreateTestTabContents());
-  TabContentsWrapper tab3(CreateTestTabContents());
+  TabContentsWrapper tab1(CreateTestWebContents());
+  TabContentsWrapper tab2(CreateTestWebContents());
+  TabContentsWrapper tab3(CreateTestWebContents());
 
   ash::LauncherID id;
   {
     State state1(this, std::string(), LauncherUpdater::TYPE_TABBED);
     app_icon_loader_->SetAppID(&tab1, "1");
     state1.tab_strip.InsertTabContentsAt(0, &tab1, TabStripModel::ADD_ACTIVE);
     ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
     id = launcher_model_->items()[initial_size].id;
     EXPECT_EQ(ash::TYPE_APP, launcher_model_->items()[initial_size].type);
     // Shouldn't be pinned.
@@ skipping 66 matching lines @@
     new_id = launcher_model_->items()[initial_size].id;
     EXPECT_EQ(id, new_id);
     EXPECT_EQ(ash::TYPE_APP, launcher_model_->items()[initial_size].type);
     EXPECT_EQ(&(state1.updater), GetUpdaterByID(new_id));
   }
 }
 
 // Verifies pinned apps are persisted and restored.
 TEST_F(LauncherUpdaterTest, PersistPinned) {
   size_t initial_size = launcher_model_->items().size();
-  TabContentsWrapper tab1(CreateTestTabContents());
+  TabContentsWrapper tab1(CreateTestWebContents());
 
   app_icon_loader_->SetAppID(&tab1, "1");
   app_icon_loader_->SetAppID(NULL, "2");
   {
     State state1(this, std::string(), LauncherUpdater::TYPE_TABBED);
     state1.tab_strip.InsertTabContentsAt(0, &tab1, TabStripModel::ADD_ACTIVE);
     ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
     ash::LauncherID id = launcher_model_->items()[initial_size].id;
     EXPECT_EQ(ash::TYPE_APP, launcher_model_->items()[initial_size].type);
     // Shouldn't be pinned.
@@ skipping 37 matching lines @@
 
   UnpinAppsWithID("1");
   ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
   ash::LauncherID id3 = launcher_model_->items()[initial_size].id;
   EXPECT_EQ(id2, id3);
 }
 
 // Confirm that tabbed browsers with apps handle activation correctly.
 TEST_F(LauncherUpdaterTest, ActivateAppsInBrowser) {
   State state(this, std::string(), LauncherUpdater::TYPE_TABBED);
-  TabContentsWrapper app_tab1(CreateTestTabContents());
+  TabContentsWrapper app_tab1(CreateTestWebContents());
   app_icon_loader_->SetAppID(&app_tab1, "1");
-  TabContentsWrapper app_tab2(CreateTestTabContents());
+  TabContentsWrapper app_tab2(CreateTestWebContents());
   app_icon_loader_->SetAppID(&app_tab2, "2");
-  TabContentsWrapper app_tab3(CreateTestTabContents());
+  TabContentsWrapper app_tab3(CreateTestWebContents());
   app_icon_loader_->SetAppID(&app_tab3, "3");
 
   // Insert an app tab.
   state.tab_strip.InsertTabContentsAt(0, &app_tab1, TabStripModel::ADD_ACTIVE);
   ASSERT_EQ(0, state.tab_strip.active_index());
   EXPECT_EQ(ash::STATUS_ACTIVE, GetItem(state.updater, &app_tab1).status);
 
   // Add a second, inactive tab.
   state.tab_strip.InsertTabContentsAt(1, &app_tab2, TabStripModel::ADD_NONE);
   ASSERT_EQ(0, state.tab_strip.active_index());
   EXPECT_EQ(ash::STATUS_ACTIVE, GetItem(state.updater, &app_tab1).status);
   EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab2).status);
 
   // Add a third, and make it active.
   state.tab_strip.InsertTabContentsAt(2, &app_tab3, TabStripModel::ADD_ACTIVE);
   ASSERT_EQ(2, state.tab_strip.active_index());
   EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab1).status);
   EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab2).status);
   EXPECT_EQ(ash::STATUS_ACTIVE, GetItem(state.updater, &app_tab3).status);
 
   // Make the first active
   state.tab_strip.ActivateTabAt(0, false);
   ASSERT_EQ(0, state.tab_strip.active_index());
   EXPECT_EQ(ash::STATUS_ACTIVE, GetItem(state.updater, &app_tab1).status);
   EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab2).status);
   EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab3).status);
 
   {
     // Add a 4th tab.
-    TabContentsWrapper app_tab4(CreateTestTabContents());
+    TabContentsWrapper app_tab4(CreateTestWebContents());
     app_icon_loader_->SetAppID(&app_tab3, "4");
     state.tab_strip.InsertTabContentsAt(
         4, &app_tab4, TabStripModel::ADD_ACTIVE);
     ASSERT_EQ(3, state.tab_strip.active_index());
     EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab1).status);
     EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab2).status);
     EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab3).status);
     EXPECT_EQ(ash::STATUS_ACTIVE, GetItem(state.updater, &app_tab4).status);
   }
 
   // After the 4th is closed the third becomes active.
   ASSERT_EQ(2, state.tab_strip.active_index());
   EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab1).status);
   EXPECT_EQ(ash::STATUS_RUNNING, GetItem(state.updater, &app_tab2).status);
   EXPECT_EQ(ash::STATUS_ACTIVE, GetItem(state.updater, &app_tab3).status);
 }
 
 // Confirm that tabbed browsers handle activation correctly.
 TEST_F(LauncherUpdaterTest, ActivateBrowsers) {
   State state1(this, std::string(), LauncherUpdater::TYPE_TABBED);
-  TabContentsWrapper tab1(CreateTestTabContents());
+  TabContentsWrapper tab1(CreateTestWebContents());
   state1.tab_strip.InsertTabContentsAt(0, &tab1, TabStripModel::ADD_ACTIVE);
 
   // First browser is active.
   EXPECT_EQ(ash::STATUS_ACTIVE, state1.GetUpdaterItem().status);
 
   {
     // Second browser is active and first is inactive.
     State state2(this, std::string(), LauncherUpdater::TYPE_TABBED);
-    TabContentsWrapper tab2(CreateTestTabContents());
+    TabContentsWrapper tab2(CreateTestWebContents());
     state2.tab_strip.InsertTabContentsAt(0, &tab1, TabStripModel::ADD_ACTIVE);
     EXPECT_EQ(ash::STATUS_ACTIVE, state2.GetUpdaterItem().status);
     EXPECT_EQ(ash::STATUS_RUNNING, state1.GetUpdaterItem().status);
 
     // Make first browser active again.
     activation_client_->ActivateWindow(&state1.window);
     EXPECT_EQ(ash::STATUS_ACTIVE, state1.GetUpdaterItem().status);
     EXPECT_EQ(ash::STATUS_RUNNING, state2.GetUpdaterItem().status);
 
     // And back to second.
@@ skipping 57 matching lines @@
 
   // And to the second item active.
   ash::LauncherItem new_item2(launcher_model_->items()[index2]);
   new_item2.status = ash::STATUS_ACTIVE;
   launcher_model_->Set(index2, new_item2);
   EXPECT_EQ(ash::STATUS_RUNNING, launcher_model_->items()[index1].status);
   EXPECT_EQ(ash::STATUS_ACTIVE, launcher_model_->items()[index2].status);
   EXPECT_EQ(&state2.window, activation_client_->GetActiveWindow());
 }