Remove HostDesktopType from BrowserList::GetInstance()

chrome/browser/memory/tab_manager.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/memory/tab_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 187 matching lines @@
 // Things to collect on the browser thread (because TabStripModel isn't thread
 // safe):
 // 1) whether or not a tab is pinned
 // 2) last time a tab was selected
 // 3) is the tab currently selected
 TabStatsList TabManager::GetTabStats() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TabStatsList stats_list;
   stats_list.reserve(32);  // 99% of users have < 30 tabs open
 
-  // Go through each window to get all the tabs. Depending on the platform,
-  // windows are either native or ash or both. The goal is to make sure to go
-  // through them all, starting with the active window first (use
-  // chrome::GetActiveDesktop to get the current used type).
-  AddTabStats(BrowserList::GetInstance(chrome::GetActiveDesktop()), true,
-              &stats_list);
-  if (chrome::GetActiveDesktop() != chrome::HOST_DESKTOP_TYPE_NATIVE) {
-    AddTabStats(BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_NATIVE),
-                false, &stats_list);
-  } else if (chrome::GetActiveDesktop() != chrome::HOST_DESKTOP_TYPE_ASH) {
-    AddTabStats(BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH), false,
-                &stats_list);
-  }
+  // Go through each window to get all the tabs.
+  AddTabStats(&stats_list);
 
   // Sort the collected data so that least desirable to be killed is first, most
   // desirable is last.
   std::sort(stats_list.begin(), stats_list.end(), CompareTabStats);
   return stats_list;
 }
 
 bool TabManager::IsTabDiscarded(content::WebContents* contents) const {
   return GetWebContentsData(contents)->IsDiscarded();
 }
@@ skipping 171 matching lines @@
   }
 }
 
 int TabManager::GetTabCount() const {
   int tab_count = 0;
   for (chrome::BrowserIterator it; !it.done(); it.Next())
     tab_count += it->tab_strip_model()->count();
   return tab_count;
 }
 
-void TabManager::AddTabStats(BrowserList* browser_list,
-                             bool active_desktop,
-                             TabStatsList* stats_list) {
-  // If it's the active desktop, the first window will be the active one.
-  // Otherwise, assume no active windows.
-  bool browser_active = active_desktop;
+void TabManager::AddTabStats(TabStatsList* stats_list) {
+  BrowserList* browser_list = BrowserList::GetInstance();
+  // The first window will be the active one.
+  bool browser_active = true;
   for (BrowserList::const_reverse_iterator browser_iterator =
            browser_list->begin_last_active();
        browser_iterator != browser_list->end_last_active();
        ++browser_iterator) {
     Browser* browser = *browser_iterator;
     bool is_browser_for_app = browser->is_app();
     const TabStripModel* model = browser->tab_strip_model();
     for (int i = 0; i < model->count(); i++) {
       WebContents* contents = model->GetWebContentsAt(i);
       if (!contents->IsCrashed()) {
@@ skipping 25 matching lines @@
 }
 
 // This function is called when |update_timer_| fires. It will adjust the clock
 // if needed (if it detects that the machine was asleep) and will fire the stats
 // updating on ChromeOS via the delegate.
 void TabManager::UpdateTimerCallback() {
   // If Chrome is shutting down, do not do anything.
   if (g_browser_process->IsShuttingDown())
     return;
 
-  if (BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH)->empty() &&
-      BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_NATIVE)->empty())
+  if (BrowserList::GetInstance()->empty())
     return;
 
   // Check for a discontinuity in time caused by the machine being suspended.
   if (!last_adjust_time_.is_null()) {
     TimeDelta suspend_time = NowTicks() - last_adjust_time_;
     if (suspend_time.InSeconds() > kSuspendThresholdSeconds) {
       // System was probably suspended, move the event timers forward in time so
       // when they get subtracted out later, "uptime" is being counted.
       start_time_ += suspend_time;
       if (!last_discard_time_.is_null())
@@ skipping 187 matching lines @@
 }
 
 TimeTicks TabManager::NowTicks() const {
   if (!test_tick_clock_)
     return TimeTicks::Now();
 
   return test_tick_clock_->NowTicks();
 }
 
 }  // namespace memory