Remove usage of FOR_EACH_OBSERVER macro in google_apis

google_apis/gaia/oauth2_token_service.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 "google_apis/gaia/oauth2_token_service.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
@@ skipping 465 matching lines @@
     const ScopeSet& scopes,
     Consumer* consumer) {
   DCHECK(CalledOnValidThread());
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 OAuth2TokenService::StartRequestForClientWithContext 1"));
   std::unique_ptr<RequestImpl> request(new RequestImpl(account_id, consumer));
-  FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
-                    OnAccessTokenRequested(account_id,
-                                           consumer->id(),
-                                           scopes));
+  for (auto& observer : diagnostics_observer_list_)
+    observer.OnAccessTokenRequested(account_id, consumer->id(), scopes);
 
   if (!RefreshTokenIsAvailable(account_id)) {
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile2(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "422460 OAuth2TokenService::StartRequestForClientWithContext 2"));
 
     GoogleServiceAuthError error(GoogleServiceAuthError::USER_NOT_SIGNED_UP);
 
-    FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
-                      OnFetchAccessTokenComplete(
-                          account_id, consumer->id(), scopes, error,
-                          base::Time()));
+    for (auto& observer : diagnostics_observer_list_) {
+      observer.OnFetchAccessTokenComplete(account_id, consumer->id(), scopes,
+                                          error, base::Time());
+    }
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&RequestImpl::InformConsumer, request->AsWeakPtr(), error,
                    std::string(), base::Time()));
     return std::move(request);
   }
 
   RequestParameters request_parameters(client_id,
                                        account_id,
@@ skipping 57 matching lines @@
     OAuth2AccessTokenConsumer* consumer) {
   return delegate_->CreateAccessTokenFetcher(account_id, getter, consumer);
 }
 
 void OAuth2TokenService::StartCacheLookupRequest(
     RequestImpl* request,
     const OAuth2TokenService::RequestParameters& request_parameters,
     OAuth2TokenService::Consumer* consumer) {
   CHECK(HasCacheEntry(request_parameters));
   const CacheEntry* cache_entry = GetCacheEntry(request_parameters);
-  FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
-                    OnFetchAccessTokenComplete(
-                        request_parameters.account_id,
-                        consumer->id(),
-                        request_parameters.scopes,
-                        GoogleServiceAuthError::AuthErrorNone(),
-                        cache_entry->expiration_date));
+  for (auto& observer : diagnostics_observer_list_) {
+    observer.OnFetchAccessTokenComplete(
+        request_parameters.account_id, consumer->id(),
+        request_parameters.scopes, GoogleServiceAuthError::AuthErrorNone(),
+        cache_entry->expiration_date);
+  }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&RequestImpl::InformConsumer, request->AsWeakPtr(),
                  GoogleServiceAuthError(GoogleServiceAuthError::NONE),
                  cache_entry->access_token, cache_entry->expiration_date));
 }
 
 std::vector<std::string> OAuth2TokenService::GetAccounts() const {
   return delegate_->GetAccounts();
 }
@@ skipping 76 matching lines @@
   RequestParameters request_param(fetcher->GetClientId(),
                                   fetcher->GetAccountId(),
                                   fetcher->GetScopeSet());
 
   const OAuth2TokenService::CacheEntry* entry = GetCacheEntry(request_param);
   const std::vector<base::WeakPtr<RequestImpl> >& requests =
       fetcher->waiting_requests();
   for (size_t i = 0; i < requests.size(); ++i) {
     const RequestImpl* req = requests[i].get();
     if (req) {
-      FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
-                        OnFetchAccessTokenComplete(
-                            req->GetAccountId(), req->GetConsumerId(),
-                            fetcher->GetScopeSet(), fetcher->error(),
-                            entry ? entry->expiration_date : base::Time()));
+      for (auto& observer : diagnostics_observer_list_) {
+        observer.OnFetchAccessTokenComplete(
+            req->GetAccountId(), req->GetConsumerId(), fetcher->GetScopeSet(),
+            fetcher->error(), entry ? entry->expiration_date : base::Time());
+      }
     }
   }
 
   auto iter = pending_fetchers_.find(request_param);
   DCHECK(iter != pending_fetchers_.end());
   DCHECK_EQ(fetcher, iter->second.get());
 
   // The Fetcher deletes itself.
   iter->second.release();
   pending_fetchers_.erase(iter);
@@ skipping 18 matching lines @@
   return &token_iterator->second;
 }
 
 bool OAuth2TokenService::RemoveCacheEntry(
     const RequestParameters& request_parameters,
     const std::string& token_to_remove) {
   DCHECK(CalledOnValidThread());
   TokenCache::iterator token_iterator = token_cache_.find(request_parameters);
   if (token_iterator != token_cache_.end() &&
       token_iterator->second.access_token == token_to_remove) {
-    FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
-                      OnTokenRemoved(request_parameters.account_id,
-                                     request_parameters.scopes));
+    for (auto& observer : diagnostics_observer_list_) {
+      observer.OnTokenRemoved(request_parameters.account_id,
+                              request_parameters.scopes);
+    }
     token_cache_.erase(token_iterator);
     return true;
   }
   return false;
 }
 void OAuth2TokenService::UpdateAuthError(const std::string& account_id,
                                          const GoogleServiceAuthError& error) {
   delegate_->UpdateAuthError(account_id, error);
 }
 
 void OAuth2TokenService::RegisterCacheEntry(
     const std::string& client_id,
     const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token,
     const base::Time& expiration_date) {
   DCHECK(CalledOnValidThread());
 
   CacheEntry& token = token_cache_[RequestParameters(client_id,
                                                      account_id,
                                                      scopes)];
   token.access_token = access_token;
   token.expiration_date = expiration_date;
 }
 
 void OAuth2TokenService::ClearCache() {
   DCHECK(CalledOnValidThread());
   for (TokenCache::iterator iter = token_cache_.begin();
        iter != token_cache_.end(); ++iter) {
-    FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
-                      OnTokenRemoved(iter->first.account_id,
-                                     iter->first.scopes));
+    for (auto& observer : diagnostics_observer_list_)
+      observer.OnTokenRemoved(iter->first.account_id, iter->first.scopes);
   }
 
   token_cache_.clear();
 }
 
 void OAuth2TokenService::ClearCacheForAccount(const std::string& account_id) {
   DCHECK(CalledOnValidThread());
   for (TokenCache::iterator iter = token_cache_.begin();
        iter != token_cache_.end();
        /* iter incremented in body */) {
     if (iter->first.account_id == account_id) {
-      FOR_EACH_OBSERVER(DiagnosticsObserver, diagnostics_observer_list_,
-                        OnTokenRemoved(account_id, iter->first.scopes));
+      for (auto& observer : diagnostics_observer_list_)
+        observer.OnTokenRemoved(account_id, iter->first.scopes);
       token_cache_.erase(iter++);
     } else {
       ++iter;
     }
   }
 }
 
 void OAuth2TokenService::CancelAllRequests() {
   std::vector<Fetcher*> fetchers_to_cancel;
   for (auto iter = pending_fetchers_.begin(); iter != pending_fetchers_.end();
@@ skipping 30 matching lines @@
 
 size_t OAuth2TokenService::GetNumPendingRequestsForTesting(
     const std::string& client_id,
     const std::string& account_id,
     const ScopeSet& scopes) const {
   auto iter = pending_fetchers_.find(
       OAuth2TokenService::RequestParameters(client_id, account_id, scopes));
   return iter == pending_fetchers_.end() ?
              0 : iter->second->GetWaitingRequestCount();
 }