Preserve the hardware read-only flag in Disk object.

chromeos/disks/disk_mount_manager.h

 // 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.
 
 #ifndef CHROMEOS_DISKS_DISK_MOUNT_MANAGER_H_
 #define CHROMEOS_DISKS_DISK_MOUNT_MANAGER_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 38 matching lines @@
   enum FormatEvent {
     FORMAT_STARTED,
     FORMAT_COMPLETED
   };
 
   // Used to house an instance of each found mount device.
   class Disk {
    public:
     Disk(const std::string& device_path,
          const std::string& mount_path,
+         bool write_disabled_by_policy,

[satorux1, 2016/10/24 01:39:55]

any reason why this should be added here? i thought it'd be nicer to add this to
a location below where other bool parameters are listed.

[yamaguchi, 2016/10/24 01:53:30]

I think that the parameter is tied to the mount_path above, as it conveys
information that originates from the mount operation by CrOS, as opposed to that
the most of other fields are originated from the physical device itself. Also,
the field is only valid when mount_path is non-empty.

[satorux1, 2016/10/24 02:00:11]

Ah OK. Then please add a comment that explains the relationship between
mount_path and this parameter. Then it'll be clear and informative.

[yamaguchi, 2016/10/24 04:43:23]

Done.

          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);
     Disk(const Disk& other);
     ~Disk();
 
     // The path of the device, used by devicekit-disks.
     // (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1)
     const std::string& device_path() const { return device_path_; }
 
     // The path to the mount point of this device. Will be empty if not mounted.
     // (e.g. /media/removable/VOLUME)
-    const std::string&  mount_path() const { return mount_path_; }
+    const std::string& mount_path() const { return mount_path_; }
 
     // The path of the device according to the udev system.
     // (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1)
     const std::string& system_path() const { return system_path_; }
 
     // The path of the device according to filesystem.
     // (e.g. /dev/sdb)
     const std::string& file_path() const { return file_path_; }
 
     // Device's label.
@@ skipping 26 matching lines @@
 
     // Device type.
     DeviceType device_type() const { return device_type_; }
 
     // Total size of the device in bytes.
     uint64_t total_size_in_bytes() const { return total_size_in_bytes_; }
 
     // Is the device is a parent device (i.e. sdb rather than sdb1).
     bool is_parent() const { return is_parent_; }
 
+    // Whether the user can write to the device. True if read-only.
+    bool is_read_only() const {
+      return is_read_only_hardware_ || write_disabled_by_policy_;
+    }
+
     // Is the device read only.
-    bool is_read_only() const { return is_read_only_; }
+    bool is_read_only_hardware() const { return is_read_only_hardware_; }
 
     // Does the device contains media.
     bool has_media() const { return has_media_; }
 
     // Is the device on the boot device.
     bool on_boot_device() const { return on_boot_device_; }
 
     // Is the device on the removable device.
     bool on_removable_device() const { return on_removable_device_; }
 
     // Shoud the device be shown in the UI, or automounted.
     bool is_hidden() const { return is_hidden_; }
 
     void set_mount_path(const std::string& mount_path) {
       mount_path_ = mount_path;
     }
 
-    void set_read_only(bool is_read_only) { is_read_only_ = is_read_only; }
+    void set_write_disabled_by_policy(bool disable) {
+      write_disabled_by_policy_ = disable;
+    }
 
     void clear_mount_path() { mount_path_.clear(); }
 
    private:
     std::string device_path_;
     std::string mount_path_;

[satorux1, 2016/10/24 01:39:55]

ditto.

[yamaguchi, 2016/10/24 04:43:23]

Done.

+    bool write_disabled_by_policy_;
     std::string system_path_;
     std::string file_path_;
     std::string device_label_;
     std::string drive_label_;
     std::string vendor_id_;
     std::string vendor_name_;
     std::string product_id_;
     std::string product_name_;
     std::string fs_uuid_;
     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_;
   };
   typedef std::map<std::string, std::unique_ptr<Disk>> DiskMap;
 
   // A struct to store information about mount point.
   struct MountPointInfo {
     // Device's path.
@@ skipping 132 matching lines @@
 
   // Returns a pointer to the global DiskMountManager instance.
   // Initialize() should already have been called.
   static DiskMountManager* GetInstance();
 };
 
 }  // namespace disks
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DISKS_DISK_MOUNT_MANAGER_H_