Allow to pass remount option to Mount method of cros_disks_client.

chromeos/dbus/cros_disks_client.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/dbus/cros_disks_client.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 19 matching lines @@
 
 namespace chromeos {
 
 namespace {
 
 const char* kDefaultMountOptions[] = {
     "nodev", "noexec", "nosuid",
 };
 const char kReadOnlyOption[] = "ro";
 const char kReadWriteOption[] = "rw";
+const char kRemountOption[] = "remount";
 const char kMountLabelOption[] = "mountlabel";
 
 const char* kDefaultUnmountOptions[] = {
   "force",
 };
 
 const char kLazyUnmountOption[] = "lazy";
 
 // Checks if retrieved media type is in boundaries of DeviceMediaType.
 bool IsValidMediaType(uint32_t type) {
@@ skipping 47 matching lines @@
 // The CrosDisksClient implementation.
 class CrosDisksClientImpl : public CrosDisksClient {
  public:
   CrosDisksClientImpl() : proxy_(NULL), weak_ptr_factory_(this) {}
 
   // CrosDisksClient override.
   void Mount(const std::string& source_path,
              const std::string& source_format,
              const std::string& mount_label,
              MountAccessMode access_mode,
+             RemountOption remount,
              const base::Closure& callback,
              const base::Closure& error_callback) override {
     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
                                  cros_disks::kMount);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(source_path);
     writer.AppendString(source_format);
     std::vector<std::string> mount_options =
-        ComposeMountOptions(mount_label, access_mode);
+        ComposeMountOptions(mount_label, access_mode, remount);
     writer.AppendArrayOfStrings(mount_options);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CrosDisksClientImpl::OnMount,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback,
                                   error_callback));
   }
 
   // CrosDisksClient override.
   void Unmount(const std::string& device_path,
@@ skipping 522 matching lines @@
 // static
 base::FilePath CrosDisksClient::GetRemovableDiskMountPoint() {
   return base::FilePath(base::SysInfo::IsRunningOnChromeOS() ?
                         FILE_PATH_LITERAL("/media/removable") :
                         FILE_PATH_LITERAL("/tmp/chromeos/media/removable"));
 }
 
 // static
 std::vector<std::string> CrosDisksClient::ComposeMountOptions(
     const std::string& mount_label,
-    MountAccessMode access_mode) {
+    MountAccessMode access_mode,
+    RemountOption remount) {
   std::vector<std::string> mount_options(
       kDefaultMountOptions,
       kDefaultMountOptions + arraysize(kDefaultMountOptions));
   switch (access_mode) {
     case MOUNT_ACCESS_MODE_READ_ONLY:
       mount_options.push_back(kReadOnlyOption);
       break;
     case MOUNT_ACCESS_MODE_READ_WRITE:
       mount_options.push_back(kReadWriteOption);
       break;
   }
+  if (remount == REMOUNT_OPTION_REMOUNT_EXISTING_DEVICE) {
+    mount_options.push_back(kRemountOption);
+  }
 
   if (!mount_label.empty()) {
     std::string mount_label_option =
         base::StringPrintf("%s=%s", kMountLabelOption, mount_label.c_str());
     mount_options.push_back(mount_label_option);
   }
   return mount_options;
 }
 
 }  // namespace chromeos