Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(15)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: webkit/chromeos/fileapi/cros_mount_point_provider_unittest.cc

Issue 16010006: Move webkit/chromeos into webkit/browser/chromeos (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « webkit/chromeos/fileapi/cros_mount_point_provider.cc ('k') | webkit/chromeos/fileapi/file_access_permissions.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2013 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 "webkit/chromeos/fileapi/cros_mount_point_provider.h"
6
7 #include <set>
8
9 #include "base/files/file_path.h"
10 #include "chromeos/dbus/cros_disks_client.h"
11 #include "googleurl/src/url_util.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13 #include "webkit/browser/fileapi/external_mount_points.h"
14 #include "webkit/browser/fileapi/file_permission_policy.h"
15 #include "webkit/browser/fileapi/file_system_url.h"
16 #include "webkit/browser/fileapi/isolated_context.h"
17 #include "webkit/quota/mock_special_storage_policy.h"
18
19 #define FPL(x) FILE_PATH_LITERAL(x)
20
21 using fileapi::ExternalMountPoints;
22 using fileapi::FileSystemURL;
23
24 namespace {
25
26 FileSystemURL CreateFileSystemURL(const std::string& extension,
27 const char* path,
28 ExternalMountPoints* mount_points) {
29 return mount_points->CreateCrackedFileSystemURL(
30 GURL("chrome-extension://" + extension + "/"),
31 fileapi::kFileSystemTypeExternal,
32 base::FilePath::FromUTF8Unsafe(path));
33 }
34
35 TEST(CrosMountPointProviderTest, DefaultMountPoints) {
36 scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
37 new quota::MockSpecialStoragePolicy();
38 scoped_refptr<fileapi::ExternalMountPoints> mount_points(
39 fileapi::ExternalMountPoints::CreateRefCounted());
40 chromeos::CrosMountPointProvider provider(
41 storage_policy,
42 mount_points.get(),
43 fileapi::ExternalMountPoints::GetSystemInstance());
44 std::vector<base::FilePath> root_dirs = provider.GetRootDirectories();
45 std::set<base::FilePath> root_dirs_set(root_dirs.begin(), root_dirs.end());
46
47 // By default there should be 3 mount points (in system mount points):
48 EXPECT_EQ(3u, root_dirs.size());
49 EXPECT_TRUE(root_dirs_set.count(
50 chromeos::CrosDisksClient::GetRemovableDiskMountPoint()));
51 EXPECT_TRUE(root_dirs_set.count(
52 chromeos::CrosDisksClient::GetArchiveMountPoint()));
53 EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/usr/share/oem"))));
54 }
55
56 TEST(CrosMountPointProviderTest, GetRootDirectories) {
57 scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
58 new quota::MockSpecialStoragePolicy();
59 scoped_refptr<fileapi::ExternalMountPoints> mount_points(
60 fileapi::ExternalMountPoints::CreateRefCounted());
61
62 scoped_refptr<fileapi::ExternalMountPoints> system_mount_points(
63 fileapi::ExternalMountPoints::CreateRefCounted());
64
65 chromeos::CrosMountPointProvider provider(
66 storage_policy,
67 mount_points.get(),
68 system_mount_points.get());
69
70 const size_t initial_root_dirs_size = provider.GetRootDirectories().size();
71
72 // Register 'local' test mount points.
73 mount_points->RegisterFileSystem("c",
74 fileapi::kFileSystemTypeNativeLocal,
75 base::FilePath(FPL("/a/b/c")));
76 mount_points->RegisterFileSystem("d",
77 fileapi::kFileSystemTypeNativeLocal,
78 base::FilePath(FPL("/b/c/d")));
79
80 // Register system test mount points.
81 system_mount_points->RegisterFileSystem("d",
82 fileapi::kFileSystemTypeNativeLocal,
83 base::FilePath(FPL("/g/c/d")));
84 system_mount_points->RegisterFileSystem("e",
85 fileapi::kFileSystemTypeNativeLocal,
86 base::FilePath(FPL("/g/d/e")));
87
88 std::vector<base::FilePath> root_dirs = provider.GetRootDirectories();
89 std::set<base::FilePath> root_dirs_set(root_dirs.begin(), root_dirs.end());
90 EXPECT_EQ(initial_root_dirs_size + 4, root_dirs.size());
91 EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/a/b/c"))));
92 EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/b/c/d"))));
93 EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/g/c/d"))));
94 EXPECT_TRUE(root_dirs_set.count(base::FilePath(FPL("/g/d/e"))));
95 }
96
97 TEST(CrosMountPointProviderTest, AccessPermissions) {
98 const int kPermission = fileapi::kReadFilePermissions;
99
100 url_util::AddStandardScheme("chrome-extension");
101
102 scoped_refptr<quota::MockSpecialStoragePolicy> storage_policy =
103 new quota::MockSpecialStoragePolicy();
104 scoped_refptr<fileapi::ExternalMountPoints> mount_points(
105 fileapi::ExternalMountPoints::CreateRefCounted());
106 scoped_refptr<fileapi::ExternalMountPoints> system_mount_points(
107 fileapi::ExternalMountPoints::CreateRefCounted());
108 chromeos::CrosMountPointProvider provider(
109 storage_policy,
110 mount_points.get(),
111 system_mount_points.get());
112
113 std::string extension("ddammdhioacbehjngdmkjcjbnfginlla");
114
115 storage_policy->AddFileHandler(extension);
116
117 // Initialize mount points.
118 ASSERT_TRUE(system_mount_points->RegisterFileSystem(
119 "system",
120 fileapi::kFileSystemTypeNativeLocal,
121 base::FilePath(FPL("/g/system"))));
122 ASSERT_TRUE(mount_points->RegisterFileSystem(
123 "removable",
124 fileapi::kFileSystemTypeNativeLocal,
125 base::FilePath(FPL("/media/removable"))));
126 ASSERT_TRUE(mount_points->RegisterFileSystem(
127 "oem",
128 fileapi::kFileSystemTypeRestrictedNativeLocal,
129 base::FilePath(FPL("/usr/share/oem"))));
130
131 // Provider specific mount point access.
132 EXPECT_EQ(
133 fileapi::FILE_PERMISSION_ALWAYS_DENY,
134 provider.GetPermissionPolicy(
135 CreateFileSystemURL(extension, "removable/foo", mount_points.get()),
136 kPermission));
137
138 provider.GrantFileAccessToExtension(extension,
139 base::FilePath(FPL("removable/foo")));
140 EXPECT_EQ(
141 fileapi::FILE_PERMISSION_USE_FILE_PERMISSION,
142 provider.GetPermissionPolicy(
143 CreateFileSystemURL(extension, "removable/foo", mount_points.get()),
144 kPermission));
145 EXPECT_EQ(
146 fileapi::FILE_PERMISSION_ALWAYS_DENY,
147 provider.GetPermissionPolicy(
148 CreateFileSystemURL(extension, "removable/foo1", mount_points.get()),
149 kPermission));
150
151 // System mount point access.
152 EXPECT_EQ(
153 fileapi::FILE_PERMISSION_ALWAYS_DENY,
154 provider.GetPermissionPolicy(
155 CreateFileSystemURL(extension, "system/foo",
156 system_mount_points.get()),
157 kPermission));
158
159 provider.GrantFileAccessToExtension(extension,
160 base::FilePath(FPL("system/foo")));
161 EXPECT_EQ(
162 fileapi::FILE_PERMISSION_USE_FILE_PERMISSION,
163 provider.GetPermissionPolicy(
164 CreateFileSystemURL(extension, "system/foo",
165 system_mount_points.get()),
166 kPermission));
167 EXPECT_EQ(
168 fileapi::FILE_PERMISSION_ALWAYS_DENY,
169 provider.GetPermissionPolicy(
170 CreateFileSystemURL(extension, "system/foo1",
171 system_mount_points.get()),
172 kPermission));
173
174 // oem is restricted file system.
175 provider.GrantFileAccessToExtension(extension, base::FilePath(FPL("oem/foo"))) ;
176 // The extension should not be able to access the file even if
177 // GrantFileAccessToExtension was called.
178 EXPECT_EQ(
179 fileapi::FILE_PERMISSION_ALWAYS_DENY,
180 provider.GetPermissionPolicy(
181 CreateFileSystemURL(extension, "oem/foo", mount_points.get()),
182 kPermission));
183
184 provider.GrantFullAccessToExtension(extension);
185 // The extension should be able to access restricted file system after it was
186 // granted full access.
187 EXPECT_EQ(
188 fileapi::FILE_PERMISSION_USE_FILE_PERMISSION,
189 provider.GetPermissionPolicy(
190 CreateFileSystemURL(extension, "oem/foo", mount_points.get()),
191 kPermission));
192 // The extension which was granted full access should be able to access any
193 // path on current file systems.
194 EXPECT_EQ(
195 fileapi::FILE_PERMISSION_USE_FILE_PERMISSION,
196 provider.GetPermissionPolicy(
197 CreateFileSystemURL(extension, "removable/foo1", mount_points.get()),
198 kPermission));
199 EXPECT_EQ(
200 fileapi::FILE_PERMISSION_USE_FILE_PERMISSION,
201 provider.GetPermissionPolicy(
202 CreateFileSystemURL(extension, "system/foo1",
203 system_mount_points.get()),
204 kPermission));
205
206 // The extension cannot access new mount points.
207 // TODO(tbarzic): This should probably be changed.
208 ASSERT_TRUE(mount_points->RegisterFileSystem(
209 "test",
210 fileapi::kFileSystemTypeNativeLocal,
211 base::FilePath(FPL("/foo/test"))));
212 EXPECT_EQ(
213 fileapi::FILE_PERMISSION_ALWAYS_DENY,
214 provider.GetPermissionPolicy(
215 CreateFileSystemURL(extension, "test_/foo", mount_points.get()),
216 kPermission));
217
218 provider.RevokeAccessForExtension(extension);
219 EXPECT_EQ(
220 fileapi::FILE_PERMISSION_ALWAYS_DENY,
221 provider.GetPermissionPolicy(
222 CreateFileSystemURL(extension, "removable/foo", mount_points.get()),
223 kPermission));
224
225 fileapi::FileSystemURL internal_url = FileSystemURL::CreateForTest(
226 GURL("chrome://foo"),
227 fileapi::kFileSystemTypeExternal,
228 base::FilePath(FPL("removable/")));
229 // Internal WebUI should have full access.
230 EXPECT_EQ(
231 fileapi::FILE_PERMISSION_ALWAYS_ALLOW,
232 provider.GetPermissionPolicy(internal_url, kPermission));
233 }
234
235 TEST(CrosMountPointProvider, GetVirtualPathConflictWithSystemPoints) {
236 scoped_refptr<quota::MockSpecialStoragePolicy> storage_policy =
237 new quota::MockSpecialStoragePolicy();
238 scoped_refptr<fileapi::ExternalMountPoints> mount_points(
239 fileapi::ExternalMountPoints::CreateRefCounted());
240 scoped_refptr<fileapi::ExternalMountPoints> system_mount_points(
241 fileapi::ExternalMountPoints::CreateRefCounted());
242 chromeos::CrosMountPointProvider provider(storage_policy,
243 mount_points.get(),
244 system_mount_points.get());
245
246 const fileapi::FileSystemType type = fileapi::kFileSystemTypeNativeLocal;
247
248 // Provider specific mount points.
249 ASSERT_TRUE(
250 mount_points->RegisterFileSystem("b", type, base::FilePath(FPL("/a/b"))));
251 ASSERT_TRUE(
252 mount_points->RegisterFileSystem("y", type, base::FilePath(FPL("/z/y"))));
253 ASSERT_TRUE(
254 mount_points->RegisterFileSystem("n", type, base::FilePath(FPL("/m/n"))));
255
256 // System mount points
257 ASSERT_TRUE(system_mount_points->RegisterFileSystem(
258 "gb", type, base::FilePath(FPL("/a/b"))));
259 ASSERT_TRUE(
260 system_mount_points->RegisterFileSystem("gz", type, base::FilePath(FPL("/z "))));
261 ASSERT_TRUE(system_mount_points->RegisterFileSystem(
262 "gp", type, base::FilePath(FPL("/m/n/o/p"))));
263
264 struct TestCase {
265 const base::FilePath::CharType* const local_path;
266 bool success;
267 const base::FilePath::CharType* const virtual_path;
268 };
269
270 const TestCase kTestCases[] = {
271 // Same paths in both mount points.
272 { FPL("/a/b/c/d"), true, FPL("b/c/d") },
273 // System mount points path more specific.
274 { FPL("/m/n/o/p/r/s"), true, FPL("n/o/p/r/s") },
275 // System mount points path less specific.
276 { FPL("/z/y/x"), true, FPL("y/x") },
277 // Only system mount points path matches.
278 { FPL("/z/q/r/s"), true, FPL("gz/q/r/s") },
279 // No match.
280 { FPL("/foo/xxx"), false, FPL("") },
281 };
282
283 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
284 // Initialize virtual path with a value.
285 base::FilePath virtual_path(FPL("/mount"));
286 base::FilePath local_path(kTestCases[i].local_path);
287 EXPECT_EQ(kTestCases[i].success,
288 provider.GetVirtualPath(local_path, &virtual_path))
289 << "Resolving " << kTestCases[i].local_path;
290
291 // There are no guarantees for |virtual_path| value if |GetVirtualPath|
292 // fails.
293 if (!kTestCases[i].success)
294 continue;
295
296 base::FilePath expected_virtual_path(kTestCases[i].virtual_path);
297 EXPECT_EQ(expected_virtual_path, virtual_path)
298 << "Resolving " << kTestCases[i].local_path;
299 }
300 }
301
302 } // namespace
OLDNEW
« no previous file with comments | « webkit/chromeos/fileapi/cros_mount_point_provider.cc ('k') | webkit/chromeos/fileapi/file_access_permissions.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698