Remove FOR_EACH_OBSERVER macro usage in chrome/browser/sync_file_system

chrome/browser/sync_file_system/drive_backend/sync_worker.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 "chrome/browser/sync_file_system/drive_backend/sync_worker.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 198 matching lines @@
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (sync_enabled_ == enabled)
     return;
 
   RemoteServiceState old_state = GetCurrentState();
   sync_enabled_ = enabled;
   if (old_state == GetCurrentState())
     return;
 
-  FOR_EACH_OBSERVER(
-      Observer,
-      observers_,
-      UpdateServiceState(
-          GetCurrentState(),
-          enabled ? "Sync is enabled" : "Sync is disabled"));
+  for (auto& observer : observers_) {
+    observer.UpdateServiceState(
+        GetCurrentState(), enabled ? "Sync is enabled" : "Sync is disabled");
+  }
 }
 
 void SyncWorker::PromoteDemotedChanges(const base::Closure& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   MetadataDatabase* metadata_db = GetMetadataDatabase();
   if (metadata_db && metadata_db->HasDemotedDirtyTracker()) {
     metadata_db->PromoteDemotedTrackers();
-    FOR_EACH_OBSERVER(
-        Observer,
-        observers_,
-        OnPendingFileListUpdated(metadata_db->CountDirtyTracker()));
+    for (auto& observer : observers_)
+      observer.OnPendingFileListUpdated(metadata_db->CountDirtyTracker());
   }
   callback.Run();
 }
 
 void SyncWorker::ApplyLocalChange(const FileChange& local_change,
                                   const base::FilePath& local_path,
                                   const SyncFileMetadata& local_metadata,
                                   const storage::FileSystemURL& url,
                                   const SyncStatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
@@ skipping 28 matching lines @@
 }
 
 void SyncWorker::NotifyLastOperationStatus(
     SyncStatusCode status,
     bool used_network) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   UpdateServiceStateFromSyncStatusCode(status, used_network);
 
   if (GetMetadataDatabase()) {
-    FOR_EACH_OBSERVER(
-        Observer, observers_,
-        OnPendingFileListUpdated(GetMetadataDatabase()->CountDirtyTracker()));
+    for (auto& observer : observers_) {
+      observer.OnPendingFileListUpdated(
+          GetMetadataDatabase()->CountDirtyTracker());
+    }
   }
 }
 
 void SyncWorker::RecordTaskLog(std::unique_ptr<TaskLogger::TaskLog> task_log) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   context_->GetUITaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&TaskLogger::RecordLog,
                  context_->GetTaskLogger(),
@@ skipping 195 matching lines @@
   if (syncer->is_sync_root_deletion()) {
     MetadataDatabase::ClearDatabase(context_->PassMetadataDatabase());
     PostInitializeTask();
     callback.Run(status, syncer->url());
     return;
   }
 
   if (status == SYNC_STATUS_OK) {
     if (syncer->sync_action() != SYNC_ACTION_NONE &&
         syncer->url().is_valid()) {
-      FOR_EACH_OBSERVER(
-          Observer, observers_,
-          OnFileStatusChanged(
-              syncer->url(),
-              syncer->file_type(),
-              SYNC_FILE_STATUS_SYNCED,
-              syncer->sync_action(),
-              SYNC_DIRECTION_REMOTE_TO_LOCAL));
+      for (auto& observer : observers_) {
+        observer.OnFileStatusChanged(
+            syncer->url(), syncer->file_type(), SYNC_FILE_STATUS_SYNCED,
+            syncer->sync_action(), SYNC_DIRECTION_REMOTE_TO_LOCAL);
+      }
     }
 
     if (syncer->sync_action() == SYNC_ACTION_DELETED &&
         syncer->url().is_valid() &&
         storage::VirtualPath::IsRootPath(syncer->url().path())) {
       RegisterOrigin(syncer->url().origin(), base::Bind(&EmptyStatusCallback));
     }
     should_check_conflict_ = true;
   }
   callback.Run(status, syncer->url());
 }
 
 void SyncWorker::DidApplyLocalChange(LocalToRemoteSyncer* syncer,
                                      const SyncStatusCallback& callback,
                                      SyncStatusCode status) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if ((status == SYNC_STATUS_OK || status == SYNC_STATUS_RETRY) &&
       syncer->url().is_valid() &&
       syncer->sync_action() != SYNC_ACTION_NONE) {
     storage::FileSystemURL updated_url = syncer->url();
     if (!syncer->target_path().empty()) {
       updated_url = CreateSyncableFileSystemURL(syncer->url().origin(),
                                                 syncer->target_path());
     }
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      OnFileStatusChanged(updated_url,
-                                          syncer->file_type(),
-                                          SYNC_FILE_STATUS_SYNCED,
-                                          syncer->sync_action(),
-                                          SYNC_DIRECTION_LOCAL_TO_REMOTE));
+    for (auto& observer : observers_) {
+      observer.OnFileStatusChanged(
+          updated_url, syncer->file_type(), SYNC_FILE_STATUS_SYNCED,
+          syncer->sync_action(), SYNC_DIRECTION_LOCAL_TO_REMOTE);
+    }
   }
 
   if (status == SYNC_STATUS_UNKNOWN_ORIGIN && syncer->url().is_valid()) {
     RegisterOrigin(syncer->url().origin(),
                    base::Bind(&EmptyStatusCallback));
   }
 
   if (syncer->needs_remote_change_listing() &&
       !listing_remote_changes_) {
     task_manager_->ScheduleSyncTask(
@@ skipping 121 matching lines @@
   RemoteServiceState old_state = GetCurrentState();
   service_state_ = state;
 
   if (old_state == GetCurrentState())
     return;
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "Service state changed: %d->%d: %s",
             old_state, GetCurrentState(), description.c_str());
 
-  FOR_EACH_OBSERVER(
-      Observer, observers_,
-      UpdateServiceState(GetCurrentState(), description));
+  for (auto& observer : observers_)
+    observer.UpdateServiceState(GetCurrentState(), description);
 }
 
 void SyncWorker::CallOnIdleForTesting(const base::Closure& callback) {
   if (task_manager_->ScheduleTaskIfIdle(
           FROM_HERE,
           base::Bind(&InvokeIdleCallback, callback),
           base::Bind(&EmptyStatusCallback)))
     return;
   call_on_idle_callback_ = base::Bind(
       &SyncWorker::CallOnIdleForTesting,
@@ skipping 11 matching lines @@
   return context_->GetDriveUploader();
 }
 
 MetadataDatabase* SyncWorker::GetMetadataDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   return context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system