Reduce FOR_EACH_OBSERVER usage in extensions

extensions/browser/extension_host.cc

 // Copyright 2014 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 "extensions/browser/extension_host.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 84 matching lines @@
       extension_ && BackgroundInfo::HasLazyBackgroundPage(extension_) &&
       load_start_.get()) {
     UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageActiveTime2",
                              load_start_->Elapsed());
   }
 
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
       content::Source<BrowserContext>(browser_context_),
       content::Details<ExtensionHost>(this));
-  FOR_EACH_OBSERVER(ExtensionHostObserver, observer_list_,
-                    OnExtensionHostDestroyed(this));
-  FOR_EACH_OBSERVER(DeferredStartRenderHostObserver,
-                    deferred_start_render_host_observer_list_,
-                    OnDeferredStartRenderHostDestroyed(this));
+  for (auto& observer : observer_list_)
+    observer.OnExtensionHostDestroyed(this);
+  for (auto& observer : deferred_start_render_host_observer_list_)
+    observer.OnDeferredStartRenderHostDestroyed(this);
 
   // Remove ourselves from the queue as late as possible (before effectively
   // destroying self, but after everything else) so that queues that are
   // monitoring lifetime get a chance to see stop-loading events.
   delegate_->GetExtensionHostQueue()->Remove(this);
 
   // Deliberately stop observing |host_contents_| because its destruction
   // events (like DidStopLoading, it turns out) can call back into
   // ExtensionHost re-entrantly, when anything declared after |host_contents_|
   // has already been destroyed.
@@ skipping 84 matching lines @@
 }
 
 void ExtensionHost::RemoveObserver(ExtensionHostObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void ExtensionHost::OnBackgroundEventDispatched(const std::string& event_name,
                                                 int event_id) {
   CHECK(IsBackgroundPage());
   unacked_messages_.insert(event_id);
-  FOR_EACH_OBSERVER(ExtensionHostObserver, observer_list_,
-                    OnBackgroundEventDispatched(this, event_name, event_id));
+  for (auto& observer : observer_list_)
+    observer.OnBackgroundEventDispatched(this, event_name, event_id);
 }
 
 void ExtensionHost::OnNetworkRequestStarted(uint64_t request_id) {
-  FOR_EACH_OBSERVER(ExtensionHostObserver, observer_list_,
-                    OnNetworkRequestStarted(this, request_id));
+  for (auto& observer : observer_list_)
+    observer.OnNetworkRequestStarted(this, request_id);
 }
 
 void ExtensionHost::OnNetworkRequestDone(uint64_t request_id) {
-  FOR_EACH_OBSERVER(ExtensionHostObserver, observer_list_,
-                    OnNetworkRequestDone(this, request_id));
+  for (auto& observer : observer_list_)
+    observer.OnNetworkRequestDone(this, request_id);
 }
 
 const GURL& ExtensionHost::GetURL() const {
   return host_contents()->GetURL();
 }
 
 void ExtensionHost::LoadInitialURL() {
   load_start_.reset(new base::ElapsedTimer());
   host_contents_->GetController().LoadURL(
       initial_url_, content::Referrer(), ui::PAGE_TRANSITION_LINK,
@@ skipping 44 matching lines @@
   // and they aren't all going to use ExtensionHost. This should be in someplace
   // more central, like EPM maybe.
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
       content::Source<BrowserContext>(browser_context_),
       content::Details<ExtensionHost>(this));
 }
 
 void ExtensionHost::DidStartLoading() {
   if (!has_loaded_once_) {
-    FOR_EACH_OBSERVER(DeferredStartRenderHostObserver,
-                      deferred_start_render_host_observer_list_,
-                      OnDeferredStartRenderHostDidStartFirstLoad(this));
+    for (auto& observer : deferred_start_render_host_observer_list_)
+      observer.OnDeferredStartRenderHostDidStartFirstLoad(this);
   }
 }
 
 void ExtensionHost::DidStopLoading() {
   // Only record UMA for the first load. Subsequent loads will likely behave
   // quite different, and it's first load we're most interested in.
   bool first_load = !has_loaded_once_;
   has_loaded_once_ = true;
   if (first_load) {
     RecordStopLoadingUMA();
     OnDidStopFirstLoad();
     content::NotificationService::current()->Notify(
         extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_FIRST_LOAD,
         content::Source<BrowserContext>(browser_context_),
         content::Details<ExtensionHost>(this));
-    FOR_EACH_OBSERVER(DeferredStartRenderHostObserver,
-                      deferred_start_render_host_observer_list_,
-                      OnDeferredStartRenderHostDidStopFirstLoad(this));
+    for (auto& observer : deferred_start_render_host_observer_list_)
+      observer.OnDeferredStartRenderHostDidStopFirstLoad(this);
   }
 }
 
 void ExtensionHost::OnDidStopFirstLoad() {
   DCHECK_EQ(extension_host_type_, VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   // Nothing to do for background pages.
 }
 
 void ExtensionHost::DocumentAvailableInMainFrame() {
   // If the document has already been marked as available for this host, then
@@ skipping 43 matching lines @@
                  << ", which does not have a lazy background page.";
     return;
   }
 
   // A compromised renderer could start sending out arbitrary event ids, which
   // may affect other renderers by causing downstream methods to think that
   // events for other extensions have been acked.  Make sure that the event id
   // sent by the renderer is one that this ExtensionHost expects to receive.
   // This way if a renderer _is_ compromised, it can really only affect itself.
   if (unacked_messages_.erase(event_id) > 0) {
-    FOR_EACH_OBSERVER(ExtensionHostObserver, observer_list_,
-                      OnBackgroundEventAcked(this, event_id));
+    for (auto& observer : observer_list_)
+      observer.OnBackgroundEventAcked(this, event_id);
   } else {
     // We have received an unexpected event id from the renderer.  It might be
     // compromised or it might have some other issue.  Kill it just to be safe.
     DCHECK(render_process_host());
     LOG(ERROR) << "Killing renderer for extension " << extension_id() << " for "
                << "sending an EventAck message with a bad event id.";
     bad_message::ReceivedBadMessage(render_process_host(),
                                     bad_message::EH_BAD_EVENT_ID);
   }
 }
@@ skipping 100 matching lines @@
     }
   } else if (extension_host_type_ == VIEW_TYPE_EXTENSION_POPUP) {
     UMA_HISTOGRAM_MEDIUM_TIMES("Extensions.PopupLoadTime2",
                                load_start_->Elapsed());
     UMA_HISTOGRAM_MEDIUM_TIMES("Extensions.PopupCreateTime",
                                create_start_.Elapsed());
   }
 }
 
 }  // namespace extensions