Move storage-related files from webkit/ to new top-level directory storage/

content/browser/child_process_security_policy_unittest.cc

 // Copyright (c) 2012 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 <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/public/common/url_constants.h"
 #include "content/test/test_content_browser_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
-#include "webkit/browser/fileapi/file_permission_policy.h"
-#include "webkit/browser/fileapi/file_system_url.h"
-#include "webkit/browser/fileapi/isolated_context.h"
-#include "webkit/common/fileapi/file_system_types.h"
+#include "storage/browser/fileapi/file_permission_policy.h"
+#include "storage/browser/fileapi/file_system_url.h"
+#include "storage/browser/fileapi/isolated_context.h"
+#include "storage/common/fileapi/file_system_types.h"
 
 namespace content {
 namespace {
 
 const int kRendererID = 42;
 const int kWorkerRendererID = kRendererID + 1;
 
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
 #define TEST_PATH(x) FILE_PATH_LITERAL("c:") FILE_PATH_LITERAL(x)
 #else
@@ skipping 62 matching lines @@
   void CheckHasNoFileSystemPermission(ChildProcessSecurityPolicyImpl* p,
                                       const std::string& child_id) {
     EXPECT_FALSE(p->CanReadFileSystem(kRendererID, child_id));
     EXPECT_FALSE(p->CanReadWriteFileSystem(kRendererID, child_id));
     EXPECT_FALSE(p->CanCopyIntoFileSystem(kRendererID, child_id));
     EXPECT_FALSE(p->CanDeleteFromFileSystem(kRendererID, child_id));
   }
 
   void CheckHasNoFileSystemFilePermission(ChildProcessSecurityPolicyImpl* p,
                                           const base::FilePath& file,
-                                          const fileapi::FileSystemURL& url) {
+                                          const storage::FileSystemURL& url) {
     EXPECT_FALSE(p->CanReadFile(kRendererID, file));
     EXPECT_FALSE(p->CanCreateReadWriteFile(kRendererID, file));
     EXPECT_FALSE(p->CanReadFileSystemFile(kRendererID, url));
     EXPECT_FALSE(p->CanWriteFileSystemFile(kRendererID, url));
     EXPECT_FALSE(p->CanCreateFileSystemFile(kRendererID, url));
     EXPECT_FALSE(p->CanCreateReadWriteFileSystemFile(kRendererID, url));
     EXPECT_FALSE(p->CanCopyIntoFileSystemFile(kRendererID, url));
     EXPECT_FALSE(p->CanDeleteFileSystemFile(kRendererID, url));
   }
 
@@ skipping 189 matching lines @@
   EXPECT_TRUE(p->CanRequestURL(kRendererID, sensitive_url));
 
   p->Remove(kRendererID);
 }
 
 TEST_F(ChildProcessSecurityPolicyTest, FileSystemGrantsTest) {
   ChildProcessSecurityPolicyImpl* p =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
   p->Add(kRendererID);
-  std::string read_id = fileapi::IsolatedContext::GetInstance()->
-      RegisterFileSystemForVirtualPath(fileapi::kFileSystemTypeTest,
-                                       "read_filesystem",
-                                       base::FilePath());
-  std::string read_write_id = fileapi::IsolatedContext::GetInstance()->
-      RegisterFileSystemForVirtualPath(fileapi::kFileSystemTypeTest,
-                                       "read_write_filesystem",
-                                       base::FilePath());
-  std::string copy_into_id = fileapi::IsolatedContext::GetInstance()->
-      RegisterFileSystemForVirtualPath(fileapi::kFileSystemTypeTest,
-                                       "copy_into_filesystem",
-                                       base::FilePath());
-  std::string delete_from_id = fileapi::IsolatedContext::GetInstance()->
-      RegisterFileSystemForVirtualPath(fileapi::kFileSystemTypeTest,
-                                       "delete_from_filesystem",
-                                       base::FilePath());
+  std::string read_id =
+      storage::IsolatedContext::GetInstance()->RegisterFileSystemForVirtualPath(
+          storage::kFileSystemTypeTest, "read_filesystem", base::FilePath());
+  std::string read_write_id =
+      storage::IsolatedContext::GetInstance()->RegisterFileSystemForVirtualPath(
+          storage::kFileSystemTypeTest,
+          "read_write_filesystem",
+          base::FilePath());
+  std::string copy_into_id =
+      storage::IsolatedContext::GetInstance()->RegisterFileSystemForVirtualPath(
+          storage::kFileSystemTypeTest,
+          "copy_into_filesystem",
+          base::FilePath());
+  std::string delete_from_id =
+      storage::IsolatedContext::GetInstance()->RegisterFileSystemForVirtualPath(
+          storage::kFileSystemTypeTest,
+          "delete_from_filesystem",
+          base::FilePath());
 
   // Test initially having no permissions.
   CheckHasNoFileSystemPermission(p, read_id);
   CheckHasNoFileSystemPermission(p, read_write_id);
   CheckHasNoFileSystemPermission(p, copy_into_id);
   CheckHasNoFileSystemPermission(p, delete_from_id);
 
   // Testing varying combinations of grants and checks.
   p->GrantReadFileSystem(kRendererID, read_id);
   EXPECT_TRUE(p->CanReadFileSystem(kRendererID, read_id));
@@ skipping 29 matching lines @@
 
   // Test having no permissions upon re-adding same renderer ID.
   p->Add(kRendererID);
   CheckHasNoFileSystemPermission(p, read_id);
   CheckHasNoFileSystemPermission(p, read_write_id);
   CheckHasNoFileSystemPermission(p, copy_into_id);
   CheckHasNoFileSystemPermission(p, delete_from_id);
 
   // Cleanup.
   p->Remove(kRendererID);
-  fileapi::IsolatedContext::GetInstance()->RevokeFileSystem(read_id);
-  fileapi::IsolatedContext::GetInstance()->RevokeFileSystem(read_write_id);
-  fileapi::IsolatedContext::GetInstance()->RevokeFileSystem(copy_into_id);
-  fileapi::IsolatedContext::GetInstance()->RevokeFileSystem(delete_from_id);
+  storage::IsolatedContext::GetInstance()->RevokeFileSystem(read_id);
+  storage::IsolatedContext::GetInstance()->RevokeFileSystem(read_write_id);
+  storage::IsolatedContext::GetInstance()->RevokeFileSystem(copy_into_id);
+  storage::IsolatedContext::GetInstance()->RevokeFileSystem(delete_from_id);
 }
 
 TEST_F(ChildProcessSecurityPolicyTest, FilePermissionGrantingAndRevoking) {
   ChildProcessSecurityPolicyImpl* p =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
   p->RegisterFileSystemPermissionPolicy(
-      fileapi::kFileSystemTypeTest,
-      fileapi::FILE_PERMISSION_USE_FILE_PERMISSION);
+      storage::kFileSystemTypeTest,
+      storage::FILE_PERMISSION_USE_FILE_PERMISSION);
 
   p->Add(kRendererID);
   base::FilePath file(TEST_PATH("/dir/testfile"));
   file = file.NormalizePathSeparators();
-  fileapi::FileSystemURL url = fileapi::FileSystemURL::CreateForTest(
-      GURL("http://foo/"), fileapi::kFileSystemTypeTest, file);
+  storage::FileSystemURL url = storage::FileSystemURL::CreateForTest(
+      GURL("http://foo/"), storage::kFileSystemTypeTest, file);
 
   // Test initially having no permissions.
   CheckHasNoFileSystemFilePermission(p, file, url);
 
   // Testing every combination of permissions granting and revoking.
   p->GrantReadFile(kRendererID, file);
   EXPECT_TRUE(p->CanReadFile(kRendererID, file));
   EXPECT_FALSE(p->CanCreateReadWriteFile(kRendererID, file));
   EXPECT_TRUE(p->CanReadFileSystemFile(kRendererID, url));
   EXPECT_FALSE(p->CanWriteFileSystemFile(kRendererID, url));
@@ skipping 228 matching lines @@
   // queried on the IO thread.  The ChildProcessSecurityPolicy needs to be
   // prepared to answer policy questions about renderers who no longer exist.
 
   // In this case, we default to secure behavior.
   EXPECT_FALSE(p->CanRequestURL(kRendererID, url));
   EXPECT_FALSE(p->CanReadFile(kRendererID, file));
   EXPECT_FALSE(p->HasWebUIBindings(kRendererID));
 }
 
 }  // namespace content