Cleanup: Rename LocalFileSystemTestOriginHelper (aka test_helper_) to SandboxFileSystemTestHelper

webkit/browser/fileapi/obfuscated_file_util_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 <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/file_system_mount_point_provider.h"
 #include "webkit/browser/fileapi/file_system_usage_cache.h"
 #include "webkit/browser/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/async_file_test_helper.h"
 #include "webkit/fileapi/external_mount_points.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_task_runners.h"
-#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/mock_file_change_observer.h"
 #include "webkit/fileapi/mock_file_system_context.h"
+#include "webkit/fileapi/sandbox_file_system_test_helper.h"
 #include "webkit/fileapi/test_file_set.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 namespace fileapi {
 
 namespace {
 
 bool FileExists(const base::FilePath& path) {
@@ skipping 76 matching lines @@
 // TODO(ericu): The vast majority of this and the other FSFU subclass tests
 // could theoretically be shared.  It would basically be a FSFU interface
 // compliance test, and only the subclass-specific bits that look into the
 // implementation would need to be written per-subclass.
 class ObfuscatedFileUtilTest : public testing::Test {
  public:
   ObfuscatedFileUtilTest()
       : origin_(GURL("http://www.example.com")),
         type_(kFileSystemTypeTemporary),
         weak_factory_(this),
-        test_helper_(origin_, type_),
+        sandbox_file_system_(origin_, type_),
         quota_status_(quota::kQuotaStatusUnknown),
         usage_(-1) {
   }
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
     scoped_refptr<quota::SpecialStoragePolicy> storage_policy =
         new quota::MockSpecialStoragePolicy();
 
     quota_manager_ = new quota::QuotaManager(
         false /* is_incognito */,
         data_dir_.path(),
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
         storage_policy);
 
-    // Every time we create a new helper, it creates another context, which
-    // creates another path manager, another sandbox_mount_point_provider, and
+    // Every time we create a new sandbox_file_system helper,
+    // it creates another context, which creates another path manager,
+    // another sandbox_mount_point_provider, and
     // another OFU.  We need to pass in the context to skip all that.
     file_system_context_ = CreateFileSystemContextForTesting(
         quota_manager_->proxy(),
         data_dir_.path());
 
-    test_helper_.SetUp(file_system_context_.get());
+    sandbox_file_system_.SetUp(file_system_context_.get());
 
     change_observers_ = MockFileChangeObserver::CreateList(&change_observer_);
   }
 
   virtual void TearDown() {
     quota_manager_ = NULL;
-    test_helper_.TearDown();
+    sandbox_file_system_.TearDown();
   }
 
   scoped_ptr<FileSystemOperationContext> LimitedContext(
       int64 allowed_bytes_growth) {
     scoped_ptr<FileSystemOperationContext> context(
-        test_helper_.NewOperationContext());
+        sandbox_file_system_.NewOperationContext());
     context->set_allowed_bytes_growth(allowed_bytes_growth);
     return context.Pass();
   }
 
   scoped_ptr<FileSystemOperationContext> UnlimitedContext() {
     return LimitedContext(kint64max);
   }
 
   FileSystemOperationContext* NewContext(
-      LocalFileSystemTestOriginHelper* helper) {
+      SandboxFileSystemTestHelper* file_system) {
     change_observer()->ResetCount();
     FileSystemOperationContext* context;
-    if (helper)
-      context = helper->NewOperationContext();
+    if (file_system)
+      context = file_system->NewOperationContext();
     else
-      context = test_helper_.NewOperationContext();
+      context = sandbox_file_system_.NewOperationContext();
     // Setting allowed_bytes_growth big enough for all tests.
     context->set_allowed_bytes_growth(1024 * 1024);
     context->set_change_observers(change_observers());
     return context;
   }
 
   const ChangeObserverList& change_observers() const {
     return change_observers_;
   }
 
   MockFileChangeObserver* change_observer() {
     return &change_observer_;
   }
 
   // This can only be used after SetUp has run and created file_system_context_
   // and obfuscated_file_util_.
   // Use this for tests which need to run in multiple origins; we need a test
   // helper per origin.
-  LocalFileSystemTestOriginHelper* NewHelper(
+  SandboxFileSystemTestHelper* NewFileSystem(
       const GURL& origin, fileapi::FileSystemType type) {
-    LocalFileSystemTestOriginHelper* helper =
-        new LocalFileSystemTestOriginHelper(origin, type);
+    SandboxFileSystemTestHelper* file_system =
+        new SandboxFileSystemTestHelper(origin, type);
 
-    helper->SetUp(file_system_context_.get());
-    return helper;
+    file_system->SetUp(file_system_context_.get());
+    return file_system;
   }
 
   ObfuscatedFileUtil* ofu() {
-    return static_cast<ObfuscatedFileUtil*>(test_helper_.file_util());
+    return static_cast<ObfuscatedFileUtil*>(sandbox_file_system_.file_util());
   }
 
   const base::FilePath& test_directory() const {
     return data_dir_.path();
   }
 
   const GURL& origin() const {
     return origin_;
   }
 
   fileapi::FileSystemType type() const {
     return type_;
   }
 
   int64 ComputeTotalFileSize() {
-    return test_helper_.ComputeCurrentOriginUsage() -
-        test_helper_.ComputeCurrentDirectoryDatabaseUsage();
+    return sandbox_file_system_.ComputeCurrentOriginUsage() -
+        sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   void GetUsageFromQuotaManager() {
     int64 quota = -1;
     quota_status_ = AsyncFileTestHelper::GetUsageAndQuota(
-      quota_manager_, origin(), test_helper_.type(),
+      quota_manager_, origin(), sandbox_file_system_.type(),
       &usage_, &quota);
     EXPECT_EQ(quota::kQuotaStatusOk, quota_status_);
   }
 
   void RevokeUsageCache() {
-    quota_manager_->ResetUsageTracker(test_helper_.storage_type());
-    usage_cache()->Delete(test_helper_.GetUsageCachePath());
+    quota_manager_->ResetUsageTracker(sandbox_file_system_.storage_type());
+    usage_cache()->Delete(sandbox_file_system_.GetUsageCachePath());
   }
 
   int64 SizeByQuotaUtil() {
-    return test_helper_.GetCachedOriginUsage();
+    return sandbox_file_system_.GetCachedOriginUsage();
   }
 
   int64 SizeInUsageFile() {
     base::MessageLoop::current()->RunUntilIdle();
     int64 usage = 0;
-    return usage_cache()->GetUsage(test_helper_.GetUsageCachePath(), &usage) ?
-        usage : -1;
+    return usage_cache()->GetUsage(
+        sandbox_file_system_.GetUsageCachePath(), &usage) ? usage : -1;
   }
 
   bool PathExists(const FileSystemURL& url) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     base::PlatformFileInfo file_info;
     base::FilePath platform_path;
     base::PlatformFileError error = ofu()->GetFileInfo(
         context.get(), url, &file_info, &platform_path);
     return error == base::PLATFORM_FILE_OK;
   }
 
   bool DirectoryExists(const FileSystemURL& url) {
     return AsyncFileTestHelper::DirectoryExists(file_system_context(), url);
   }
 
   int64 usage() const { return usage_; }
   FileSystemUsageCache* usage_cache() {
-    return test_helper_.usage_cache();
+    return sandbox_file_system_.usage_cache();
   }
 
   FileSystemURL CreateURLFromUTF8(const std::string& path) {
-    return test_helper_.CreateURLFromUTF8(path);
+    return sandbox_file_system_.CreateURLFromUTF8(path);
   }
 
   int64 PathCost(const FileSystemURL& url) {
     return ObfuscatedFileUtil::ComputeFilePathCost(url.path());
   }
 
   FileSystemURL CreateURL(const base::FilePath& path) {
-    return test_helper_.CreateURL(path);
+    return sandbox_file_system_.CreateURL(path);
   }
 
   void CheckFileAndCloseHandle(
       const FileSystemURL& url, base::PlatformFile file_handle) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     base::FilePath local_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
         context.get(), url, &local_path));
 
     base::PlatformFileInfo file_info0;
