Change webkit/{fileapi,quota} code to use TaskRunner.

webkit/fileapi/file_writer_delegate.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/callback.h"
 #include "base/file_util_proxy.h"
-#include "base/message_loop.h"
+#include "base/message_loop_proxy.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_quota_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 
 namespace fileapi {
 
 static const int kReadBufSize = 32768;
 
 namespace {
 
 typedef base::Callback<void(base::PlatformFileError /* error code */,
                             const base::PlatformFileInfo& /* file_info */)>
     InitializeTaskCallback;
 
 class InitializeTask : public base::RefCountedThreadSafe<InitializeTask> {
  public:
   InitializeTask(
       base::PlatformFile file,
       const FileSystemPath& path,
       FileSystemOperationContext* context,
       const InitializeTaskCallback& callback)
-      : origin_message_loop_proxy_(
-            base::MessageLoopProxy::current()),
+      : origin_task_runner_(base::MessageLoopProxy::current()),
         error_code_(base::PLATFORM_FILE_OK),
         file_(file),
         path_(path),
         context_(*context),
         callback_(callback) {
     DCHECK_EQ(false, callback.is_null());
   }
 
-  bool Start(scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+  bool Start(base::TaskRunner* task_runner,
              const tracked_objects::Location& from_here) {
-    return message_loop_proxy->PostTask(
+    return task_runner->PostTask(
         from_here,
         base::Bind(&InitializeTask::ProcessOnTargetThread, this));
   }
 
  private:
   friend class base::RefCountedThreadSafe<InitializeTask>;
 
   void RunCallback() {
     callback_.Run(error_code_, file_info_);
   }
 
   void ProcessOnTargetThread() {
     DCHECK(context_.file_system_context());
     FileSystemQuotaUtil* quota_util = context_.file_system_context()->
         GetQuotaUtil(path_.type());
     if (quota_util) {
       DCHECK(quota_util->proxy());
       quota_util->proxy()->StartUpdateOrigin(path_.origin(), path_.type());
     }
     if (!base::GetPlatformFileInfo(file_, &file_info_))
       error_code_ = base::PLATFORM_FILE_ERROR_FAILED;
-    origin_message_loop_proxy_->PostTask(
+    origin_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&InitializeTask::RunCallback, this));
   }
 
-  scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
+  scoped_refptr<base::TaskRunner> origin_task_runner_;

[michaeln, 2012/04/27 01:04:03]

My vote would be to keep this as a MLP for clarity or maybe switch it to
SingleThreadTaskRunner.

[kinuko, 2012/04/27 10:10:29]

Yup, I reverted this change.

   base::PlatformFileError error_code_;
 
   base::PlatformFile file_;
   FileSystemPath path_;
   FileSystemOperationContext context_;
   InitializeTaskCallback callback_;
 
   base::PlatformFileInfo file_info_;
 };
 
 }  // namespace (anonymous)
 
 FileWriterDelegate::FileWriterDelegate(
     FileSystemOperation* file_system_operation,
     const FileSystemPath& path,
     int64 offset,
-    scoped_refptr<base::MessageLoopProxy> proxy)
+    base::TaskRunner* task_runner)
     : file_system_operation_(file_system_operation),
       file_(base::kInvalidPlatformFileValue),
       path_(path),
       offset_(offset),
-      proxy_(proxy),
+      task_runner_(task_runner),
       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)),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 FileWriterDelegate::~FileWriterDelegate() {
@@ skipping 26 matching lines @@
 void FileWriterDelegate::Start(base::PlatformFile file,
                                net::URLRequest* request) {
   file_ = file;
   request_ = request;
 
   scoped_refptr<InitializeTask> relay = new InitializeTask(
       file_, path_,
       file_system_operation_context(),
       base::Bind(&FileWriterDelegate::OnGetFileInfoAndCallStartUpdate,
                  weak_factory_.GetWeakPtr()));
-  relay->Start(proxy_, FROM_HERE);
+  relay->Start(task_runner_, 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,
@@ skipping 41 matching lines @@
     return;
   }
   OnDataReceived(bytes_read);
 }
 
 void FileWriterDelegate::Read() {
   bytes_written_ = 0;
   bytes_read_ = 0;
   if (request_->Read(io_buffer_.get(), io_buffer_->size(),
                      &bytes_read_)) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoopProxy::current()->PostTask(

[michaeln, 2012/04/27 01:04:03]

nit: change not really needed (afaict)

[kinuko, 2012/04/27 10:10:29]

This was another not-indended-fix... reverted.

         FROM_HERE,
         base::Bind(&FileWriterDelegate::OnDataReceived,
                    weak_factory_.GetWeakPtr(), bytes_read_));
   } else if (!request_->status().is_io_pending()) {
     OnError(base::PLATFORM_FILE_ERROR_FAILED);
   }
 }
 
 void FileWriterDelegate::OnDataReceived(int bytes_read) {
   bytes_read_ = bytes_read;
@@ skipping 23 matching lines @@
   int64 bytes_to_write = bytes_read_ - bytes_written_;
   if (bytes_to_write > allowed_bytes_to_write_ - total_bytes_written_)
     bytes_to_write = allowed_bytes_to_write_ - total_bytes_written_;
 
   int write_response =
       file_stream_->Write(cursor_,
                           static_cast<int>(bytes_to_write),
                           base::Bind(&FileWriterDelegate::OnDataWritten,
                                      weak_factory_.GetWeakPtr()));
   if (write_response > 0)
-    MessageLoop::current()->PostTask(
+    base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(&FileWriterDelegate::OnDataWritten,
                    weak_factory_.GetWeakPtr(), write_response));
   else if (net::ERR_IO_PENDING != write_response)
     OnError(base::PLATFORM_FILE_ERROR_FAILED);
 }
 
 void FileWriterDelegate::OnDataWritten(int write_response) {
   if (write_response > 0) {
     OnProgress(write_response, false);
@@ skipping 58 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(
       path_.type());
 }
 
 }  // namespace fileapi