Change access mode of disk devices when mounting based on config.

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 117 matching lines @@
           volume.mount_path().BaseName().AsUTF8Unsafe());
 }
 
 std::string GetMountPointNameForMediaStorage(
     const storage_monitor::StorageInfo& info) {
   std::string name(kFileManagerMTPMountNamePrefix);
   name += info.device_id();
   return name;
 }
 
+chromeos::MountAccessMode GetExternalStorageAccessMode(const Profile* profile) {
+  return profile->GetPrefs()->GetBoolean(prefs::kExternalStorageReadOnly)
+             ? chromeos::MOUNT_ACCESS_MODE_READ_ONLY
+             : chromeos::MOUNT_ACCESS_MODE_READ_WRITE;
+}
+
 }  // 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),
@@ skipping 339 matching lines @@
       }
 
       bool mounting = false;
       if (disk->mount_path().empty() && disk->has_media() &&
           !profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
         // If disk is not mounted yet and it has media and there is no policy
         // forbidding external storage, give it a try.
         // Initiate disk mount operation. MountPath auto-detects the filesystem
         // format if the second argument is empty. The third argument (mount
         // label) is not used in a disk mount operation.
-        disk_mount_manager_->MountPath(
-            disk->device_path(), std::string(), std::string(),
-            chromeos::MOUNT_TYPE_DEVICE);
+        disk_mount_manager_->MountPath(disk->device_path(), std::string(),
+                                       std::string(),
+                                       chromeos::MOUNT_TYPE_DEVICE,
+                                       GetExternalStorageAccessMode(profile_));
         mounting = true;
       }
 
       // Notify to observers.
       FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
                         OnDiskAdded(*disk, mounting));
       return;
     }
 
     case chromeos::disks::DiskMountManager::DISK_REMOVED:
@@ skipping 92 matching lines @@
           VolumeManagerObserver, observers_,
           OnFormatStarted(device_path,
                           error_code == chromeos::FORMAT_ERROR_NONE));
       return;
     case chromeos::disks::DiskMountManager::FORMAT_COMPLETED:
       if (error_code == chromeos::FORMAT_ERROR_NONE) {
         // If format is completed successfully, try to mount the device.
         // MountPath auto-detects filesystem format if second argument is
         // empty. The third argument (mount label) is not used in a disk mount
         // operation.
-        disk_mount_manager_->MountPath(
-            device_path, std::string(), std::string(),
-            chromeos::MOUNT_TYPE_DEVICE);
+        disk_mount_manager_->MountPath(device_path, std::string(),
+                                       std::string(),
+                                       chromeos::MOUNT_TYPE_DEVICE,
+                                       GetExternalStorageAccessMode(profile_));
       }
 
       FOR_EACH_OBSERVER(
           VolumeManagerObserver, observers_,
           OnFormatCompleted(device_path,
                             error_code == chromeos::FORMAT_ERROR_NONE));
 
       return;
   }
   NOTREACHED();
@@ skipping 250 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_EACH_OBSERVER(VolumeManagerObserver, observers_,
                     OnVolumeUnmounted(error_code, *volume.get()));
 }
 
 }  // namespace file_manager