Replace FOR_EACH_OBSERVER in components/drive with range-based for

components/drive/chromeos/file_system.cc

 // Copyright (c) 2012 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/drive/chromeos/file_system.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 806 matching lines @@
   drive::internal::SearchMetadata(
       blocking_task_runner_, resource_metadata_,
       /* any file name */ "", base::Bind(&CheckHashes, hashes),
       std::numeric_limits<size_t>::max(),
       base::Bind(&RunSearchByHashesCallback, callback));
 }
 
 void FileSystem::OnFileChangedByOperation(const FileChange& changed_files) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  FOR_EACH_OBSERVER(
-      FileSystemObserver, observers_, OnFileChanged(changed_files));
+  for (auto& observer : observers_)
+    observer.OnFileChanged(changed_files);
 }
 
 void FileSystem::OnEntryUpdatedByOperation(const ClientContext& context,
                                            const std::string& local_id) {
   sync_client_->AddUpdateTask(context, local_id);
 }
 
 void FileSystem::OnDriveSyncError(file_system::DriveSyncErrorType type,
                                   const std::string& local_id) {
   base::FilePath* file_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&internal::ResourceMetadata::GetFilePath,
                  base::Unretained(resource_metadata_),
                  local_id,
                  file_path),
       base::Bind(&FileSystem::OnDriveSyncErrorAfterGetFilePath,
                  weak_ptr_factory_.GetWeakPtr(),
                  type,
                  base::Owned(file_path)));
 }
 
 void FileSystem::OnDriveSyncErrorAfterGetFilePath(
     file_system::DriveSyncErrorType type,
     const base::FilePath* file_path,
     FileError error) {
   if (error != FILE_ERROR_OK)
     return;
-  FOR_EACH_OBSERVER(FileSystemObserver,
-                    observers_,
-                    OnDriveSyncError(type, *file_path));
+  for (auto& observer : observers_)
+    observer.OnDriveSyncError(type, *file_path);
 }
 
 bool FileSystem::WaitForSyncComplete(const std::string& local_id,
                                      const FileOperationCallback& callback) {
   return sync_client_->WaitForUpdateTaskToComplete(local_id, callback);
 }
 
 void FileSystem::OnDirectoryReloaded(const base::FilePath& directory_path) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  FOR_EACH_OBSERVER(
-      FileSystemObserver, observers_, OnDirectoryChanged(directory_path));
+  for (auto& observer : observers_)
+    observer.OnDirectoryChanged(directory_path);
 }
 
 void FileSystem::OnFileChanged(const FileChange& changed_files) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  FOR_EACH_OBSERVER(
-      FileSystemObserver, observers_, OnFileChanged(changed_files));
+  for (auto& observer : observers_)
+    observer.OnFileChanged(changed_files);
 }
 
 void FileSystem::OnLoadFromServerComplete() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   sync_client_->StartCheckingExistingPinnedFiles();
 }
 
 void FileSystem::OnInitialLoadComplete() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 175 matching lines @@
 
 void FileSystem::CalculateEvictableCacheSize(
     const CacheSizeCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&CalculateEvictableCacheSizeOnBlockingPool, cache_), callback);
 }
 }  // namespace drive