Remove TabContents from ui/ash.

chrome/browser/ui/ash/launcher/chrome_launcher_controller_per_browser.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/chrome_launcher_controller_per_browser.h"
 
 #include <vector>
 
 #include "ash/launcher/launcher_model.h"
 #include "ash/shell.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/ui/ash/launcher/launcher_app_icon_loader.h"
 #include "chrome/browser/ui/ash/launcher/launcher_app_tab_helper.h"
 #include "chrome/browser/ui/ash/launcher/launcher_context_menu.h"
 #include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/shell_window_launcher_controller.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/url_pattern.h"
 #include "grit/theme_resources.h"
 #include "ui/aura/window.h"
 
+using content::WebContents;
 using extensions::Extension;
 
 namespace {
 
 // Item controller for an app shortcut. Shortcuts track app and launcher ids,
 // but do not have any associated windows (opening a shortcut will replace the
 // item with the appropriate LauncherItemController type).
 class AppShortcutLauncherItemController : public LauncherItemController {
  public:
   AppShortcutLauncherItemController(
@@ skipping 350 matching lines @@
 
     AppShortcutLauncherItemController* app_controller =
         static_cast<AppShortcutLauncherItemController*>(controller);
     const GURL refocus_url = app_controller->refocus_url();
 
     if (!refocus_url.is_empty())
       refocus_pattern.Parse(refocus_url.spec());
   }
 
   // Check if there are any open tabs for this app.
-  AppIDToTabContentsListMap::iterator app_i =
-      app_id_to_tab_contents_list_.find(app_id);
-  if (app_i != app_id_to_tab_contents_list_.end()) {
-    for (TabContentsList::iterator tab_i = app_i->second.begin();
+  AppIDToWebContentsListMap::iterator app_i =
+      app_id_to_web_contents_list_.find(app_id);
+  if (app_i != app_id_to_web_contents_list_.end()) {
+    for (WebContentsList::iterator tab_i = app_i->second.begin();
          tab_i != app_i->second.end();
          ++tab_i) {
-      TabContents* tab = *tab_i;
-      const GURL tab_url = tab->web_contents()->GetURL();
+      WebContents* tab = *tab_i;
+      const GURL tab_url = tab->GetURL();
       if (refocus_pattern.MatchesURL(tab_url)) {
-        Browser* browser = chrome::FindBrowserWithWebContents(
-            tab->web_contents());
+        Browser* browser = chrome::FindBrowserWithWebContents(tab);
         TabStripModel* tab_strip = browser->tab_strip_model();
-        int index = tab_strip->GetIndexOfTabContents(tab);
+        int index = tab_strip->GetIndexOfWebContents(tab);
         DCHECK_NE(TabStripModel::kNoTab, index);
         tab_strip->ActivateTabAt(index, false);
         browser->window()->Show();
         ash::wm::ActivateWindow(browser->window()->GetNativeWindow());
         return;
       }
     }
   }
 
   LaunchApp(app_id, event_flags);
@@ skipping 144 matching lines @@
     aura::RootWindow* root_window) {
   ash::ShelfAutoHideBehavior behavior = GetShelfAutoHideBehavior(root_window) ==
       ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS ?
           ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER :
           ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
   SetShelfAutoHideBehaviorPrefs(behavior, root_window);
   return;
 }
 
 void ChromeLauncherControllerPerBrowser::RemoveTabFromRunningApp(
-    TabContents* tab,
+    WebContents* tab,
     const std::string& app_id) {
-  tab_contents_to_app_id_.erase(tab);
-  AppIDToTabContentsListMap::iterator i_app_id =
-      app_id_to_tab_contents_list_.find(app_id);
-  if (i_app_id != app_id_to_tab_contents_list_.end()) {
-    TabContentsList* tab_list = &i_app_id->second;
+  web_contents_to_app_id_.erase(tab);
+  AppIDToWebContentsListMap::iterator i_app_id =
+      app_id_to_web_contents_list_.find(app_id);
+  if (i_app_id != app_id_to_web_contents_list_.end()) {
+    WebContentsList* tab_list = &i_app_id->second;
     tab_list->remove(tab);
     if (tab_list->empty()) {
-      app_id_to_tab_contents_list_.erase(i_app_id);
-      i_app_id = app_id_to_tab_contents_list_.end();
+      app_id_to_web_contents_list_.erase(i_app_id);
+      i_app_id = app_id_to_web_contents_list_.end();
       ash::LauncherID id = GetLauncherIDForAppID(app_id);
       if (id > 0)
         SetItemStatus(id, ash::STATUS_CLOSED);
     }
   }
 }
 
 void ChromeLauncherControllerPerBrowser::UpdateAppState(
     content::WebContents* contents,
     AppState app_state) {
   std::string app_id = GetAppID(contents);
 
   // Check the old |app_id| for a tab. If the contents has changed we need to
   // remove it from the previous app.
-  TabContents* tab = TabContents::FromWebContents(contents);
-  if (tab_contents_to_app_id_.find(tab) != tab_contents_to_app_id_.end()) {
-    std::string last_app_id = tab_contents_to_app_id_[tab];
+  if (web_contents_to_app_id_.find(contents) != web_contents_to_app_id_.end()) {
+    std::string last_app_id = web_contents_to_app_id_[contents];
     if (last_app_id != app_id)
-      RemoveTabFromRunningApp(tab, last_app_id);
+      RemoveTabFromRunningApp(contents, last_app_id);
   }
 
   if (app_id.empty())
     return;
 
-  tab_contents_to_app_id_[tab] = app_id;
+  web_contents_to_app_id_[contents] = app_id;
 
   if (app_state == APP_STATE_REMOVED) {
     // The tab has gone away.
-    RemoveTabFromRunningApp(tab, app_id);
+    RemoveTabFromRunningApp(contents, app_id);
   } else {
-    TabContentsList& tab_list(app_id_to_tab_contents_list_[app_id]);
+    WebContentsList& tab_list(app_id_to_web_contents_list_[app_id]);
 
     if (app_state == APP_STATE_INACTIVE) {
-      TabContentsList::const_iterator i_tab =
-          std::find(tab_list.begin(), tab_list.end(), tab);
+      WebContentsList::const_iterator i_tab =
+          std::find(tab_list.begin(), tab_list.end(), contents);
       if (i_tab == tab_list.end())
-        tab_list.push_back(tab);
+        tab_list.push_back(contents);
       if (i_tab != tab_list.begin()) {
         // Going inactive, but wasn't the front tab, indicating that a new
         // tab has already become active.
         return;
       }
     } else {
-      tab_list.remove(tab);
-      tab_list.push_front(tab);
+      tab_list.remove(contents);
+      tab_list.push_front(contents);
     }
     ash::LauncherID id = GetLauncherIDForAppID(app_id);
     if (id > 0) {
       // If the window is active, mark the app as active.
       SetItemStatus(id, app_state == APP_STATE_WINDOW_ACTIVE ?
           ash::STATUS_ACTIVE : ash::STATUS_RUNNING);
     }
   }
 }
 
@@ skipping 364 matching lines @@
   ash::ShelfAlignment alignment = ash::SHELF_ALIGNMENT_BOTTOM;
   if (alignment_value == ash::kShelfAlignmentLeft)
     alignment = ash::SHELF_ALIGNMENT_LEFT;
   else if (alignment_value == ash::kShelfAlignmentRight)
     alignment = ash::SHELF_ALIGNMENT_RIGHT;
   // TODO(oshima): Support multiple displays.
   ash::Shell::GetInstance()->SetShelfAlignment(
       alignment, ash::Shell::GetPrimaryRootWindow());
 }
 
-TabContents* ChromeLauncherControllerPerBrowser::GetLastActiveTabContents(
+WebContents* ChromeLauncherControllerPerBrowser::GetLastActiveWebContents(
     const std::string& app_id) {
-  AppIDToTabContentsListMap::const_iterator i =
-      app_id_to_tab_contents_list_.find(app_id);
-  if (i == app_id_to_tab_contents_list_.end())
+  AppIDToWebContentsListMap::const_iterator i =
+      app_id_to_web_contents_list_.find(app_id);
+  if (i == app_id_to_web_contents_list_.end())
     return NULL;
   DCHECK_GT(i->second.size(), 0u);
   return *i->second.begin();
 }
 
 ash::LauncherID ChromeLauncherControllerPerBrowser::InsertAppLauncherItem(
     LauncherItemController* controller,
     const std::string& app_id,
     ash::LauncherItemStatus status,
     int index) {
   ash::LauncherID id = model_->next_id();
   DCHECK(!HasItemController(id));
   DCHECK(controller);
   id_to_item_controller_map_[id] = controller;
   controller->set_launcher_id(id);
 
   ash::LauncherItem item;
   item.type = controller->GetLauncherItemType();
   item.is_incognito = false;
   item.image = Extension::GetDefaultIcon(true);
 
-  TabContents* active_tab = GetLastActiveTabContents(app_id);
+  WebContents* active_tab = GetLastActiveWebContents(app_id);
   if (active_tab) {
-    Browser* browser = chrome::FindBrowserWithWebContents(
-        active_tab->web_contents());
+    Browser* browser = chrome::FindBrowserWithWebContents(active_tab);
     DCHECK(browser);
     if (browser->window()->IsActive())
       status = ash::STATUS_ACTIVE;
     else
       status = ash::STATUS_RUNNING;
   }
   item.status = status;
 
   model_->AddAt(index, item);
 
@@ skipping 29 matching lines @@
     AppIconLoader* loader) {
   app_icon_loader_.reset(loader);
 }
 
 const std::string&
 ChromeLauncherControllerPerBrowser::GetAppIdFromLauncherIdForTest(
     ash::LauncherID id) {
   return id_to_item_controller_map_[id]->app_id();
 }