Cleanup: Rename LocalFileSystemTestOriginHelper (aka test_helper_) to SandboxFileSystemTestHelper

Now LocalFileSystemTestOriginHelper is used only for
Sandbox FileSystems, I'd like to rename this to more
specific, clear name (as the previous name was too vague and
unclear).

BUG=241701,240658
TEST=existing tests
TBR=avi@chromium.org, nhiroki@chromium.org, tzik@chromium.org

Review URL: https://codereview.chromium.org/15810004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@202037 0039d316-1c4b-4281-b951-d872f2087c98

content/content_tests.gypi

@@ -467,10 +467,10 @@
         '../webkit/fileapi/local_file_system_cross_operation_unittest.cc',
         '../webkit/fileapi/local_file_system_operation_unittest.cc',
         '../webkit/fileapi/local_file_system_operation_write_unittest.cc',
-        '../webkit/fileapi/local_file_system_test_helper.cc',
-        '../webkit/fileapi/local_file_system_test_helper.h',
         '../webkit/fileapi/mock_file_change_observer.cc',
         '../webkit/fileapi/mock_file_change_observer.h',
+        '../webkit/fileapi/sandbox_file_system_test_helper.cc',
+        '../webkit/fileapi/sandbox_file_system_test_helper.h',
         '../webkit/fileapi/syncable/canned_syncable_file_system.cc',
         '../webkit/fileapi/syncable/canned_syncable_file_system.h',
         '../webkit/fileapi/syncable/file_change_unittest.cc',

webkit/browser/fileapi/sandbox_mount_point_provider.h

@@ -184,7 +184,7 @@ class WEBKIT_STORAGE_EXPORT SandboxMountPointProvider
 
  private:
   friend class SandboxQuotaObserver;
-  friend class LocalFileSystemTestOriginHelper;
+  friend class SandboxFileSystemTestHelper;
   friend class SandboxMountPointProviderMigrationTest;
   friend class SandboxMountPointProviderOriginEnumeratorTest;
 

webkit/fileapi/local_file_system_operation_unittest.cc

@@ -20,8 +20,8 @@
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_util.h"
-#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/mock_file_change_observer.h"
+#include "webkit/fileapi/sandbox_file_system_test_helper.h"
 #include "webkit/quota/mock_quota_manager.h"
 #include "webkit/quota/quota_manager.h"
 
@@ -65,7 +65,7 @@ class LocalFileSystemOperationTest
     quota_manager_proxy_ = new quota::MockQuotaManagerProxy(
         quota_manager(),
         base::MessageLoopProxy::current());
-    test_helper_.SetUp(base_dir, quota_manager_proxy_.get());
+    sandbox_file_system_.SetUp(base_dir, quota_manager_proxy_.get());
   }
 
   virtual void TearDown() OVERRIDE {
@@ -73,11 +73,11 @@ class LocalFileSystemOperationTest
     quota_manager_proxy()->SimulateQuotaManagerDestroyed();
     quota_manager_ = NULL;
     quota_manager_proxy_ = NULL;
-    test_helper_.TearDown();
+    sandbox_file_system_.TearDown();
   }
 
   LocalFileSystemOperation* NewOperation() {
-    LocalFileSystemOperation* operation = test_helper_.NewOperation();
+    LocalFileSystemOperation* operation = sandbox_file_system_.NewOperation();
     operation->operation_context()->set_change_observers(change_observers());
     return operation;
   }
