base::Bind: Convert FileUtilProxy::GetFileInfoCallback.

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 451 matching lines @@
 
  private:
   base::FileUtilProxy::ReadDirectoryCallback* callback_;
   FilePath file_path_;
   std::vector<base::FileUtilProxy::Entry> entries_;
 };
 
 class RelayGetFileInfo : public MessageLoopRelay {
  public:
   RelayGetFileInfo(const FilePath& file_path,
-                   base::FileUtilProxy::GetFileInfoCallback* callback)
+                   const base::FileUtilProxy::GetFileInfoCallback& callback)
       : callback_(callback),
         file_path_(file_path) {
-    DCHECK(callback);
+    DCHECK_EQ(false, callback.is_null());
   }
 
  protected:
   virtual void RunWork() {
     if (!file_util::PathExists(file_path_)) {
       set_error_code(base::PLATFORM_FILE_ERROR_NOT_FOUND);
       return;
     }
     if (!file_util::GetFileInfo(file_path_, &file_info_))
       set_error_code(base::PLATFORM_FILE_ERROR_FAILED);
   }
 
   virtual void RunCallback() {
-    callback_->Run(error_code(), file_info_);
-    delete callback_;
+    callback_.Run(error_code(), file_info_);
   }
 
  private:
-  base::FileUtilProxy::GetFileInfoCallback* callback_;
+  base::FileUtilProxy::GetFileInfoCallback callback_;
   FilePath file_path_;
   base::PlatformFileInfo file_info_;
 };
 
 class RelayGetFileInfoFromPlatformFile : public MessageLoopRelay {
  public:
   RelayGetFileInfoFromPlatformFile(
       base::PlatformFile file,
-      base::FileUtilProxy::GetFileInfoCallback* callback)
+      const base::FileUtilProxy::GetFileInfoCallback& callback)
       : callback_(callback),
         file_(file) {
-    DCHECK(callback);
+    DCHECK_EQ(false, callback.is_null());
   }
 
  protected:
   virtual void RunWork() {
     if (!base::GetPlatformFileInfo(file_, &file_info_))
       set_error_code(base::PLATFORM_FILE_ERROR_FAILED);
   }
 
   virtual void RunCallback() {
-    callback_->Run(error_code(), file_info_);
-    delete callback_;
+    callback_.Run(error_code(), file_info_);
   }
 
  private:
-  base::FileUtilProxy::GetFileInfoCallback* callback_;
+  base::FileUtilProxy::GetFileInfoCallback callback_;
   base::PlatformFile file_;
   base::PlatformFileInfo file_info_;
 };
 
 class RelayRead : public MessageLoopRelay {
  public:
   RelayRead(base::PlatformFile file,
             int64 offset,
             int bytes_to_read,
             base::FileUtilProxy::ReadCallback* callback)
@@ skipping 235 matching lines @@
     const EnsureFileExistsCallback& callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayEnsureFileExists(
       message_loop_proxy, file_path, callback));
 }
 
 // Retrieves the information about a file. It is invalid to pass NULL for the
 // callback.
 bool FileUtilProxy::GetFileInfo(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path,
-    GetFileInfoCallback* callback) {
+    const GetFileInfoCallback& callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayGetFileInfo(
                file_path, callback));
 }
 
 // static
 bool FileUtilProxy::GetFileInfoFromPlatformFile(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
-    GetFileInfoCallback* callback) {
+    const GetFileInfoCallback& callback) {
   return Start(FROM_HERE, message_loop_proxy,
                new RelayGetFileInfoFromPlatformFile(file, callback));
 }
 
 // static
 bool FileUtilProxy::ReadDirectory(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path,
     ReadDirectoryCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayReadDirectory(
@@ skipping 124 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