Count-up/down the dirty count in the usage cache at FileSystemOperation, not at QuotaFU.

webkit/fileapi/file_system_operation.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_operation.h"
 
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/local_file_system_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_types.h"
 
 namespace fileapi {
 
+FileSystemOperation::ScopedQuotaUtilHelper::ScopedQuotaUtilHelper(
+    FileSystemContext* context, const GURL& origin_url, FileSystemType type)
+    : origin_url_(origin_url), type_(type) {
+  DCHECK(context);
+  DCHECK(type != kFileSystemTypeUnknown);
+  quota_util_ = context->GetQuotaUtil(type_);
+  if (quota_util_) {
+    DCHECK(quota_util_->proxy());
+    quota_util_->proxy()->StartUpdateOrigin(origin_url_, type_);
+  }
+}
+
+FileSystemOperation::ScopedQuotaUtilHelper::~ScopedQuotaUtilHelper() {
+  if (quota_util_) {
+    DCHECK(quota_util_->proxy());
+    quota_util_->proxy()->EndUpdateOrigin(origin_url_, type_);
+  }
+}
+
 FileSystemOperation::FileSystemOperation(
     FileSystemCallbackDispatcher* dispatcher,
     scoped_refptr<base::MessageLoopProxy> proxy,
     FileSystemContext* file_system_context,
     FileSystemFileUtil* file_system_file_util)
     : proxy_(proxy),
       dispatcher_(dispatcher),
       file_system_operation_context_(
           file_system_context, file_system_file_util),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
@@ skipping 63 matching lines @@
 void FileSystemOperation::DelayedCreateFileForQuota(
     quota::QuotaStatusCode status, int64 usage, int64 quota) {
   if (file_system_context()->IsStorageUnlimited(
           file_system_operation_context()->src_origin_url()) ||
       quota == QuotaFileUtil::kNoLimit) {
     file_system_operation_context_.set_allowed_bytes_growth(
         QuotaFileUtil::kNoLimit);
   } else {
     file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
   }
+
+  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
+      file_system_context(),
+      file_system_operation_context_.src_origin_url(),
+      file_system_operation_context_.src_type()));
+
   FileSystemFileUtilProxy::EnsureFileExists(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       callback_factory_.NewCallback(
           exclusive_ ? &FileSystemOperation::DidEnsureFileExistsExclusive
                      : &FileSystemOperation::DidEnsureFileExistsNonExclusive));
 }
 
 void FileSystemOperation::CreateDirectory(const GURL& path,
@@ skipping 30 matching lines @@
 void FileSystemOperation::DelayedCreateDirectoryForQuota(
     quota::QuotaStatusCode status, int64 usage, int64 quota) {
   if (file_system_context()->IsStorageUnlimited(
           file_system_operation_context()->src_origin_url()) ||
       quota == QuotaFileUtil::kNoLimit) {
     file_system_operation_context_.set_allowed_bytes_growth(
         QuotaFileUtil::kNoLimit);
   } else {
     file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
   }
+
+  quota_util_helper_.reset(new ScopedQuotaUtilHelper(

[ericu, 2011/08/19 04:12:59]

This feels a bit odd here, given that many filesystems won't have quota issues. 
Perhaps in OFSFU and QFU both, as came up in the meeting on Wednesday?

[Dai Mikurube (NOT FULLTIME), 2011/08/19 10:21:10]

I basically agree with that, but I guess it has a trade-off issue.  If we do
that both in FUs, we have to make sure that the inner pair of ++/-- is
sandwiched by the outer pair of ++/-- in some way.

For example, if we do an operation in the following order:
1) OFSFU's ++ 
2) OFSFU path name accounting
3) OFSFU's --
4) QFU's ++
5) QFU file content accounting
6) QFU's --
the usage cache can have an inconsistent state.

What do you think, Kinuko-san?

[kinuko, 2011/08/19 11:13:08]

I'm ok with eric's proposal iff we can make sure the ordering and that all the
operations that modify both database and filesystem also mark dirty in the
OFSFU.  (Sounds like it's true after this path name accounting change, but I'd
like to make double-sure)

