chrome: Remove 11 exit time destructors and 4 static initializers.

chrome/browser/ui/browser_list.cc

 // Copyright (c) 2011 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/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "build/build_config.h"
@@ skipping 99 matching lines @@
 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() {

[joth, 2011/11/18 01:18:14]

again non-const refs

+  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,
@@ skipping 114 matching lines @@
     chromeos::WmIpc::instance()->NotifyAboutSignout();
     notified = true;
   }
 #endif
 }
 
 #endif
 
 }  // namespace
 
-BrowserList::BrowserVector BrowserList::browsers_;
-ObserverList<BrowserList::Observer> BrowserList::observers_;
-
 // static
 void BrowserList::AddBrowser(Browser* browser) {
   DCHECK(browser);
-  browsers_.push_back(browser);
+  browsers().push_back(browser);
 
   g_browser_process->AddRefModule();
 
   if (!activity_observer)
     activity_observer = new BrowserActivityObserver;
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BROWSER_OPENED,
       content::Source<Browser>(browser),
       content::NotificationService::NoDetails());
 
   // Send out notifications after add has occurred. Do some basic checking to
   // try to catch evil observers that change the list from under us.
-  size_t original_count = observers_.size();
-  FOR_EACH_OBSERVER(Observer, observers_, OnBrowserAdded(browser));
-  DCHECK_EQ(original_count, observers_.size())
+  size_t original_count = observers().size();
+  FOR_EACH_OBSERVER(Observer, observers(), OnBrowserAdded(browser));
+  DCHECK_EQ(original_count, observers().size())
       << "observer list modified during notification";
 }
 
 // static
 void BrowserList::MarkAsCleanShutdown() {
   for (const_iterator i = begin(); i != end(); ++i) {
     (*i)->profile()->MarkAsCleanShutdown();
   }
 }
 
@@ skipping 43 matching lines @@
     }
     return;
   }
   // If running the Chrome OS build, but we're not on the device, fall through
 #endif
   AllBrowsersClosedAndAppExiting();
 }
 
 // static
 void BrowserList::RemoveBrowser(Browser* browser) {
-  RemoveBrowserFrom(browser, &last_active_browsers_);
+  RemoveBrowserFrom(browser, &last_active_browsers());
 
   // Closing all windows does not indicate quitting the application on the Mac,
   // however, many UI tests rely on this behavior so leave it be for now and
   // simply ignore the behavior on the Mac outside of unit tests.
   // TODO(andybons): Fix the UI tests to Do The Right Thing.
-  bool closing_last_browser = (browsers_.size() == 1);
+  bool closing_last_browser = (browsers().size() == 1);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::Source<Browser>(browser),
       content::Details<bool>(&closing_last_browser));
 
-  RemoveBrowserFrom(browser, &browsers_);
+  RemoveBrowserFrom(browser, &browsers());
 
   // Do some basic checking to try to catch evil observers
   // that change the list from under us.
-  size_t original_count = observers_.size();
-  FOR_EACH_OBSERVER(Observer, observers_, OnBrowserRemoved(browser));
-  DCHECK_EQ(original_count, observers_.size())
+  size_t original_count = observers().size();
+  FOR_EACH_OBSERVER(Observer, observers(), OnBrowserRemoved(browser));
+  DCHECK_EQ(original_count, observers().size())
       << "observer list modified during notification";
 
   // If the last Browser object was destroyed, make sure we try to close any
   // remaining dependent windows too.
