Cleanup: Rename LocalFileSystemTestOriginHelper (aka test_helper_) to SandboxFileSystemTestHelper

webkit/fileapi/local_file_system_operation_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/fileapi/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/async_file_test_helper.h"
 #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"
 
 using quota::QuotaManager;
 using quota::QuotaManagerProxy;
 using webkit_blob::ShareableFileReference;
 
 namespace fileapi {
 
 namespace {
@@ skipping 23 matching lines @@
 
     base::FilePath base_dir = base_.path().AppendASCII("filesystem");
     quota_manager_ = new quota::MockQuotaManager(
         false /* is_incognito */, base_dir,
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
         NULL /* special storage policy */);
     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 {
     // Let the client go away before dropping a ref of the quota manager proxy.
     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;
   }
 
   int status() const { return status_; }
   const base::PlatformFileInfo& info() const { return info_; }
   const base::FilePath& path() const { return path_; }
   const std::vector<DirectoryEntry>& entries() const {
     return entries_;
   }
 
   const ShareableFileReference* shareable_file_ref() const {
     return shareable_file_ref_;
   }
 
   quota::MockQuotaManager* quota_manager() {
     return static_cast<quota::MockQuotaManager*>(quota_manager_.get());
   }
 
   quota::MockQuotaManagerProxy* quota_manager_proxy() {
     return static_cast<quota::MockQuotaManagerProxy*>(
         quota_manager_proxy_.get());
   }
 
  FileSystemFileUtil* file_util() {
-    return test_helper_.file_util();
+    return sandbox_file_system_.file_util();
   }
 
  const ChangeObserverList& change_observers() const {
     return change_observers_;
   }
 
   MockFileChangeObserver* change_observer() {
     return &change_observer_;
   }
 
   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;
   }
 
   FileSystemURL CreateDirectory(const std::string& path) {
     FileSystemURL url = URLForPath(path);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               file_util()->CreateDirectory(NewContext().get(), url,
                                            false /* exclusive */, true));
     return url;
@@ skipping 51 matching lines @@
       const base::PlatformFileInfo& info,
       const base::FilePath& platform_path,
       const scoped_refptr<ShareableFileReference>& shareable_file_ref) {
     info_ = info;
     path_ = platform_path;
     status_ = status;
     shareable_file_ref_ = shareable_file_ref;
   }
 
   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);
   }
 
   int64 ComputePathCost(const FileSystemURL& url) {
     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));
     base::MessageLoop::current()->RunUntilIdle();
     change_observer()->ResetCount();
 
     int64 total_usage;
     GetUsageAndQuota(&total_usage, NULL);
     return total_usage - base_usage;
   }
 
   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);
   }
 
   int64 GetUsage() {
     int64 usage = 0;
     GetUsageAndQuota(&usage, NULL);
     return usage;
   }
 
   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);
   }
 
   base::MessageLoop message_loop_;
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
 
   // Common temp base for nondestructive uses.
   base::ScopedTempDir base_;
 
-  LocalFileSystemTestOriginHelper test_helper_;
+  SandboxFileSystemTestHelper sandbox_file_system_;
 
   // For post-operation status.
   int status_;
   base::PlatformFileInfo info_;
   base::FilePath path_;
   std::vector<DirectoryEntry> entries_;
   scoped_refptr<ShareableFileReference> shareable_file_ref_;
 
   MockFileChangeObserver change_observer_;
   ChangeObserverList change_observers_;
@@ skipping 886 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   expected_usage += grandchild_file_size + grandchild_path_cost;
   usage = GetUsage();
   EXPECT_EQ(2 * child_file_size + 3 * grandchild_file_size,
             GetDataSizeOnDisk());
   EXPECT_EQ(expected_usage, usage);
 }
 
 }  // namespace fileapi