base::Bind: Convert FileUtilProxy::CreateOrOpenCallback.

webkit/fileapi/file_system_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 "webkit/fileapi/file_system_file_util_proxy.h"
 
 #include "base/message_loop_proxy.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
@@ skipping 61 matching lines @@
   fileapi::FileSystemFileUtil* file_util_;
 };
 
 class RelayCreateOrOpen : public MessageLoopRelay {
  public:
   RelayCreateOrOpen(
       const fileapi::FileSystemOperationContext& context,
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const FilePath& file_path,
       int file_flags,
-      fileapi::FileSystemFileUtilProxy::CreateOrOpenCallback* callback)
+      const fileapi::FileSystemFileUtilProxy::CreateOrOpenCallback& callback)
       : MessageLoopRelay(context),
         message_loop_proxy_(message_loop_proxy),
         file_path_(file_path),
         file_flags_(file_flags),
         callback_(callback),
         file_handle_(base::kInvalidPlatformFileValue),
         created_(false) {
-    DCHECK(callback);
+    DCHECK_EQ(false, callback.is_null());
   }
 
  protected:
   virtual ~RelayCreateOrOpen() {
     if (file_handle_ != base::kInvalidPlatformFileValue)
       fileapi::FileSystemFileUtilProxy::Close(*context(),
           message_loop_proxy_, file_handle_, NULL);
   }
 
   virtual void RunWork() {
     set_error_code(file_util()->CreateOrOpen(
         context(), file_path_, file_flags_, &file_handle_, &created_));
   }
 
   virtual void RunCallback() {
-    callback_->Run(error_code(), base::PassPlatformFile(&file_handle_),
-                   created_);
-    delete callback_;
+    callback_.Run(error_code(), base::PassPlatformFile(&file_handle_),
+                  created_);
   }
 
  private:
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   FilePath file_path_;
   int file_flags_;
-  fileapi::FileSystemFileUtilProxy::CreateOrOpenCallback* callback_;
+  fileapi::FileSystemFileUtilProxy::CreateOrOpenCallback callback_;
   base::PlatformFile file_handle_;
   bool created_;
 };
 
 class RelayWithStatusCallback : public MessageLoopRelay {
  public:
   RelayWithStatusCallback(
       const fileapi::FileSystemOperationContext& context,
       fileapi::FileSystemFileUtilProxy::StatusCallback* callback)
       : MessageLoopRelay(context),
@@ skipping 299 matching lines @@
 
 }  // namespace
 
 namespace fileapi {
 
 // static
 bool FileSystemFileUtilProxy::CreateOrOpen(
     const FileSystemOperationContext& context,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path, int file_flags,
-    CreateOrOpenCallback* callback) {
+    const CreateOrOpenCallback& callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayCreateOrOpen(context,
       message_loop_proxy, file_path, file_flags, callback));
 }
 
 // static
 bool FileSystemFileUtilProxy::Close(
     const FileSystemOperationContext& context,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     base::PlatformFile file_handle,
     StatusCallback* callback) {
@@ skipping 106 matching lines @@
     const FileSystemOperationContext& context,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& path,
     int64 length,
     StatusCallback* callback) {
   return Start(FROM_HERE, message_loop_proxy,
                new RelayTruncate(context, path, length, callback));
 }
 
 }  // namespace fileapi