@@ -103,7 +103,7 @@ class LocalFileSystemOperationTest
   }
 
  FileSystemFileUtil* file_util() {
-    return test_helper_.file_util();
+    return sandbox_file_system_.file_util();
   }
 
  const ChangeObserverList& change_observers() const {
@@ -115,36 +115,39 @@ class LocalFileSystemOperationTest
   }
 
   scoped_ptr<FileSystemOperationContext> NewContext() {
-    FileSystemOperationContext* context = test_helper_.NewOperationContext();
+    FileSystemOperationContext* context =
+        sandbox_file_system_.NewOperationContext();
     // Grant enough quota for all test cases.
     context->set_allowed_bytes_growth(1000000);
     return make_scoped_ptr(context);
   }
 
   FileSystemURL URLForPath(const std::string& path) const {
-    return test_helper_.CreateURLFromUTF8(path);
+    return sandbox_file_system_.CreateURLFromUTF8(path);
   }
 
   base::FilePath PlatformPath(const std::string& path) {
-    return test_helper_.GetLocalPath(base::FilePath::FromUTF8Unsafe(path));
+    return sandbox_file_system_.GetLocalPath(
+        base::FilePath::FromUTF8Unsafe(path));
   }
 
   bool FileExists(const std::string& path) {
     return AsyncFileTestHelper::FileExists(
-        test_helper_.file_system_context(), URLForPath(path),
+        sandbox_file_system_.file_system_context(), URLForPath(path),
         AsyncFileTestHelper::kDontCheckSize);
   }
 
   bool DirectoryExists(const std::string& path) {
     return AsyncFileTestHelper::DirectoryExists(
-        test_helper_.file_system_context(), URLForPath(path));
+        sandbox_file_system_.file_system_context(), URLForPath(path));
   }
 
   FileSystemURL CreateFile(const std::string& path) {
     FileSystemURL url = URLForPath(path);
     bool created = false;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-              file_util()->EnsureFileExists(NewContext().get(), url, &created));
+              file_util()->EnsureFileExists(NewContext().get(),
+                                            url, &created));
     EXPECT_TRUE(created);
     return url;
   }
