Replace FOR_EACH_OBSERVER in c/b/chromeos with range-based for

chrome/browser/chromeos/file_system_provider/provided_file_system.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/chromeos/file_system_provider/provided_file_system.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/files/file.h"
@@ skipping 669 matching lines @@
 
   // Call all notification callbacks (if any).
   for (const auto& subscriber_it : watcher_it->second.subscribers) {
     const storage::WatcherManager::NotificationCallback& notification_callback =
         subscriber_it.second.notification_callback;
     if (!notification_callback.is_null())
       notification_callback.Run(change_type);
   }
 
   // Notify all observers.
-  FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
-                    observers_,
-                    OnWatcherChanged(file_system_info_,
-                                     watcher_it->second,
-                                     change_type,
-                                     changes_ref,
-                                     auto_updater->CreateCallback()));
+  for (auto& observer : observers_) {
+    observer.OnWatcherChanged(file_system_info_, watcher_it->second,
+                              change_type, changes_ref,
+                              auto_updater->CreateCallback());
+  }
 
   return AbortCallback();
 }
 
 base::WeakPtr<ProvidedFileSystemInterface> ProvidedFileSystem::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void ProvidedFileSystem::OnAddWatcherInQueueCompleted(
     size_t token,
@@ skipping 14 matching lines @@
     callback.Run(base::File::FILE_OK);
     watcher_queue_.Complete(token);
     return;
   }
 
   Watcher* const watcher = &watchers_[key];
   watcher->entry_path = entry_path;
   watcher->recursive = recursive;
   watcher->subscribers[subscriber.origin] = subscriber;
 
-  FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
-                    observers_,
-                    OnWatcherListChanged(file_system_info_, watchers_));
+  for (auto& observer : observers_)
+    observer.OnWatcherListChanged(file_system_info_, watchers_);
 
   callback.Run(base::File::FILE_OK);
   watcher_queue_.Complete(token);
 }
 
 void ProvidedFileSystem::OnRemoveWatcherInQueueCompleted(
     size_t token,
     const GURL& origin,
     const WatcherKey& key,
     const storage::AsyncFileUtil::StatusCallback& callback,
     bool extension_response,
     base::File::Error result) {
   if (!extension_response && result != base::File::FILE_OK) {
     watcher_queue_.Complete(token);
     callback.Run(result);
     return;
   }
 
   // Even if the extension returns an error, the callback is called with base::
   // File::FILE_OK.
   const auto it = watchers_.find(key);
   DCHECK(it != watchers_.end());
   DCHECK(it->second.subscribers.find(origin) != it->second.subscribers.end());
 
   it->second.subscribers.erase(origin);
 
-  FOR_EACH_OBSERVER(ProvidedFileSystemObserver, observers_,
-                    OnWatcherListChanged(file_system_info_, watchers_));
+  for (auto& observer : observers_)
+    observer.OnWatcherListChanged(file_system_info_, watchers_);
 
   // If there are no more subscribers, then remove the watcher.
   if (it->second.subscribers.empty())
     watchers_.erase(it);
 
   callback.Run(base::File::FILE_OK);
   watcher_queue_.Complete(token);
 }
 
 void ProvidedFileSystem::OnNotifyInQueueCompleted(
     std::unique_ptr<NotifyInQueueArgs> args,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     args->callback.Run(result);
     watcher_queue_.Complete(args->token);
     return;
   }
 
   // Check if the entry is still watched.
   const WatcherKey key(args->entry_path, args->recursive);
   const Watchers::iterator it = watchers_.find(key);
   if (it == watchers_.end()) {
     args->callback.Run(base::File::FILE_ERROR_NOT_FOUND);
     watcher_queue_.Complete(args->token);
     return;
   }
 
   it->second.last_tag = args->tag;
 
-  FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
-                    observers_,
-                    OnWatcherTagUpdated(file_system_info_, it->second));
+  for (auto& observer : observers_)
+    observer.OnWatcherTagUpdated(file_system_info_, it->second);
 
   // If the watched entry is deleted, then remove the watcher.
   if (args->change_type == storage::WatcherManager::DELETED) {
     // Make a copy, since the |it| iterator will get invalidated on the last
     // subscriber.
     Subscribers subscribers = it->second.subscribers;
     for (const auto& subscriber_it : subscribers) {
       RemoveWatcher(subscriber_it.second.origin, args->entry_path,
                     args->recursive, base::Bind(&EmptyStatusCallback));
     }
@@ skipping 22 matching lines @@
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
   // Closing files is final. Even if an error happened, we remove it from the
   // list of opened files.
   opened_files_.erase(file_handle);
   callback.Run(result);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos