Preserve the hardware read-only flag in Disk object.

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 350 matching lines @@
         // from CrosDisksClientImpl::OnMountCompleted.
         // The disk should be treated as read-only when:
         //  - the read-only option was passed when issuing mount command
         //  - or the device hardware is read-only.
         // |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() &&
             it->second == chromeos::MOUNT_ACCESS_MODE_READ_ONLY) {
-          disk->set_read_only(true);
+          disk->set_write_disabled_by_policy(true);
         }
         disk->set_mount_path(mount_info.mount_path);
       }
     }
     // Observers may read the values of disks_. So notify them after tweaking
     // values of disks_.
     NotifyMountStatusUpdate(MOUNTING, entry.error_code(), mount_info);
   }
 
   // Callback for UnmountPath.
@@ skipping 80 matching lines @@
       return;
 
     LOG(WARNING) << "Found disk " << disk_info.device_path();
     // Delete previous disk info for this path:
     bool is_new = true;
     DiskMap::iterator iter = disks_.find(disk_info.device_path());
     if (iter != disks_.end()) {
       disks_.erase(iter);
       is_new = false;
     }
+
+    // If the device was mounted by the instance, apply recorded parameter.
+    // Otherwise, default to false.
+    // Lookup by |device_path| which we pass to cros-disks when mounting a
+    // device in |VolumeManager::OnDiskEvent()|.
+    AccessModeMap::iterator access_mode =

[hashimoto, 2016/10/21 08:39:59]

nit: You can do
  auto access_mode = access_modes_.find(...);

[yamaguchi, 2016/10/21 08:53:03]

Done.

+        access_modes_.find(disk_info.device_path());
+    bool write_disabled_by_policy = access_mode != access_modes_.end()
+        && access_mode->second == chromeos::MOUNT_ACCESS_MODE_READ_ONLY;
     Disk* disk = new Disk(disk_info.device_path(),
                           disk_info.mount_path(),
+                          write_disabled_by_policy,
                           disk_info.system_path(),
                           disk_info.file_path(),
                           disk_info.label(),
                           disk_info.drive_label(),
                           disk_info.vendor_id(),
                           disk_info.vendor_name(),
                           disk_info.product_id(),
                           disk_info.product_name(),
                           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(), base::WrapUnique(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(); ) {
@@ skipping 162 matching lines @@
 
   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,
+                             bool write_disabled_by_policy,
                              const std::string& system_path,
                              const std::string& file_path,
                              const std::string& device_label,
                              const std::string& drive_label,
                              const std::string& vendor_id,
                              const std::string& vendor_name,
                              const std::string& product_id,
                              const std::string& product_name,
                              const std::string& fs_uuid,
                              const std::string& system_path_prefix,
                              DeviceType device_type,
                              uint64_t total_size_in_bytes,
                              bool is_parent,
-                             bool is_read_only,
+                             bool is_read_only_hardware,
                              bool has_media,
                              bool on_boot_device,
                              bool on_removable_device,
                              bool is_hidden)
     : device_path_(device_path),
       mount_path_(mount_path),
+      write_disabled_by_policy_(write_disabled_by_policy),
       system_path_(system_path),
       file_path_(file_path),
       device_label_(device_label),
       drive_label_(drive_label),
       vendor_id_(vendor_id),
       vendor_name_(vendor_name),
       product_id_(product_id),
       product_name_(product_name),
       fs_uuid_(fs_uuid),
       system_path_prefix_(system_path_prefix),
       device_type_(device_type),
       total_size_in_bytes_(total_size_in_bytes),
       is_parent_(is_parent),
-      is_read_only_(is_read_only),
+      is_read_only_hardware_(is_read_only_hardware),
       has_media_(has_media),
       on_boot_device_(on_boot_device),
       on_removable_device_(on_removable_device),
       is_hidden_(is_hidden) {}
 
 DiskMountManager::Disk::Disk(const Disk& other) = default;
 
 DiskMountManager::Disk::~Disk() {}
 
 bool DiskMountManager::AddDiskForTest(std::unique_ptr<Disk> disk) {
@@ skipping 67 matching lines @@
   VLOG(1) << "DiskMountManager Shutdown completed";
 }
 
 // static
 DiskMountManager* DiskMountManager::GetInstance() {
   return g_disk_mount_manager;
 }
 
 }  // namespace disks
 }  // namespace chromeos