base::Bind: Convert FileUtilProxy::WriteCallback.

BUG=none
TEST=none

R=csilv@chromium.org

Review URL: http://codereview.chromium.org/8321014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@105912 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 41 insertions, 40 deletions

diff --git a/webkit/plugins/ppapi/ppb_file_io_impl.cc b/webkit/plugins/ppapi/ppb_file_io_impl.cc
index 26f0154..62c4715 100644
--- a/webkit/plugins/ppapi/ppb_file_io_impl.cc
+++ b/webkit/plugins/ppapi/ppb_file_io_impl.cc
@@ -201,13 +201,15 @@ int32_t PPB_FileIO_Impl::Write(int64_t offset,
   if (quota_file_io_.get()) {
     if (!quota_file_io_->Write(
             offset, buffer, bytes_to_write,
-            callback_factory_.NewCallback(&PPB_FileIO_Impl::WriteCallback)))
+            base::Bind(&PPB_FileIO_Impl::WriteCallback,
+                       weak_factory_.GetWeakPtr())))
       return PP_ERROR_FAILED;
   } else {
     if (!base::FileUtilProxy::Write(
-            plugin_delegate->GetFileThreadMessageLoopProxy(),
-            file_, offset, buffer, bytes_to_write,
-            callback_factory_.NewCallback(&PPB_FileIO_Impl::WriteCallback)))
+            plugin_delegate->GetFileThreadMessageLoopProxy(), file_, offset,
+            buffer, bytes_to_write,
+            base::Bind(&PPB_FileIO_Impl::WriteCallback,
+                       weak_factory_.GetWeakPtr())))
       return PP_ERROR_FAILED;
   }
 
@@ -292,7 +294,8 @@ int32_t PPB_FileIO_Impl::WillWrite(int64_t offset,
 
   if (!quota_file_io_->WillWrite(
           offset, bytes_to_write,
-          callback_factory_.NewCallback(&PPB_FileIO_Impl::WillWriteCallback)))
+          base::Bind(&PPB_FileIO_Impl::WillWriteCallback,
+                     weak_factory_.GetWeakPtr())))
     return PP_ERROR_FAILED;
 
   RegisterCallback(OPERATION_EXCLUSIVE, callback, NULL);
diff --git a/webkit/plugins/ppapi/quota_file_io.cc b/webkit/plugins/ppapi/quota_file_io.cc
index c0210a3..53409d4 100644
--- a/webkit/plugins/ppapi/quota_file_io.cc
+++ b/webkit/plugins/ppapi/quota_file_io.cc
@@ -8,6 +8,7 @@
 
 #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"
@@ -64,7 +65,7 @@ class QuotaFileIO::WriteOperation : public PendingOperationBase {
                  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),
@@ -72,8 +73,8 @@ class QuotaFileIO::WriteOperation : public PendingOperationBase {
         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.
@@ -104,7 +105,8 @@ class QuotaFileIO::WriteOperation : public PendingOperationBase {
     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;
     }
@@ -134,20 +136,19 @@ class QuotaFileIO::WriteOperation : public PendingOperationBase {
   }
 
   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_;
 };
 
@@ -240,11 +241,10 @@ QuotaFileIO::~QuotaFileIO() {
 
 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);
@@ -258,7 +258,7 @@ bool QuotaFileIO::SetLength(int64_t length, StatusCallback* callback) {
 }
 
 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);
diff --git a/webkit/plugins/ppapi/quota_file_io.h b/webkit/plugins/ppapi/quota_file_io.h
index 9c47113..a6fcfa9 100644
--- a/webkit/plugins/ppapi/quota_file_io.h
+++ b/webkit/plugins/ppapi/quota_file_io.h
@@ -47,10 +47,10 @@ class QuotaFileIO {
   bool Write(int64_t offset,
              const char* buffer,
              int32_t bytes_to_write,
-             WriteCallback* callback);
+             const WriteCallback& callback);
   bool WillWrite(int64_t offset,
                  int32_t bytes_to_write,
-                 WriteCallback* callback);
+                 const WriteCallback& callback);
 
   bool SetLength(int64_t length, StatusCallback* callback);
   bool WillSetLength(int64_t length, StatusCallback* callback);
