Simplify the Observer pattern used in the BrowserList.

chrome/browser/browser_list.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/browser_list.h"
 
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 83 matching lines @@
       profile_match;
 }
 
 // Finds a registered Browser object matching |profile| and |type|. This
 // walks the list of Browsers that have ever been activated from most recently
 // activated to least. If a Browser has never been activated, such as in a test
 // scenario, this function will _not_ find it. Fall back to
 // FindBrowserMatching() in that case.
 Browser* FindInLastActiveMatching(Profile* profile, Browser::Type type,
                                   bool match_incognito) {
-  for (BrowserList::list_type::const_reverse_iterator i =
+  for (BrowserList::BrowserVector::const_reverse_iterator i =
        BrowserList::begin_last_active(); i != BrowserList::end_last_active();
        ++i) {
     if (BrowserMatchesProfileAndType(*i, profile, type, match_incognito))
       return *i;
   }
   return NULL;
 }
 
 // Finds a registered Browser object matching |profile| and |type| even if that
 // Browser has never been activated. This is a forward walk, and intended as a
 // last ditch fallback mostly to handle tests run on machines where no window is
 // ever activated. The user experience if this function is relied on is not good
 // since matching browsers will be returned in registration (creation) order.
 Browser* FindBrowserMatching(Profile* profile, Browser::Type type,
                              bool match_incognito) {
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     if (BrowserMatchesProfileAndType(*i, profile, type, match_incognito))
       return *i;
   }
   return NULL;
 }
 
 }  // namespace
 
-BrowserList::list_type BrowserList::browsers_;
-std::vector<BrowserList::Observer*> BrowserList::observers_;
+BrowserList::BrowserVector BrowserList::browsers_;
+ObserverList<BrowserList::Observer> BrowserList::observers_;
 
 // static
 void BrowserList::AddBrowser(Browser* browser) {
   DCHECK(browser);
   browsers_.push_back(browser);
 
   g_browser_process->AddRefModule();
 
   if (!activity_observer)
     activity_observer = new BrowserActivityObserver;
 
   NotificationService::current()->Notify(
       NotificationType::BROWSER_OPENED,
       Source<Browser>(browser),
       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 (size_t i = 0; i < observers_.size(); ++i)
-    observers_[i]->OnBrowserAdded(browser);
+  FOR_EACH_OBSERVER(Observer, observers_, OnBrowserAdded(browser));
   DCHECK_EQ(original_count, observers_.size())
       << "observer list modified during notification";
 }
 
 // static
 void BrowserList::RemoveBrowser(Browser* browser) {
   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 close_app_non_mac = (browsers_.size() == 1);
   NotificationService::current()->Notify(
       NotificationType::BROWSER_CLOSED,
       Source<Browser>(browser), Details<bool>(&close_app_non_mac));
 
   // Send out notifications before anything changes. Do some basic checking to
   // try to catch evil observers that change the list from under us.
   size_t original_count = observers_.size();
-  for (size_t i = 0; i < observers_.size(); ++i)
-    observers_[i]->OnBrowserRemoving(browser);
+  FOR_EACH_OBSERVER(Observer, observers_, OnBrowserRemoving(browser));
   DCHECK_EQ(original_count, observers_.size())
       << "observer list modified during notification";
 
   RemoveBrowserFrom(browser, &browsers_);
 
   // If the last Browser object was destroyed, make sure we try to close any
   // remaining dependent windows too.
   if (browsers_.empty()) {
     AllBrowsersClosed();
 
     delete activity_observer;
     activity_observer = NULL;
   }
 
   g_browser_process->ReleaseModule();
 }
 
 // static
 void BrowserList::AddObserver(BrowserList::Observer* observer) {
-  DCHECK(std::find(observers_.begin(), observers_.end(), observer)
-         == observers_.end()) << "Adding an observer twice";
-  observers_.push_back(observer);
+  observers_.AddObserver(observer);
 }
 
 // static
 void BrowserList::RemoveObserver(BrowserList::Observer* observer) {
-  std::vector<Observer*>::iterator i =
-      std::find(observers_.begin(), observers_.end(), observer);
-  if (i == observers_.end()) {
-    NOTREACHED() << "Removing an observer that isn't registered.";
-    return;
-  }
-  observers_.erase(i);
+  observers_.RemoveObserver(observer);
 }
 
 // static
 void BrowserList::CloseAllBrowsers(bool use_post) {
   // Before we close the browsers shutdown all session services. That way an
   // exit can restore all browsers open before exiting.
   ProfileManager::ShutdownSessionServices();
 
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end();) {
@@ skipping 91 matching lines @@
 }
 
 // static
 bool BrowserList::IsInPersistentMode() {
   // TODO(atwilson): check the boolean state variable that you will set for
   // persisent instances.
   return false;
 }
 
 // static
-BrowserList::list_type BrowserList::last_active_browsers_;
+BrowserList::BrowserVector BrowserList::last_active_browsers_;
 
 // static
 void BrowserList::SetLastActive(Browser* browser) {
   RemoveBrowserFrom(browser, &last_active_browsers_);
   last_active_browsers_.push_back(browser);
 
-  for (std::vector<Observer*>::const_iterator i = observers_.begin();
-       i != observers_.end(); ++i) {
-    (*i)->OnBrowserSetLastActive(browser);
-  }
+  FOR_EACH_OBSERVER(Observer, observers_, OnBrowserSetLastActive(browser));
 }
 
 // static
 Browser* BrowserList::GetLastActive() {
   if (!last_active_browsers_.empty())
     return *(last_active_browsers_.rbegin());
 
   return NULL;
 }
 
@@ skipping 53 matching lines @@
 bool BrowserList::IsOffTheRecordSessionActive() {
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     if ((*i)->profile()->IsOffTheRecord())
       return true;
   }
   return false;
 }
 
 // static
-void BrowserList::RemoveBrowserFrom(Browser* browser, list_type* browser_list) {
+void BrowserList::RemoveBrowserFrom(Browser* browser,
+                                    BrowserVector* browser_list) {
   const iterator remove_browser =
       std::find(browser_list->begin(), browser_list->end(), browser);
   if (remove_browser != browser_list->end())
     browser_list->erase(remove_browser);
 }
 
 TabContentsIterator::TabContentsIterator()
     : browser_iterator_(BrowserList::begin()),
       web_view_index_(-1),
       cur_(NULL) {
@@ skipping 21 matching lines @@
     }
 
     TabContents* next_tab =
         (*browser_iterator_)->GetTabContentsAt(web_view_index_);
     if (next_tab) {
       cur_ = next_tab;
       return;
     }
   }
 }