Reduce FOR_EACH_OBSERVER usage in extensions

extensions/browser/process_manager.cc

 // Copyright 2013 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/process_manager.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 271 matching lines @@
     content::RenderFrameHost* render_frame_host,
     const Extension* extension) {
   ExtensionRenderFrameData* data = &all_extension_frames_[render_frame_host];
   data->view_type = GetViewType(web_contents);
 
   // Keep the lazy background page alive as long as any non-background-page
   // extension views are visible. Keepalive count balanced in
   // UnregisterRenderFrame.
   AcquireLazyKeepaliveCountForFrame(render_frame_host);
 
-  FOR_EACH_OBSERVER(ProcessManagerObserver,
-                    observer_list_,
-                    OnExtensionFrameRegistered(extension->id(),
-                                               render_frame_host));
+  for (auto& observer : observer_list_)
+    observer.OnExtensionFrameRegistered(extension->id(), render_frame_host);
 }
 
 void ProcessManager::UnregisterRenderFrameHost(
     content::RenderFrameHost* render_frame_host) {
   ExtensionRenderFrames::iterator frame =
       all_extension_frames_.find(render_frame_host);
 
   if (frame != all_extension_frames_.end()) {
     std::string extension_id = GetExtensionID(render_frame_host);
     // Keepalive count, balanced in RegisterRenderFrame.
     ReleaseLazyKeepaliveCountForFrame(render_frame_host);
     all_extension_frames_.erase(frame);
 
-    FOR_EACH_OBSERVER(ProcessManagerObserver,
-                      observer_list_,
-                      OnExtensionFrameUnregistered(extension_id,
-                                                   render_frame_host));
+    for (auto& observer : observer_list_)
+      observer.OnExtensionFrameUnregistered(extension_id, render_frame_host);
   }
 }
 
 void ProcessManager::DidNavigateRenderFrameHost(
     content::RenderFrameHost* render_frame_host) {
   ExtensionRenderFrames::iterator frame =
       all_extension_frames_.find(render_frame_host);
 
   if (frame != all_extension_frames_.end()) {
     std::string extension_id = GetExtensionID(render_frame_host);
 
-    FOR_EACH_OBSERVER(ProcessManagerObserver,
-                      observer_list_,
-                      OnExtensionFrameNavigated(extension_id,
-                                                render_frame_host));
+    for (auto& observer : observer_list_)
+      observer.OnExtensionFrameNavigated(extension_id, render_frame_host);
   }
 }
 
 scoped_refptr<content::SiteInstance> ProcessManager::GetSiteInstanceForURL(
     const GURL& url) {
   return site_instance_->GetRelatedSiteInstance(url);
 }
 
 const ProcessManager::FrameSet ProcessManager::GetAllFrames() const {
   FrameSet result;
@@ skipping 358 matching lines @@
   if (host != nullptr)
     CloseBackgroundHost(host);
   UnregisterExtension(extension->id());
 }
 
 void ProcessManager::CreateStartupBackgroundHosts() {
   DCHECK(!startup_background_hosts_created_);
   for (const scoped_refptr<const Extension>& extension :
            extension_registry_->enabled_extensions()) {
     CreateBackgroundHostForExtensionLoad(this, extension.get());
-    FOR_EACH_OBSERVER(ProcessManagerObserver,
-                      observer_list_,
-                      OnBackgroundHostStartup(extension.get()));
+    for (auto& observer : observer_list_)
+      observer.OnBackgroundHostStartup(extension.get());
   }
 }
 
 void ProcessManager::OnBackgroundHostCreated(ExtensionHost* host) {
   DCHECK_EQ(browser_context_, host->browser_context());
   background_hosts_.insert(host);
 
   if (BackgroundInfo::HasLazyBackgroundPage(host->extension())) {
     std::unique_ptr<base::ElapsedTimer> since_suspended = std::move(
         background_page_data_[host->extension()->id()].since_suspended);
     if (since_suspended.get()) {
       UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageIdleTime",
                                since_suspended->Elapsed());
     }
   }
-  FOR_EACH_OBSERVER(ProcessManagerObserver, observer_list_,
-                    OnBackgroundHostCreated(host));
+  for (auto& observer : observer_list_)
+    observer.OnBackgroundHostCreated(host);
 }
 
 void ProcessManager::CloseBackgroundHost(ExtensionHost* host) {
   ExtensionId extension_id = host->extension_id();
   CHECK(host->extension_host_type() == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   delete host;
   // |host| should deregister itself from our structures.
   CHECK(background_hosts_.find(host) == background_hosts_.end());
 
-  FOR_EACH_OBSERVER(ProcessManagerObserver,
-                    observer_list_,
-                    OnBackgroundHostClose(extension_id));
+  for (auto& observer : observer_list_)
+    observer.OnBackgroundHostClose(extension_id);
 }
 
 void ProcessManager::AcquireLazyKeepaliveCountForFrame(
     content::RenderFrameHost* render_frame_host) {
   ExtensionRenderFrames::iterator it =
       all_extension_frames_.find(render_frame_host);
   if (it == all_extension_frames_.end())
     return;
 
   ExtensionRenderFrameData& data = it->second;
@@ skipping 170 matching lines @@
   // The lazy_keepalive_count may be greater than zero at this point because
   // RenderFrameHosts are still alive. During extension reloading, they will
   // decrement the lazy_keepalive_count to negative for the new extension
   // instance when they are destroyed. Since we are erasing the background page
   // data for the unloaded extension, unregister the RenderFrameHosts too.
   for (ExtensionRenderFrames::iterator it = all_extension_frames_.begin();
        it != all_extension_frames_.end(); ) {
     content::RenderFrameHost* host = it->first;
     if (GetExtensionID(host) == extension_id) {
       all_extension_frames_.erase(it++);
-      FOR_EACH_OBSERVER(ProcessManagerObserver,
-                        observer_list_,
-                        OnExtensionFrameUnregistered(extension_id, host));
+      for (auto& observer : observer_list_)
+        observer.OnExtensionFrameUnregistered(extension_id, host);
     } else {
       ++it;
     }
   }
 
   background_page_data_.erase(extension_id);
 }
 
 void ProcessManager::ClearBackgroundPageData(const std::string& extension_id) {
   background_page_data_.erase(extension_id);
@@ skipping 46 matching lines @@
   if (extension && !IncognitoInfo::IsSplitMode(extension)) {
     BrowserContext* original_context =
         ExtensionsBrowserClient::Get()->GetOriginalContext(browser_context());
     return ProcessManager::Get(original_context)->GetSiteInstanceForURL(url);
   }
 
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions