[fsp] Group arguments for mounting into a struct.

chrome/browser/chromeos/file_system_provider/service.cc

 // Copyright 2014 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_system_provider/service.h"
 
 #include "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
@@ skipping 83 matching lines @@
   observers_.RemoveObserver(observer);
 }
 
 void Service::SetFileSystemFactoryForTesting(
     const FileSystemFactoryCallback& factory_callback) {
   DCHECK(!factory_callback.is_null());
   file_system_factory_ = factory_callback;
 }
 
 bool Service::MountFileSystem(const std::string& extension_id,
-                              const std::string& file_system_id,
-                              const std::string& display_name,
-                              bool writable,
-                              bool supports_notify_tag) {
+                              const MountOptions& options) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If already exists a file system provided by the same extension with this
   // id, then abort.
-  if (GetProvidedFileSystem(extension_id, file_system_id)) {
+  if (GetProvidedFileSystem(extension_id, options.file_system_id)) {
     FOR_EACH_OBSERVER(Observer,
                       observers_,
                       OnProvidedFileSystemMount(ProvidedFileSystemInfo(),
                                                 base::File::FILE_ERROR_EXISTS));
     return false;
   }
 
   // Restrict number of file systems to prevent system abusing.
   if (file_system_map_.size() + 1 > kMaxFileSystems) {
     FOR_EACH_OBSERVER(
         Observer,
         observers_,
         OnProvidedFileSystemMount(ProvidedFileSystemInfo(),
                                   base::File::FILE_ERROR_TOO_MANY_OPENED));
     return false;
   }
 
   storage::ExternalMountPoints* const mount_points =
       storage::ExternalMountPoints::GetSystemInstance();
   DCHECK(mount_points);
 
   // The mount point path and name are unique per system, since they are system
   // wide. This is necessary for copying between profiles.
   const base::FilePath& mount_path =
-      util::GetMountPath(profile_, extension_id, file_system_id);
+      util::GetMountPath(profile_, extension_id, options.file_system_id);
   const std::string mount_point_name = mount_path.BaseName().AsUTF8Unsafe();
 
   if (!mount_points->RegisterFileSystem(mount_point_name,
                                         storage::kFileSystemTypeProvided,
                                         storage::FileSystemMountOption(),
                                         mount_path)) {
     FOR_EACH_OBSERVER(
         Observer,
         observers_,
         OnProvidedFileSystemMount(ProvidedFileSystemInfo(),
                                   base::File::FILE_ERROR_INVALID_OPERATION));
     return false;
   }
 
   // Store the file system descriptor. Use the mount point name as the file
   // system provider file system id.
   // Examples:
   //   file_system_id = hello_world
   //   mount_point_name =  b33f1337-hello_world-5aa5
   //   writable = false
   //   supports_notify_tag = false
   //   mount_path = /provided/b33f1337-hello_world-5aa5
-  ProvidedFileSystemInfo file_system_info(extension_id,
-                                          file_system_id,
-                                          display_name,
-                                          writable,
-                                          supports_notify_tag,
-                                          mount_path);
+  ProvidedFileSystemInfo file_system_info(extension_id, options, mount_path);
 
   ProvidedFileSystemInterface* file_system =
       file_system_factory_.Run(profile_, file_system_info);
   DCHECK(file_system);
-  file_system_map_[FileSystemKey(extension_id, file_system_id)] = file_system;
+  file_system_map_[FileSystemKey(extension_id, options.file_system_id)] =
+      file_system;
   mount_point_name_to_key_map_[mount_point_name] =
-      FileSystemKey(extension_id, file_system_id);
+      FileSystemKey(extension_id, options.file_system_id);
   RememberFileSystem(file_system_info);
 
   FOR_EACH_OBSERVER(
       Observer,
       observers_,
       OnProvidedFileSystemMount(file_system_info, base::File::FILE_OK));
 
   return true;
 }
 
@@ skipping 260 matching lines @@
                                                     &display_name) ||
         !file_system->GetBooleanWithoutPathExpansion(kPrefKeyWritable,
                                                      &writable) ||
         !file_system->GetBooleanWithoutPathExpansion(kPrefKeySupportsNotifyTag,
                                                      &supports_notify_tag) ||
         file_system_id.empty() || display_name.empty()) {
       LOG(ERROR)
           << "Malformed provided file system information in preferences.";
       continue;
     }
-    const bool result = MountFileSystem(extension_id,
-                                        file_system_id,
-                                        display_name,
-                                        writable,
-                                        supports_notify_tag);
+    MountOptions options;
+    options.file_system_id = file_system_id;
+    options.display_name = display_name;
+    options.writable = writable;
+    options.supports_notify_tag = supports_notify_tag;
+    const bool result = MountFileSystem(extension_id, options);
     if (!result) {
       LOG(ERROR) << "Failed to restore a provided file system from "
                  << "preferences: " << extension_id << ", " << file_system_id
                  << ", " << display_name << ".";
       // Since remounting of the file system failed, then remove it from
       // preferences to avoid remounting it over and over again with a failure.
       ForgetFileSystem(extension_id, file_system_id);
     }
   }
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos