Simplify directory path accounting.

webkit/fileapi/file_system_test_helper.cc

 // Copyright (c) 2011 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/file_system_test_helper.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "googleurl/src/gurl.h"
@@ skipping 94 matching lines @@
       NULL);
 
   DCHECK(file_system_context_->path_manager());
   DCHECK(file_system_context_->path_manager()->sandbox_provider());
 
   // Prepare the origin's root directory.
   file_system_context_->path_manager()->
       ValidateFileSystemRootAndGetPathOnFileThread(
           origin_, type_, FilePath(), true /* create */);
 
-  // Initialize the usage cache file.
+  // Initialize the usage cache file.  This code assumes that we're either using
+  // OFSFU or we've mocked it out in the sandbox provider.
   FilePath usage_cache_path = file_system_context_->path_manager()
       ->sandbox_provider()->GetUsageCachePathForOriginAndType(origin_, type_);
   FileSystemUsageCache::UpdateUsage(usage_cache_path, 0);
-
-  // We expect the origin directory to be always empty, except for possibly
-  // the usage cache file.  We record the initial usage file size here
-  // (it will be either 0 or kUsageFileSize) so that later we can compute
-  // how much the size of the origin directory has grown.
-  initial_usage_size_ = file_util::ComputeDirectorySize(
-      GetOriginRootPath());
-
-  FileSystemUsageCache::UpdateUsage(usage_cache_path, initial_usage_size_);
 }
 
 void FileSystemTestOriginHelper::TearDown() {
   file_system_context_ = NULL;
   MessageLoop::current()->RunAllPending();
 }
 
 FilePath FileSystemTestOriginHelper::GetOriginRootPath() const {
   return file_system_context_->path_manager()->
       ValidateFileSystemRootAndGetPathOnFileThread(
@@ skipping 25 matching lines @@
 
 int64 FileSystemTestOriginHelper::GetCachedOriginUsage() const {
   return FileSystemUsageCache::GetUsage(GetUsageCachePath());
 }
 
 bool FileSystemTestOriginHelper::RevokeUsageCache() const {
   return file_util::Delete(GetUsageCachePath(), false);
 }
 
 int64 FileSystemTestOriginHelper::ComputeCurrentOriginUsage() const {
-  // Depending on the file_util GetOriginRootPath() may include usage
-  // cache file size or may not.  Here we subtract the initial size to
-  // make it work for multiple file_utils.
-  return file_util::ComputeDirectorySize(GetOriginRootPath()) -
-      initial_usage_size_;
+  int64 size = file_util::ComputeDirectorySize(GetOriginRootPath());
+  if (file_util::PathExists(GetUsageCachePath()))
+    size -= FileSystemUsageCache::kUsageFileSize;
+  return size;
 }
 
 FileSystemOperation* FileSystemTestOriginHelper::NewOperation(
     FileSystemCallbackDispatcher* callback_dispatcher) {
   DCHECK(file_system_context_.get());
   DCHECK(file_util_);
   FileSystemOperation* operation =
     new FileSystemOperation(callback_dispatcher,
                             base::MessageLoopProxy::current(),
                             file_system_context_.get(),
@@ skipping 14 matching lines @@
 void FileSystemTestOriginHelper::InitializeOperationContext(
     FileSystemOperationContext* context) {
   DCHECK(context);
   context->set_src_origin_url(origin_);
   context->set_src_type(type_);
   context->set_dest_origin_url(origin_);
   context->set_dest_type(type_);
 }
 
 }  // namespace fileapi