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

webkit/fileapi/file_system_operation.h

 // 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.
 
 #ifndef WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_
 
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/process.h"
 #include "googleurl/src/gurl.h"
+#include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_types.h"
-#include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/quota/quota_manager.h"
 
 namespace base {
 class Time;
 }
 
 namespace net {
 class URLRequest;
 class URLRequestContext;
 }  // namespace net
 
 class GURL;
 
 namespace fileapi {
 
 class FileSystemCallbackDispatcher;
 class FileSystemContext;
 class FileWriterDelegate;
 class FileSystemOperationTest;
+class FileSystemQuotaUtil;
 
 // This class is designed to serve one-time file system operation per instance.
 // Only one method(CreateFile, CreateDirectory, Copy, Move, DirectoryExists,
 // GetMetadata, ReadDirectory and Remove) may be called during the lifetime of
 // this object and it should be called no more than once.
 // This class is self-destructed and an instance automatically gets deleted
 // when its operation is finished.
 class FileSystemOperation {
  public:
   // |dispatcher| will be owned by this class.
@@ skipping 34 matching lines @@
       const GURL& path,
       int file_flags,
       base::ProcessHandle peer_handle);
 
   // Try to cancel the current operation [we support cancelling write or
   // truncate only].  Report failure for the current operation, then tell the
   // passed-in operation to report success.
   void Cancel(FileSystemOperation* cancel_operation);
 
  private:
+  class ScopedQuotaUtilHelper {

[kinuko, 2011/08/25 09:12:00]

I think we can just declare 'class ScopedQuotaUtilHelper' here and move all the
class definition/impl to .cc?

[Dai Mikurube (NOT FULLTIME), 2011/08/25 09:19:46]

We have to pass this quota_util_helper from a function to its delayed function
(e.g. CreateFile to DelayedCreateFileForQuota).  In order to pass it, it should
be a member variable of FileSystemOperation.  It's the reason why this class is
declared in the header file.

[kinuko, 2011/08/29 05:22:51]

If keeping it as a member var is the only concern we can do that while moving
the definition to .cc:

class FileSystemOperation {
  ...
 private
  class ScopedQuotaUtilHelper;
  scoped_ptr<ScopedQuotaUtilHelper> quota_util_helper_;
};

in .cc:

class FileSystemOperation::ScopedQuotaUtilHelper {
 public:
  ...
};

(Your version definitely works and it's not a big issue, but it'd be preferable
to hide unnecessary code in .cc and to keep .h files lightweight for build-time
optimization)

[Dai Mikurube (NOT FULLTIME), 2011/08/30 08:03:01]

Thanks for the information!  Done it.

+   public:
+    explicit 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);
+  };
+
   FileSystemContext* file_system_context() const {
     return file_system_operation_context_.file_system_context();
   }
 
   FileSystemOperationContext* file_system_operation_context() {
     return &file_system_operation_context_;
   }
 
   friend class FileSystemOperationTest;
   friend class FileSystemOperationWriteTest;
@@ skipping 127 matching lines @@
 
   // Proxy for calling file_util_proxy methods.
   scoped_refptr<base::MessageLoopProxy> proxy_;
 
   scoped_ptr<FileSystemCallbackDispatcher> dispatcher_;
 
   FileSystemOperationContext file_system_operation_context_;
 
   base::ScopedCallbackFactory<FileSystemOperation> callback_factory_;
 
+  scoped_ptr<ScopedQuotaUtilHelper> quota_util_helper_;
+
   // These are all used only by Write().
   friend class FileWriterDelegate;
   scoped_ptr<FileWriterDelegate> file_writer_delegate_;
   scoped_ptr<net::URLRequest> blob_request_;
   scoped_ptr<FileSystemOperation> cancel_operation_;
 
   // Used only by OpenFile, in order to clone the file handle back to the
   // requesting process.
   base::ProcessHandle peer_handle_;
 
@@ skipping 12 matching lines @@
 
   // Length to be truncated.
   int64 length_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperation);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_