OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <string> | 5 #include <string> |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include "base/basictypes.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 9 #include "testing/gtest/include/gtest/gtest.h" |
10 #include "webkit/fileapi/file_system_url.h" | 10 #include "webkit/fileapi/file_system_url.h" |
11 #include "webkit/fileapi/isolated_context.h" | 11 #include "webkit/fileapi/isolated_context.h" |
12 | 12 |
13 #define FPL(x) FILE_PATH_LITERAL(x) | 13 #define FPL(x) FILE_PATH_LITERAL(x) |
14 | 14 |
15 #if defined(FILE_PATH_USES_DRIVE_LETTERS) | 15 #if defined(FILE_PATH_USES_DRIVE_LETTERS) |
16 #define DRIVE FPL("C:") | 16 #define DRIVE FPL("C:") |
17 #else | 17 #else |
18 #define DRIVE | 18 #define DRIVE |
19 #endif | 19 #endif |
20 | 20 |
21 namespace fileapi { | 21 namespace fileapi { |
22 | 22 |
23 typedef IsolatedContext::MountPointInfo FileInfo; | 23 typedef IsolatedContext::MountPointInfo FileInfo; |
24 | 24 |
25 namespace { | 25 namespace { |
26 | 26 |
27 const FilePath kTestPaths[] = { | 27 const base::FilePath kTestPaths[] = { |
28 FilePath(DRIVE FPL("/a/b.txt")), | 28 base::FilePath(DRIVE FPL("/a/b.txt")), |
29 FilePath(DRIVE FPL("/c/d/e")), | 29 base::FilePath(DRIVE FPL("/c/d/e")), |
30 FilePath(DRIVE FPL("/h/")), | 30 base::FilePath(DRIVE FPL("/h/")), |
31 FilePath(DRIVE FPL("/")), | 31 base::FilePath(DRIVE FPL("/")), |
32 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | 32 #if defined(FILE_PATH_USES_WIN_SEPARATORS) |
33 FilePath(DRIVE FPL("\\foo\\bar")), | 33 base::FilePath(DRIVE FPL("\\foo\\bar")), |
34 FilePath(DRIVE FPL("\\")), | 34 base::FilePath(DRIVE FPL("\\")), |
35 #endif | 35 #endif |
36 // For duplicated base name test. | 36 // For duplicated base name test. |
37 FilePath(DRIVE FPL("/")), | 37 base::FilePath(DRIVE FPL("/")), |
38 FilePath(DRIVE FPL("/f/e")), | 38 base::FilePath(DRIVE FPL("/f/e")), |
39 FilePath(DRIVE FPL("/f/b.txt")), | 39 base::FilePath(DRIVE FPL("/f/b.txt")), |
40 }; | 40 }; |
41 | 41 |
42 } // namespace | 42 } // namespace |
43 | 43 |
44 class IsolatedContextTest : public testing::Test { | 44 class IsolatedContextTest : public testing::Test { |
45 public: | 45 public: |
46 IsolatedContextTest() { | 46 IsolatedContextTest() { |
47 for (size_t i = 0; i < arraysize(kTestPaths); ++i) | 47 for (size_t i = 0; i < arraysize(kTestPaths); ++i) |
48 fileset_.insert(kTestPaths[i].NormalizePathSeparators()); | 48 fileset_.insert(kTestPaths[i].NormalizePathSeparators()); |
49 } | 49 } |
(...skipping 14 matching lines...) Expand all Loading... |
64 void TearDown() { | 64 void TearDown() { |
65 IsolatedContext::GetInstance()->RemoveReference(id_); | 65 IsolatedContext::GetInstance()->RemoveReference(id_); |
66 } | 66 } |
67 | 67 |
68 IsolatedContext* isolated_context() const { | 68 IsolatedContext* isolated_context() const { |
69 return IsolatedContext::GetInstance(); | 69 return IsolatedContext::GetInstance(); |
70 } | 70 } |
71 | 71 |
72 protected: | 72 protected: |
73 std::string id_; | 73 std::string id_; |
74 std::multiset<FilePath> fileset_; | 74 std::multiset<base::FilePath> fileset_; |
75 std::vector<std::string> names_; | 75 std::vector<std::string> names_; |
76 | 76 |
77 private: | 77 private: |
78 DISALLOW_COPY_AND_ASSIGN(IsolatedContextTest); | 78 DISALLOW_COPY_AND_ASSIGN(IsolatedContextTest); |
79 }; | 79 }; |
80 | 80 |
81 TEST_F(IsolatedContextTest, RegisterAndRevokeTest) { | 81 TEST_F(IsolatedContextTest, RegisterAndRevokeTest) { |
82 // See if the returned top-level entries match with what we registered. | 82 // See if the returned top-level entries match with what we registered. |
83 std::vector<FileInfo> toplevels; | 83 std::vector<FileInfo> toplevels; |
84 ASSERT_TRUE(isolated_context()->GetDraggedFileInfo(id_, &toplevels)); | 84 ASSERT_TRUE(isolated_context()->GetDraggedFileInfo(id_, &toplevels)); |
85 ASSERT_EQ(fileset_.size(), toplevels.size()); | 85 ASSERT_EQ(fileset_.size(), toplevels.size()); |
86 for (size_t i = 0; i < toplevels.size(); ++i) { | 86 for (size_t i = 0; i < toplevels.size(); ++i) { |
87 ASSERT_TRUE(fileset_.find(toplevels[i].path) != fileset_.end()); | 87 ASSERT_TRUE(fileset_.find(toplevels[i].path) != fileset_.end()); |
88 } | 88 } |
89 | 89 |
90 // See if the name of each registered kTestPaths (that is what we | 90 // See if the name of each registered kTestPaths (that is what we |
91 // register in SetUp() by RegisterDraggedFileSystem) is properly cracked as | 91 // register in SetUp() by RegisterDraggedFileSystem) is properly cracked as |
92 // a valid virtual path in the isolated filesystem. | 92 // a valid virtual path in the isolated filesystem. |
93 for (size_t i = 0; i < arraysize(kTestPaths); ++i) { | 93 for (size_t i = 0; i < arraysize(kTestPaths); ++i) { |
94 FilePath virtual_path = isolated_context()->CreateVirtualRootPath(id_) | 94 base::FilePath virtual_path = isolated_context()->CreateVirtualRootPath(id_) |
95 .AppendASCII(names_[i]); | 95 .AppendASCII(names_[i]); |
96 std::string cracked_id; | 96 std::string cracked_id; |
97 FilePath cracked_path; | 97 base::FilePath cracked_path; |
98 FileSystemType cracked_type; | 98 FileSystemType cracked_type; |
99 ASSERT_TRUE(isolated_context()->CrackVirtualPath( | 99 ASSERT_TRUE(isolated_context()->CrackVirtualPath( |
100 virtual_path, &cracked_id, &cracked_type, &cracked_path)); | 100 virtual_path, &cracked_id, &cracked_type, &cracked_path)); |
101 ASSERT_EQ(kTestPaths[i].NormalizePathSeparators().value(), | 101 ASSERT_EQ(kTestPaths[i].NormalizePathSeparators().value(), |
102 cracked_path.value()); | 102 cracked_path.value()); |
103 ASSERT_EQ(id_, cracked_id); | 103 ASSERT_EQ(id_, cracked_id); |
104 ASSERT_EQ(kFileSystemTypeDragged, cracked_type); | 104 ASSERT_EQ(kFileSystemTypeDragged, cracked_type); |
105 } | 105 } |
106 | 106 |
107 // Make sure GetRegisteredPath returns false for id_ since it is | 107 // Make sure GetRegisteredPath returns false for id_ since it is |
108 // registered for dragged files. | 108 // registered for dragged files. |
109 FilePath path; | 109 base::FilePath path; |
110 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id_, &path)); | 110 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id_, &path)); |
111 | 111 |
112 // Deref the current one and registering a new one. | 112 // Deref the current one and registering a new one. |
113 isolated_context()->RemoveReference(id_); | 113 isolated_context()->RemoveReference(id_); |
114 | 114 |
115 std::string id2 = isolated_context()->RegisterFileSystemForPath( | 115 std::string id2 = isolated_context()->RegisterFileSystemForPath( |
116 kFileSystemTypeNativeLocal, FilePath(DRIVE FPL("/foo")), NULL); | 116 kFileSystemTypeNativeLocal, base::FilePath(DRIVE FPL("/foo")), NULL); |
117 | 117 |
118 // Make sure the GetDraggedFileInfo returns false for both ones. | 118 // Make sure the GetDraggedFileInfo returns false for both ones. |
119 ASSERT_FALSE(isolated_context()->GetDraggedFileInfo(id2, &toplevels)); | 119 ASSERT_FALSE(isolated_context()->GetDraggedFileInfo(id2, &toplevels)); |
120 ASSERT_FALSE(isolated_context()->GetDraggedFileInfo(id_, &toplevels)); | 120 ASSERT_FALSE(isolated_context()->GetDraggedFileInfo(id_, &toplevels)); |
121 | 121 |
122 // Make sure the GetRegisteredPath returns true only for the new one. | 122 // Make sure the GetRegisteredPath returns true only for the new one. |
123 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id_, &path)); | 123 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id_, &path)); |
124 ASSERT_TRUE(isolated_context()->GetRegisteredPath(id2, &path)); | 124 ASSERT_TRUE(isolated_context()->GetRegisteredPath(id2, &path)); |
125 | 125 |
126 // Try registering three more file systems for the same path as id2. | 126 // Try registering three more file systems for the same path as id2. |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
158 | 158 |
159 // Now all the file systems associated to the path must be invalid. | 159 // Now all the file systems associated to the path must be invalid. |
160 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id2, &path)); | 160 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id2, &path)); |
161 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id3, &path)); | 161 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id3, &path)); |
162 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id4, &path)); | 162 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id4, &path)); |
163 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id5, &path)); | 163 ASSERT_FALSE(isolated_context()->GetRegisteredPath(id5, &path)); |
164 } | 164 } |
165 | 165 |
166 TEST_F(IsolatedContextTest, CrackWithRelativePaths) { | 166 TEST_F(IsolatedContextTest, CrackWithRelativePaths) { |
167 const struct { | 167 const struct { |
168 FilePath::StringType path; | 168 base::FilePath::StringType path; |
169 bool valid; | 169 bool valid; |
170 } relatives[] = { | 170 } relatives[] = { |
171 { FPL("foo"), true }, | 171 { FPL("foo"), true }, |
172 { FPL("foo/bar"), true }, | 172 { FPL("foo/bar"), true }, |
173 { FPL(".."), false }, | 173 { FPL(".."), false }, |
174 { FPL("foo/.."), false }, | 174 { FPL("foo/.."), false }, |
175 { FPL("foo/../bar"), false }, | 175 { FPL("foo/../bar"), false }, |
176 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | 176 #if defined(FILE_PATH_USES_WIN_SEPARATORS) |
177 # define SHOULD_FAIL_WITH_WIN_SEPARATORS false | 177 # define SHOULD_FAIL_WITH_WIN_SEPARATORS false |
178 #else | 178 #else |
179 # define SHOULD_FAIL_WITH_WIN_SEPARATORS true | 179 # define SHOULD_FAIL_WITH_WIN_SEPARATORS true |
180 #endif | 180 #endif |
181 { FPL("foo\\..\\baz"), SHOULD_FAIL_WITH_WIN_SEPARATORS }, | 181 { FPL("foo\\..\\baz"), SHOULD_FAIL_WITH_WIN_SEPARATORS }, |
182 { FPL("foo/..\\baz"), SHOULD_FAIL_WITH_WIN_SEPARATORS }, | 182 { FPL("foo/..\\baz"), SHOULD_FAIL_WITH_WIN_SEPARATORS }, |
183 }; | 183 }; |
184 | 184 |
185 for (size_t i = 0; i < arraysize(kTestPaths); ++i) { | 185 for (size_t i = 0; i < arraysize(kTestPaths); ++i) { |
186 for (size_t j = 0; j < ARRAYSIZE_UNSAFE(relatives); ++j) { | 186 for (size_t j = 0; j < ARRAYSIZE_UNSAFE(relatives); ++j) { |
187 SCOPED_TRACE(testing::Message() << "Testing " | 187 SCOPED_TRACE(testing::Message() << "Testing " |
188 << kTestPaths[i].value() << " " << relatives[j].path); | 188 << kTestPaths[i].value() << " " << relatives[j].path); |
189 FilePath virtual_path = isolated_context()->CreateVirtualRootPath(id_) | 189 base::FilePath virtual_path = isolated_context()->CreateVirtualRootPath(id
_) |
190 .AppendASCII(names_[i]).Append(relatives[j].path); | 190 .AppendASCII(names_[i]).Append(relatives[j].path); |
191 std::string cracked_id; | 191 std::string cracked_id; |
192 FilePath cracked_path; | 192 base::FilePath cracked_path; |
193 FileSystemType cracked_type; | 193 FileSystemType cracked_type; |
194 if (!relatives[j].valid) { | 194 if (!relatives[j].valid) { |
195 ASSERT_FALSE(isolated_context()->CrackVirtualPath( | 195 ASSERT_FALSE(isolated_context()->CrackVirtualPath( |
196 virtual_path, &cracked_id, &cracked_type, &cracked_path)); | 196 virtual_path, &cracked_id, &cracked_type, &cracked_path)); |
197 continue; | 197 continue; |
198 } | 198 } |
199 ASSERT_TRUE(isolated_context()->CrackVirtualPath( | 199 ASSERT_TRUE(isolated_context()->CrackVirtualPath( |
200 virtual_path, &cracked_id, &cracked_type, &cracked_path)); | 200 virtual_path, &cracked_id, &cracked_type, &cracked_path)); |
201 ASSERT_EQ(kTestPaths[i].Append(relatives[j].path) | 201 ASSERT_EQ(kTestPaths[i].Append(relatives[j].path) |
202 .NormalizePathSeparators().value(), | 202 .NormalizePathSeparators().value(), |
203 cracked_path.value()); | 203 cracked_path.value()); |
204 ASSERT_EQ(id_, cracked_id); | 204 ASSERT_EQ(id_, cracked_id); |
205 ASSERT_EQ(kFileSystemTypeDragged, cracked_type); | 205 ASSERT_EQ(kFileSystemTypeDragged, cracked_type); |
206 } | 206 } |
207 } | 207 } |
208 } | 208 } |
209 | 209 |
210 TEST_F(IsolatedContextTest, CrackURLWithRelativePaths) { | 210 TEST_F(IsolatedContextTest, CrackURLWithRelativePaths) { |
211 const struct { | 211 const struct { |
212 FilePath::StringType path; | 212 base::FilePath::StringType path; |
213 bool valid; | 213 bool valid; |
214 } relatives[] = { | 214 } relatives[] = { |
215 { FPL("foo"), true }, | 215 { FPL("foo"), true }, |
216 { FPL("foo/bar"), true }, | 216 { FPL("foo/bar"), true }, |
217 { FPL(".."), false }, | 217 { FPL(".."), false }, |
218 { FPL("foo/.."), false }, | 218 { FPL("foo/.."), false }, |
219 { FPL("foo/../bar"), false }, | 219 { FPL("foo/../bar"), false }, |
220 #if defined(FILE_PATH_USES_WIN_SEPARATORS) | 220 #if defined(FILE_PATH_USES_WIN_SEPARATORS) |
221 # define SHOULD_FAIL_WITH_WIN_SEPARATORS false | 221 # define SHOULD_FAIL_WITH_WIN_SEPARATORS false |
222 #else | 222 #else |
223 # define SHOULD_FAIL_WITH_WIN_SEPARATORS true | 223 # define SHOULD_FAIL_WITH_WIN_SEPARATORS true |
224 #endif | 224 #endif |
225 { FPL("foo\\..\\baz"), SHOULD_FAIL_WITH_WIN_SEPARATORS }, | 225 { FPL("foo\\..\\baz"), SHOULD_FAIL_WITH_WIN_SEPARATORS }, |
226 { FPL("foo/..\\baz"), SHOULD_FAIL_WITH_WIN_SEPARATORS }, | 226 { FPL("foo/..\\baz"), SHOULD_FAIL_WITH_WIN_SEPARATORS }, |
227 }; | 227 }; |
228 | 228 |
229 for (size_t i = 0; i < arraysize(kTestPaths); ++i) { | 229 for (size_t i = 0; i < arraysize(kTestPaths); ++i) { |
230 for (size_t j = 0; j < ARRAYSIZE_UNSAFE(relatives); ++j) { | 230 for (size_t j = 0; j < ARRAYSIZE_UNSAFE(relatives); ++j) { |
231 SCOPED_TRACE(testing::Message() << "Testing " | 231 SCOPED_TRACE(testing::Message() << "Testing " |
232 << kTestPaths[i].value() << " " << relatives[j].path); | 232 << kTestPaths[i].value() << " " << relatives[j].path); |
233 FilePath virtual_path = isolated_context()->CreateVirtualRootPath(id_) | 233 base::FilePath virtual_path = isolated_context()->CreateVirtualRootPath(id
_) |
234 .AppendASCII(names_[i]).Append(relatives[j].path); | 234 .AppendASCII(names_[i]).Append(relatives[j].path); |
235 | 235 |
236 FileSystemURL cracked = isolated_context()->CreateCrackedFileSystemURL( | 236 FileSystemURL cracked = isolated_context()->CreateCrackedFileSystemURL( |
237 GURL("http://chromium.org"), kFileSystemTypeIsolated, virtual_path); | 237 GURL("http://chromium.org"), kFileSystemTypeIsolated, virtual_path); |
238 | 238 |
239 ASSERT_EQ(relatives[j].valid, cracked.is_valid()); | 239 ASSERT_EQ(relatives[j].valid, cracked.is_valid()); |
240 | 240 |
241 if (!relatives[j].valid) | 241 if (!relatives[j].valid) |
242 continue; | 242 continue; |
243 ASSERT_EQ(GURL("http://chromium.org"), cracked.origin()); | 243 ASSERT_EQ(GURL("http://chromium.org"), cracked.origin()); |
244 ASSERT_EQ(kTestPaths[i].Append(relatives[j].path) | 244 ASSERT_EQ(kTestPaths[i].Append(relatives[j].path) |
245 .NormalizePathSeparators().value(), | 245 .NormalizePathSeparators().value(), |
246 cracked.path().value()); | 246 cracked.path().value()); |
247 ASSERT_EQ(virtual_path.NormalizePathSeparators(), cracked.virtual_path()); | 247 ASSERT_EQ(virtual_path.NormalizePathSeparators(), cracked.virtual_path()); |
248 ASSERT_EQ(id_, cracked.filesystem_id()); | 248 ASSERT_EQ(id_, cracked.filesystem_id()); |
249 ASSERT_EQ(kFileSystemTypeDragged, cracked.type()); | 249 ASSERT_EQ(kFileSystemTypeDragged, cracked.type()); |
250 ASSERT_EQ(kFileSystemTypeIsolated, cracked.mount_type()); | 250 ASSERT_EQ(kFileSystemTypeIsolated, cracked.mount_type()); |
251 } | 251 } |
252 } | 252 } |
253 } | 253 } |
254 | 254 |
255 TEST_F(IsolatedContextTest, TestWithVirtualRoot) { | 255 TEST_F(IsolatedContextTest, TestWithVirtualRoot) { |
256 std::string cracked_id; | 256 std::string cracked_id; |
257 FilePath cracked_path; | 257 base::FilePath cracked_path; |
258 | 258 |
259 // Trying to crack virtual root "/" returns true but with empty cracked path | 259 // Trying to crack virtual root "/" returns true but with empty cracked path |
260 // as "/" of the isolated filesystem is a pure virtual directory | 260 // as "/" of the isolated filesystem is a pure virtual directory |
261 // that has no corresponding platform directory. | 261 // that has no corresponding platform directory. |
262 FilePath virtual_path = isolated_context()->CreateVirtualRootPath(id_); | 262 base::FilePath virtual_path = isolated_context()->CreateVirtualRootPath(id_); |
263 ASSERT_TRUE(isolated_context()->CrackVirtualPath( | 263 ASSERT_TRUE(isolated_context()->CrackVirtualPath( |
264 virtual_path, &cracked_id, NULL, &cracked_path)); | 264 virtual_path, &cracked_id, NULL, &cracked_path)); |
265 ASSERT_EQ(FPL(""), cracked_path.value()); | 265 ASSERT_EQ(FPL(""), cracked_path.value()); |
266 ASSERT_EQ(id_, cracked_id); | 266 ASSERT_EQ(id_, cracked_id); |
267 | 267 |
268 // Trying to crack "/foo" should fail (because "foo" is not the one | 268 // Trying to crack "/foo" should fail (because "foo" is not the one |
269 // included in the kTestPaths). | 269 // included in the kTestPaths). |
270 virtual_path = isolated_context()->CreateVirtualRootPath( | 270 virtual_path = isolated_context()->CreateVirtualRootPath( |
271 id_).AppendASCII("foo"); | 271 id_).AppendASCII("foo"); |
272 ASSERT_FALSE(isolated_context()->CrackVirtualPath( | 272 ASSERT_FALSE(isolated_context()->CrackVirtualPath( |
273 virtual_path, &cracked_id, NULL, &cracked_path)); | 273 virtual_path, &cracked_id, NULL, &cracked_path)); |
274 } | 274 } |
275 | 275 |
276 TEST_F(IsolatedContextTest, CanHandleURL) { | 276 TEST_F(IsolatedContextTest, CanHandleURL) { |
277 const GURL test_origin("http://chromium.org"); | 277 const GURL test_origin("http://chromium.org"); |
278 const FilePath test_path(FPL("/mount")); | 278 const base::FilePath test_path(FPL("/mount")); |
279 | 279 |
280 // Should handle isolated file system. | 280 // Should handle isolated file system. |
281 EXPECT_TRUE(isolated_context()->HandlesFileSystemMountType( | 281 EXPECT_TRUE(isolated_context()->HandlesFileSystemMountType( |
282 fileapi::kFileSystemTypeIsolated)); | 282 fileapi::kFileSystemTypeIsolated)); |
283 | 283 |
284 // Shouldn't handle the rest. | 284 // Shouldn't handle the rest. |
285 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( | 285 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( |
286 fileapi::kFileSystemTypeExternal)); | 286 fileapi::kFileSystemTypeExternal)); |
287 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( | 287 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( |
288 fileapi::kFileSystemTypeTemporary)); | 288 fileapi::kFileSystemTypeTemporary)); |
289 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( | 289 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( |
290 fileapi::kFileSystemTypePersistent)); | 290 fileapi::kFileSystemTypePersistent)); |
291 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( | 291 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( |
292 fileapi::kFileSystemTypeTest)); | 292 fileapi::kFileSystemTypeTest)); |
293 // Not even if it's isolated subtype. | 293 // Not even if it's isolated subtype. |
294 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( | 294 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( |
295 fileapi::kFileSystemTypeNativeLocal)); | 295 fileapi::kFileSystemTypeNativeLocal)); |
296 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( | 296 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( |
297 fileapi::kFileSystemTypeDragged)); | 297 fileapi::kFileSystemTypeDragged)); |
298 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( | 298 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( |
299 fileapi::kFileSystemTypeNativeMedia)); | 299 fileapi::kFileSystemTypeNativeMedia)); |
300 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( | 300 EXPECT_FALSE(isolated_context()->HandlesFileSystemMountType( |
301 fileapi::kFileSystemTypeDeviceMedia)); | 301 fileapi::kFileSystemTypeDeviceMedia)); |
302 } | 302 } |
303 | 303 |
304 } // namespace fileapi | 304 } // namespace fileapi |
OLD | NEW |