base::Bind: Convert FileUtilProxy::EnsureFileExistsCallback.

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 237 matching lines @@
 
  private:
   base::PlatformFile file_handle_;
 };
 
 class RelayEnsureFileExists : public MessageLoopRelay {
  public:
   RelayEnsureFileExists(
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const FilePath& file_path,
-      base::FileUtilProxy::EnsureFileExistsCallback* callback)
+      const base::FileUtilProxy::EnsureFileExistsCallback& callback)
       : message_loop_proxy_(message_loop_proxy),
         file_path_(file_path),
         callback_(callback),
         created_(false) {
-    DCHECK(callback);
+    DCHECK_EQ(false, callback.is_null());
   }
 
  protected:
   virtual void RunWork() {
     if (!file_util::DirectoryExists(file_path_.DirName())) {
       // If its parent does not exist, should return NOT_FOUND error.
       set_error_code(base::PLATFORM_FILE_ERROR_NOT_FOUND);
       return;
     }
     base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
     // Tries to create the |file_path_| exclusively.  This should fail
     // with PLATFORM_FILE_ERROR_EXISTS if the path already exists.
     base::PlatformFile handle = base::CreatePlatformFile(
         file_path_,
         base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ,
         &created_, &error_code);
     if (error_code == base::PLATFORM_FILE_ERROR_EXISTS) {
       // Make sure created_ is false.
       created_ = false;
       error_code = base::PLATFORM_FILE_OK;
     }
     if (handle != base::kInvalidPlatformFileValue)
       base::ClosePlatformFile(handle);
     set_error_code(error_code);
   }
 
   virtual void RunCallback() {
-    callback_->Run(error_code(), created_);
-    delete callback_;
+    callback_.Run(error_code(), created_);
   }
 
  private:
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   FilePath file_path_;
-  base::FileUtilProxy::EnsureFileExistsCallback* callback_;
+  base::FileUtilProxy::EnsureFileExistsCallback callback_;
   bool created_;
 };
 
 class RelayDelete : public RelayWithStatusCallback {
  public:
   RelayDelete(const FilePath& file_path,
               bool recursive,
               base::FileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(callback),
         file_path_(file_path),
@@ skipping 449 matching lines @@
                           base::PlatformFile file_handle,
                           StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy,
                new RelayClose(file_handle, callback));
 }
 
 // static
 bool FileUtilProxy::EnsureFileExists(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path,
-    EnsureFileExistsCallback* callback) {
+    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) {
@@ skipping 143 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