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 {
 
+class FileSystemOperation::ScopedQuotaUtilHelper {
+ public:
+  ScopedQuotaUtilHelper(FileSystemContext* context,
+                        const GURL& origin_url,
+                        FileSystemType type);
+  ~ScopedQuotaUtilHelper();
+
+ private:
+  FileSystemQuotaUtil* quota_util_;
+  const GURL& origin_url_;
+  FileSystemType type_;
+  DISALLOW_COPY_AND_ASSIGN(ScopedQuotaUtilHelper);
+};
+
+FileSystemOperation::ScopedQuotaUtilHelper::ScopedQuotaUtilHelper(
+    FileSystemContext* context, const GURL& origin_url, FileSystemType type)
+    : origin_url_(origin_url), type_(type) {
+  DCHECK(context);
+  DCHECK(type != kFileSystemTypeUnknown);

[ericu, 2011/08/30 17:50:29]

It would be safer to check that it's one of the known types.

[Dai Mikurube (NOT FULLTIME), 2011/08/31 07:12:02]

Thanks.  I guess we want some other opinion on this.  There're many DCHECKs like
this.  We can fix all of such DCHECKs in another change.

What do you think, Kinuko-san?

[kinuko, 2011/08/31 07:25:34]

Basically if it's one of the types that doesn't support quota GetQuotaUtil(type)
should return NULL, so I think the check (type != Unknown) would be safe enough.

Btw DCHECK_NE(type, kFileSystemTypeUnknown) would be a preferred way according
to lint.

+  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 61 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_,
       src_virtual_path_,
       callback_factory_.NewCallback(
           exclusive_ ? &FileSystemOperation::DidEnsureFileExistsExclusive
                      : &FileSystemOperation::DidEnsureFileExistsNonExclusive));
 }
 
 void FileSystemOperation::CreateDirectory(const GURL& path,
@@ skipping 28 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(
+      file_system_context(),
+      file_system_operation_context_.src_origin_url(),
+      file_system_operation_context_.src_type()));
+
   FileSystemFileUtilProxy::CreateDirectory(
       file_system_operation_context_,
       proxy_,
       src_virtual_path_,
       exclusive_,
       recursive_,
       callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
@@ skipping 36 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_,
       src_virtual_path_,
       dest_virtual_path_,
       callback_factory_.NewCallback(
         &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::Move(const GURL& src_path,
@@ skipping 35 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_,
       src_virtual_path_,
       dest_virtual_path_,
       callback_factory_.NewCallback(
         &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::DirectoryExists(const GURL& path) {
@@ skipping 161 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_,
       src_virtual_path_,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
           base::PLATFORM_FILE_ASYNC,
       callback_factory_.NewCallback(
           &FileSystemOperation::OnFileOpenedForWrite));
 }
 
@@ skipping 24 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_,
       src_virtual_path_,
       length_, callback_factory_.NewCallback(
           &FileSystemOperation::DidFinishFileOperation));
 }
 
 void FileSystemOperation::TouchFile(const GURL& path,
                                     const base::Time& last_access_time,
@@ skipping 74 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_,
       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 300 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