@@ -216,14 +219,16 @@ class LocalFileSystemOperationTest
   }
 
   int64 GetDataSizeOnDisk() {
-    return test_helper_.ComputeCurrentOriginUsage() -
-        test_helper_.ComputeCurrentDirectoryDatabaseUsage();
+    return sandbox_file_system_.ComputeCurrentOriginUsage() -
+        sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   void GetUsageAndQuota(int64* usage, int64* quota) {
     quota::QuotaStatusCode status =
         AsyncFileTestHelper::GetUsageAndQuota(
-            quota_manager_, test_helper_.origin(), test_helper_.type(),
+            quota_manager_,
+            sandbox_file_system_.origin(),
+            sandbox_file_system_.type(),
             usage, quota);
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(quota::kQuotaStatusOk, status);
@@ -233,7 +238,8 @@ class LocalFileSystemOperationTest
     int64 base_usage;
     GetUsageAndQuota(&base_usage, NULL);
 
-    AsyncFileTestHelper::CreateFile(test_helper_.file_system_context(), url);
+    AsyncFileTestHelper::CreateFile(
+        sandbox_file_system_.file_system_context(), url);
     NewOperation()->Remove(url, false /* recursive */,
                            base::Bind(&AssertFileErrorEq, FROM_HERE,
                                       base::PLATFORM_FILE_OK));
@@ -248,8 +254,8 @@ class LocalFileSystemOperationTest
   void GrantQuotaForCurrentUsage() {
     int64 usage;
     GetUsageAndQuota(&usage, NULL);
-    quota_manager()->SetQuota(test_helper_.origin(),
-                              test_helper_.storage_type(),
+    quota_manager()->SetQuota(sandbox_file_system_.origin(),
+                              sandbox_file_system_.storage_type(),
                               usage);
   }
 
@@ -262,8 +268,8 @@ class LocalFileSystemOperationTest
   void AddQuota(int64 quota_delta) {
     int64 quota;
     GetUsageAndQuota(NULL, &quota);
-    quota_manager()->SetQuota(test_helper_.origin(),
-                              test_helper_.storage_type(),
+    quota_manager()->SetQuota(sandbox_file_system_.origin(),
+                              sandbox_file_system_.storage_type(),
                               quota + quota_delta);
   }
 
@@ -274,7 +280,7 @@ class LocalFileSystemOperationTest
   // Common temp base for nondestructive uses.
   base::ScopedTempDir base_;
 
-  LocalFileSystemTestOriginHelper test_helper_;
+  SandboxFileSystemTestHelper sandbox_file_system_;
 
   // For post-operation status.
   int status_;

webkit/fileapi/local_file_system_test_helper.cc → webkit/fileapi/sandbox_file_system_test_helper.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "webkit/fileapi/local_file_system_test_helper.h"
+#include "webkit/fileapi/sandbox_file_system_test_helper.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ -22,72 +22,51 @@
 
 namespace fileapi {
 
-LocalFileSystemTestOriginHelper::LocalFileSystemTestOriginHelper(
+SandboxFileSystemTestHelper::SandboxFileSystemTestHelper(
     const GURL& origin, FileSystemType type)
     : origin_(origin), type_(type), file_util_(NULL) {
 }
 
-LocalFileSystemTestOriginHelper::LocalFileSystemTestOriginHelper()
+SandboxFileSystemTestHelper::SandboxFileSystemTestHelper()
     : origin_(GURL("http://foo.com")),
       type_(kFileSystemTypeTemporary),
       file_util_(NULL) {
 }
 
-LocalFileSystemTestOriginHelper::~LocalFileSystemTestOriginHelper() {
+SandboxFileSystemTestHelper::~SandboxFileSystemTestHelper() {
 }
 
-void LocalFileSystemTestOriginHelper::SetUp(const base::FilePath& base_dir) {
+void SandboxFileSystemTestHelper::SetUp(const base::FilePath& base_dir) {
   SetUp(base_dir, NULL);
 }
 
-void LocalFileSystemTestOriginHelper::SetUp(
+void SandboxFileSystemTestHelper::SetUp(
     FileSystemContext* file_system_context) {
   file_system_context_ = file_system_context;
 
-  SetUpFileUtil();
-
-  // Prepare the origin's root directory.
-  file_system_context_->GetMountPointProvider(type_)->
-      GetFileSystemRootPathOnFileThread(CreateURL(base::FilePath()),
-                                        true /* create */);
-
-  // Initialize the usage cache file.
-  base::FilePath usage_cache_path = GetUsageCachePath();
-  if (!usage_cache_path.empty())
-    usage_cache()->UpdateUsage(usage_cache_path, 0);
+  SetUpFileSystem();
 }
 
-void LocalFileSystemTestOriginHelper::SetUp(
+void SandboxFileSystemTestHelper::SetUp(
     const base::FilePath& base_dir,
     quota::QuotaManagerProxy* quota_manager_proxy) {
   file_system_context_ = CreateFileSystemContextForTesting(
       quota_manager_proxy, base_dir);
 
-  SetUpFileUtil();
-
-  // Prepare the origin's root directory.
-  FileSystemMountPointProvider* mount_point_provider =
-      file_system_context_->GetMountPointProvider(type_);
-  mount_point_provider->GetFileSystemRootPathOnFileThread(
-      CreateURL(base::FilePath()), true /* create */);
-
-  // Initialize the usage cache file.
-  base::FilePath usage_cache_path = GetUsageCachePath();
-  if (!usage_cache_path.empty())
-    usage_cache()->UpdateUsage(usage_cache_path, 0);
+  SetUpFileSystem();
 }
 
-void LocalFileSystemTestOriginHelper::TearDown() {
+void SandboxFileSystemTestHelper::TearDown() {
   file_system_context_ = NULL;
   base::MessageLoop::current()->RunUntilIdle();
 }
 
-base::FilePath LocalFileSystemTestOriginHelper::GetOriginRootPath() const {
-  return file_system_context_->GetMountPointProvider(type_)->
-      GetFileSystemRootPathOnFileThread(CreateURL(base::FilePath()), false);
+base::FilePath SandboxFileSystemTestHelper::GetOriginRootPath() const {
+  return file_system_context_->sandbox_provider()->
+      GetBaseDirectoryForOriginAndType(origin_, type_, false);
 }
 
-base::FilePath LocalFileSystemTestOriginHelper::GetLocalPath(
+base::FilePath SandboxFileSystemTestHelper::GetLocalPath(
     const base::FilePath& path) {
   DCHECK(file_util_);
   base::FilePath local_path;
@@ -96,31 +75,27 @@ base::FilePath LocalFileSystemTestOriginHelper::GetLocalPath(
   return local_path;
 }
 
-base::FilePath LocalFileSystemTestOriginHelper::GetLocalPathFromASCII(
+base::FilePath SandboxFileSystemTestHelper::GetLocalPathFromASCII(
     const std::string& path) {
   return GetLocalPath(base::FilePath().AppendASCII(path));
 }
 
-base::FilePath LocalFileSystemTestOriginHelper::GetUsageCachePath() const {
-  if (type_ != kFileSystemTypeTemporary &&
-      type_ != kFileSystemTypePersistent &&
-      type_ != kFileSystemTypeSyncable)
-    return base::FilePath();
+base::FilePath SandboxFileSystemTestHelper::GetUsageCachePath() const {
   return file_system_context_->
       sandbox_provider()->GetUsageCachePathForOriginAndType(origin_, type_);
 }
 
-FileSystemURL LocalFileSystemTestOriginHelper::CreateURL(
+FileSystemURL SandboxFileSystemTestHelper::CreateURL(
     const base::FilePath& path) const {
   return file_system_context_->CreateCrackedFileSystemURL(origin_, type_, path);
 }
 
-int64 LocalFileSystemTestOriginHelper::GetCachedOriginUsage() const {
+int64 SandboxFileSystemTestHelper::GetCachedOriginUsage() const {
   return file_system_context_->GetQuotaUtil(type_)->GetOriginUsageOnFileThread(
       file_system_context_, origin_, type_);
 }
 
-int64 LocalFileSystemTestOriginHelper::ComputeCurrentOriginUsage() {
+int64 SandboxFileSystemTestHelper::ComputeCurrentOriginUsage() {
   usage_cache()->CloseCacheFiles();
   int64 size = file_util::ComputeDirectorySize(GetOriginRootPath());
   if (file_util::PathExists(GetUsageCachePath()))
@@ -129,16 +104,14 @@ int64 LocalFileSystemTestOriginHelper::ComputeCurrentOriginUsage() {
 }
 
 int64
-LocalFileSystemTestOriginHelper::ComputeCurrentDirectoryDatabaseUsage() const {
+SandboxFileSystemTestHelper::ComputeCurrentDirectoryDatabaseUsage() const {
   return file_util::ComputeDirectorySize(
       GetOriginRootPath().AppendASCII("Paths"));
 }
 
-LocalFileSystemOperation* LocalFileSystemTestOriginHelper::NewOperation() {
+LocalFileSystemOperation* SandboxFileSystemTestHelper::NewOperation() {
   DCHECK(file_system_context_.get());
   DCHECK(file_util_);
-  scoped_ptr<FileSystemOperationContext> operation_context(
-      NewOperationContext());
   LocalFileSystemOperation* operation = static_cast<LocalFileSystemOperation*>(
       file_system_context_->CreateFileSystemOperation(
           CreateURL(base::FilePath()), NULL));
@@ -146,7 +119,7 @@ LocalFileSystemOperation* LocalFileSystemTestOriginHelper::NewOperation() {
 }
 
 FileSystemOperationContext*
-LocalFileSystemTestOriginHelper::NewOperationContext() {
+SandboxFileSystemTestHelper::NewOperationContext() {
   DCHECK(file_system_context_.get());
   FileSystemOperationContext* context =
     new FileSystemOperationContext(file_system_context_.get());
@@ -155,14 +128,26 @@ LocalFileSystemTestOriginHelper::NewOperationContext() {
   return context;
 }
 
-FileSystemUsageCache* LocalFileSystemTestOriginHelper::usage_cache() {
+FileSystemUsageCache* SandboxFileSystemTestHelper::usage_cache() {
   return file_system_context()->sandbox_provider()->usage_cache();
 }
 
-void LocalFileSystemTestOriginHelper::SetUpFileUtil() {
+void SandboxFileSystemTestHelper::SetUpFileSystem() {
   DCHECK(file_system_context_);
+  DCHECK(file_system_context_->sandbox_provider()->CanHandleType(type_));
+
   file_util_ = file_system_context_->GetFileUtil(type_);
   DCHECK(file_util_);
+
+  // Prepare the origin's root directory.
+  file_system_context_->sandbox_provider()->
+      GetFileSystemRootPathOnFileThread(CreateURL(base::FilePath()),
+                                        true /* create */);
+
+  // Initialize the usage cache file.
+  base::FilePath usage_cache_path = GetUsageCachePath();
+  if (!usage_cache_path.empty())
+    usage_cache()->UpdateUsage(usage_cache_path, 0);
 }
 
 }  // namespace fileapi

webkit/fileapi/local_file_system_test_helper.h → webkit/fileapi/sandbox_file_system_test_helper.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_TEST_HELPER_H_
-#define WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_TEST_HELPER_H_
+#ifndef WEBKIT_FILEAPI_SANDBOX_FILE_SYSTEM_TEST_HELPER_H_
+#define WEBKIT_FILEAPI_SANDBOX_FILE_SYSTEM_TEST_HELPER_H_
 
 #include <string>
 
@@ -33,15 +33,15 @@ class LocalFileSystemOperation;
 
 // Filesystem test helper class that encapsulates test environment for
 // a given {origin, type} pair.  This helper only works for sandboxed
-// file systems (Temporary, Persistent or Test types).
-class LocalFileSystemTestOriginHelper {
+// file systems (Temporary or Persistent).
+class SandboxFileSystemTestHelper {
  public:
-  LocalFileSystemTestOriginHelper(const GURL& origin, FileSystemType type);
-  LocalFileSystemTestOriginHelper();
-  ~LocalFileSystemTestOriginHelper();
+  SandboxFileSystemTestHelper(const GURL& origin, FileSystemType type);
+  SandboxFileSystemTestHelper();
+  ~SandboxFileSystemTestHelper();
 
   void SetUp(const base::FilePath& base_dir);
-  // If you want to use more than one LocalFileSystemTestOriginHelper in
+  // If you want to use more than one SandboxFileSystemTestHelper in
   // a single base directory, they have to share a context, so that they don't
   // have multiple databases fighting over the lock to the origin directory
   // [deep down inside ObfuscatedFileUtil].
@@ -86,7 +86,7 @@ class LocalFileSystemTestOriginHelper {
   FileSystemUsageCache* usage_cache();
 
  private:
-  void SetUpFileUtil();
+  void SetUpFileSystem();
 
   scoped_refptr<FileSystemContext> file_system_context_;
 
@@ -97,4 +97,4 @@ class LocalFileSystemTestOriginHelper {
 
 }  // namespace fileapi
 
-#endif  // WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_TEST_HELPER_H_
+#endif  // WEBKIT_FILEAPI_SANDBOX_FILE_SYSTEM_TEST_HELPER_H_

webkit/fileapi/syncable/syncable_file_system_unittest.cc

@@ -11,7 +11,7 @@
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/local_file_system_operation.h"
-#include "webkit/fileapi/local_file_system_test_helper.h"
+#include "webkit/fileapi/sandbox_file_system_test_helper.h"
 #include "webkit/fileapi/syncable/canned_syncable_file_system.h"
 #include "webkit/fileapi/syncable/local_file_change_tracker.h"
 #include "webkit/fileapi/syncable/local_file_sync_context.h"
@@ -24,7 +24,7 @@ using fileapi::FileSystemContext;
 using fileapi::FileSystemOperationContext;
 using fileapi::FileSystemURL;
 using fileapi::FileSystemURLSet;
-using fileapi::LocalFileSystemTestOriginHelper;
+using fileapi::SandboxFileSystemTestHelper;
 using quota::QuotaManager;
 using quota::QuotaStatusCode;
 
@@ -248,7 +248,7 @@ TEST_F(SyncableFileSystemTest, DisableDirectoryOperations) {
             file_system_.CreateDirectory(URL("dir")));
 
   // Set up another (non-syncable) local file system.
-  LocalFileSystemTestOriginHelper other_file_system_(
+  SandboxFileSystemTestHelper other_file_system_(
       GURL("http://foo.com/"), fileapi::kFileSystemTypeTemporary);
   other_file_system_.SetUp(file_system_.file_system_context());