TabContentsWrapper -> TabContents, part 48.

chrome/browser/ui/views/ash/launcher/browser_launcher_item_controller_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/browser_launcher_item_controller.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/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/test_tab_strip_model_delegate.h"
 #include "chrome/browser/ui/views/ash/launcher/chrome_launcher_controller.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/activation_delegate.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_activation_client.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 
 namespace {
 
 // Test implementation of AppIconLoader.
 class AppIconLoaderImpl : public ChromeLauncherController::AppIconLoader {
  public:
   AppIconLoaderImpl() : fetch_count_(0) {}
   virtual ~AppIconLoaderImpl() {}
 
   // Sets the id for the specified tab. The id is removed if Remove() is
   // invoked.
-  void SetAppID(TabContentsWrapper* tab, const std::string& id) {
+  void SetAppID(TabContents* tab, const std::string& id) {
     tab_id_map_[tab] = id;
   }
 
   // Returns true if there is an id registered for |tab|.
-  bool HasAppID(TabContentsWrapper* tab) const {
+  bool HasAppID(TabContents* tab) const {
     return tab_id_map_.find(tab) != tab_id_map_.end();
   }
 
   // Returns the number of times FetchImage() has been invoked and resets the
   // count to 0.
   int GetAndClearFetchCount() {
     int value = fetch_count_;
     fetch_count_ = 0;
     return value;
   }
 
   // AppIconLoader implementation:
-  virtual std::string GetAppID(TabContentsWrapper* tab) OVERRIDE {
+  virtual std::string GetAppID(TabContents* tab) OVERRIDE {
     return tab_id_map_.find(tab) != tab_id_map_.end() ? tab_id_map_[tab] :
         std::string();
   }
 
   virtual bool IsValidID(const std::string& id) OVERRIDE {
     for (TabToStringMap::const_iterator i = tab_id_map_.begin();
          i != tab_id_map_.end(); ++i) {
       if (i->second == id)
         return true;
     }
     return false;
   }
 
   virtual void FetchImage(const std::string& id) OVERRIDE {
     fetch_count_++;
   }
 
  private:
-  typedef std::map<TabContentsWrapper*, std::string> TabToStringMap;
+  typedef std::map<TabContents*, std::string> TabToStringMap;
 
   TabToStringMap tab_id_map_;
 
   int fetch_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AppIconLoaderImpl);
 };
 
 }  // namespace
 
@@ skipping 102 matching lines @@
   content::TestBrowserThread browser_thread_;
   std::vector<State*> states;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserLauncherItemControllerTest);
 };
 
 // Verifies a new launcher item is added for TYPE_TABBED.
 TEST_F(BrowserLauncherItemControllerTest, TabbedSetup) {
   size_t initial_size = launcher_model_->items().size();
   {
-    TabContentsWrapper wrapper(CreateTestWebContents());
+    TabContents tab_contents(CreateTestWebContents());
     State state(this, std::string(),
                 BrowserLauncherItemController::TYPE_TABBED);
 
     // 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, state.GetUpdaterItem().type);
   }
 
   // Deleting the BrowserLauncherItemController 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(CreateTestWebContents());
+    TabContents tab_contents(CreateTestWebContents());
 
     TestTabStripModelDelegate tab_strip_delegate;
     TabStripModel tab_strip(&tab_strip_delegate, profile());
-    tab_strip.InsertTabContentsAt(0, &wrapper, TabStripModel::ADD_ACTIVE);
+    tab_strip.InsertTabContentsAt(0, &tab_contents, TabStripModel::ADD_ACTIVE);
     aura::Window window(NULL);
     window.Init(ui::LAYER_NOT_DRAWN);
     root_window()->AddChild(&window);
     BrowserLauncherItemController updater(
         &window, &tab_strip, launcher_delegate_.get(),
         BrowserLauncherItemController::TYPE_TABBED, std::string());
     updater.Init();
 
     // 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, GetItem(&updater).type);
   }
 }
 
 // Verifies Panels items work.
 TEST_F(BrowserLauncherItemControllerTest, PanelItem) {
   size_t initial_size = launcher_model_->items().size();
 
   // Add an App panel.
   {
     aura::Window window(NULL);
     TestTabStripModelDelegate tab_strip_delegate;
     TabStripModel tab_strip(&tab_strip_delegate, profile());
-    TabContentsWrapper panel_tab(CreateTestWebContents());
+    TabContents panel_tab(CreateTestWebContents());
     app_icon_loader_->SetAppID(&panel_tab, "1");  // Panels are apps.
     tab_strip.InsertTabContentsAt(0, &panel_tab, TabStripModel::ADD_ACTIVE);
     BrowserLauncherItemController updater(
         &window, &tab_strip, launcher_delegate_.get(),
         BrowserLauncherItemController::TYPE_APP_PANEL, std::string());
     updater.Init();
     ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
     EXPECT_EQ(ash::TYPE_APP_PANEL, GetItem(&updater).type);
     EXPECT_EQ(static_cast<void*>(NULL), updater.favicon_loader_.get());
   }
 
   // Add an Extension panel.
   {
     aura::Window window(NULL);
     TestTabStripModelDelegate tab_strip_delegate;
     TabStripModel tab_strip(&tab_strip_delegate, profile());
-    TabContentsWrapper panel_tab(CreateTestWebContents());
+    TabContents panel_tab(CreateTestWebContents());
     app_icon_loader_->SetAppID(&panel_tab, "1");  // Panels are apps.
     tab_strip.InsertTabContentsAt(0, &panel_tab, TabStripModel::ADD_ACTIVE);
     BrowserLauncherItemController updater(
         &window, &tab_strip, launcher_delegate_.get(),
         BrowserLauncherItemController::TYPE_EXTENSION_PANEL, std::string());
     updater.Init();
     ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
     EXPECT_EQ(ash::TYPE_APP_PANEL, GetItem(&updater).type);
     EXPECT_NE(static_cast<void*>(NULL), updater.favicon_loader_.get());
   }
 }
 
 // Verifies pinned apps are persisted and restored.
 TEST_F(BrowserLauncherItemControllerTest, PersistPinned) {
   size_t initial_size = launcher_model_->items().size();
-  TabContentsWrapper tab1(CreateTestWebContents());
+  TabContents tab1(CreateTestWebContents());
 
   app_icon_loader_->SetAppID(&tab1, "1");
 
   app_icon_loader_->GetAndClearFetchCount();
   launcher_delegate_->PinAppWithID("1");
   EXPECT_GT(app_icon_loader_->GetAndClearFetchCount(), 0);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT,
             launcher_model_->items()[1].type);
   EXPECT_TRUE(launcher_delegate_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_delegate_->IsAppPinned("0"));
@@ skipping 95 matching lines @@
   EXPECT_EQ(ash::STATUS_RUNNING, app_state.GetUpdaterItem().status);
 
   // App window should go to attention state.
   app_state.window.SetProperty(aura::client::kDrawAttentionKey, true);
   EXPECT_EQ(ash::STATUS_ATTENTION, app_state.GetUpdaterItem().status);
 
   // Activating app window should clear attention state.
   activation_client_->ActivateWindow(&app_state.window);
   EXPECT_EQ(ash::STATUS_ACTIVE, app_state.GetUpdaterItem().status);
 }