Pepper quota support

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"
@@ skipping 32 matching lines @@
 // 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.
   // |file_system_file_util| is optional; if supplied, it will not be deleted by
   // the class.  It's expecting a pointer to a singleton.
-  FileSystemOperation(FileSystemCallbackDispatcher* dispatcher,
-                      scoped_refptr<base::MessageLoopProxy> proxy,
-                      FileSystemContext* file_system_context,
-                      FileSystemFileUtil* file_system_file_util);
+ FileSystemOperation(FileSystemCallbackDispatcher* dispatcher,
+                     scoped_refptr<base::MessageLoopProxy> proxy,
+                     FileSystemContext* file_system_context,
+                     FileSystemFileUtil* file_system_file_util);
   virtual ~FileSystemOperation();
 
   void OpenFileSystem(const GURL& origin_url,
                       fileapi::FileSystemType type,
                       bool create);
   void CreateFile(const GURL& path,
                   bool exclusive);
   void CreateDirectory(const GURL& path,
                        bool exclusive,
                        bool recursive);
@@ skipping 34 matching lines @@
   }
 
   friend class FileSystemOperationTest;
   friend class FileSystemOperationWriteTest;
   friend class FileWriterDelegateTest;
   friend class FileSystemTestOriginHelper;
   friend class FileSystemQuotaTest;
 
   bool GetUsageAndQuotaThenCallback(
       const GURL& origin_url,
+      FileSystemType type,
       quota::QuotaManager::GetUsageAndQuotaCallback* callback);
 
   void DelayedCopyForQuota(quota::QuotaStatusCode status,
                            int64 usage, int64 quota);
   void DelayedMoveForQuota(quota::QuotaStatusCode status,
                            int64 usage, int64 quota);
   void DelayedWriteForQuota(quota::QuotaStatusCode status,
                             int64 usage, int64 quota);
   void DelayedTruncateForQuota(quota::QuotaStatusCode status,
                                int64 usage, int64 quota);
@@ skipping 27 matching lines @@
       base::PlatformFileError rv,
       const std::vector<base::FileUtilProxy::Entry>& entries);
   void DidWrite(
       base::PlatformFileError rv,
       int64 bytes,
       bool complete);
   void DidTouchFile(base::PlatformFileError rv);
   void DidOpenFile(
       base::PlatformFileError rv,
       base::PassPlatformFile file,
-      bool created);
+      bool created,
+      int64 file_size);
 
   // Helper for Write().
   void OnFileOpenedForWrite(
       base::PlatformFileError rv,
       base::PassPlatformFile file,
-      bool created);
+      bool created,
+      int64 file_size);
 
   // Checks the validity of a given |path| for reading, cracks the path into
   // root URL and virtual path components, and returns the correct
   // FileSystemFileUtil subclass for this type.
   // Returns true if the given |path| is a valid FileSystem path.
   // Otherwise it calls dispatcher's DidFail method with
   // PLATFORM_FILE_ERROR_SECURITY and returns false.
   // (Note: this doesn't delete this when it calls DidFail and returns false;
   // it's the caller's responsibility.)
   bool VerifyFileSystemPathForRead(const GURL& path,
@@ skipping 64 matching lines @@
   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_;
 
   // Length to be truncated.
   int64 length_;
 
+  // Indicates whether this operation may modify the filesystem or not.
+  bool is_write_operation_;
+
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperation);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_