+      file_system_context(),
+      file_system_operation_context_.src_origin_url(),
+      file_system_operation_context_.src_type()));
+
   FileSystemFileUtilProxy::CreateDirectory(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       exclusive_,
       recursive_,
       callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
@@ skipping 40 matching lines @@
 void FileSystemOperation::DelayedCopyForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
   if (file_system_context()->IsStorageUnlimited(
           file_system_operation_context()->dest_origin_url()) ||
       quota == QuotaFileUtil::kNoLimit) {
     file_system_operation_context_.set_allowed_bytes_growth(
         QuotaFileUtil::kNoLimit);
   } else {
     file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
   }
+
+  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
+      file_system_context(),
+      file_system_operation_context_.dest_origin_url(),
+      file_system_operation_context_.dest_type()));
+
   FileSystemFileUtilProxy::Copy(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       file_system_operation_context_.dest_virtual_path(),
       callback_factory_.NewCallback(
         &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::Move(const GURL& src_path,
@@ skipping 39 matching lines @@
 void FileSystemOperation::DelayedMoveForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
   if (file_system_context()->IsStorageUnlimited(
           file_system_operation_context()->dest_origin_url()) ||
       quota == QuotaFileUtil::kNoLimit) {
     file_system_operation_context_.set_allowed_bytes_growth(
         QuotaFileUtil::kNoLimit);
   } else {
     file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
   }
+
+  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
+      file_system_context(),
+      file_system_operation_context_.dest_origin_url(),
+      file_system_operation_context_.dest_type()));
+
   FileSystemFileUtilProxy::Move(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       file_system_operation_context_.dest_virtual_path(),
       callback_factory_.NewCallback(
         &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::DirectoryExists(const GURL& path) {
@@ skipping 163 matching lines @@
 void FileSystemOperation::DelayedWriteForQuota(quota::QuotaStatusCode status,
                                                int64 usage, int64 quota) {
   if (file_system_context()->IsStorageUnlimited(
           file_system_operation_context()->src_origin_url()) ||
       quota == QuotaFileUtil::kNoLimit) {
     file_system_operation_context_.set_allowed_bytes_growth(
         QuotaFileUtil::kNoLimit);
   } else {
     file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
   }
+
+  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
+      file_system_context(),
+      file_system_operation_context_.src_origin_url(),
+      file_system_operation_context_.src_type()));
+
   FileSystemFileUtilProxy::CreateOrOpen(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
           base::PLATFORM_FILE_ASYNC,
       callback_factory_.NewCallback(
           &FileSystemOperation::OnFileOpenedForWrite));
 }
 
@@ skipping 26 matching lines @@
 void FileSystemOperation::DelayedTruncateForQuota(quota::QuotaStatusCode status,
                                                   int64 usage, int64 quota) {
   if (file_system_context()->IsStorageUnlimited(
           file_system_operation_context()->src_origin_url()) ||
       quota == QuotaFileUtil::kNoLimit) {
     file_system_operation_context_.set_allowed_bytes_growth(
         QuotaFileUtil::kNoLimit);
   } else {
     file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
   }
+
+  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
+      file_system_context(),
+      file_system_operation_context_.src_origin_url(),
+      file_system_operation_context_.src_type()));
+
   FileSystemFileUtilProxy::Truncate(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       length_, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::TouchFile(const GURL& path,
                                     const base::Time& last_access_time,
@@ skipping 76 matching lines @@
                                                   int64 usage, int64 quota) {
   if (file_system_context()->IsStorageUnlimited(
           file_system_operation_context()->dest_origin_url()) ||
       quota == QuotaFileUtil::kNoLimit) {
     file_system_operation_context_.set_allowed_bytes_growth(
         QuotaFileUtil::kNoLimit);
   } else {
     file_system_operation_context_.set_allowed_bytes_growth(quota - usage);
   }
 
+  quota_util_helper_.reset(new ScopedQuotaUtilHelper(
+      file_system_context(),
+      file_system_operation_context_.src_origin_url(),
+      file_system_operation_context_.src_type()));
+
   FileSystemFileUtilProxy::CreateOrOpen(
       file_system_operation_context_,
       proxy_,
       file_system_operation_context_.src_virtual_path(),
       file_flags_,
       callback_factory_.NewCallback(
           &FileSystemOperation::DidOpenFile));
 }
 
 // We can only get here on a write or truncate that's not yet completed.
@@ skipping 301 matching lines @@
   }
   DCHECK(file_system_file_util);
   *file_system_file_util =
       file_system_context()->path_manager()->GetFileSystemFileUtil(*type);
   DCHECK(*file_system_file_util);
 
   return true;
 }
 
 }  // namespace fileapi