-  if (browsers_.empty()) {
+  if (browsers().empty()) {
     delete activity_observer;
     activity_observer = NULL;
   }
 
   g_browser_process->ReleaseModule();
 
   // If we're exiting, send out the APP_TERMINATING notification to allow other
   // modules to shut themselves down.
-  if (browsers_.empty() &&
+  if (browsers().empty() &&
       (browser_shutdown::IsTryingToQuit() ||
        g_browser_process->IsShuttingDown())) {
     // Last browser has just closed, and this is a user-initiated quit or there
     // is no module keeping the app alive, so send out our notification. No need
     // to call ProfileManager::ShutdownSessionServices() as part of the
     // shutdown, because Browser::WindowClosing() already makes sure that the
     // SessionService is created and notified.
     NotifyAppTerminating();
     AllBrowsersClosedAndAppExiting();
   }
 }
 
 // static
 void BrowserList::AddObserver(BrowserList::Observer* observer) {
-  observers_.AddObserver(observer);
+  observers().AddObserver(observer);
 }
 
 // static
 void BrowserList::RemoveObserver(BrowserList::Observer* observer) {
-  observers_.RemoveObserver(observer);
+  observers().RemoveObserver(observer);
 }
 
 // static
 void BrowserList::CloseAllBrowsers() {
   bool session_ending =
       browser_shutdown::GetShutdownType() == browser_shutdown::END_SESSION;
   // Tell everyone that we are shutting down.
   browser_shutdown::SetTryingToQuit(true);
 
   // Before we close the browsers shutdown all session services. That way an
   // exit can restore all browsers open before exiting.
   ProfileManager::ShutdownSessionServices();
 
   // If there are no browsers, send the APP_TERMINATING action here. Otherwise,
   // it will be sent by RemoveBrowser() when the last browser has closed.
   if (browser_shutdown::ShuttingDownWithoutClosingBrowsers() ||
-      browsers_.empty()) {
+      browsers().empty()) {
     NotifyAndTerminate(true);
     return;
   }
 
 #if defined(OS_CHROMEOS)
   chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker(
       "StartedClosingWindows", false);
 #endif
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end();) {
@@ skipping 196 matching lines @@
   // Although we should have a browser process, if there is none,
   // there is nothing to do.
   if (!g_browser_process) return;
 
   // Allow the app to shutdown again.
   if (!WillKeepAlive()) {
     g_browser_process->ReleaseModule();
     // If there are no browsers open and we aren't already shutting down,
     // initiate a shutdown. Also skips shutdown if this is a unit test
     // (MessageLoop::current() == null).
-    if (browsers_.empty() && !browser_shutdown::IsTryingToQuit() &&
+    if (browsers().empty() && !browser_shutdown::IsTryingToQuit() &&
         MessageLoop::current())
       CloseAllBrowsers();
   }
 }
 
 // static
 bool BrowserList::WillKeepAlive() {
   return keep_alive_count_ > 0;
 }
 
 // static
-BrowserList::BrowserVector BrowserList::last_active_browsers_;
+BrowserList::const_iterator BrowserList::begin() {
+  return browsers().begin();
+}
+
+// static
+BrowserList::const_iterator BrowserList::end() {
+  return browsers().end();
+}
+
+// static
+bool BrowserList::empty() {
+  return browsers().empty();
+}
+
+// static
+size_t BrowserList::size() {
+  return browsers().size();
+}
 
 // static
 void BrowserList::SetLastActive(Browser* browser) {
   // If the browser is currently trying to quit, we don't want to set the last
   // active browser because that can alter the last active browser that the user
   // intended depending on the order in which the windows close.
   if (browser_shutdown::IsTryingToQuit())
     return;
-  RemoveBrowserFrom(browser, &last_active_browsers_);
-  last_active_browsers_.push_back(browser);
+  RemoveBrowserFrom(browser, &last_active_browsers());
+  last_active_browsers().push_back(browser);
 
-  FOR_EACH_OBSERVER(Observer, observers_, OnBrowserSetLastActive(browser));
+  FOR_EACH_OBSERVER(Observer, observers(), OnBrowserSetLastActive(browser));
 }
 
 // static
 Browser* BrowserList::GetLastActive() {
-  if (!last_active_browsers_.empty())
-    return *(last_active_browsers_.rbegin());
+  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,
@@ skipping 54 matching lines @@
 Browser* BrowserList::FindBrowserWithTabContents(TabContents* tab_contents) {
   DCHECK(tab_contents);
   for (TabContentsIterator it; !it.done(); ++it) {
     if (it->tab_contents() == tab_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
-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
 bool BrowserList::IsOffTheRecordSessionActive() {
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     if ((*i)->profile()->IsOffTheRecord())
       return true;
   }
   return false;
 }
@@ skipping 51 matching lines @@
   // If no more TabContents 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 TabContents.
   cur_ = NULL;
 }