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(mount_label, access_mode));

[satorux1, 2016/08/12 02:47:51]

At this point, mount isn't complete yet. How about doing this inside
OnMountCompleted()? You can pass 'access_mode' to OnMountCompleted() function.

[yamaguchi, 2016/08/15 15:32:48]

OnMountCompleted is invoked by the signal from DBus. So it will be doable when
we review the dbus message.

   }
 
   // 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 244 matching lines @@
         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.
+      AccessModeMap::iterator it = access_modes_.find(disk->mount_path());

[satorux1, 2016/08/12 02:47:51]

access_modes_'s keys are mount labels, but here, it's accessed with
mount_path(). Are they the same thing? Would be nice to add some comment?

[yamaguchi, 2016/08/15 15:32:48]

Good catch. We need to use device path instead of mount_path, because mount_path
is not given when we insert it to the dict.

+      if (it != access_modes_.end()) {
+        disk->set_read_only(it->second ==
+                            chromeos::MOUNT_ACCESS_MODE_READ_ONLY);
+      }

[satorux1, 2016/08/12 02:47:52]

If 'access_mode' is passed to OnMountCompleted(), code around this can be as
simple as

  disk->set_read_only(access_mode == 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.
+    AccessModeMap::iterator mount_option =

[satorux1, 2016/08/12 02:47:52]

mount_option -> access_mode?

[yamaguchi, 2016/08/15 15:32:48]

Done.

+        access_modes_.find(disk->mount_path());
+    if (mount_option != access_modes_.end()) {
+      disk->set_read_only(mount_option->second ==
+                          chromeos::MOUNT_ACCESS_MODE_READ_ONLY);
+    }

[satorux1, 2016/08/12 02:47:52]

another approach: instead of introducing access_modes_, how about relying on the
previous disk info, that's deleted on the line 460? 

[yamaguchi, 2016/08/15 15:32:48]

The previous disk will be available only when this is called from the call path
of SuspendUnmountManager::SuspendDone, but not when it come from OnMountEvent
(=after mounting a new device).

     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 mount label (not mount source).
+  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