diff --git a/webkit/plugins/ppapi/quota_file_io_unittest.cc b/webkit/plugins/ppapi/quota_file_io_unittest.cc
index 2b7d575..d64f3c5 100644
--- a/webkit/plugins/ppapi/quota_file_io_unittest.cc
+++ b/webkit/plugins/ppapi/quota_file_io_unittest.cc
@@ -35,7 +35,7 @@ class QuotaMockPluginDelegate : public MockPluginDelegate {
       : available_space_(0),
         will_update_count_(0),
         file_thread_(MessageLoopProxy::current()),
-        weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   }
   virtual ~QuotaMockPluginDelegate() {}
 
@@ -47,12 +47,11 @@ class QuotaMockPluginDelegate : public MockPluginDelegate {
       const GURL& origin,
       quota::StorageType type,
       const Callback& callback) OVERRIDE {
-    DCHECK(!callback.is_null());
+    DCHECK_EQ(false, callback.is_null());
     MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(
             &QuotaMockPluginDelegate::RunAvailableSpaceCallback,
-            weak_ptr_factory_.GetWeakPtr(),
-            callback));
+            weak_factory_.GetWeakPtr(), callback));
   }
 
   virtual void WillUpdateFile(const GURL& file_path) OVERRIDE {
@@ -79,14 +78,15 @@ class QuotaMockPluginDelegate : public MockPluginDelegate {
   int will_update_count_;
   GURL file_path_;
   scoped_refptr<MessageLoopProxy> file_thread_;
-  base::WeakPtrFactory<QuotaMockPluginDelegate> weak_ptr_factory_;
+  base::WeakPtrFactory<QuotaMockPluginDelegate> weak_factory_;
 };
 }  // namespace
 
 class QuotaFileIOTest : public PpapiUnittest {
  public:
   QuotaFileIOTest()
-      : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+      : ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
   virtual void SetUp() OVERRIDE {
     PpapiUnittest::SetUp();
@@ -123,14 +123,13 @@ class QuotaFileIOTest : public PpapiUnittest {
 
   void WriteTestBody(bool will_operation) {
     // Attempt to write zero bytes.
-    EXPECT_FALSE(quota_file_io_->Write(0, "data", 0,
-                                       callback_factory_.NewCallback(
-                                           &QuotaFileIOTest::DidWrite)));
+    EXPECT_FALSE(quota_file_io_->Write(
+        0, "data", 0,
+        base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr())));
     // Attempt to write negative number of bytes.
-    EXPECT_FALSE(quota_file_io_->Write(0, "data",
-                                       std::numeric_limits<int32_t>::min(),
-                                       callback_factory_.NewCallback(
-                                           &QuotaFileIOTest::DidWrite)));
+    EXPECT_FALSE(quota_file_io_->Write(
+        0, "data", std::numeric_limits<int32_t>::min(),
+        base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr())));
 
     quota_plugin_delegate()->set_available_space(100);
     std::string read_buffer;
@@ -355,14 +354,12 @@ class QuotaFileIOTest : public PpapiUnittest {
   void Write(int64_t offset, const std::string& data, bool will_operation) {
     if (will_operation) {
       ASSERT_TRUE(quota_file_io_->WillWrite(
-                      offset, data.size(),
-                      callback_factory_.NewCallback(
-                          &QuotaFileIOTest::DidWrite)));
+          offset, data.size(),
+          base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr())));
     } else {
       ASSERT_TRUE(quota_file_io_->Write(
-                      offset, data.c_str(), data.size(),
-                      callback_factory_.NewCallback(
-                          &QuotaFileIOTest::DidWrite)));
+          offset, data.c_str(), data.size(),
+          base::Bind(&QuotaFileIOTest::DidWrite, weak_factory_.GetWeakPtr())));
     }
   }
 
@@ -434,6 +431,7 @@ class QuotaFileIOTest : public PpapiUnittest {
   std::deque<int> bytes_written_;
   std::deque<PlatformFileError> status_;
   base::ScopedCallbackFactory<QuotaFileIOTest> callback_factory_;
+  base::WeakPtrFactory<QuotaFileIOTest> weak_factory_;
 };
 
 TEST_F(QuotaFileIOTest, Write) {