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

chrome/browser/chromeos/file_system_provider/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 "chrome/browser/chromeos/file_system_provider/service.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 110 matching lines @@
 
 base::File::Error Service::MountFileSystemInternal(
     const std::string& extension_id,
     const MountOptions& options,
     MountContext context) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If already exists a file system provided by the same extension with this
   // id, then abort.
   if (GetProvidedFileSystem(extension_id, options.file_system_id)) {
-    FOR_EACH_OBSERVER(
-        Observer, observers_,
-        OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
-                                  base::File::FILE_ERROR_EXISTS));
+    for (auto& observer : observers_) {
+      observer.OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
+                                         base::File::FILE_ERROR_EXISTS);
+    }
     return base::File::FILE_ERROR_EXISTS;
   }
 
   // Restrict number of file systems to prevent system abusing.
   if (file_system_map_.size() + 1 > kMaxFileSystems) {
-    FOR_EACH_OBSERVER(
-        Observer, observers_,
-        OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
-                                  base::File::FILE_ERROR_TOO_MANY_OPENED));
+    for (auto& observer : observers_) {
+      observer.OnProvidedFileSystemMount(
+          ProvidedFileSystemInfo(), context,
+          base::File::FILE_ERROR_TOO_MANY_OPENED);
+    }
     return base::File::FILE_ERROR_TOO_MANY_OPENED;
   }
 
   storage::ExternalMountPoints* const mount_points =
       storage::ExternalMountPoints::GetSystemInstance();
   DCHECK(mount_points);
 
   // The mount point path and name are unique per system, since they are system
   // wide. This is necessary for copying between profiles.
   const base::FilePath& mount_path =
       util::GetMountPath(profile_, extension_id, options.file_system_id);
   const std::string mount_point_name = mount_path.BaseName().AsUTF8Unsafe();
 
   if (!mount_points->RegisterFileSystem(
           mount_point_name, storage::kFileSystemTypeProvided,
           storage::FileSystemMountOption(
               storage::FlushPolicy::FLUSH_ON_COMPLETION),
           mount_path)) {
-    FOR_EACH_OBSERVER(
-        Observer, observers_,
-        OnProvidedFileSystemMount(ProvidedFileSystemInfo(), context,
-                                  base::File::FILE_ERROR_INVALID_OPERATION));
+    for (auto& observer : observers_) {
+      observer.OnProvidedFileSystemMount(
+          ProvidedFileSystemInfo(), context,
+          base::File::FILE_ERROR_INVALID_OPERATION);
+    }
     return base::File::FILE_ERROR_INVALID_OPERATION;
   }
 
   ProvidingExtensionInfo provider_info;
   // TODO(mtomasz): Set up a testing extension in unit tests.
   GetProvidingExtensionInfo(extension_id, &provider_info);
   // Store the file system descriptor. Use the mount point name as the file
   // system provider file system id.
   // Examples:
   //   file_system_id = hello_world
@@ skipping 12 matching lines @@
 
   ProvidedFileSystemInterface* file_system =
       file_system_factory_.Run(profile_, file_system_info);
   DCHECK(file_system);
   file_system_map_[FileSystemKey(extension_id, options.file_system_id)] =
       file_system;
   mount_point_name_to_key_map_[mount_point_name] =
       FileSystemKey(extension_id, options.file_system_id);
   registry_->RememberFileSystem(file_system_info, *file_system->GetWatchers());
 
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnProvidedFileSystemMount(file_system_info, context,
-                                              base::File::FILE_OK));
+  for (auto& observer : observers_) {
+    observer.OnProvidedFileSystemMount(file_system_info, context,
+                                       base::File::FILE_OK);
+  }
 
   return base::File::FILE_OK;
 }
 
 base::File::Error Service::UnmountFileSystem(const std::string& extension_id,
                                              const std::string& file_system_id,
                                              UnmountReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const ProvidedFileSystemMap::iterator file_system_it =
       file_system_map_.find(FileSystemKey(extension_id, file_system_id));
   if (file_system_it == file_system_map_.end()) {
     const ProvidedFileSystemInfo empty_file_system_info;
-    FOR_EACH_OBSERVER(
-        Observer,
-        observers_,
-        OnProvidedFileSystemUnmount(empty_file_system_info,
-                                    base::File::FILE_ERROR_NOT_FOUND));
+    for (auto& observer : observers_) {
+      observer.OnProvidedFileSystemUnmount(empty_file_system_info,
+                                           base::File::FILE_ERROR_NOT_FOUND);
+    }
     return base::File::FILE_ERROR_NOT_FOUND;
   }
 
   storage::ExternalMountPoints* const mount_points =
       storage::ExternalMountPoints::GetSystemInstance();
   DCHECK(mount_points);
 
   const ProvidedFileSystemInfo& file_system_info =
       file_system_it->second->GetFileSystemInfo();
 
   const std::string mount_point_name =
       file_system_info.mount_path().BaseName().value();
   if (!mount_points->RevokeFileSystem(mount_point_name)) {
-    FOR_EACH_OBSERVER(
-        Observer,
-        observers_,
-        OnProvidedFileSystemUnmount(file_system_info,
-                                    base::File::FILE_ERROR_INVALID_OPERATION));
+    for (auto& observer : observers_) {
+      observer.OnProvidedFileSystemUnmount(
+          file_system_info, base::File::FILE_ERROR_INVALID_OPERATION);
+    }
     return base::File::FILE_ERROR_INVALID_OPERATION;
   }
 
-  FOR_EACH_OBSERVER(
-      Observer,
-      observers_,
-      OnProvidedFileSystemUnmount(file_system_info, base::File::FILE_OK));
+  for (auto& observer : observers_)
+    observer.OnProvidedFileSystemUnmount(file_system_info, base::File::FILE_OK);
 
   mount_point_name_to_key_map_.erase(mount_point_name);
 
   if (reason == UNMOUNT_REASON_USER) {
     registry_->ForgetFileSystem(file_system_info.extension_id(),
                                 file_system_info.file_system_id());
   }
 
   delete file_system_it->second;
   file_system_map_.erase(file_system_it);
@@ skipping 176 matching lines @@
   return file_system_it->second;
 }
 
 void Service::OnRequestUnmountStatus(
     const ProvidedFileSystemInfo& file_system_info,
     base::File::Error error) {
   // Notify observers about failure in unmounting, since mount() will not be
   // called by the provided file system. In case of success mount() will be
   // invoked, and observers notified, so there is no need to call them now.
   if (error != base::File::FILE_OK) {
-    FOR_EACH_OBSERVER(Observer,
-                      observers_,
-                      OnProvidedFileSystemUnmount(file_system_info, error));
+    for (auto& observer : observers_)
+      observer.OnProvidedFileSystemUnmount(file_system_info, error);
   }
 }
 
 void Service::OnWatcherChanged(const ProvidedFileSystemInfo& file_system_info,
                                const Watcher& watcher,
                                storage::WatcherManager::ChangeType change_type,
                                const Changes& changes,
                                const base::Closure& callback) {
   callback.Run();
 }
 
 void Service::OnWatcherTagUpdated(
     const ProvidedFileSystemInfo& file_system_info,
     const Watcher& watcher) {
   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);
 
   registry_->UpdateWatcherTag(file_system_info, watcher);
 }
 
 void Service::OnWatcherListChanged(
     const ProvidedFileSystemInfo& file_system_info,
     const Watchers& watchers) {
   registry_->RememberFileSystem(file_system_info, watchers);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos