base::Bind: Convert FileUtilProxy::WriteCallback.

webkit/plugins/ppapi/quota_file_io.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/plugins/ppapi/quota_file_io.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/memory/scoped_callback_factory.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/task.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 #include "webkit/plugins/ppapi/resource_tracker.h"
 
 using base::PlatformFile;
 using base::PlatformFileError;
 using quota::StorageType;
@@ skipping 36 matching lines @@
   const bool is_will_operation_;
 };
 
 class QuotaFileIO::WriteOperation : public PendingOperationBase {
  public:
   WriteOperation(QuotaFileIO* quota_io,
                  bool is_will_operation,
                  int64_t offset,
                  const char* buffer,
                  int32_t bytes_to_write,
-                 WriteCallback* callback)
+                 const WriteCallback& callback)
       : PendingOperationBase(quota_io, is_will_operation),
         offset_(offset),
         bytes_to_write_(bytes_to_write),
         callback_(callback),
         finished_(false),
         status_(base::PLATFORM_FILE_OK),
         bytes_written_(0),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-        runnable_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
+        ALLOW_THIS_IN_INITIALIZER_LIST(runnable_factory_(this)) {
     if (!is_will_operation) {
       // TODO(kinuko): check the API convention if we really need to keep a
       // copy of the buffer during the async write operations.
       buffer_.reset(new char[bytes_to_write]);
       memcpy(buffer_.get(), buffer, bytes_to_write);
     }
   }
   virtual ~WriteOperation() {}
   virtual void Run() OVERRIDE {
     DCHECK(quota_io_);
@@ skipping 10 matching lines @@
 
     PluginDelegate* plugin_delegate = quota_io_->GetPluginDelegate();
     if (!plugin_delegate) {
       DidFail(base::PLATFORM_FILE_ERROR_FAILED);
       return;
     }
 
     if (!base::FileUtilProxy::Write(
             plugin_delegate->GetFileThreadMessageLoopProxy(),
             quota_io_->file_, offset_, buffer_.get(), bytes_to_write_,
-            callback_factory_.NewCallback(&WriteOperation::DidFinish))) {
+            base::Bind(&WriteOperation::DidFinish,
+                       weak_factory_.GetWeakPtr()))) {
       DidFail(base::PLATFORM_FILE_ERROR_FAILED);
       return;
     }
   }
 
   virtual void DidFail(PlatformFileError error) OVERRIDE {
     DidFinish(error, 0);
   }
 
   bool finished() const { return finished_; }
 
   virtual void WillRunCallback() {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, runnable_factory_.NewRunnableMethod(
             &WriteOperation::RunCallback));
   }
 
  private:
   void DidFinish(PlatformFileError status, int bytes_written) {
     finished_ = true;
     status_ = status;
     bytes_written_ = bytes_written;
     int64_t max_offset =
         (status != base::PLATFORM_FILE_OK) ? 0 : offset_ + bytes_written;
     // This may delete itself by calling RunCallback.
     quota_io_->DidWrite(this, max_offset);
   }
 
   virtual void RunCallback() {
-    DCHECK(callback_.get());
-    callback_->Run(status_, bytes_written_);
-    callback_.reset();
+    DCHECK_EQ(false, callback_.is_null());
+    callback_.Run(status_, bytes_written_);
     delete this;
   }
 
   const int64_t offset_;
   scoped_array<char> buffer_;
   const int32_t bytes_to_write_;
-  scoped_ptr<WriteCallback> callback_;
+  WriteCallback callback_;
   bool finished_;
   PlatformFileError status_;
   int64_t bytes_written_;
-  base::ScopedCallbackFactory<WriteOperation> callback_factory_;
+  base::WeakPtrFactory<WriteOperation> weak_factory_;
   ScopedRunnableMethodFactory<WriteOperation> runnable_factory_;
 };
 
 class QuotaFileIO::SetLengthOperation : public PendingOperationBase {
  public:
   SetLengthOperation(QuotaFileIO* quota_io,
                      bool is_will_operation,
                      int64_t length,
                      StatusCallback* callback)
       : PendingOperationBase(quota_io, is_will_operation),
@@ skipping 72 matching lines @@
 QuotaFileIO::~QuotaFileIO() {
   // Note that this doesn't dispatch pending callbacks.
   STLDeleteContainerPointers(pending_operations_.begin(),
                              pending_operations_.end());
   STLDeleteContainerPointers(pending_callbacks_.begin(),
                              pending_callbacks_.end());
 }
 
 bool QuotaFileIO::Write(
     int64_t offset, const char* buffer, int32_t bytes_to_write,
-    WriteCallback* callback) {
-  if (bytes_to_write <= 0) {
-    delete callback;
+    const WriteCallback& callback) {
+  if (bytes_to_write <= 0)
     return false;
-  }
+
   WriteOperation* op = new WriteOperation(
       this, false, offset, buffer, bytes_to_write, callback);
   return RegisterOperationForQuotaChecks(op);
 }
 
 bool QuotaFileIO::SetLength(int64_t length, StatusCallback* callback) {
   DCHECK(pending_operations_.empty());
   SetLengthOperation* op = new SetLengthOperation(
       this, false, length, callback);
   return RegisterOperationForQuotaChecks(op);
 }
 
 bool QuotaFileIO::WillWrite(
-    int64_t offset, int32_t bytes_to_write, WriteCallback* callback) {
+    int64_t offset, int32_t bytes_to_write, const WriteCallback& callback) {
   WriteOperation* op = new WriteOperation(
       this, true, offset, NULL, bytes_to_write, callback);
   return RegisterOperationForQuotaChecks(op);
 }
 
 bool QuotaFileIO::WillSetLength(int64_t length, StatusCallback* callback) {
   DCHECK(pending_operations_.empty());
   SetLengthOperation* op = new SetLengthOperation(this, true, length, callback);
   return RegisterOperationForQuotaChecks(op);
 }
@@ skipping 125 matching lines @@
 
 
   PluginDelegate* plugin_delegate = GetPluginDelegate();
   if (plugin_delegate)
     plugin_delegate->DidUpdateFile(file_url_, delta);
   inflight_operations_ = 0;
 }
 
 }  // namespace ppapi
 }  // namespace webkit