Propagate the read_only_hardware flag of volumes to js.

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 133 matching lines @@
 }  // namespace
 
 Volume::Volume()
     : source_(SOURCE_FILE),
       type_(VOLUME_TYPE_GOOGLE_DRIVE),
       device_type_(chromeos::DEVICE_TYPE_UNKNOWN),
       mount_condition_(chromeos::disks::MOUNT_CONDITION_NONE),
       mount_context_(MOUNT_CONTEXT_UNKNOWN),
       is_parent_(false),
       is_read_only_(false),
+      is_read_only_hardware_(false),
       has_media_(false),
       configurable_(false),
-      watchable_(false) {
-}
+      watchable_(false) {}

[fukino, 2016/10/26 07:23:31]

nit: looks unnecessary change (the style is not consistent with the dtor)

[yamaguchi, 2016/10/26 11:14:20]

Done.

 
 Volume::~Volume() {
 }
 
 // static
 Volume* Volume::CreateForDrive(Profile* profile) {
   const base::FilePath& drive_path =
       drive::util::GetDriveMountPointPath(profile);
   Volume* const volume = new Volume;
   volume->type_ = VOLUME_TYPE_GOOGLE_DRIVE;
@@ skipping 32 matching lines @@
                         ? SOURCE_FILE
                         : SOURCE_DEVICE;
   volume->mount_path_ = base::FilePath(mount_point.mount_path);
   volume->mount_condition_ = mount_point.mount_condition;
   volume->volume_label_ = volume->mount_path().BaseName().AsUTF8Unsafe();
   if (disk) {
     volume->device_type_ = disk->device_type();
     volume->system_path_prefix_ = base::FilePath(disk->system_path_prefix());
     volume->is_parent_ = disk->is_parent();
     volume->is_read_only_ = disk->is_read_only();
+    volume->is_read_only_hardware_ = disk->is_read_only_hardware();
     volume->has_media_ = disk->has_media();
   } else {
     volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
-    volume->is_read_only_ =
+    volume->is_read_only_ = volume->is_read_only_hardware_ =
         (mount_point.mount_type == chromeos::MOUNT_TYPE_ARCHIVE);
   }
   volume->volume_id_ = GenerateVolumeId(*volume);
   volume->watchable_ = true;
   return volume;
 }
 
 // static
 Volume* Volume::CreateForProvidedFileSystem(
     const chromeos::file_system_provider::ProvidedFileSystemInfo&
@@ skipping 13 matching lines @@
       volume->source_ = SOURCE_NETWORK;
       break;
   }
   volume->volume_label_ = file_system_info.display_name();
   volume->type_ = VOLUME_TYPE_PROVIDED;
   volume->mount_path_ = file_system_info.mount_path();
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->mount_context_ = mount_context;
   volume->is_parent_ = true;
   volume->is_read_only_ = !file_system_info.writable();
+  volume->is_read_only_hardware_ = volume->is_read_only_;
   volume->configurable_ = file_system_info.configurable();
   volume->watchable_ = file_system_info.watchable();
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
 // static
 Volume* Volume::CreateForMTP(const base::FilePath& mount_path,
                              const std::string& label,
                              bool read_only) {
@@ skipping 645 matching lines @@
   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 (auto& observer : observers_)
     observer.OnVolumeUnmounted(error_code, *volume.get());
 }
 
 }  // namespace file_manager