@@ skipping 66 matching lines @@
     for (iter = directories.begin(); iter != directories.end(); ++iter) {
       context.reset(NewContext(NULL));
       EXPECT_TRUE(DirectoryExists(
           FileSystemURLAppend(root_url, *iter)));
     }
   }
 
   class UsageVerifyHelper {
    public:
     UsageVerifyHelper(scoped_ptr<FileSystemOperationContext> context,
-                      LocalFileSystemTestOriginHelper* test_helper,
+                      SandboxFileSystemTestHelper* file_system,
                       int64 expected_usage)
         : context_(context.Pass()),
-          test_helper_(test_helper),
+          sandbox_file_system_(file_system),
           expected_usage_(expected_usage) {}
 
     ~UsageVerifyHelper() {
       base::MessageLoop::current()->RunUntilIdle();
       Check();
     }
 
     FileSystemOperationContext* context() {
       return context_.get();
     }
 
    private:
     void Check() {
       ASSERT_EQ(expected_usage_,
-                test_helper_->GetCachedOriginUsage());
+                sandbox_file_system_->GetCachedOriginUsage());
     }
 
     scoped_ptr<FileSystemOperationContext> context_;
-    LocalFileSystemTestOriginHelper* test_helper_;
+    SandboxFileSystemTestHelper* sandbox_file_system_;
     int64 expected_usage_;
   };
 
   scoped_ptr<UsageVerifyHelper> AllowUsageIncrease(int64 requested_growth) {
-    int64 usage = test_helper_.GetCachedOriginUsage();
+    int64 usage = sandbox_file_system_.GetCachedOriginUsage();
     return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper(
         LimitedContext(requested_growth),
-        &test_helper_, usage + requested_growth));
+        &sandbox_file_system_, usage + requested_growth));
   }
 
   scoped_ptr<UsageVerifyHelper> DisallowUsageIncrease(int64 requested_growth) {
-    int64 usage = test_helper_.GetCachedOriginUsage();
+    int64 usage = sandbox_file_system_.GetCachedOriginUsage();
     return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper(
-        LimitedContext(requested_growth - 1), &test_helper_, usage));
+        LimitedContext(requested_growth - 1), &sandbox_file_system_, usage));
   }
 
   void FillTestDirectory(
       const FileSystemURL& root_url,
       std::set<base::FilePath::StringType>* files,
       std::set<base::FilePath::StringType>* directories) {
     scoped_ptr<FileSystemOperationContext> context;
     std::vector<DirectoryEntry> entries;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               AsyncFileTestHelper::ReadDirectory(
@@ skipping 222 matching lines @@
                                     src_file_url, dest_file_url,
                                     copy));
     if (copy)
       EXPECT_EQ(base::Time(), GetModifiedTime(src_dir_url));
     else
       EXPECT_NE(base::Time(), GetModifiedTime(src_dir_url));
     EXPECT_NE(base::Time(), GetModifiedTime(dest_dir_url));
   }
 
   int64 ComputeCurrentUsage() {
-    return test_helper_.ComputeCurrentOriginUsage() -
-        test_helper_.ComputeCurrentDirectoryDatabaseUsage();
-  }
-
-  const LocalFileSystemTestOriginHelper& test_helper() const {
-    return test_helper_;
+    return sandbox_file_system_.ComputeCurrentOriginUsage() -
+        sandbox_file_system_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   FileSystemContext* file_system_context() {
-    return test_helper_.file_system_context();
+    return sandbox_file_system_.file_system_context();
   }
 
  private:
   base::ScopedTempDir data_dir_;
   base::MessageLoop message_loop_;
   scoped_refptr<quota::QuotaManager> quota_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   GURL origin_;
   fileapi::FileSystemType type_;
   base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_;
-  LocalFileSystemTestOriginHelper test_helper_;
+  SandboxFileSystemTestHelper sandbox_file_system_;
   quota::QuotaStatusCode quota_status_;
   int64 usage_;
   MockFileChangeObserver change_observer_;
   ChangeObserverList change_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilTest);
 };
 
 TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) {
   base::PlatformFile file_handle = base::kInvalidPlatformFileValue;
@@ skipping 734 matching lines @@
 
   std::set<base::FilePath::StringType> files;
   std::set<base::FilePath::StringType> directories;
   FillTestDirectory(src_url, &files, &directories);
 
   FileSystemURL dest_url = CreateURLFromUTF8("destination dir");
 
   EXPECT_FALSE(DirectoryExists(dest_url));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             AsyncFileTestHelper::Copy(
-                test_helper().file_system_context(), src_url, dest_url));
+                file_system_context(), src_url, dest_url));
 
   ValidateTestDirectory(dest_url, files, directories);
   EXPECT_TRUE(DirectoryExists(src_url));
   EXPECT_TRUE(DirectoryExists(dest_url));
   recursive = true;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             AsyncFileTestHelper::Remove(
                 file_system_context(), dest_url, recursive));
   EXPECT_FALSE(DirectoryExists(dest_url));
 }
