base::Bind: Convert FileUtilProxy::WriteCallback.

base/file_util_proxy.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 "base/file_util_proxy.h"
 
 #include "base/message_loop_proxy.h"
 
 // TODO(jianli): Move the code from anonymous namespace to base namespace so
 // that all of the base:: prefixes would be unnecessary.
@@ skipping 546 matching lines @@
   base::FileUtilProxy::ReadCallback callback_;
   int bytes_read_;
 };
 
 class RelayWrite : public MessageLoopRelay {
  public:
   RelayWrite(base::PlatformFile file,
              int64 offset,
              const char* buffer,
              int bytes_to_write,
-             base::FileUtilProxy::WriteCallback* callback)
+             const base::FileUtilProxy::WriteCallback& callback)
       : file_(file),
         offset_(offset),
         buffer_(new char[bytes_to_write]),
         bytes_to_write_(bytes_to_write),
         callback_(callback),
         bytes_written_(0) {
     memcpy(buffer_.get(), buffer, bytes_to_write);
   }
 
  protected:
   virtual void RunWork() {
     bytes_written_ = base::WritePlatformFile(file_, offset_, buffer_.get(),
                                              bytes_to_write_);
     if (bytes_written_ < 0)
       set_error_code(base::PLATFORM_FILE_ERROR_FAILED);
   }
 
   virtual void RunCallback() {
-    if (callback_) {
-      callback_->Run(error_code(), bytes_written_);
-      delete callback_;
-    }
+    if (!callback_.is_null())
+      callback_.Run(error_code(), bytes_written_);
   }
 
  private:
   base::PlatformFile file_;
   int64 offset_;
   scoped_array<char> buffer_;
   int bytes_to_write_;
-  base::FileUtilProxy::WriteCallback* callback_;
+  base::FileUtilProxy::WriteCallback callback_;
   int bytes_written_;
 };
 
 class RelayTouch : public RelayWithStatusCallback {
  public:
   RelayTouch(base::PlatformFile file,
              const base::Time& last_access_time,
              const base::Time& last_modified_time,
              base::FileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(callback),
@@ skipping 247 matching lines @@
                new RelayRead(file, offset, bytes_to_read, callback));
 }
 
 // static
 bool FileUtilProxy::Write(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
     int64 offset,
     const char* buffer,
     int bytes_to_write,
-    WriteCallback* callback) {
-  if (bytes_to_write <= 0) {
-    delete callback;
+    const WriteCallback& callback) {
+  if (bytes_to_write <= 0)
     return false;
-  }
+
   return Start(FROM_HERE, message_loop_proxy,
                new RelayWrite(file, offset, buffer, bytes_to_write, callback));
 }
 
 // static
 bool FileUtilProxy::Touch(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
@@ skipping 37 matching lines @@
 
 // static
 bool FileUtilProxy::Flush(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
     StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayFlush(file, callback));
 }
 
 }  // namespace base