Moving file_system_proxy to base/ and changing it to work with MessageLoopPro...

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 "chrome/browser/file_system_proxy.h"
+#include "base/file_util_proxy.h"
 
 #include "base/file_util.h"
-#include "chrome/browser/chrome_thread_relay.h"
+#include "base/message_loop_proxy.h"
 
 namespace {
 
-class RelayCreateOrOpen : public ChromeThreadRelay {
+class MessageLoopRelay
+    : public base::RefCountedThreadSafe<MessageLoopRelay> {
+ public:
+  MessageLoopRelay()
+      : origin_message_loop_proxy_(
+          base::MessageLoopProxy::CreateForCurrentThread()) {
+  }
+
+  void Start(scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+             const tracked_objects::Location& from_here) {
+    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;
+
+ private:
+  void ProcessOnTargetThread() {
+    RunWork();
+    origin_message_loop_proxy_->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(this, &MessageLoopRelay::RunCallback));
+  }
+
+  scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
+};
+
+class RelayCreateOrOpen : public MessageLoopRelay {
  public:
   RelayCreateOrOpen(
+      scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const FilePath& file_path,
       int file_flags,
-      FileSystemProxy::CreateOrOpenCallback* callback)
-      : file_path_(file_path),
+      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)
-      FileSystemProxy::Close(file_handle_, NULL);
+      base::FileUtilProxy::Close(message_loop_proxy_, file_handle_, NULL);
   }
 
   virtual void RunWork() {
     file_handle_ = base::CreatePlatformFile(file_path_, file_flags_, &created_);
   }
 
   virtual void RunCallback() {
     callback_->Run(base::PassPlatformFile(&file_handle_), created_);
     delete callback_;
   }
 
  private:
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   FilePath file_path_;
   int file_flags_;
-  FileSystemProxy::CreateOrOpenCallback* callback_;
+  base::FileUtilProxy::CreateOrOpenCallback* callback_;
   base::PlatformFile file_handle_;
   bool created_;
 };
 
-class RelayCreateTemporary : public ChromeThreadRelay {
+class RelayCreateTemporary : public MessageLoopRelay {
  public:
-  explicit RelayCreateTemporary(
-      FileSystemProxy::CreateTemporaryCallback* callback)
-      : callback_(callback),
+  RelayCreateTemporary(
+      scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+      base::FileUtilProxy::CreateTemporaryCallback* callback)
+      : message_loop_proxy_(message_loop_proxy),
+        callback_(callback),
         file_handle_(base::kInvalidPlatformFileValue) {
     DCHECK(callback);
   }
 
  protected:
   virtual ~RelayCreateTemporary() {
     if (file_handle_ != base::kInvalidPlatformFileValue)
-      FileSystemProxy::Close(file_handle_, NULL);
+      base::FileUtilProxy::Close(message_loop_proxy_, file_handle_, NULL);
   }
 
   virtual void RunWork() {
     // TODO(darin): file_util should have a variant of CreateTemporaryFile
     // that returns a FilePath and a PlatformFile.
     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);
   }
 
   virtual void RunCallback() {
     callback_->Run(base::PassPlatformFile(&file_handle_), file_path_);
     delete callback_;
   }
 
  private:
-  FileSystemProxy::CreateTemporaryCallback* callback_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  base::FileUtilProxy::CreateTemporaryCallback* callback_;
   base::PlatformFile file_handle_;
   FilePath file_path_;
 };
 
-class RelayWithStatusCallback : public ChromeThreadRelay {
+class RelayWithStatusCallback : public MessageLoopRelay {
  public:
-  explicit RelayWithStatusCallback(FileSystemProxy::StatusCallback* callback)
+  explicit RelayWithStatusCallback(
+      base::FileUtilProxy::StatusCallback* callback)
       : callback_(callback),
         succeeded_(false) {
     // 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_);
       delete callback_;
     }
   }
 
   void SetStatus(bool succeeded) { succeeded_ = succeeded; }
 
  private:
-  FileSystemProxy::StatusCallback* callback_;
+  base::FileUtilProxy::StatusCallback* callback_;
   bool succeeded_;
 };
 
 class RelayClose : public RelayWithStatusCallback {
  public:
   RelayClose(base::PlatformFile file_handle,
-             FileSystemProxy::StatusCallback* callback)
+             base::FileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(callback),
         file_handle_(file_handle) {
   }
 
  protected:
   virtual void RunWork() {
     SetStatus(base::ClosePlatformFile(file_handle_));
   }
 
  private:
   base::PlatformFile file_handle_;
 };
 
 class RelayDelete : public RelayWithStatusCallback {
  public:
   RelayDelete(const FilePath& file_path,
               bool recursive,
-              FileSystemProxy::StatusCallback* callback)
+              base::FileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(callback),
         file_path_(file_path),
         recursive_(recursive) {
   }
 
  protected:
   virtual void RunWork() {
     SetStatus(file_util::Delete(file_path_, recursive_));
   }
 
  private:
   FilePath file_path_;
   bool recursive_;
 };
 
 void Start(const tracked_objects::Location& from_here,
-           scoped_refptr<ChromeThreadRelay> relay) {
-  relay->Start(ChromeThread::FILE, from_here);
+           scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+           scoped_refptr<MessageLoopRelay> relay) {
+  relay->Start(message_loop_proxy, from_here);
 }
 
 }  // namespace
 
-void FileSystemProxy::CreateOrOpen(const FilePath& file_path, int file_flags,
-                                   CreateOrOpenCallback* callback) {
-  Start(FROM_HERE, new RelayCreateOrOpen(file_path, file_flags, callback));
+namespace base {
+
+// static
+void 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(
+      message_loop_proxy, file_path, file_flags, callback));
 }
 
-void FileSystemProxy::CreateTemporary(CreateTemporaryCallback* callback) {
-  Start(FROM_HERE, new RelayCreateTemporary(callback));
+// static
+void FileUtilProxy::CreateTemporary(
+    scoped_refptr<MessageLoopProxy> message_loop_proxy,
+    CreateTemporaryCallback* callback) {
+  Start(FROM_HERE, message_loop_proxy,
+        new RelayCreateTemporary(message_loop_proxy, callback));
 }
 
-void FileSystemProxy::Close(base::PlatformFile file_handle,
+// static
+void FileUtilProxy::Close(scoped_refptr<MessageLoopProxy> message_loop_proxy,
+                            base::PlatformFile file_handle,
                             StatusCallback* callback) {
-  Start(FROM_HERE, new RelayClose(file_handle, callback));
+  Start(FROM_HERE, message_loop_proxy, new RelayClose(file_handle, callback));
 }
 
-void FileSystemProxy::Delete(const FilePath& file_path,
+// static
+void FileUtilProxy::Delete(scoped_refptr<MessageLoopProxy> message_loop_proxy,
+                             const FilePath& file_path,
                              StatusCallback* callback) {
-  Start(FROM_HERE, new RelayDelete(file_path, false, callback));
+  Start(FROM_HERE, message_loop_proxy,
+        new RelayDelete(file_path, false, callback));
 }
 
-void FileSystemProxy::RecursiveDelete(const FilePath& file_path,
-                                      StatusCallback* callback) {
-  Start(FROM_HERE, new RelayDelete(file_path, true, callback));
+// static
+void 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));
 }
+
+} // namespace base