FileAPI: Move FileSystemQuotaUtil related functions into SandboxContext

webkit/browser/fileapi/sandbox_file_system_backend_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 "webkit/browser/fileapi/sandbox_file_system_backend.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
@@ skipping 71 matching lines @@
 }  // namespace
 
 class SandboxFileSystemBackendTest : public testing::Test {
  protected:
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     context_.reset(new SandboxContext(
         NULL /* quota_manager_proxy */,
         base::MessageLoopProxy::current().get(),
         data_dir_.path(),
-        NULL /* special_storage_policy */));
+        NULL /* special_storage_policy */,
+        CreateAllowFileAccessOptions()));
   }
 
   void SetUpNewBackend(const FileSystemOptions& options) {
-    backend_.reset(new SandboxFileSystemBackend(context_.get(), options));
+    context_->set_file_system_options(options);

[kinuko, 2013/07/31 06:12:34]

Is set_file_system_option added only for this?

Looks like we should just reset the context too?
(Before we split context out of backend we were re-creating Backend here, so if
we do the same resetting context here sounds more reasonable to me)

[nhiroki, 2013/07/31 07:23:19]

Right.
I see. Done.

+    backend_.reset(new SandboxFileSystemBackend(context_.get()));
   }
 
-  SandboxFileSystemBackend::OriginEnumerator* CreateOriginEnumerator() const {
+  SandboxContext::OriginEnumerator* CreateOriginEnumerator() const {
     return backend_->CreateOriginEnumerator();
   }
 
   void CreateOriginTypeDirectory(const GURL& origin,
                                  fileapi::FileSystemType type) {
-    base::FilePath target = backend_->
+    base::FilePath target = context_->
         GetBaseDirectoryForOriginAndType(origin, type, true);
     ASSERT_TRUE(!target.empty());
     ASSERT_TRUE(base::DirectoryExists(target));
   }
 
   bool GetRootPath(const GURL& origin_url,
                    fileapi::FileSystemType type,
                    OpenFileSystemMode mode,
                    base::FilePath* root_path) {
     base::PlatformFileError error = base::PLATFORM_FILE_OK;
     backend_->OpenFileSystem(
         origin_url, type, mode,
         base::Bind(&DidOpenFileSystem, &error));
     base::MessageLoop::current()->RunUntilIdle();
     if (error != base::PLATFORM_FILE_OK)
       return false;
     base::FilePath returned_root_path =
-        backend_->GetBaseDirectoryForOriginAndType(
+        context_->GetBaseDirectoryForOriginAndType(
             origin_url, type, false /* create */);
     if (root_path)
       *root_path = returned_root_path;
     return !returned_root_path.empty();
   }
 
   base::FilePath file_system_path() const {
     return data_dir_.path().Append(SandboxContext::kFileSystemDirectory);
   }
 
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
   scoped_ptr<SandboxContext> context_;
   scoped_ptr<SandboxFileSystemBackend> backend_;
 };
 
 TEST_F(SandboxFileSystemBackendTest, Empty) {
   SetUpNewBackend(CreateAllowFileAccessOptions());
-  scoped_ptr<SandboxFileSystemBackend::OriginEnumerator> enumerator(
+  scoped_ptr<SandboxContext::OriginEnumerator> enumerator(
       CreateOriginEnumerator());
   ASSERT_TRUE(enumerator->Next().is_empty());
 }
 
 TEST_F(SandboxFileSystemBackendTest, EnumerateOrigins) {
   SetUpNewBackend(CreateAllowFileAccessOptions());
   const char* temporary_origins[] = {
     "http://www.bar.com/",
     "http://www.foo.com/",
     "http://www.foo.com:1/",
@@ skipping 12 matching lines @@
     CreateOriginTypeDirectory(GURL(temporary_origins[i]),
         fileapi::kFileSystemTypeTemporary);
     temporary_set.insert(GURL(temporary_origins[i]));
   }
   for (size_t i = 0; i < persistent_size; ++i) {
     CreateOriginTypeDirectory(GURL(persistent_origins[i]),
         kFileSystemTypePersistent);
     persistent_set.insert(GURL(persistent_origins[i]));
   }
 
-  scoped_ptr<SandboxFileSystemBackend::OriginEnumerator> enumerator(
+  scoped_ptr<SandboxContext::OriginEnumerator> enumerator(
       CreateOriginEnumerator());
   size_t temporary_actual_size = 0;
   size_t persistent_actual_size = 0;
   GURL current;
   while (!(current = enumerator->Next()).is_empty()) {
     SCOPED_TRACE(testing::Message() << "EnumerateOrigin " << current.spec());
     if (enumerator->HasFileSystemType(kFileSystemTypeTemporary)) {
       ASSERT_TRUE(temporary_set.find(current) != temporary_set.end());
       ++temporary_actual_size;
     }
     if (enumerator->HasFileSystemType(kFileSystemTypePersistent)) {
       ASSERT_TRUE(persistent_set.find(current) != persistent_set.end());
       ++persistent_actual_size;
     }
   }
 
   EXPECT_EQ(temporary_size, temporary_actual_size);
   EXPECT_EQ(persistent_size, persistent_actual_size);
 }
 
-TEST_F(SandboxFileSystemBackendTest, IsAccessValid) {
-  SetUpNewBackend(CreateAllowFileAccessOptions());
-
-  // Normal case.
-  EXPECT_TRUE(backend_->IsAccessValid(CreateFileSystemURL("a")));
-
-  // Access to a path with parent references ('..') should be disallowed.
-  EXPECT_FALSE(backend_->IsAccessValid(CreateFileSystemURL("a/../b")));
-
-  // Access from non-allowed scheme should be disallowed.
-  EXPECT_FALSE(backend_->IsAccessValid(
-      FileSystemURL::CreateForTest(
-          GURL("unknown://bar"), kFileSystemTypeTemporary,
-          base::FilePath::FromUTF8Unsafe("foo"))));
-
-  // Access for non-sandbox type should be disallowed.
-  EXPECT_FALSE(backend_->IsAccessValid(
-      FileSystemURL::CreateForTest(
-          GURL("http://foo/"), kFileSystemTypeTest,
-          base::FilePath::FromUTF8Unsafe("foo"))));
-
-  // Access with restricted name should be disallowed.
-  EXPECT_FALSE(backend_->IsAccessValid(CreateFileSystemURL(".")));
-  EXPECT_FALSE(backend_->IsAccessValid(CreateFileSystemURL("..")));
-
-  // This is also diallowed due to Windows XP parent path handling.
-  EXPECT_FALSE(backend_->IsAccessValid(CreateFileSystemURL("...")));
-
-  // These are identified as unsafe cases due to weird path handling
-  // on Windows.
-  EXPECT_FALSE(backend_->IsAccessValid(CreateFileSystemURL(" ..")));
-  EXPECT_FALSE(backend_->IsAccessValid(CreateFileSystemURL(".. ")));
-
-  // Similar but safe cases.
-  EXPECT_TRUE(backend_->IsAccessValid(CreateFileSystemURL(" .")));
-  EXPECT_TRUE(backend_->IsAccessValid(CreateFileSystemURL(". ")));
-  EXPECT_TRUE(backend_->IsAccessValid(CreateFileSystemURL("b.")));
-  EXPECT_TRUE(backend_->IsAccessValid(CreateFileSystemURL(".b")));
-
-  // A path that looks like a drive letter.
-  EXPECT_TRUE(backend_->IsAccessValid(CreateFileSystemURL("c:")));
-}
-
 TEST_F(SandboxFileSystemBackendTest, GetRootPathCreateAndExamine) {
   std::vector<base::FilePath> returned_root_path(
       ARRAYSIZE_UNSAFE(kRootPathTestCases));
   SetUpNewBackend(CreateAllowFileAccessOptions());
 
   // Create a new root directory.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (create) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
 
@@ skipping 102 matching lines @@
                             OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                             &root_path));
     base::FilePath expected = file_system_path().AppendASCII(
         kRootPathFileURITestCases[i].expected_path);
     EXPECT_EQ(expected.value(), root_path.value());
     EXPECT_TRUE(base::DirectoryExists(root_path));
   }
 }
 
 }  // namespace fileapi