Store correct read-only flag of mounted disks.

chromeos/disks/disk_mount_manager.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 "chromeos/disks/disk_mount_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 69 matching lines @@
       }
     }
     cros_disks_client_->Mount(
         source_path, source_format, mount_label, access_mode,
         // When succeeds, OnMountCompleted will be called by
         // "MountCompleted" signal instead.
         base::Bind(&base::DoNothing),
         base::Bind(&DiskMountManagerImpl::OnMountCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
                    MountEntry(MOUNT_ERROR_INTERNAL, source_path, type, "")));
+
+    // Record the access mode option passed to CrosDisks.
+    // This is needed because CrosDisks service methods doesn't return the info
+    // via DBus.
+    access_modes_.insert(std::make_pair(source_path, access_mode));
   }
 
   // DiskMountManager override.
   void UnmountPath(const std::string& mount_path,
                    UnmountOptions options,
                    const UnmountPathCallback& callback) override {
     UnmountChildMounts(mount_path);
     cros_disks_client_->Unmount(mount_path, options,
                                 base::Bind(&DiskMountManagerImpl::OnUnmountPath,
                                            weak_ptr_factory_.GetWeakPtr(),
@@ skipping 228 matching lines @@
       }
       if (entry.error_code() == MOUNT_ERROR_UNSUPPORTED_FILESYSTEM) {
         mount_condition = MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM;
       }
     }
     const MountPointInfo mount_info(entry.source_path(),
                                     entry.mount_path(),
                                     entry.mount_type(),
                                     mount_condition);
 
     NotifyMountStatusUpdate(MOUNTING, entry.error_code(), mount_info);

[yamaguchi, 2016/08/24 06:46:28]

This will invoke observer functions. Especially, StorageMonitorCros will call
back to this disk_mount_manager and reads values of disks_. So we need to update
disks_ before this.
https://cs.chromium.org/chromium/src/components/storage_monitor/storage_monit...

 
     // If the device is corrupted but it's still possible to format it, it will
     // be fake mounted.
     if ((entry.error_code() == MOUNT_ERROR_NONE ||
          mount_info.mount_condition) &&
         mount_points_.find(mount_info.mount_path) == mount_points_.end()) {
       mount_points_.insert(MountPointMap::value_type(mount_info.mount_path,
                                                      mount_info));
     }
     if ((entry.error_code() == MOUNT_ERROR_NONE ||
          mount_info.mount_condition) &&
         mount_info.mount_type == MOUNT_TYPE_DEVICE &&
         !mount_info.source_path.empty() &&
         !mount_info.mount_path.empty()) {
       DiskMap::iterator iter = disks_.find(mount_info.source_path);
       if (iter == disks_.end()) {
         // disk might have been removed by now?
         return;
       }
       Disk* disk = iter->second;
       DCHECK(disk);
+      // The is_read_only field in *disk may be incorrect when this is called
+      // from CrosDisksClientImpl::OnMountCompleted.
+      // Overwrite based on the access mode option that was passed when issuing
+      // mount command to the same mount path last time.
+      // |source_path| should be same as |disk->device_path| because
+      // |VolumeManager::OnDiskEvent()| passes the latter to cros-disks as a
+      // source path when mounting a device.
+      AccessModeMap::iterator it = access_modes_.find(entry.source_path());
+      if (it != access_modes_.end()) {
+        disk->set_read_only(it->second ==
+                            chromeos::MOUNT_ACCESS_MODE_READ_ONLY);
+      }
       disk->set_mount_path(mount_info.mount_path);
     }
   }
 
   // Callback for UnmountPath.
   void OnUnmountPath(const UnmountPathCallback& callback,
                      bool success,
                      const std::string& mount_path) {
     MountPointMap::iterator mount_points_it = mount_points_.find(mount_path);
     if (mount_points_it == mount_points_.end()) {
@@ skipping 96 matching lines @@
                           disk_info.uuid(),
                           FindSystemPathPrefix(disk_info.system_path()),
                           disk_info.device_type(),
                           disk_info.total_size_in_bytes(),
                           disk_info.is_drive(),
                           disk_info.is_read_only(),
                           disk_info.has_media(),
                           disk_info.on_boot_device(),
                           disk_info.on_removable_device(),
                           disk_info.is_hidden());
+    // If the device was mounted by the instance, apply recorded parameter.
+    // Lookup by |device_path| which we pass to cros-disks when mounting a
+    // device in |VolumeManager::OnDiskEvent()|.
+    AccessModeMap::iterator access_mode =
+        access_modes_.find(disk->device_path());
+    if (access_mode != access_modes_.end()) {
+      disk->set_read_only(access_mode->second ==
+                          chromeos::MOUNT_ACCESS_MODE_READ_ONLY);
+    }
     disks_.insert(std::make_pair(disk_info.device_path(), disk));
     NotifyDiskStatusUpdate(is_new ? DISK_ADDED : DISK_CHANGED, disk);
   }
 
   // Part of EnsureMountInfoRefreshed(). Called after the list of devices are
   // enumerated.
   void RefreshAfterEnumerateDevices(const std::vector<std::string>& devices) {
     std::set<std::string> current_device_set(devices.begin(), devices.end());
     for (DiskMap::iterator iter = disks_.begin(); iter != disks_.end(); ) {
       if (current_device_set.find(iter->first) == current_device_set.end()) {
@@ skipping 147 matching lines @@
   DiskMountManager::MountPointMap mount_points_;
 
   typedef std::set<std::string> SystemPathPrefixSet;
   SystemPathPrefixSet system_path_prefixes_;
 
   bool already_refreshed_;
   std::vector<EnsureMountInfoRefreshedCallback> refresh_callbacks_;
 
   std::unique_ptr<SuspendUnmountManager> suspend_unmount_manager_;
 
+  // Whether the instance attempted to mount a device in read-only mode for
+  // each source path.
+  typedef std::map<std::string, chromeos::MountAccessMode> AccessModeMap;
+  AccessModeMap access_modes_;
+
   base::WeakPtrFactory<DiskMountManagerImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DiskMountManagerImpl);
 };
 
 }  // namespace
 
 DiskMountManager::Disk::Disk(const std::string& device_path,
                              const std::string& mount_path,
                              const std::string& system_path,
@@ skipping 110 matching lines @@
   VLOG(1) << "DiskMountManager Shutdown completed";
 }
 
 // static
 DiskMountManager* DiskMountManager::GetInstance() {
   return g_disk_mount_manager;
 }
 
 }  // namespace disks
 }  // namespace chromeos