Pepper quota support

webkit/fileapi/file_writer_delegate.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_writer_delegate.h"
 
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/net_errors.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation.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/quota_file_util.h"
 
 namespace fileapi {
 
 static const int kReadBufSize = 32768;
 
-namespace {
-
-typedef Callback2<base::PlatformFileError /* error code */,
-                  const base::PlatformFileInfo& /* file_info */
-                  >::Type InitializeTaskCallback;
-
-class InitializeTask : public base::RefCountedThreadSafe<InitializeTask> {
- public:
-  InitializeTask(
-      base::PlatformFile file,
-      FileSystemOperationContext* context,
-      InitializeTaskCallback* callback)
-      : origin_message_loop_proxy_(
-            base::MessageLoopProxy::CreateForCurrentThread()),
-        error_code_(base::PLATFORM_FILE_OK),
-        file_(file),
-        context_(*context),
-        callback_(callback) {
-    DCHECK(callback);
-  }
-
-  bool Start(scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
-             const tracked_objects::Location& from_here) {
-    return message_loop_proxy->PostTask(from_here, NewRunnableMethod(this,
-        &InitializeTask::ProcessOnTargetThread));
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<InitializeTask>;
-
-  void RunCallback() {
-    callback_->Run(error_code_, file_info_);
-    delete callback_;
-  }
-
-  void ProcessOnTargetThread() {
-    DCHECK(context_.file_system_context());
-    FileSystemQuotaUtil* quota_util = context_.file_system_context()->
-        GetQuotaUtil(context_.src_type());
-    if (quota_util) {
-      DCHECK(quota_util->proxy());
-      quota_util->proxy()->StartUpdateOrigin(
-          context_.src_origin_url(), context_.src_type());
-    }
-    if (!base::GetPlatformFileInfo(file_, &file_info_))
-      error_code_ = base::PLATFORM_FILE_ERROR_FAILED;
-    origin_message_loop_proxy_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &InitializeTask::RunCallback));
-  }
-
-  scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
-  base::PlatformFileError error_code_;
-
-  base::PlatformFile file_;
-  FileSystemOperationContext context_;
-  InitializeTaskCallback* callback_;
-
-  base::PlatformFileInfo file_info_;
-};
-
-}  // namespace (anonymous)
-
 FileWriterDelegate::FileWriterDelegate(
     FileSystemOperation* file_system_operation, int64 offset,
     scoped_refptr<base::MessageLoopProxy> proxy)
     : file_system_operation_(file_system_operation),
       file_(base::kInvalidPlatformFileValue),
       offset_(offset),
       proxy_(proxy),
       bytes_written_backlog_(0),
       bytes_written_(0),
       bytes_read_(0),
       total_bytes_written_(0),
       allowed_bytes_to_write_(0),
       io_buffer_(new net::IOBufferWithSize(kReadBufSize)),
       io_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                    &FileWriterDelegate::OnDataWritten),
       method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 FileWriterDelegate::~FileWriterDelegate() {
 }
 
-void FileWriterDelegate::OnGetFileInfoAndCallStartUpdate(
-    base::PlatformFileError error,
-    const base::PlatformFileInfo& file_info) {
-  if (error) {
-    OnError(error);
-    return;
+void FileWriterDelegate::Start(base::PlatformFile file,
+                               int64 file_size,
+                               net::URLRequest* request) {
+  file_ = file;
+  size_ = file_size;
+  request_ = request;
+
+  DCHECK(file_system_operation_);
+  FileSystemQuotaUtil* quota_util =
+      file_system_operation_->file_system_context()->GetQuotaUtil(
+      file_system_operation_context()->src_type());
+  if (quota_util) {
+    DCHECK(quota_util->proxy());
+    quota_util->proxy()->StartUpdateOrigin(
+        file_system_operation_context()->src_origin_url(),
+        file_system_operation_context()->src_type());
   }
+
   int64 allowed_bytes_growth =
       file_system_operation_context()->allowed_bytes_growth();
   if (allowed_bytes_growth == QuotaFileUtil::kNoLimit ||
       file_system_operation_->file_system_context()->IsStorageUnlimited(
           file_system_operation_context()->src_origin_url())) {
     // TODO(kinuko): kNoLimit is kint64max therefore all the calculation/
     // comparison with the value should just work, but we should drop
     // such implicit assumption and should use an explicit boolean flag
     // or something.
     allowed_bytes_to_write_ = QuotaFileUtil::kNoLimit;
   } else {
     if (allowed_bytes_growth < 0)
       allowed_bytes_growth = 0;
-    allowed_bytes_to_write_ = file_info.size - offset_ + allowed_bytes_growth;
+    allowed_bytes_to_write_ = file_size - offset_ + allowed_bytes_growth;
   }
-  size_ = file_info.size;
   file_stream_.reset(new net::FileStream(file_,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
       base::PLATFORM_FILE_ASYNC));
   request_->Start();
 }
 
-void FileWriterDelegate::Start(base::PlatformFile file,
-                               net::URLRequest* request) {
-  file_ = file;
-  request_ = request;
-
-  scoped_refptr<InitializeTask> relay = new InitializeTask(
-      file_, file_system_operation_context(),
-      callback_factory_.NewCallback(
-          &FileWriterDelegate::OnGetFileInfoAndCallStartUpdate));
-  relay->Start(proxy_, FROM_HERE);
-}
-
 void FileWriterDelegate::OnReceivedRedirect(
     net::URLRequest* request, const GURL& new_url, bool* defer_redirect) {
   NOTREACHED();
   OnError(base::PLATFORM_FILE_ERROR_SECURITY);
 }
 
 void FileWriterDelegate::OnAuthRequired(
     net::URLRequest* request, net::AuthChallengeInfo* auth_info) {
   NOTREACHED();
   OnError(base::PLATFORM_FILE_ERROR_SECURITY);
@@ skipping 163 matching lines @@
 
 FileSystemQuotaUtil* FileWriterDelegate::quota_util() const {
   DCHECK(file_system_operation_);
   DCHECK(file_system_operation_->file_system_context());
   DCHECK(file_system_operation_->file_system_operation_context());
   return file_system_operation_->file_system_context()->GetQuotaUtil(
       file_system_operation_context()->src_type());
 }
 
 }  // namespace fileapi