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

Unified Diff: webkit/chromeos/fileapi/cros_mount_point_provider_unittest.cc

Issue 11648027: Extract external file systems handling from isolated context. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: gypi file Created 7 years, 11 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 side-by-side diff with in-line comments
Download patch
Index: webkit/chromeos/fileapi/cros_mount_point_provider_unittest.cc
diff --git a/webkit/chromeos/fileapi/cros_mount_point_provider_unittest.cc b/webkit/chromeos/fileapi/cros_mount_point_provider_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3dfda44de853bf542ee34beeaa8e194d0c4fce0d
--- /dev/null
+++ b/webkit/chromeos/fileapi/cros_mount_point_provider_unittest.cc
@@ -0,0 +1,325 @@
+// Copyright (c) 2013 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 "webkit/chromeos/fileapi/cros_mount_point_provider.h"
+
+#include <set>
+
+#include "base/file_path.h"
+#include "googleurl/src/url_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/fileapi/external_mount_points.h"
+#include "webkit/fileapi/file_system_url.h"
+#include "webkit/fileapi/isolated_context.h"
+#include "webkit/quota/mock_special_storage_policy.h"
+
+#define FPL(x) FILE_PATH_LITERAL(x)
+
+namespace {
+
+fileapi::FileSystemURL CreateFileSystemURL(const std::string& extension,
+ const char* path) {
+ return fileapi::FileSystemURL(GURL("chrome-extension://" + extension + "/"),
+ fileapi::kFileSystemTypeNativeLocal,
+ FilePath::FromUTF8Unsafe(path));
+}
+
+TEST(CrosMountPointProviderTest, DefaultMountPoints) {
+ scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
+ new quota::MockSpecialStoragePolicy();
+ scoped_refptr<fileapi::ExternalMountPoints> mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+ chromeos::CrosMountPointProvider provider(
+ storage_policy,
+ mount_points.get(),
+ fileapi::ExternalMountPoints::GetSystemInstance());
+ // By default there should be 4 mount points.
+ std::vector<FilePath> root_dirs = provider.GetRootDirectories();
+ std::set<FilePath> root_dirs_set(root_dirs.begin(), root_dirs.end());
+ EXPECT_EQ(4u, root_dirs.size());
+ EXPECT_TRUE(root_dirs_set.count(FilePath(FPL("/media/removable"))));
+ EXPECT_TRUE(root_dirs_set.count(FilePath(FPL("/media/archive"))));
+ EXPECT_TRUE(root_dirs_set.count(FilePath(FPL("/usr/share/oem"))));
+ // Fourth mount point is Downloads, but its local path is device specific.
+}
+
+TEST(CrosMountPointProviderTest, GetRootDirectories) {
+ scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
+ new quota::MockSpecialStoragePolicy();
+ scoped_refptr<fileapi::ExternalMountPoints> mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+
+ scoped_refptr<fileapi::ExternalMountPoints> system_mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+
+ chromeos::CrosMountPointProvider provider(
+ storage_policy,
+ mount_points.get(),
+ system_mount_points.get());
+
+ // Register 'local' test mount points.
+ mount_points->RegisterFileSystem("c",
+ fileapi::kFileSystemTypeNativeLocal,
+ FilePath(FPL("/a/b/c")));
+ mount_points->RegisterFileSystem("d",
+ fileapi::kFileSystemTypeNativeLocal,
+ FilePath(FPL("/b/c/d")));
+
+ // Register system test mount points.
+ system_mount_points->RegisterFileSystem("d",
+ fileapi::kFileSystemTypeNativeLocal,
+ FilePath(FPL("/g/c/d")));
+ system_mount_points->RegisterFileSystem("e",
+ fileapi::kFileSystemTypeNativeLocal,
+ FilePath(FPL("/g/d/e")));
+
+ std::vector<FilePath> root_dirs = provider.GetRootDirectories();
+ std::set<FilePath> root_dirs_set(root_dirs.begin(), root_dirs.end());
+ EXPECT_EQ(4u, root_dirs.size());
+ EXPECT_TRUE(root_dirs_set.count(FilePath(FPL("/a/b/c"))));
+ EXPECT_TRUE(root_dirs_set.count(FilePath(FPL("/b/c/d"))));
+ EXPECT_TRUE(root_dirs_set.count(FilePath(FPL("/g/c/d"))));
+ EXPECT_TRUE(root_dirs_set.count(FilePath(FPL("/g/d/e"))));
+}
+
+TEST(CrosMountPointProviderTest, MountPointsVisibility) {
+ scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
+ new quota::MockSpecialStoragePolicy();
+ scoped_refptr<fileapi::ExternalMountPoints> mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+ scoped_refptr<fileapi::ExternalMountPoints> sibling_mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+
+ scoped_refptr<fileapi::ExternalMountPoints> system_mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+
+ chromeos::CrosMountPointProvider provider(
+ storage_policy,
+ mount_points.get(),
+ system_mount_points.get());
+
+ // A provider that shares system_mount_points with |provider|.
+ chromeos::CrosMountPointProvider sibling_provider(
+ storage_policy,
+ sibling_mount_points.get(),
+ system_mount_points.get());
+
+ FilePath ignored;
+
+ // Adding empty mount point should fail.
+ EXPECT_FALSE(provider.AddLocalMountPoint(FilePath()));
+
+ // Add mount point to the provider.
+ EXPECT_TRUE(provider.AddLocalMountPoint(FilePath(FPL("/a/b/c"))));
+
+ EXPECT_TRUE(provider.HasMountPoint(FilePath(FPL("/a/b/c"))));
+ // The mount point with the same name exists, but path is different.
+ EXPECT_FALSE(provider.HasMountPoint(FilePath(FPL("/x/a/b/c"))));
+ EXPECT_FALSE(sibling_provider.HasMountPoint(FilePath(FPL("/a/b/c"))));
+ EXPECT_TRUE(mount_points->GetRegisteredPath("c", &ignored));
+ EXPECT_FALSE(system_mount_points->GetRegisteredPath("c", &ignored));
+
+ // Add mount point directly to |mount_points|. It should be seen by
+ // |provider|.
+ EXPECT_TRUE(mount_points->RegisterFileSystem(
+ "d", fileapi::kFileSystemTypeNativeLocal, FilePath(FPL("/b/c/d"))));
+
+ EXPECT_TRUE(provider.HasMountPoint(FilePath(FPL("/b/c/d"))));
+ EXPECT_FALSE(sibling_provider.HasMountPoint(FilePath(FPL("/b/c/d"))));
+
+ // Add mount point to system mount points.
+ EXPECT_TRUE(system_mount_points->RegisterFileSystem(
+ "e", fileapi::kFileSystemTypeNativeLocal, FilePath(FPL("/g/c/d/e"))));
+
+ EXPECT_FALSE(provider.HasMountPoint(FilePath(FPL("/g/c/d/e"))));
+ EXPECT_FALSE(sibling_provider.HasMountPoint(FilePath(FPL("/g/c/d/e"))));
+
+ // Can't remove system mount point.
+ provider.RemoveMountPoint(FilePath(FPL("/g/c/d/e")));
+ EXPECT_TRUE(system_mount_points->GetRegisteredPath("e", &ignored));
+
+ // Add a mount points whose paths overlap with the system one's.
+ // The same path:
+ EXPECT_TRUE(provider.AddLocalMountPoint(FilePath(FPL("/g/c/d/e"))));
+ EXPECT_TRUE(provider.HasMountPoint(FilePath(FPL("/g/c/d/e"))));
+ provider.RemoveMountPoint(FilePath(FPL("/g/c/d/e")));
+ EXPECT_FALSE(provider.HasMountPoint(FilePath(FPL("/g/c/d/e"))));
+ // Parent path:
+ EXPECT_TRUE(provider.AddLocalMountPoint(FilePath(FPL("/g"))));
+ EXPECT_TRUE(provider.HasMountPoint(FilePath(FPL("/g"))));
+ provider.RemoveMountPoint(FilePath(FPL("/g")));
+ // Child path:
+ EXPECT_TRUE(provider.AddLocalMountPoint(FilePath(FPL("/g/c/d/e/f/g"))));
+ EXPECT_TRUE(provider.HasMountPoint(FilePath(FPL("/g/c/d/e/f/g"))));
+ provider.RemoveMountPoint(FilePath(FPL("/g/c/d/e/f/g")));
+
+ // Add mount point with the same name as a global one. Should succeed.
+ EXPECT_TRUE(provider.AddLocalMountPoint(FilePath(FPL("/d/e"))));
+
+ EXPECT_TRUE(provider.HasMountPoint(FilePath(FPL("/d/e"))));
+
+ // Remove system mount point with the same name as the added one.
+ // Should fail.
+ provider.RemoveMountPoint(FilePath(FPL("/g/c/d/e")));
+
+ EXPECT_TRUE(provider.HasMountPoint(FilePath(FPL("/d/e"))));
+ EXPECT_TRUE(system_mount_points->GetRegisteredPath("e", &ignored));
+
+ // Remove mount point.
+ provider.RemoveMountPoint(FilePath(FPL("/d/e")));
+
+ EXPECT_FALSE(provider.HasMountPoint(FilePath(FPL("/d/e"))));
+}
+
+TEST(CrosMountPointProviderTest, AccessPermissions) {
+ url_util::AddStandardScheme("chrome-extension");
+
+ scoped_refptr<quota::MockSpecialStoragePolicy> storage_policy =
+ new quota::MockSpecialStoragePolicy();
+ scoped_refptr<fileapi::ExternalMountPoints> mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+ scoped_refptr<fileapi::ExternalMountPoints> system_mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+ chromeos::CrosMountPointProvider provider(
+ storage_policy,
+ mount_points.get(),
+ system_mount_points.get());
+
+ std::string extension("ddammdhioacbehjngdmkjcjbnfginlla");
+
+ storage_policy->AddFileHandler(extension);
+
+ // Initialize mount points.
+ system_mount_points->RegisterFileSystem("system",
+ fileapi::kFileSystemTypeNativeLocal,
+ FilePath(FPL("/g/system")));
+ ASSERT_TRUE(provider.AddLocalMountPoint(FilePath(FPL("/media/removable"))));
+ ASSERT_TRUE(provider.AddRestrictedLocalMountPoint(
+ FilePath(FPL("/usr/share/oem"))));
+
+ // Provider specific mount point access.
+ EXPECT_FALSE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "removable/foo")));
+
+ provider.GrantFileAccessToExtension(extension,
+ FilePath(FPL("removable/foo")));
+ EXPECT_TRUE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "removable/foo")));
+ EXPECT_FALSE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "removable/foo1")));
+
+ // System mount point access.
+ EXPECT_FALSE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "system/foo")));
+
+ provider.GrantFileAccessToExtension(extension, FilePath(FPL("system/foo")));
+ EXPECT_TRUE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "system/foo")));
+ EXPECT_FALSE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "system/foo1")));
+
+ // oem is restricted file system.
+ provider.GrantFileAccessToExtension(extension, FilePath(FPL("oem/foo")));
+ // The extension should not be able to access the file even if
+ // GrantFileAccessToExtension was called.
+ EXPECT_FALSE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "oem/foo")));
+
+ provider.GrantFullAccessToExtension(extension);
+ // The extension should be able to access restricted file system after it was
+ // granted full access.
+ EXPECT_TRUE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "oem/foo")));
+ // The extension which was granted full access should be able to access any
+ // path on current file systems.
+ EXPECT_TRUE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "removable/foo1")));
+ EXPECT_TRUE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "system/foo1")));
+
+ // The extension still cannot access new mount points.
+ ASSERT_TRUE(provider.AddLocalMountPoint(FilePath(FPL("/foo/test"))));
+ EXPECT_FALSE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "test_/foo")));
+
+ provider.RevokeAccessForExtension(extension);
+ EXPECT_FALSE(provider.IsAccessAllowed(
+ CreateFileSystemURL(extension, "removable/foo")));
+
+ fileapi::FileSystemURL internal_url(GURL("chrome://foo"),
+ fileapi::kFileSystemTypeExternal,
+ FilePath(FPL("removable/")));
+ // Internal WebUI should have full access.
+ EXPECT_TRUE(provider.IsAccessAllowed(internal_url));
+}
+
+TEST(CrosMountPointProvider, GetVirtualPathConflictWithSystemPoints) {
+ scoped_refptr<quota::MockSpecialStoragePolicy> storage_policy =
+ new quota::MockSpecialStoragePolicy();
+ scoped_refptr<fileapi::ExternalMountPoints> mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+ scoped_refptr<fileapi::ExternalMountPoints> system_mount_points(
+ fileapi::ExternalMountPoints::CreateRefCounted());
+ chromeos::CrosMountPointProvider provider(storage_policy,
+ mount_points.get(),
+ system_mount_points.get());
+
+ const fileapi::FileSystemType type = fileapi::kFileSystemTypeNativeLocal;
+
+ // Provider specific mount points.
+ ASSERT_TRUE(
+ mount_points->RegisterFileSystem("b", type, FilePath(FPL("/a/b"))));
+ ASSERT_TRUE(
+ mount_points->RegisterFileSystem("y", type, FilePath(FPL("/z/y"))));
+ ASSERT_TRUE(
+ mount_points->RegisterFileSystem("n", type, FilePath(FPL("/m/n"))));
+
+ // System mount points
+ ASSERT_TRUE(system_mount_points->RegisterFileSystem(
+ "gb", type, FilePath(FPL("/a/b"))));
+ ASSERT_TRUE(
+ system_mount_points->RegisterFileSystem("gz", type, FilePath(FPL("/z"))));
+ ASSERT_TRUE(system_mount_points->RegisterFileSystem(
+ "gp", type, FilePath(FPL("/m/n/o/p"))));
+
+ struct TestCase {
+ const FilePath::CharType* const local_path;
+ bool success;
+ const FilePath::CharType* const virtual_path;
+ };
+
+ const TestCase kTestCases[] = {
+ // Same paths in both mount points.
+ { FPL("/a/b/c/d"), true, FPL("b/c/d") },
+ // System mount points path more specific.
+ { FPL("/m/n/o/p/r/s"), true, FPL("n/o/p/r/s") },
+ // System mount points path less specific.
+ { FPL("/z/y/x"), true, FPL("y/x") },
+ // Only system mount points path matches.
+ { FPL("/z/q/r/s"), true, FPL("gz/q/r/s") },
+ // No match.
+ { FPL("/foo/xxx"), false, FPL("") },
+ };
+
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+ // Initialize virtual path with a value.
+ FilePath virtual_path(FPL("/mount"));
+ FilePath local_path(kTestCases[i].local_path);
+ EXPECT_EQ(kTestCases[i].success,
+ provider.GetVirtualPath(local_path, &virtual_path))
+ << "Resolving " << kTestCases[i].local_path;
+
+ // There are no guarantees for |virtual_path| value if |GetVirtualPath|
+ // fails.
+ if (!kTestCases[i].success)
+ continue;
+
+ FilePath expected_virtual_path(kTestCases[i].virtual_path);
+ EXPECT_EQ(expected_virtual_path, virtual_path)
+ << "Resolving " << kTestCases[i].local_path;
+ }
+}
+
+} // namespace
+

Powered by Google App Engine
This is Rietveld 408576698