[fsp] Group arguments for mounting into a struct.

chrome/browser/chromeos/file_system_provider/mount_path_util_unittest.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/mount_path_util.h"
 
 #include <string>
 
 #include "base/files/file.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 110 matching lines @@
       base::FilePath::FromUTF8Unsafe("provided/hello-world/test.txt")));
   EXPECT_FALSE(IsFileSystemProviderLocalPath(
       base::FilePath::FromUTF8Unsafe("/provided")));
   EXPECT_FALSE(
       IsFileSystemProviderLocalPath(base::FilePath::FromUTF8Unsafe("/")));
   EXPECT_FALSE(IsFileSystemProviderLocalPath(base::FilePath()));
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, Parser) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId,
-      kFileSystemId,
-      kDisplayName,
-      false /* writable */,
-      false /* supports_notify_tag */);
+      kExtensionId, MountOptions(kFileSystemId, kDisplayName));
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath =
       base::FilePath::FromUTF8Unsafe("/hello/world.txt");
   const storage::FileSystemURL url =
       CreateFileSystemURL(profile_, file_system_info, kFilePath);
   EXPECT_TRUE(url.is_valid());
 
   FileSystemURLParser parser(url);
   EXPECT_TRUE(parser.Parse());
 
   ProvidedFileSystemInterface* file_system = parser.file_system();
   ASSERT_TRUE(file_system);
   EXPECT_EQ(kFileSystemId, file_system->GetFileSystemInfo().file_system_id());
   EXPECT_EQ(kFilePath.AsUTF8Unsafe(), parser.file_path().AsUTF8Unsafe());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, Parser_RootPath) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId,
-      kFileSystemId,
-      kDisplayName,
-      false /* writable */,
-      false /* supports_notify_tag */);
+      kExtensionId, MountOptions(kFileSystemId, kDisplayName));
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath = base::FilePath::FromUTF8Unsafe("/");
   const storage::FileSystemURL url =
       CreateFileSystemURL(profile_, file_system_info, kFilePath);
   EXPECT_TRUE(url.is_valid());
 
   FileSystemURLParser parser(url);
   EXPECT_TRUE(parser.Parse());
 
   ProvidedFileSystemInterface* file_system = parser.file_system();
   ASSERT_TRUE(file_system);
   EXPECT_EQ(kFileSystemId, file_system->GetFileSystemInfo().file_system_id());
   EXPECT_EQ(kFilePath.AsUTF8Unsafe(), parser.file_path().AsUTF8Unsafe());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, Parser_WrongUrl) {
   const ProvidedFileSystemInfo file_system_info(
       kExtensionId,
-      kFileSystemId,
-      kDisplayName,
-      false /* writable */,
-      false /* supports_notify_tag */,
+      MountOptions(kFileSystemId, kDisplayName),
       GetMountPath(profile_, kExtensionId, kFileSystemId));
 
   const base::FilePath kFilePath = base::FilePath::FromUTF8Unsafe("/hello");
   const storage::FileSystemURL url =
       CreateFileSystemURL(profile_, file_system_info, kFilePath);
   // It is impossible to create a cracked URL for a mount point which doesn't
   // exist, therefore is will always be invalid, and empty.
   EXPECT_FALSE(url.is_valid());
 
   FileSystemURLParser parser(url);
   EXPECT_FALSE(parser.Parse());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, Parser_IsolatedURL) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId,
-      kFileSystemId,
-      kDisplayName,
-      false /* writable */,
-      false /* supports_notify_tag */);
+      kExtensionId, MountOptions(kFileSystemId, kDisplayName));
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath =
       base::FilePath::FromUTF8Unsafe("/hello/world.txt");
   const storage::FileSystemURL url =
       CreateFileSystemURL(profile_, file_system_info, kFilePath);
@@ skipping 25 matching lines @@
   EXPECT_TRUE(parser.Parse());
 
   ProvidedFileSystemInterface* file_system = parser.file_system();
   ASSERT_TRUE(file_system);
   EXPECT_EQ(kFileSystemId, file_system->GetFileSystemInfo().file_system_id());
   EXPECT_EQ(kFilePath.AsUTF8Unsafe(), parser.file_path().AsUTF8Unsafe());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, LocalPathParser) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId,
-      kFileSystemId,
-      kDisplayName,
-      false /* writable */,
-      false /* supports_notify_tag */);
+      kExtensionId, MountOptions(kFileSystemId, kDisplayName));
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath =
       base::FilePath::FromUTF8Unsafe("/hello/world.txt");
   const base::FilePath kLocalFilePath = file_system_info.mount_path().Append(
       base::FilePath(kFilePath.value().substr(1)));
 
   LOG(ERROR) << kLocalFilePath.value();
   LocalPathParser parser(profile_, kLocalFilePath);
   EXPECT_TRUE(parser.Parse());
 
   ProvidedFileSystemInterface* file_system = parser.file_system();
   ASSERT_TRUE(file_system);
   EXPECT_EQ(kFileSystemId, file_system->GetFileSystemInfo().file_system_id());
   EXPECT_EQ(kFilePath.AsUTF8Unsafe(), parser.file_path().AsUTF8Unsafe());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, LocalPathParser_RootPath) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId,
-      kFileSystemId,
-      kDisplayName,
-      false /* writable */,
-      false /* supports_notify_tag */);
+      kExtensionId, MountOptions(kFileSystemId, kDisplayName));
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath = base::FilePath::FromUTF8Unsafe("/");
   const base::FilePath kLocalFilePath = file_system_info.mount_path();
 
   LocalPathParser parser(profile_, kLocalFilePath);
@@ skipping 23 matching lines @@
     const base::FilePath kFilePath =
         base::FilePath::FromUTF8Unsafe("provided/hello/world");
     LocalPathParser parser(profile_, kFilePath);
     EXPECT_FALSE(parser.Parse());
   }
 }
 
 }  // namespace util
 }  // namespace file_system_provider
 }  // namespace chromeos