Change the FileUtilProxy callbacks to report error codes instead of booleans....

base/file_util_proxy.cc

 // Copyright (c) 2010 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/file_util.h"
 #include "base/message_loop_proxy.h"
 
 namespace {
 
 class MessageLoopRelay
     : public base::RefCountedThreadSafe<MessageLoopRelay> {
  public:
   MessageLoopRelay()
       : origin_message_loop_proxy_(
-          base::MessageLoopProxy::CreateForCurrentThread()) {
+          base::MessageLoopProxy::CreateForCurrentThread()),
+        error_code_(base::PLATFORM_FILE_OK) {
   }
 
-  void Start(scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+  bool Start(scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
              const tracked_objects::Location& from_here) {
-    message_loop_proxy->PostTask(
+    return message_loop_proxy->PostTask(
         from_here,
         NewRunnableMethod(this, &MessageLoopRelay::ProcessOnTargetThread));
   }
 
  protected:
   friend class base::RefCountedThreadSafe<MessageLoopRelay>;
   virtual ~MessageLoopRelay() {}
 
   // Called to perform work on the FILE thread.
   virtual void RunWork() = 0;
 
   // Called to notify the callback on the origin thread.
   virtual void RunCallback() = 0;
 
+  void SetErrorCode(int error_code) {
+    error_code_ = error_code;
+  }
+
+  int ErrorCode() {

[darin (slow to review), 2010/08/24 17:43:14]

nit: consider naming these set_error_code() and error_code().  also, the getter
should be 'const'

[dumi, 2010/08/24 19:14:57]

done. when do we use methods_like_this() and MethodsLikeThis()? i'm asking
because all other functions are LikeThis().

+    return error_code_;
+  }
+
  private:
   void ProcessOnTargetThread() {
     RunWork();
     origin_message_loop_proxy_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &MessageLoopRelay::RunCallback));
   }
 
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
+  int error_code_;
 };
 
 class RelayCreateOrOpen : public MessageLoopRelay {
  public:
   RelayCreateOrOpen(
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const FilePath& file_path,
       int file_flags,
       base::FileUtilProxy::CreateOrOpenCallback* callback)
       : message_loop_proxy_(message_loop_proxy),
         file_path_(file_path),
         file_flags_(file_flags),
         callback_(callback),
         file_handle_(base::kInvalidPlatformFileValue),
         created_(false) {
     DCHECK(callback);
   }
 
  protected:
   virtual ~RelayCreateOrOpen() {
     if (file_handle_ != base::kInvalidPlatformFileValue)
       base::FileUtilProxy::Close(message_loop_proxy_, file_handle_, NULL);
   }
 
   virtual void RunWork() {
     file_handle_ = base::CreatePlatformFile(file_path_, file_flags_, &created_);
+    if (file_handle_ == base::kInvalidPlatformFileValue)
+      SetErrorCode(base::PLATFORM_FILE_ERROR);
   }
 
   virtual void RunCallback() {
-    callback_->Run(base::PassPlatformFile(&file_handle_), created_);
+    callback_->Run(ErrorCode(), base::PassPlatformFile(&file_handle_),
+                   created_);
     delete callback_;
   }
 
  private:
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   FilePath file_path_;
   int file_flags_;
   base::FileUtilProxy::CreateOrOpenCallback* callback_;
   base::PlatformFile file_handle_;
   bool created_;
@@ skipping 22 matching lines @@
     file_util::CreateTemporaryFile(&file_path_);
 
     // Use a fixed set of flags that are appropriate for writing to a temporary
     // file from the IO thread using a net::FileStream.
     int file_flags =
         base::PLATFORM_FILE_CREATE_ALWAYS |
         base::PLATFORM_FILE_WRITE |
         base::PLATFORM_FILE_ASYNC |
         base::PLATFORM_FILE_TEMPORARY;
     file_handle_ = base::CreatePlatformFile(file_path_, file_flags, NULL);
+    if (file_handle_ == base::kInvalidPlatformFileValue)
+      SetErrorCode(base::PLATFORM_FILE_ERROR);
   }
 
   virtual void RunCallback() {
-    callback_->Run(base::PassPlatformFile(&file_handle_), file_path_);
+    callback_->Run(ErrorCode(), base::PassPlatformFile(&file_handle_),
+                   file_path_);
     delete callback_;
   }
 
  private:
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   base::FileUtilProxy::CreateTemporaryCallback* callback_;
   base::PlatformFile file_handle_;
   FilePath file_path_;
 };
 
 class RelayWithStatusCallback : public MessageLoopRelay {
  public:
   explicit RelayWithStatusCallback(
       base::FileUtilProxy::StatusCallback* callback)
-      : callback_(callback),
-        succeeded_(false) {
+      : callback_(callback) {
     // It is OK for callback to be NULL.
   }
 
  protected:
   virtual void RunCallback() {
     // The caller may not have been interested in the result.
     if (callback_) {
-      callback_->Run(succeeded_);
+      callback_->Run(ErrorCode());
       delete callback_;
     }
   }
 
-  void SetStatus(bool succeeded) { succeeded_ = succeeded; }
-
  private:
   base::FileUtilProxy::StatusCallback* callback_;
-  bool succeeded_;
 };
 
 class RelayClose : public RelayWithStatusCallback {
  public:
   RelayClose(base::PlatformFile file_handle,
              base::FileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(callback),
         file_handle_(file_handle) {
   }
 
  protected:
   virtual void RunWork() {
-    SetStatus(base::ClosePlatformFile(file_handle_));
+    if (!base::ClosePlatformFile(file_handle_))
+      SetErrorCode(base::PLATFORM_FILE_ERROR);
   }
 
  private:
   base::PlatformFile file_handle_;
 };
 
 class RelayDelete : public RelayWithStatusCallback {
  public:
   RelayDelete(const FilePath& file_path,
               bool recursive,
               base::FileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(callback),
         file_path_(file_path),
         recursive_(recursive) {
   }
 
  protected:
   virtual void RunWork() {
-    SetStatus(file_util::Delete(file_path_, recursive_));
+    if (!file_util::Delete(file_path_, recursive_))
+      SetErrorCode(base::PLATFORM_FILE_ERROR);
   }
 
  private:
   FilePath file_path_;
   bool recursive_;
 };
 
-void Start(const tracked_objects::Location& from_here,
+bool Start(const tracked_objects::Location& from_here,
            scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
            scoped_refptr<MessageLoopRelay> relay) {
-  relay->Start(message_loop_proxy, from_here);
+  return relay->Start(message_loop_proxy, from_here);
 }
 
 }  // namespace
 
 namespace base {
 
 // static
-void FileUtilProxy::CreateOrOpen(
+bool FileUtilProxy::CreateOrOpen(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path, int file_flags,
     CreateOrOpenCallback* callback) {
-  Start(FROM_HERE, message_loop_proxy, new RelayCreateOrOpen(
+  return Start(FROM_HERE, message_loop_proxy, new RelayCreateOrOpen(
       message_loop_proxy, file_path, file_flags, callback));
 }
 
 // static
-void FileUtilProxy::CreateTemporary(
+bool FileUtilProxy::CreateTemporary(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     CreateTemporaryCallback* callback) {
-  Start(FROM_HERE, message_loop_proxy,
-        new RelayCreateTemporary(message_loop_proxy, callback));
+  return Start(FROM_HERE, message_loop_proxy,
+               new RelayCreateTemporary(message_loop_proxy, callback));
 }
 
 // static
-void FileUtilProxy::Close(scoped_refptr<MessageLoopProxy> message_loop_proxy,
+bool FileUtilProxy::Close(scoped_refptr<MessageLoopProxy> message_loop_proxy,
                           base::PlatformFile file_handle,
                           StatusCallback* callback) {
-  Start(FROM_HERE, message_loop_proxy, new RelayClose(file_handle, callback));
+  return Start(FROM_HERE, message_loop_proxy,
+               new RelayClose(file_handle, callback));
 }
 
 // static
-void FileUtilProxy::Delete(scoped_refptr<MessageLoopProxy> message_loop_proxy,
+bool FileUtilProxy::Delete(scoped_refptr<MessageLoopProxy> message_loop_proxy,
                            const FilePath& file_path,
                            StatusCallback* callback) {
-  Start(FROM_HERE, message_loop_proxy,
-        new RelayDelete(file_path, false, callback));
+  return Start(FROM_HERE, message_loop_proxy,
+               new RelayDelete(file_path, false, callback));
 }
 
 // static
-void FileUtilProxy::RecursiveDelete(
+bool FileUtilProxy::RecursiveDelete(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path,
     StatusCallback* callback) {
-  Start(FROM_HERE, message_loop_proxy,
-        new RelayDelete(file_path, true, callback));
+  return Start(FROM_HERE, message_loop_proxy,
+               new RelayDelete(file_path, true, callback));
 }
 
 } // namespace base