src/content/browser/fileapi/external_mount_points_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "storage/browser/fileapi/external_mount_points.h"
   6
   7 #include <string>
   8
   9 #include "base/files/file_path.h"
  10 #include "storage/browser/fileapi/file_system_url.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 #define FPL FILE_PATH_LITERAL
  14
  15 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
  16 #define DRIVE FPL("C:")
  17 #else
  18 #define DRIVE
  19 #endif
  20
  21 using storage::FileSystemURL;
  22
  23 namespace content {
  24
  25 TEST(ExternalMountPointsTest, AddMountPoint) {
  26   scoped_refptr<storage::ExternalMountPoints> mount_points(
  27       storage::ExternalMountPoints::CreateRefCounted());
  28
  29   struct TestCase {
  30     // The mount point's name.
  31     const char* const name;
  32     // The mount point's path.
  33     const base::FilePath::CharType* const path;
  34     // Whether the mount point registration should succeed.
  35     bool success;
  36     // Path returned by GetRegisteredPath. NULL if the method is expected to
  37     // fail.
  38     const base::FilePath::CharType* const registered_path;
  39   };
  40
  41   const TestCase kTestCases[] = {
  42     // Valid mount point.
  43     { "test", DRIVE FPL("/foo/test"), true, DRIVE FPL("/foo/test") },
  44     // Valid mount point with only one path component.
  45     { "bbb", DRIVE FPL("/bbb"), true, DRIVE FPL("/bbb") },
  46     // Existing mount point path is substring of the mount points path.
  47     { "test11", DRIVE FPL("/foo/test11"), true, DRIVE FPL("/foo/test11") },
  48     // Path substring of an existing path.
  49     { "test1", DRIVE FPL("/foo/test1"), true, DRIVE FPL("/foo/test1") },
  50     // Empty mount point name and path.
  51     { "", DRIVE FPL(""), false, NULL },
  52     // Empty mount point name.
  53     { "", DRIVE FPL("/ddd"), false, NULL },
  54     // Empty mount point path.
  55     { "empty_path", FPL(""), true, FPL("") },
  56     // Name different from path's base name.
  57     { "not_base_name", DRIVE FPL("/x/y/z"), true, DRIVE FPL("/x/y/z") },
  58     // References parent.
  59     { "invalid", DRIVE FPL("../foo/invalid"), false, NULL },
  60     // Relative path.
  61     { "relative", DRIVE FPL("foo/relative"), false, NULL },
  62     // Existing mount point path.
  63     { "path_exists", DRIVE FPL("/foo/test"), false, NULL },
  64     // Mount point with the same name exists.
  65     { "test", DRIVE FPL("/foo/a/test_name_exists"), false,
  66       DRIVE FPL("/foo/test") },
  67     // Child of an existing mount point.
  68     { "a1", DRIVE FPL("/foo/test/a"), false, NULL },
  69     // Parent of an existing mount point.
  70     { "foo1", DRIVE FPL("/foo"), false, NULL },
  71     // Bit bigger depth.
  72     { "g", DRIVE FPL("/foo/a/b/c/d/e/f/g"), true,
  73       DRIVE FPL("/foo/a/b/c/d/e/f/g") },
  74     // Sibling mount point (with similar name) exists.
  75     { "ff", DRIVE FPL("/foo/a/b/c/d/e/ff"), true,
  76        DRIVE FPL("/foo/a/b/c/d/e/ff") },
  77     // Lexicographically last among existing mount points.
  78     { "yyy", DRIVE FPL("/zzz/yyy"), true, DRIVE FPL("/zzz/yyy") },
  79     // Parent of the lexicographically last mount point.
  80     { "zzz1", DRIVE FPL("/zzz"), false, NULL },
  81     // Child of the lexicographically last mount point.
  82     { "xxx1", DRIVE FPL("/zzz/yyy/xxx"), false, NULL },
  83     // Lexicographically first among existing mount points.
  84     { "b", DRIVE FPL("/a/b"), true, DRIVE FPL("/a/b") },
  85     // Parent of lexicographically first mount point.
  86     { "a2", DRIVE FPL("/a"), false, NULL },
  87     // Child of lexicographically last mount point.
  88     { "c1", DRIVE FPL("/a/b/c"), false, NULL },
  89     // Parent to all of the mount points.
  90     { "root", DRIVE FPL("/"), false, NULL },
  91     // Path contains .. component.
  92     { "funky", DRIVE FPL("/tt/fun/../funky"), false, NULL },
  93     // Windows separators.
  94 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
  95     { "win", DRIVE FPL("\\try\\separators\\win"), true,
  96       DRIVE FPL("\\try\\separators\\win") },
  97     { "win1", DRIVE FPL("\\try/separators\\win1"), true,
  98       DRIVE FPL("\\try/separators\\win1") },
  99     { "win2", DRIVE FPL("\\try/separators\\win"), false, NULL },
 100 #else
 101     { "win", DRIVE FPL("\\separators\\win"), false, NULL },
 102     { "win1", DRIVE FPL("\\try/separators\\win1"), false, NULL },
 103 #endif
 104     // Win separators, but relative path.
 105     { "win2", DRIVE FPL("try\\separators\\win2"), false, NULL },
 106   };
 107
 108   // Test adding mount points.
 109   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
 110     EXPECT_EQ(
 111         kTestCases[i].success,
 112         mount_points->RegisterFileSystem(kTestCases[i].name,
 113                                          storage::kFileSystemTypeNativeLocal,
 114                                          storage::FileSystemMountOption(),
 115                                          base::FilePath(kTestCases[i].path)))
 116         << "Adding mount point: " << kTestCases[i].name << " with path "
 117         << kTestCases[i].path;
 118   }
 119
 120   // Test that final mount point presence state is as expected.
 121   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
 122     base::FilePath found_path;
 123     EXPECT_EQ(kTestCases[i].registered_path != NULL,
 124               mount_points->GetRegisteredPath(kTestCases[i].name, &found_path))
 125         << "Test case: " << i;
 126
 127     if (kTestCases[i].registered_path) {
 128       base::FilePath expected_path(kTestCases[i].registered_path);
 129       EXPECT_EQ(expected_path.NormalizePathSeparators(), found_path);
 130     }
 131   }
 132 }
 133
 134 TEST(ExternalMountPointsTest, GetVirtualPath) {
 135   scoped_refptr<storage::ExternalMountPoints> mount_points(
 136       storage::ExternalMountPoints::CreateRefCounted());
 137
 138   mount_points->RegisterFileSystem("c",
 139                                    storage::kFileSystemTypeNativeLocal,
 140                                    storage::FileSystemMountOption(),
 141                                    base::FilePath(DRIVE FPL("/a/b/c")));
 142   // Note that "/a/b/c" < "/a/b/c(1)" < "/a/b/c/".
 143   mount_points->RegisterFileSystem("c(1)",
 144                                    storage::kFileSystemTypeNativeLocal,
 145                                    storage::FileSystemMountOption(),
 146                                    base::FilePath(DRIVE FPL("/a/b/c(1)")));
 147   mount_points->RegisterFileSystem("x",
 148                                    storage::kFileSystemTypeNativeLocal,
 149                                    storage::FileSystemMountOption(),
 150                                    base::FilePath(DRIVE FPL("/z/y/x")));
 151   mount_points->RegisterFileSystem("o",
 152                                    storage::kFileSystemTypeNativeLocal,
 153                                    storage::FileSystemMountOption(),
 154                                    base::FilePath(DRIVE FPL("/m/n/o")));
 155   // A mount point whose name does not match its path base name.
 156   mount_points->RegisterFileSystem("mount",
 157                                    storage::kFileSystemTypeNativeLocal,
 158                                    storage::FileSystemMountOption(),
 159                                    base::FilePath(DRIVE FPL("/root/foo")));
 160   // A mount point with an empty path.
 161   mount_points->RegisterFileSystem("empty_path",
 162                                    storage::kFileSystemTypeNativeLocal,
 163                                    storage::FileSystemMountOption(),
 164                                    base::FilePath());
 165
 166   struct TestCase {
 167     const base::FilePath::CharType* const local_path;
 168     bool success;
 169     const base::FilePath::CharType* const virtual_path;
 170   };
 171
 172   const TestCase kTestCases[] = {
 173     // Empty path.
 174     { FPL(""), false, FPL("") },
 175     // No registered mount point (but is parent to a mount point).
 176     { DRIVE FPL("/a/b"), false, FPL("") },
 177     // No registered mount point (but is parent to a mount point).
 178     { DRIVE FPL("/z/y"), false, FPL("") },
 179     // No registered mount point (but is parent to a mount point).
 180     { DRIVE FPL("/m/n"), false, FPL("") },
 181     // No registered mount point.
 182     { DRIVE FPL("/foo/mount"), false, FPL("") },
 183     // An existing mount point path is substring.
 184     { DRIVE FPL("/a/b/c1"), false, FPL("") },
 185     // No leading /.
 186     { DRIVE FPL("a/b/c"), false, FPL("") },
 187     // Sibling to a root path.
 188     { DRIVE FPL("/a/b/d/e"), false, FPL("") },
 189     // Sibling to a root path.
 190     { DRIVE FPL("/z/y/v/u"), false, FPL("") },
 191     // Sibling to a root path.
 192     { DRIVE FPL("/m/n/p/q"), false, FPL("") },
 193     // Mount point root path.
 194     { DRIVE FPL("/a/b/c"), true, FPL("c") },
 195     // Mount point root path.
 196     { DRIVE FPL("/z/y/x"), true, FPL("x") },
 197     // Mount point root path.
 198     { DRIVE FPL("/m/n/o"), true, FPL("o") },
 199     // Mount point child path.
 200     { DRIVE FPL("/a/b/c/d/e"), true, FPL("c/d/e") },
 201     // Mount point child path.
 202     { DRIVE FPL("/z/y/x/v/u"), true, FPL("x/v/u") },
 203     // Mount point child path.
 204     { DRIVE FPL("/m/n/o/p/q"), true, FPL("o/p/q") },
 205     // Name doesn't match mount point path base name.
 206     { DRIVE FPL("/root/foo/a/b/c"), true, FPL("mount/a/b/c") },
 207     { DRIVE FPL("/root/foo"), true, FPL("mount") },
 208     // Mount point contains character whose ASCII code is smaller than file path
 209     // separator's.
 210     { DRIVE FPL("/a/b/c(1)/d/e"), true, FPL("c(1)/d/e") },
 211 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 212     // Path with win separators mixed in.
 213     { DRIVE FPL("/a\\b\\c/d"), true, FPL("c/d") },
 214 #endif
 215   };
 216
 217   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
 218     // Initialize virtual path with a value.
 219     base::FilePath virtual_path(DRIVE FPL("/mount"));
 220     base::FilePath local_path(kTestCases[i].local_path);
 221     EXPECT_EQ(kTestCases[i].success,
 222               mount_points->GetVirtualPath(local_path, &virtual_path))
 223         << "Resolving " << kTestCases[i].local_path;
 224
 225     // There are no guarantees for |virtual_path| value if |GetVirtualPath|
 226     // fails.
 227     if (!kTestCases[i].success)
 228       continue;
 229
 230     base::FilePath expected_virtual_path(kTestCases[i].virtual_path);
 231     EXPECT_EQ(expected_virtual_path.NormalizePathSeparators(), virtual_path)
 232         << "Resolving " << kTestCases[i].local_path;
 233   }
 234 }
 235
 236 TEST(ExternalMountPointsTest, HandlesFileSystemMountType) {
 237   scoped_refptr<storage::ExternalMountPoints> mount_points(
 238       storage::ExternalMountPoints::CreateRefCounted());
 239
 240   const GURL test_origin("http://chromium.org");
 241   const base::FilePath test_path(FPL("/mount"));
 242
 243   // Should handle External File System.
 244   EXPECT_TRUE(mount_points->HandlesFileSystemMountType(
 245       storage::kFileSystemTypeExternal));
 246
 247   // Shouldn't handle the rest.
 248   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
 249       storage::kFileSystemTypeIsolated));
 250   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
 251       storage::kFileSystemTypeTemporary));
 252   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
 253       storage::kFileSystemTypePersistent));
 254   EXPECT_FALSE(
 255       mount_points->HandlesFileSystemMountType(storage::kFileSystemTypeTest));
 256   // Not even if it's external subtype.
 257   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
 258       storage::kFileSystemTypeNativeLocal));
 259   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
 260       storage::kFileSystemTypeRestrictedNativeLocal));
 261   EXPECT_FALSE(
 262       mount_points->HandlesFileSystemMountType(storage::kFileSystemTypeDrive));
 263   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
 264       storage::kFileSystemTypeSyncable));
 265 }
 266
 267 TEST(ExternalMountPointsTest, CreateCrackedFileSystemURL) {
 268   scoped_refptr<storage::ExternalMountPoints> mount_points(
 269       storage::ExternalMountPoints::CreateRefCounted());
 270
 271   const GURL kTestOrigin("http://chromium.org");
 272
 273   mount_points->RegisterFileSystem("c",
 274                                    storage::kFileSystemTypeNativeLocal,
 275                                    storage::FileSystemMountOption(),
 276                                    base::FilePath(DRIVE FPL("/a/b/c")));
 277   mount_points->RegisterFileSystem("c(1)",
 278                                    storage::kFileSystemTypeDrive,
 279                                    storage::FileSystemMountOption(),
 280                                    base::FilePath(DRIVE FPL("/a/b/c(1)")));
 281   mount_points->RegisterFileSystem("empty_path",
 282                                    storage::kFileSystemTypeSyncable,
 283                                    storage::FileSystemMountOption(),
 284                                    base::FilePath());
 285   mount_points->RegisterFileSystem("mount",
 286                                    storage::kFileSystemTypeDrive,
 287                                    storage::FileSystemMountOption(),
 288                                    base::FilePath(DRIVE FPL("/root")));
 289
 290   // Try cracking invalid GURL.
 291   FileSystemURL invalid = mount_points->CrackURL(GURL("http://chromium.og"));
 292   EXPECT_FALSE(invalid.is_valid());
 293
 294   // Try cracking isolated path.
 295   FileSystemURL isolated = mount_points->CreateCrackedFileSystemURL(
 296       kTestOrigin, storage::kFileSystemTypeIsolated, base::FilePath(FPL("c")));
 297   EXPECT_FALSE(isolated.is_valid());
 298
 299   // Try native local which is not cracked.
 300   FileSystemURL native_local = mount_points->CreateCrackedFileSystemURL(
 301       kTestOrigin,
 302       storage::kFileSystemTypeNativeLocal,
 303       base::FilePath(FPL("c")));
 304   EXPECT_FALSE(native_local.is_valid());
 305
 306   struct TestCase {
 307     const base::FilePath::CharType* const path;
 308     bool expect_valid;
 309     storage::FileSystemType expect_type;
 310     const base::FilePath::CharType* const expect_path;
 311     const char* const expect_fs_id;
 312   };
 313
 314   const TestCase kTestCases[] = {
 315     {FPL("c/d/e"), true, storage::kFileSystemTypeNativeLocal,
 316      DRIVE FPL("/a/b/c/d/e"), "c"},
 317     {FPL("c(1)/d/e"), true, storage::kFileSystemTypeDrive,
 318      DRIVE FPL("/a/b/c(1)/d/e"), "c(1)"},
 319     {FPL("c(1)"), true, storage::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"),
 320      "c(1)"},
 321     {FPL("empty_path/a"), true, storage::kFileSystemTypeSyncable, FPL("a"),
 322      "empty_path"},
 323     {FPL("empty_path"), true, storage::kFileSystemTypeSyncable, FPL(""),
 324      "empty_path"},
 325     {FPL("mount/a/b"), true, storage::kFileSystemTypeDrive,
 326      DRIVE FPL("/root/a/b"), "mount"},
 327     {FPL("mount"), true, storage::kFileSystemTypeDrive, DRIVE FPL("/root"),
 328      "mount"},
 329     {FPL("cc"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 330     {FPL(""), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 331     {FPL(".."), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 332     // Absolte paths.
 333     {FPL("/c/d/e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 334     {FPL("/c(1)/d/e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 335     {FPL("/empty_path"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 336     // PAth references parent.
 337     {FPL("c/d/../e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 338     {FPL("/empty_path/a/../b"), false, storage::kFileSystemTypeUnknown, FPL(""),
 339      ""},
 340 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 341     {FPL("c/d\\e"), true, storage::kFileSystemTypeNativeLocal,
 342      DRIVE FPL("/a/b/c/d/e"), "c"},
 343     {FPL("mount\\a\\b"), true, storage::kFileSystemTypeDrive,
 344      DRIVE FPL("/root/a/b"), "mount"},
 345 #endif
 346   };
 347
 348   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
 349     FileSystemURL cracked = mount_points->CreateCrackedFileSystemURL(
 350         kTestOrigin,
 351         storage::kFileSystemTypeExternal,
 352         base::FilePath(kTestCases[i].path));
 353
 354     EXPECT_EQ(kTestCases[i].expect_valid, cracked.is_valid())
 355         << "Test case index: " << i;
 356
 357     if (!kTestCases[i].expect_valid)
 358       continue;
 359
 360     EXPECT_EQ(kTestOrigin, cracked.origin())
 361         << "Test case index: " << i;
 362     EXPECT_EQ(kTestCases[i].expect_type, cracked.type())
 363         << "Test case index: " << i;
 364     EXPECT_EQ(base::FilePath(
 365         kTestCases[i].expect_path).NormalizePathSeparators(), cracked.path())
 366         << "Test case index: " << i;
 367     EXPECT_EQ(base::FilePath(kTestCases[i].path).NormalizePathSeparators(),
 368                        cracked.virtual_path())
 369         << "Test case index: " << i;
 370     EXPECT_EQ(kTestCases[i].expect_fs_id, cracked.filesystem_id())
 371         << "Test case index: " << i;
 372     EXPECT_EQ(storage::kFileSystemTypeExternal, cracked.mount_type())
 373         << "Test case index: " << i;
 374   }
 375 }
 376
 377 TEST(ExternalMountPointsTest, CrackVirtualPath) {
 378   scoped_refptr<storage::ExternalMountPoints> mount_points(
 379       storage::ExternalMountPoints::CreateRefCounted());
 380
 381   const GURL kTestOrigin("http://chromium.org");
 382
 383   mount_points->RegisterFileSystem("c",
 384                                    storage::kFileSystemTypeNativeLocal,
 385                                    storage::FileSystemMountOption(),
 386                                    base::FilePath(DRIVE FPL("/a/b/c")));
 387   mount_points->RegisterFileSystem("c(1)",
 388                                    storage::kFileSystemTypeDrive,
 389                                    storage::FileSystemMountOption(),
 390                                    base::FilePath(DRIVE FPL("/a/b/c(1)")));
 391   mount_points->RegisterFileSystem("empty_path",
 392                                    storage::kFileSystemTypeSyncable,
 393                                    storage::FileSystemMountOption(),
 394                                    base::FilePath());
 395   mount_points->RegisterFileSystem("mount",
 396                                    storage::kFileSystemTypeDrive,
 397                                    storage::FileSystemMountOption(),
 398                                    base::FilePath(DRIVE FPL("/root")));
 399
 400   struct TestCase {
 401     const base::FilePath::CharType* const path;
 402     bool expect_valid;
 403     storage::FileSystemType expect_type;
 404     const base::FilePath::CharType* const expect_path;
 405     const char* const expect_name;
 406   };
 407
 408   const TestCase kTestCases[] = {
 409     {FPL("c/d/e"), true, storage::kFileSystemTypeNativeLocal,
 410      DRIVE FPL("/a/b/c/d/e"), "c"},
 411     {FPL("c(1)/d/e"), true, storage::kFileSystemTypeDrive,
 412      DRIVE FPL("/a/b/c(1)/d/e"), "c(1)"},
 413     {FPL("c(1)"), true, storage::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"),
 414      "c(1)"},
 415     {FPL("empty_path/a"), true, storage::kFileSystemTypeSyncable, FPL("a"),
 416      "empty_path"},
 417     {FPL("empty_path"), true, storage::kFileSystemTypeSyncable, FPL(""),
 418      "empty_path"},
 419     {FPL("mount/a/b"), true, storage::kFileSystemTypeDrive,
 420      DRIVE FPL("/root/a/b"), "mount"},
 421     {FPL("mount"), true, storage::kFileSystemTypeDrive, DRIVE FPL("/root"),
 422      "mount"},
 423     {FPL("cc"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 424     {FPL(""), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 425     {FPL(".."), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 426     // Absolte paths.
 427     {FPL("/c/d/e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 428     {FPL("/c(1)/d/e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 429     {FPL("/empty_path"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 430     // PAth references parent.
 431     {FPL("c/d/../e"), false, storage::kFileSystemTypeUnknown, FPL(""), ""},
 432     {FPL("/empty_path/a/../b"), false, storage::kFileSystemTypeUnknown, FPL(""),
 433      ""},
 434 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 435     {FPL("c/d\\e"), true, storage::kFileSystemTypeNativeLocal,
 436      DRIVE FPL("/a/b/c/d/e"), "c"},
 437     {FPL("mount\\a\\b"), true, storage::kFileSystemTypeDrive,
 438      DRIVE FPL("/root/a/b"), "mount"},
 439 #endif
 440   };
 441
 442   for (size_t i = 0; i < arraysize(kTestCases); ++i) {
 443     std::string cracked_name;
 444     storage::FileSystemType cracked_type;
 445     std::string cracked_id;
 446     base::FilePath cracked_path;
 447     storage::FileSystemMountOption cracked_option;
 448     EXPECT_EQ(kTestCases[i].expect_valid,
 449               mount_points->CrackVirtualPath(base::FilePath(kTestCases[i].path),
 450                   &cracked_name, &cracked_type, &cracked_id, &cracked_path,
 451                   &cracked_option))
 452         << "Test case index: " << i;
 453
 454     if (!kTestCases[i].expect_valid)
 455       continue;
 456
 457     EXPECT_EQ(kTestCases[i].expect_type, cracked_type)
 458         << "Test case index: " << i;
 459     EXPECT_EQ(base::FilePath(
 460         kTestCases[i].expect_path).NormalizePathSeparators(), cracked_path)
 461         << "Test case index: " << i;
 462     EXPECT_EQ(kTestCases[i].expect_name, cracked_name)
 463         << "Test case index: " << i;
 464     // As of now we don't mount other filesystems with non-empty filesystem_id
 465     // onto external mount points.
 466     EXPECT_TRUE(cracked_id.empty()) << "Test case index: " << i;
 467   }
 468 }
 469
 470 TEST(ExternalMountPointsTest, MountOption) {
 471   scoped_refptr<storage::ExternalMountPoints> mount_points(
 472       storage::ExternalMountPoints::CreateRefCounted());
 473
 474   mount_points->RegisterFileSystem(
 475       "nosync",
 476       storage::kFileSystemTypeNativeLocal,
 477       storage::FileSystemMountOption(storage::COPY_SYNC_OPTION_NO_SYNC),
 478       base::FilePath(DRIVE FPL("/nosync")));
 479   mount_points->RegisterFileSystem(
 480       "sync",
 481       storage::kFileSystemTypeNativeLocal,
 482       storage::FileSystemMountOption(storage::COPY_SYNC_OPTION_SYNC),
 483       base::FilePath(DRIVE FPL("/sync")));
 484
 485   std::string name;
 486   storage::FileSystemType type;
 487   std::string cracked_id;
 488   storage::FileSystemMountOption option;
 489   base::FilePath path;
 490   EXPECT_TRUE(mount_points->CrackVirtualPath(
 491       base::FilePath(FPL("nosync/file")), &name, &type, &cracked_id, &path,
 492       &option));
 493   EXPECT_EQ(storage::COPY_SYNC_OPTION_NO_SYNC, option.copy_sync_option());
 494   EXPECT_TRUE(mount_points->CrackVirtualPath(
 495       base::FilePath(FPL("sync/file")), &name, &type, &cracked_id, &path,
 496       &option));
 497   EXPECT_EQ(storage::COPY_SYNC_OPTION_SYNC, option.copy_sync_option());
 498 }
 499
 500 }  // namespace content
 501