Moves methods for finding browsers to browser_finder.

chrome/browser/ui/browser_list.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/browser_list.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/printing/background_printing_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_shutdown.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 78 matching lines @@
     }
   }
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserActivityObserver);
 };
 
 BrowserActivityObserver* activity_observer = NULL;
 
-// Type used to indicate to match anything.
-const int kMatchAny                     = 0;
-
-// See BrowserMatches for details.
-const int kMatchOriginalProfile         = 1 << 0;
-const int kMatchCanSupportWindowFeature = 1 << 1;
-const int kMatchTabbed                  = 1 << 2;
-
 static BrowserList::BrowserVector& browsers() {
   CR_DEFINE_STATIC_LOCAL(BrowserList::BrowserVector, browser_vector, ());
   return browser_vector;
 }
 
 static BrowserList::BrowserVector& last_active_browsers() {
   CR_DEFINE_STATIC_LOCAL(BrowserList::BrowserVector, last_active_vector, ());
   return last_active_vector;
 }
 
 static ObserverList<BrowserList::Observer>& observers() {
   CR_DEFINE_STATIC_LOCAL(
       ObserverList<BrowserList::Observer>, observer_vector, ());
   return observer_vector;
 }
 
-// Returns true if the specified |browser| matches the specified arguments.
-// |match_types| is a bitmask dictating what parameters to match:
-// . If it contains kMatchOriginalProfile then the original profile of the
-//   browser must match |profile->GetOriginalProfile()|. This is used to match
-//   incognito windows.
-// . If it contains kMatchCanSupportWindowFeature
-//   |CanSupportWindowFeature(window_feature)| must return true.
-// . If it contains kMatchTabbed, the browser must be a tabbed browser.
-bool BrowserMatches(Browser* browser,
-                    Profile* profile,
-                    Browser::WindowFeature window_feature,
-                    uint32 match_types) {
-  if (match_types & kMatchCanSupportWindowFeature &&
-      !browser->CanSupportWindowFeature(window_feature)) {
-    return false;
-  }
-
-  if (match_types & kMatchOriginalProfile) {
-    if (browser->profile()->GetOriginalProfile() !=
-        profile->GetOriginalProfile())
-      return false;
-  } else if (browser->profile() != profile) {
-    return false;
-  }
-
-  if (match_types & kMatchTabbed)
-    return browser->is_type_tabbed();
-
-  return true;
-}
-
-// Returns the first browser in the specified iterator that returns true from
-// |BrowserMatches|, or null if no browsers match the arguments. See
-// |BrowserMatches| for details on the arguments.
-template <class T>
-Browser* FindBrowserMatching(const T& begin,
-                             const T& end,
-                             Profile* profile,
-                             Browser::WindowFeature window_feature,
-                             uint32 match_types) {
-  for (T i = begin; i != end; ++i) {
-    if (BrowserMatches(*i, profile, window_feature, match_types))
-      return *i;
-  }
-  return NULL;
-}
-
-Browser* FindBrowserWithTabbedOrAnyType(Profile* profile,
-                                        bool match_tabbed,
-                                        bool match_original_profiles) {
-  uint32 match_types = kMatchAny;
-  if (match_tabbed)
-    match_types |= kMatchTabbed;
-  if (match_original_profiles)
-    match_types |= kMatchOriginalProfile;
-  Browser* browser = FindBrowserMatching(
-      BrowserList::begin_last_active(), BrowserList::end_last_active(),
-      profile, Browser::FEATURE_NONE, match_types);
-  // Fall back to a forward scan of all Browsers if no active one was found.
-  return browser ? browser :
-      FindBrowserMatching(BrowserList::begin(), BrowserList::end(), profile,
-                          Browser::FEATURE_NONE, match_types);
-}
-
 printing::BackgroundPrintingManager* GetBackgroundPrintingManager() {
   return g_browser_process->background_printing_manager();
 }
 
 // Returns true if all browsers can be closed without user interaction.
 // This currently checks if there is pending download, or if it needs to
 // handle unload handler.
 bool AreAllBrowsersCloseable() {
   BrowserList::const_iterator browser_it = BrowserList::begin();
   if (browser_it == BrowserList::end())
@@ skipping 238 matching lines @@
         return;
       }
     }
   }
 }
 
 void BrowserList::CloseAllBrowsersWithProfile(Profile* profile) {
   BrowserVector browsers_to_close;
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
-    if (BrowserMatches(*i, profile, Browser::FEATURE_NONE,
-        kMatchOriginalProfile)) {
+    if ((*i)->profile()->GetOriginalProfile() == profile->GetOriginalProfile())
       browsers_to_close.push_back(*i);
-    }
   }
 
   for (BrowserVector::const_iterator i = browsers_to_close.begin();
        i != browsers_to_close.end(); ++i) {
     (*i)->window()->Close();
   }
 }
 
 // static
 void BrowserList::AttemptUserExit() {
@@ skipping 116 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SESSION_END,
       content::NotificationService::AllSources(),
       content::NotificationService::NoDetails());
 
   // This will end by terminating the process.
   content::ImmediateShutdownAndExitProcess();
 }
 
 // static
