Reduce FOR_EACH_OBSERVER usage in content/browser/service_worker

content/browser/service_worker/service_worker_registration.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 "content/browser/service_worker/service_worker_registration.h"
 
 #include <vector>
 
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
@@ skipping 60 matching lines @@
 
 void ServiceWorkerRegistration::AddListener(Listener* listener) {
   listeners_.AddObserver(listener);
 }
 
 void ServiceWorkerRegistration::RemoveListener(Listener* listener) {
   listeners_.RemoveObserver(listener);
 }
 
 void ServiceWorkerRegistration::NotifyRegistrationFailed() {
-  FOR_EACH_OBSERVER(Listener, listeners_, OnRegistrationFailed(this));
+  for (auto& observer : listeners_)
+    observer.OnRegistrationFailed(this);
   NotifyRegistrationFinished();
 }
 
 void ServiceWorkerRegistration::NotifyUpdateFound() {
-  FOR_EACH_OBSERVER(Listener, listeners_, OnUpdateFound(this));
+  for (auto& observer : listeners_)
+    observer.OnUpdateFound(this);
 }
 
 void ServiceWorkerRegistration::NotifyVersionAttributesChanged(
     ChangedVersionAttributesMask mask) {
-  FOR_EACH_OBSERVER(Listener, listeners_,
-                    OnVersionAttributesChanged(this, mask, GetInfo()));
+  for (auto& observer : listeners_)
+    observer.OnVersionAttributesChanged(this, mask, GetInfo());
   if (mask.active_changed() || mask.waiting_changed())
     NotifyRegistrationFinished();
 }
 
 ServiceWorkerRegistrationInfo ServiceWorkerRegistration::GetInfo() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return ServiceWorkerRegistrationInfo(
       pattern(), registration_id_,
       is_deleted_ ? ServiceWorkerRegistrationInfo::IS_DELETED
                   : ServiceWorkerRegistrationInfo::IS_NOT_DELETED,
@@ skipping 204 matching lines @@
   }
 
   // "6. Set serviceWorkerRegistration.activeWorker to activatingWorker."
   // "7. Set serviceWorkerRegistration.waitingWorker to null."
   SetActiveVersion(activating_version);
 
   // "8. Run the [[UpdateState]] algorithm passing registration.activeWorker and
   // "activating" as arguments."
   activating_version->SetStatus(ServiceWorkerVersion::ACTIVATING);
   // "9. Fire a simple event named controllerchange..."
   if (activating_version->skip_waiting())

[horo, 2016/10/17 02:22:28]

Nit: please add bracket.

  if (activating_version->skip_waiting()) {
    for (auto& observer : listeners_)
      observer.OnSkippedWaiting(this);
  }

-    FOR_EACH_OBSERVER(Listener, listeners_, OnSkippedWaiting(this));
+    for (auto& observer : listeners_)
+      observer.OnSkippedWaiting(this);
 
   // "10. Queue a task to fire an event named activate..."
   // The browser could be shutting down. To avoid spurious start worker
   // failures, wait a bit before continuing.
   if (delay) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&ServiceWorkerRegistration::ContinueActivation,
                               this, activating_version),
         base::TimeDelta::FromSeconds(1));
   } else {
@@ skipping 152 matching lines @@
   if (mask.changed()) {
     NotifyVersionAttributesChanged(mask);
 
     // Doom only after notifying attributes changed, because the spec requires
     // the attributes to be cleared by the time the statechange event is
     // dispatched.
     for (const auto& version : versions_to_doom)
       version->Doom();
   }
 
-  FOR_EACH_OBSERVER(
-      Listener, listeners_, OnRegistrationFinishedUninstalling(this));
+  for (auto& observer : listeners_)
+    observer.OnRegistrationFinishedUninstalling(this);
 }
 
 void ServiceWorkerRegistration::OnRestoreFinished(
     const StatusCallback& callback,
     scoped_refptr<ServiceWorkerVersion> version,
     ServiceWorkerStatusCode status) {
   if (!context_) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
   context_->storage()->NotifyDoneInstallingRegistration(
       this, version.get(), status);
   callback.Run(status);
 }
 
 }  // namespace content