Make TabContents ctor private; poke hole for existing callers.

chrome/browser/ui/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/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/ash/launcher/chrome_launcher_controller.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/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/activation_delegate.h"
 #include "ui/aura/client/aura_constants.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"
 #include "ui/base/event.h"
 
+// TODO(avi): Kill this when TabContents goes away.
+class BrowserLauncherItemControllerContentsCreator {
+ public:
+  static TabContents* CreateTabContents(content::WebContents* contents) {
+    return TabContents::Factory::CreateTabContents(contents);
+  }
+};
+
 namespace {
 
 // Test implementation of AppTabHelper
 class AppTabHelperImpl : public ChromeLauncherController::AppTabHelper {
  public:
   AppTabHelperImpl() {}
   virtual ~AppTabHelperImpl() {}
 
   // Sets the id for the specified tab. The id is removed if Remove() is
   // invoked.
@@ skipping 168 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();
   {
-    TabContents tab_contents(CreateTestWebContents());
+    scoped_ptr<TabContents> tab_contents(
+        BrowserLauncherItemControllerContentsCreator::CreateTabContents(
+            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.
   {
-    TabContents tab_contents(CreateTestWebContents());
+    scoped_ptr<TabContents> tab_contents(
+        BrowserLauncherItemControllerContentsCreator::CreateTabContents(
+            CreateTestWebContents()));
 
     TestTabStripModelDelegate tab_strip_delegate;
     TabStripModel tab_strip(&tab_strip_delegate, profile());
-    tab_strip.InsertTabContentsAt(0, &tab_contents, TabStripModel::ADD_ACTIVE);
+    tab_strip.InsertTabContentsAt(0,
+                                  tab_contents.get(),
+                                  TabStripModel::ADD_ACTIVE);
     aura::Window window(NULL);
     window.Init(ui::LAYER_NOT_DRAWN);
     root_window()->AddChild(&window);
     BrowserLauncherItemController updater(
         LauncherItemController::TYPE_TABBED,
         &window, &tab_strip, launcher_delegate_.get(),
         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());
-    TabContents panel_tab(CreateTestWebContents());
-    app_tab_helper_->SetAppID(&panel_tab, "1");  // Panels are apps.
-    tab_strip.InsertTabContentsAt(0, &panel_tab, TabStripModel::ADD_ACTIVE);
+    scoped_ptr<TabContents> panel_tab(
+        BrowserLauncherItemControllerContentsCreator::CreateTabContents(
+            CreateTestWebContents()));
+    app_tab_helper_->SetAppID(panel_tab.get(), "1");  // Panels are apps.
+    tab_strip.InsertTabContentsAt(0,
+                                  panel_tab.get(),
+                                  TabStripModel::ADD_ACTIVE);
     BrowserLauncherItemController updater(
         LauncherItemController::TYPE_APP_PANEL,
         &window, &tab_strip, launcher_delegate_.get(),
         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());
-    TabContents panel_tab(CreateTestWebContents());
-    app_tab_helper_->SetAppID(&panel_tab, "1");  // Panels are apps.
-    tab_strip.InsertTabContentsAt(0, &panel_tab, TabStripModel::ADD_ACTIVE);
+    scoped_ptr<TabContents> panel_tab(
+        BrowserLauncherItemControllerContentsCreator::CreateTabContents(
+            CreateTestWebContents()));
+    app_tab_helper_->SetAppID(panel_tab.get(), "1");  // Panels are apps.
+    tab_strip.InsertTabContentsAt(0,
+                                  panel_tab.get(),
+                                  TabStripModel::ADD_ACTIVE);
     BrowserLauncherItemController updater(
         LauncherItemController::TYPE_EXTENSION_PANEL,
         &window, &tab_strip, launcher_delegate_.get(),
         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();
-  TabContents tab1(CreateTestWebContents());
+    scoped_ptr<TabContents> tab1(
+        BrowserLauncherItemControllerContentsCreator::CreateTabContents(
+            CreateTestWebContents()));
 
-  app_tab_helper_->SetAppID(&tab1, "1");
+  app_tab_helper_->SetAppID(tab1.get(), "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"));
   EXPECT_EQ(initial_size + 1, launcher_model_->items().size());
 
   launcher_delegate_.reset(
       new ChromeLauncherController(profile(), launcher_model_.get()));
   app_tab_helper_ = new AppTabHelperImpl;
-  app_tab_helper_->SetAppID(&tab1, "1");
+  app_tab_helper_->SetAppID(tab1.get(), "1");
   ResetAppTabHelper();
   app_icon_loader_ = new AppIconLoaderImpl;
   ResetAppIconLoader();
   launcher_delegate_->Init();
   EXPECT_GT(app_icon_loader_->GetAndClearFetchCount(), 0);
   ASSERT_EQ(initial_size + 1, launcher_model_->items().size());
   EXPECT_TRUE(launcher_delegate_->IsAppPinned("1"));
   EXPECT_FALSE(launcher_delegate_->IsAppPinned("0"));
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT,
             launcher_model_->items()[1].type);
@@ skipping 81 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);
 }