-bool BrowserList::HasBrowserWithProfile(Profile* profile) {
-  return FindBrowserMatching(BrowserList::begin(),
-                             BrowserList::end(),
-                             profile,
-                             Browser::FEATURE_NONE,
-                             kMatchAny) != NULL;
-}
-
-// static
 int BrowserList::keep_alive_count_ = 0;
 
 // static
 void BrowserList::StartKeepAlive() {
   // Increment the browser process refcount as long as we're keeping the
   // application alive.
   if (!WillKeepAlive())
     g_browser_process->AddRefModule();
   keep_alive_count_++;
 }
@@ skipping 60 matching lines @@
 
 // static
 Browser* BrowserList::GetLastActive() {
   if (!last_active_browsers().empty())
     return *(last_active_browsers().rbegin());
 
   return NULL;
 }
 
 // static
-Browser* BrowserList::GetLastActiveWithProfile(Profile* profile) {
-  // We are only interested in last active browsers, so we don't fall back to
-  // all browsers like FindBrowserWith* do.
-  return FindBrowserMatching(
-      BrowserList::begin_last_active(), BrowserList::end_last_active(), profile,
-      Browser::FEATURE_NONE, kMatchAny);
-}
-
-// static
-Browser* BrowserList::FindTabbedBrowser(Profile* profile,
-                                        bool match_original_profiles) {
-  return FindBrowserWithTabbedOrAnyType(profile,
-                                        true,
-                                        match_original_profiles);
-}
-
-// static
-Browser* BrowserList::FindAnyBrowser(Profile* profile,
-                                     bool match_original_profiles) {
-  return FindBrowserWithTabbedOrAnyType(profile,
-                                        false,
-                                        match_original_profiles);
-}
-
-// static
-Browser* BrowserList::FindBrowserWithFeature(Profile* profile,
-                                             Browser::WindowFeature feature) {
-  Browser* browser = FindBrowserMatching(
-      BrowserList::begin_last_active(), BrowserList::end_last_active(),
-      profile, feature, kMatchCanSupportWindowFeature);
-  // Fall back to a forward scan of all Browsers if no active one was found.
-  return browser ? browser :
-      FindBrowserMatching(BrowserList::begin(), BrowserList::end(), profile,
-                          feature, kMatchCanSupportWindowFeature);
-}
-
-// static
-Browser* BrowserList::FindBrowserWithProfile(Profile* profile) {
-  return FindAnyBrowser(profile, false);
-}
-
-// static
-Browser* BrowserList::FindBrowserWithID(SessionID::id_type desired_id) {
-  for (BrowserList::const_iterator i = BrowserList::begin();
-       i != BrowserList::end(); ++i) {
-    if ((*i)->session_id().id() == desired_id)
-      return *i;
-  }
-  return NULL;
-}
-
-// static
-Browser* BrowserList::FindBrowserWithWindow(gfx::NativeWindow window) {
-  for (BrowserList::const_iterator it = BrowserList::begin();
-       it != BrowserList::end();
-       ++it) {
-    Browser* browser = *it;
-    if (browser->window() && browser->window()->GetNativeHandle() == window)
-      return browser;
-  }
-  return NULL;
-}
-
-// static
-Browser* BrowserList::FindBrowserWithWebContents(WebContents* web_contents) {
-  DCHECK(web_contents);
-  for (TabContentsIterator it; !it.done(); ++it) {
-    if (it->web_contents() == web_contents)
-      return it.browser();
-  }
-  return NULL;
-}
-
-// static
 BrowserList::const_reverse_iterator BrowserList::begin_last_active() {
   return last_active_browsers().rbegin();
 }
 
 // static
 BrowserList::const_reverse_iterator BrowserList::end_last_active() {
   return last_active_browsers().rend();
 }
 
 // static
-size_t BrowserList::GetBrowserCount(Profile* profile) {
-  size_t result = 0;
-  for (BrowserList::const_iterator i = BrowserList::begin();
-       i != BrowserList::end(); ++i) {
-    if (BrowserMatches(*i, profile, Browser::FEATURE_NONE, kMatchAny)) {
-      ++result;
-    }
-  }
-  return result;
-}
-
-// static
-size_t BrowserList::GetBrowserCountForType(Profile* profile,
-                                           bool match_tabbed) {
-  size_t result = 0;
-  for (BrowserList::const_iterator i = BrowserList::begin();
-       i != BrowserList::end(); ++i) {
-    if (BrowserMatches(*i, profile, Browser::FEATURE_NONE,
-                       match_tabbed ? kMatchTabbed : kMatchAny))
-      ++result;
-  }
-  return result;
-}
-
-// static
 bool BrowserList::IsOffTheRecordSessionActive() {
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     if ((*i)->profile()->IsOffTheRecord())
       return true;
   }
   return false;
 }
 
 // static
@@ skipping 56 matching lines @@
   // If no more WebContents from Browsers, check the BackgroundPrintingManager.
   while (bg_printing_iterator_ != GetBackgroundPrintingManager()->end()) {
     cur_ = *bg_printing_iterator_;
     CHECK(cur_);
     ++bg_printing_iterator_;
     return;
   }
   // Reached the end - no more WebContents.
   cur_ = NULL;
 }