Remove usage of FOR_EACH_OBSERVER macro in components/signin

components/signin/core/browser/gaia_cookie_manager_service.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/signin/core/browser/gaia_cookie_manager_service.h"
 
 #include <stddef.h>
 
 #include <queue>
 
@@ skipping 501 matching lines @@
                    base::Unretained(this)));
   }
 }
 
 void GaiaCookieManagerService::SignalComplete(
     const std::string& account_id,
     const GoogleServiceAuthError& error) {
   // Its possible for the observer to delete |this| object.  Don't access
   // access any members after this calling the observer.  This method should
   // be the last call in any other method.
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-                    OnAddAccountToCookieCompleted(account_id, error));
+  for (auto& observer : observer_list_)
+    observer.OnAddAccountToCookieCompleted(account_id, error);
 }
 
 void GaiaCookieManagerService::OnUbertokenSuccess(
     const std::string& uber_token) {
   DCHECK(requests_.front().request_type() ==
       GaiaCookieRequestType::ADD_ACCOUNT);
   VLOG(1) << "GaiaCookieManagerService::OnUbertokenSuccess"
           << " account=" << requests_.front().account_id();
   fetcher_retries_ = 0;
   uber_token_ = uber_token;
@@ skipping 86 matching lines @@
     account.id = AccountTrackerService::PickAccountIdForAccount(
         signin_client_->GetPrefs(), account.gaia_id, account.email);
   }
 
   list_accounts_stale_ = false;
   HandleNextRequest();
   // HandleNextRequest before sending out the notification because some
   // services, in response to OnGaiaAccountsInCookieUpdated, may try in return
   // to call ListAccounts, which would immediately return false if the
   // ListAccounts request is still sitting in queue.
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-      OnGaiaAccountsInCookieUpdated(
-          listed_accounts_,
-          signed_out_accounts_,
-          GoogleServiceAuthError(GoogleServiceAuthError::NONE)));
+  for (auto& observer : observer_list_) {
+    observer.OnGaiaAccountsInCookieUpdated(
+        listed_accounts_, signed_out_accounts_,
+        GoogleServiceAuthError(GoogleServiceAuthError::NONE));
+  }
 }
 
 void GaiaCookieManagerService::OnListAccountsFailure(
     const GoogleServiceAuthError& error) {
   VLOG(1) << "ListAccounts failed";
   DCHECK(requests_.front().request_type() ==
          GaiaCookieRequestType::LIST_ACCOUNTS);
   if (++fetcher_retries_ < kMaxFetcherRetries && error.IsTransientError()) {
     fetcher_backoff_.InformOfRequest(false);
     UMA_HISTOGRAM_ENUMERATION("Signin.ListAccountsRetry",
         error.state(), GoogleServiceAuthError::NUM_STATES);
     fetcher_timer_.Start(
         FROM_HERE, fetcher_backoff_.GetTimeUntilRelease(),
         base::Bind(&SigninClient::DelayNetworkCall,
                    base::Unretained(signin_client_),
                    base::Bind(
                        &GaiaCookieManagerService::StartFetchingListAccounts,
                        base::Unretained(this))));
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("Signin.ListAccountsFailure",
       error.state(), GoogleServiceAuthError::NUM_STATES);
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-      OnGaiaAccountsInCookieUpdated(
-            listed_accounts_, signed_out_accounts_, error));
+  for (auto& observer : observer_list_) {
+    observer.OnGaiaAccountsInCookieUpdated(listed_accounts_,
+                                           signed_out_accounts_, error);
+  }
   HandleNextRequest();
 }
 
 void GaiaCookieManagerService::OnLogOutSuccess() {
   DCHECK(requests_.front().request_type() == GaiaCookieRequestType::LOG_OUT);
   VLOG(1) << "GaiaCookieManagerService::OnLogOutSuccess";
 
   list_accounts_stale_ = true;
   fetcher_backoff_.InformOfRequest(true);
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-                    OnLogOutAccountsFromCookieCompleted(
-                        GoogleServiceAuthError(GoogleServiceAuthError::NONE)));
+  for (auto& observer : observer_list_) {
+    observer.OnLogOutAccountsFromCookieCompleted(
+        GoogleServiceAuthError(GoogleServiceAuthError::NONE));
+  }
   HandleNextRequest();
 }
 
 void GaiaCookieManagerService::OnLogOutFailure(
     const GoogleServiceAuthError& error) {
   DCHECK(requests_.front().request_type() == GaiaCookieRequestType::LOG_OUT);
   VLOG(1) << "GaiaCookieManagerService::OnLogOutFailure";
 
   if (++fetcher_retries_ < kMaxFetcherRetries) {
     fetcher_backoff_.InformOfRequest(false);
     fetcher_timer_.Start(
         FROM_HERE, fetcher_backoff_.GetTimeUntilRelease(),
         base::Bind(&SigninClient::DelayNetworkCall,
                    base::Unretained(signin_client_),
                    base::Bind(&GaiaCookieManagerService::StartFetchingLogOut,
                               base::Unretained(this))));
     return;
   }
 
-  FOR_EACH_OBSERVER(Observer, observer_list_,
-                    OnLogOutAccountsFromCookieCompleted(error));
+  for (auto& observer : observer_list_)
+    observer.OnLogOutAccountsFromCookieCompleted(error);
   HandleNextRequest();
 }
 
 void GaiaCookieManagerService::StartFetchingUbertoken() {
   VLOG(1) << "GaiaCookieManagerService::StartFetchingUbertoken account_id="
           << requests_.front().account_id();
   uber_token_fetcher_.reset(new UbertokenFetcher(
       token_service_, this, source_, signin_client_->GetURLRequestContext(),
       base::Bind(&SigninClient::CreateGaiaAuthFetcher,
                  base::Unretained(signin_client_))));
@@ skipping 66 matching lines @@
         break;
       case GaiaCookieRequestType::LIST_ACCOUNTS:
         uber_token_fetcher_.reset();
         signin_client_->DelayNetworkCall(
             base::Bind(&GaiaCookieManagerService::StartFetchingListAccounts,
                        base::Unretained(this)));
         break;
     }
   }
 }