Reduce usage of FOR_EACH_OBSERVER macro in components/

components/search_provider_logos/logo_tracker.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 "components/search_provider_logos/logo_tracker.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 139 matching lines @@
   // Cancel the current asynchronous operation, if any.
   fetcher_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Reset state.
   is_idle_ = true;
   cached_logo_.reset();
   is_cached_logo_valid_ = false;
 
   // Clear obsevers.
-  FOR_EACH_OBSERVER(LogoObserver, logo_observers_, OnObserverRemoved());
+  for (auto& observer : logo_observers_)
+    observer.OnObserverRemoved();
   logo_observers_.Clear();
 }
 
 void LogoTracker::OnCachedLogoRead(std::unique_ptr<EncodedLogo> cached_logo) {
   DCHECK(!is_idle_);
 
   if (cached_logo) {
     logo_delegate_->DecodeUntrustedImage(
         cached_logo->encoded_image,
         base::Bind(&LogoTracker::OnCachedLogoAvailable,
                    weak_ptr_factory_.GetWeakPtr(),
                    cached_logo->metadata));
   } else {
     OnCachedLogoAvailable(LogoMetadata(), SkBitmap());
   }
 }
 
 void LogoTracker::OnCachedLogoAvailable(const LogoMetadata& metadata,
                                         const SkBitmap& image) {
   DCHECK(!is_idle_);
 
   if (!image.isNull()) {
     cached_logo_.reset(new Logo());
     cached_logo_->metadata = metadata;
     cached_logo_->image = image;
   }
   is_cached_logo_valid_ = true;
   Logo* logo = cached_logo_.get();
-  FOR_EACH_OBSERVER(LogoObserver, logo_observers_, OnLogoAvailable(logo, true));
+  for (auto& observer : logo_observers_)
+    observer.OnLogoAvailable(logo, true);
   FetchLogo();
 }
 
 void LogoTracker::SetCachedLogo(std::unique_ptr<EncodedLogo> logo) {
   file_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LogoCache::SetCachedLogo,
                  base::Unretained(logo_cache_),
                  base::Owned(logo.release())));
 }
@@ skipping 87 matching lines @@
     } else {
       if (parsing_failed)
         download_outcome = DOWNLOAD_OUTCOME_PARSING_FAILED;
       else
         download_outcome = DOWNLOAD_OUTCOME_NO_LOGO_TODAY;
     }
 
     // Notify observers if a new logo was fetched, or if the new logo is NULL
     // but the cached logo was non-NULL.
     if (logo || cached_logo_) {
-      FOR_EACH_OBSERVER(LogoObserver,
-                        logo_observers_,
-                        OnLogoAvailable(logo.get(), false));
+      for (auto& observer : logo_observers_)
+        observer.OnLogoAvailable(logo.get(), false);
       SetCachedLogo(std::move(encoded_logo));
     }
   }
 
   DCHECK_NE(kDownloadOutcomeNotTracked, download_outcome);
   ReturnToIdle(download_outcome);
 }
 
 void LogoTracker::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(!is_idle_);
@@ skipping 33 matching lines @@
                                              int64_t current,
                                              int64_t total,
                                              int64_t current_network_bytes) {
   if (total > kMaxDownloadBytes || current > kMaxDownloadBytes) {
     LOG(WARNING) << "Search provider logo exceeded download size limit";
     ReturnToIdle(DOWNLOAD_OUTCOME_DOWNLOAD_FAILED);
   }
 }
 
 }  // namespace search_provider_logos