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
21using storage::FileSystemURL;
22
23namespace content {
24
25TEST(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_UNSAFE(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_UNSAFE(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
134TEST(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_UNSAFE(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
236TEST(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
267TEST(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_UNSAFE(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
377TEST(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_UNSAFE(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
470TEST(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
502