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

chrome/browser/chromeos/file_manager/volume_manager.cc

 // Copyright 2013 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_manager/volume_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 
 namespace file_manager {
 namespace {
 
 const uint32_t kAccessCapabilityReadWrite = 0;
 const uint32_t kFilesystemTypeGenericHierarchical = 2;
 const char kFileManagerMTPMountNamePrefix[] = "fileman-mtp-";
-const char kMtpVolumeIdPrefix [] = "mtp:";
+const char kMtpVolumeIdPrefix[] = "mtp:";
 const char kRootPath[] = "/";
 
 // Registers |path| as the "Downloads" folder to the FileSystem API backend.
 // If another folder is already mounted. It revokes and overrides the old one.
 bool RegisterDownloadsMountPoint(Profile* profile, const base::FilePath& path) {
   // Although we show only profile's own "Downloads" folder in Files.app,
   // in the backend we need to mount all profile's download directory globally.
   // Otherwise, Files.app cannot support cross-profile file copies, etc.
   // For this reason, we need to register to the global GetSystemInstance().
   const std::string mount_point_name =
@@ skipping 443 matching lines @@
         // format if the second argument is empty. The third argument (mount
         // label) is not used in a disk mount operation.
         disk_mount_manager_->MountPath(disk->device_path(), std::string(),
                                        std::string(),
                                        chromeos::MOUNT_TYPE_DEVICE,
                                        GetExternalStorageAccessMode(profile_));
         mounting = true;
       }
 
       // Notify to observers.
-      FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
-                        OnDiskAdded(*disk, mounting));
+      for (auto& observer : observers_)
+        observer.OnDiskAdded(*disk, mounting);
       return;
     }
 
     case chromeos::disks::DiskMountManager::DISK_REMOVED:
       // If the disk is already mounted, unmount it.
       if (!disk->mount_path().empty()) {
         disk_mount_manager_->UnmountPath(
             disk->mount_path(),
             chromeos::UNMOUNT_OPTIONS_LAZY,
             chromeos::disks::DiskMountManager::UnmountPathCallback());
       }
 
       // Notify to observers.
-      FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
-                        OnDiskRemoved(*disk));
+      for (auto& observer : observers_)
+        observer.OnDiskRemoved(*disk);
       return;
   }
   NOTREACHED();
 }
 
 void VolumeManager::OnDeviceEvent(
     chromeos::disks::DiskMountManager::DeviceEvent event,
     const std::string& device_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   DVLOG(1) << "OnDeviceEvent: " << event << ", " << device_path;
   switch (event) {
     case chromeos::disks::DiskMountManager::DEVICE_ADDED:
-      FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
-                        OnDeviceAdded(device_path));
+      for (auto& observer : observers_)
+        observer.OnDeviceAdded(device_path);
       return;
     case chromeos::disks::DiskMountManager::DEVICE_REMOVED: {
-      FOR_EACH_OBSERVER(
-          VolumeManagerObserver, observers_, OnDeviceRemoved(device_path));
+      for (auto& observer : observers_)
+        observer.OnDeviceRemoved(device_path);
       return;
     }
     case chromeos::disks::DiskMountManager::DEVICE_SCANNED:
       DVLOG(1) << "Ignore SCANNED event: " << device_path;
       return;
   }
   NOTREACHED();
 }
 
 void VolumeManager::OnMountEvent(
@@ skipping 41 matching lines @@
 void VolumeManager::OnFormatEvent(
     chromeos::disks::DiskMountManager::FormatEvent event,
     chromeos::FormatError error_code,
     const std::string& device_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DVLOG(1) << "OnDeviceEvent: " << event << ", " << error_code
            << ", " << device_path;
 
   switch (event) {
     case chromeos::disks::DiskMountManager::FORMAT_STARTED:
-      FOR_EACH_OBSERVER(
-          VolumeManagerObserver, observers_,
-          OnFormatStarted(device_path,
-                          error_code == chromeos::FORMAT_ERROR_NONE));
+      for (auto& observer : observers_) {
+        observer.OnFormatStarted(device_path,
+                                 error_code == chromeos::FORMAT_ERROR_NONE);
+      }
       return;
     case chromeos::disks::DiskMountManager::FORMAT_COMPLETED:
       if (error_code == chromeos::FORMAT_ERROR_NONE) {
         // If format is completed successfully, try to mount the device.
         // MountPath auto-detects filesystem format if second argument is
         // empty. The third argument (mount label) is not used in a disk mount
         // operation.
         disk_mount_manager_->MountPath(device_path, std::string(),
                                        std::string(),
                                        chromeos::MOUNT_TYPE_DEVICE,
                                        GetExternalStorageAccessMode(profile_));
       }
 
-      FOR_EACH_OBSERVER(
-          VolumeManagerObserver, observers_,
-          OnFormatCompleted(device_path,
-                            error_code == chromeos::FORMAT_ERROR_NONE));
+      for (auto& observer : observers_) {
+        observer.OnFormatCompleted(device_path,
+                                   error_code == chromeos::FORMAT_ERROR_NONE);
+      }
 
       return;
   }
   NOTREACHED();
 }
 
 void VolumeManager::OnProvidedFileSystemMount(
     const chromeos::file_system_provider::ProvidedFileSystemInfo&
         file_system_info,
     chromeos::file_system_provider::MountContext context,
@@ skipping 247 matching lines @@
       profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
     return;
   }
 
   if (error_code == chromeos::MOUNT_ERROR_NONE || volume->mount_condition()) {
     mounted_volumes_[volume->volume_id()] = volume;
     UMA_HISTOGRAM_ENUMERATION("FileBrowser.VolumeType", volume->type(),
                               NUM_VOLUME_TYPE);
   }
 
-  FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
-                    OnVolumeMounted(error_code, *volume));
+  for (auto& observer : observers_)
+    observer.OnVolumeMounted(error_code, *volume);
 }
 
 void VolumeManager::DoUnmountEvent(chromeos::MountError error_code,
                                    const linked_ptr<Volume>& volume) {
   if (mounted_volumes_.find(volume->volume_id()) == mounted_volumes_.end())
     return;
   if (error_code == chromeos::MOUNT_ERROR_NONE)
     mounted_volumes_.erase(volume->volume_id());
 
-  FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
-                    OnVolumeUnmounted(error_code, *volume.get()));
+  for (auto& observer : observers_)
+    observer.OnVolumeUnmounted(error_code, *volume.get());
 }
 
 }  // namespace file_manager