@@ skipping 15 matching lines @@
   origins_expected.insert(origin());
 
   for (size_t i = 0; i < arraysize(kOriginEnumerationTestRecords); ++i) {
     SCOPED_TRACE(testing::Message() <<
         "Validating kOriginEnumerationTestRecords " << i);
     const OriginEnumerationTestRecord& record =
         kOriginEnumerationTestRecords[i];
     GURL origin_url(record.origin_url);
     origins_expected.insert(origin_url);
     if (record.has_temporary) {
-      scoped_ptr<LocalFileSystemTestOriginHelper> helper(
-          NewHelper(origin_url, kFileSystemTypeTemporary));
-      scoped_ptr<FileSystemOperationContext> context(NewContext(helper.get()));
+      scoped_ptr<SandboxFileSystemTestHelper> file_system(
+          NewFileSystem(origin_url, kFileSystemTypeTemporary));
+      scoped_ptr<FileSystemOperationContext> context(
+          NewContext(file_system.get()));
       bool created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
                 ofu()->EnsureFileExists(
                     context.get(),
-                    helper->CreateURLFromUTF8("file"),
+                    file_system->CreateURLFromUTF8("file"),
                     &created));
       EXPECT_TRUE(created);
     }
     if (record.has_persistent) {
-      scoped_ptr<LocalFileSystemTestOriginHelper> helper(
-          NewHelper(origin_url, kFileSystemTypePersistent));
-      scoped_ptr<FileSystemOperationContext> context(NewContext(helper.get()));
+      scoped_ptr<SandboxFileSystemTestHelper> file_system(
+          NewFileSystem(origin_url, kFileSystemTypePersistent));
+      scoped_ptr<FileSystemOperationContext> context(
+          NewContext(file_system.get()));
       bool created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
                 ofu()->EnsureFileExists(
                     context.get(),
-                    helper->CreateURLFromUTF8("file"),
+                    file_system->CreateURLFromUTF8("file"),
                     &created));
       EXPECT_TRUE(created);
     }
   }
   enumerator.reset(ofu()->CreateOriginEnumerator());
   EXPECT_TRUE(enumerator.get());
   std::set<GURL> origins_found;
   GURL origin_url;
   while (!(origin_url = enumerator->Next()).is_empty()) {
     origins_found.insert(origin_url);
@@ skipping 759 matching lines @@
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->CreateOrOpen(
                 AllowUsageIncrease(-length)->context(), file,
                 base::PLATFORM_FILE_OPEN_TRUNCATED | base::PLATFORM_FILE_WRITE,
                 &file_handle, &created));
   ASSERT_EQ(0, ComputeTotalFileSize());
   EXPECT_TRUE(base::ClosePlatformFile(file_handle));
 }
 
 }  // namespace fileapi