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

Moving file_system_proxy to base/ and changing it to work with MessageLoopProxies instead of ChromeThreads.

BUG=none
TEST=none

Review URL: http://codereview.chromium.org/3131026

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@56923 0039d316-1c4b-4281-b951-d872f2087c98

base/base.gypi

@@ -81,6 +81,8 @@
           'file_util_mac.mm',
           'file_util_posix.cc',
           'file_util_win.cc',
+          'file_util_proxy.cc',
+          'file_util_proxy.h',
           'file_version_info.h',
           'file_version_info_mac.h',
           'file_version_info_mac.mm',

chrome/browser/file_system_proxy.cc → base/file_util_proxy.cc

@@ -2,20 +2,58 @@
 // 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),
@@ -26,7 +64,7 @@ class RelayCreateOrOpen : public ChromeThreadRelay {
  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() {
@@ -39,18 +77,21 @@ class RelayCreateOrOpen : public ChromeThreadRelay {
   }
 
  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);
   }
@@ -58,7 +99,7 @@ class RelayCreateTemporary : public ChromeThreadRelay {
  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() {
@@ -82,14 +123,16 @@ class RelayCreateTemporary : public ChromeThreadRelay {
   }
 
  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.
@@ -107,14 +150,14 @@ class RelayWithStatusCallback : public ChromeThreadRelay {
   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) {
   }
@@ -132,7 +175,7 @@ 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) {
@@ -149,32 +192,54 @@ class RelayDelete : public RelayWithStatusCallback {
 };
 
 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,
-                            StatusCallback* callback) {
-  Start(FROM_HERE, new RelayClose(file_handle, callback));
+// static
+void 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));
 }
 
-void FileSystemProxy::Delete(const FilePath& file_path,
-                             StatusCallback* callback) {
-  Start(FROM_HERE, new RelayDelete(file_path, false, callback));
+// static
+void 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));
 }
 
-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

chrome/browser/file_system_proxy.h → base/file_util_proxy.h

@@ -2,14 +2,20 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_BROWSER_FILE_SYSTEM_PROXY_H_
-#define CHROME_BROWSER_FILE_SYSTEM_PROXY_H_
+#ifndef BASE_FILE_SYSTEM_PROXY_H_
+#define BASE_FILE_SYSTEM_PROXY_H_
 
 #include "base/callback.h"
 #include "base/platform_file.h"
+#include "base/ref_counted.h"
+#include "base/tracked_objects.h"
+
+namespace base {
+
+class MessageLoopProxy;
 
 // This class provides asynchronous access to common file routines.
-class FileSystemProxy {
+class FileUtilProxy {
  public:
   // This callback is used by methods that report success with a bool.  It is
   // valid to pass NULL as the callback parameter to any function that takes a
@@ -20,7 +26,8 @@ class FileSystemProxy {
   // for the callback.
   typedef Callback2<base::PassPlatformFile, bool /* created */>::Type
       CreateOrOpenCallback;
-  static void CreateOrOpen(const FilePath& file_path,
+  static void CreateOrOpen(scoped_refptr<MessageLoopProxy> message_loop_proxy,
+                           const FilePath& file_path,
                            int file_flags,
                            CreateOrOpenCallback* callback);
 
@@ -28,21 +35,30 @@ class FileSystemProxy {
   // are returned.  It is invalid to pass NULL for the callback.
   typedef Callback2<base::PassPlatformFile, FilePath>::Type
       CreateTemporaryCallback;
-  static void CreateTemporary(CreateTemporaryCallback* callback);
+  static void CreateTemporary(
+      scoped_refptr<MessageLoopProxy> message_loop_proxy,
+      CreateTemporaryCallback* callback);
 
   // Close the given file handle.
-  static void Close(base::PlatformFile, StatusCallback* callback);
+  static void Close(scoped_refptr<MessageLoopProxy> message_loop_proxy,
+                    base::PlatformFile,
+                    StatusCallback* callback);
 
   // Deletes a file or empty directory.
-  static void Delete(const FilePath& file_path,
+  static void Delete(scoped_refptr<MessageLoopProxy> message_loop_proxy,
+                     const FilePath& file_path,
                      StatusCallback* callback);
 
   // Deletes a directory and all of its contents.
-  static void RecursiveDelete(const FilePath& file_path,
-                              StatusCallback* callback);
+  static void RecursiveDelete(
+      scoped_refptr<MessageLoopProxy> message_loop_proxy,
+      const FilePath& file_path,
+      StatusCallback* callback);
 
  private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(FileSystemProxy);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(FileUtilProxy);
 };
 
-#endif  // CHROME_BROWSER_FILE_SYSTEM_PROXY_H_
+} // namespace base
+
+#endif  // BASE_FILE_SYSTEM_PROXY_H_

chrome/browser/chrome_thread_relay.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/chrome_thread_relay.h"
-
-ChromeThreadRelay::ChromeThreadRelay() {
-  if (!ChromeThread::GetCurrentThreadIdentifier(&origin_thread_id_))
-    NOTREACHED() << "Must be created on a valid ChromeThread";
-}
-
-void ChromeThreadRelay::Start(ChromeThread::ID target_thread_id,
-                              const tracked_objects::Location& from_here) {
-  ChromeThread::PostTask(
-      target_thread_id,
-      from_here,
-      NewRunnableMethod(this, &ChromeThreadRelay::ProcessOnTargetThread));
-}
-
-void ChromeThreadRelay::ProcessOnTargetThread() {
-  RunWork();
-  ChromeThread::PostTask(
-      origin_thread_id_,
-      FROM_HERE,
-      NewRunnableMethod(this, &ChromeThreadRelay::RunCallback));
-}

chrome/browser/chrome_thread_relay.h

-// 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.
-
-// ChromeThreadRelay provides a convenient way to bounce work to a specific
-// ChromeThread and then return results back to the originating thread.
-//
-// EXAMPLE:
-//
-//  class MyRelay : public ChromeThreadRelay {
-//   public:
-//    MyRelay(const Params& params) : params_(params) {
-//    }
-//   protected:
-//    virtual void RunWork() {
-//      results_ = DoWork(params_);
-//    }
-//    virtual void RunCallback() {
-//      ... use results_ on the originating thread ...
-//    }
-//   private:
-//    Params params_;
-//    Results_ results_;
-//  };
-
-#ifndef CHROME_BROWSER_CHROME_THREAD_RELAY_H_
-#define CHROME_BROWSER_CHROME_THREAD_RELAY_H_
-
-#include "base/ref_counted.h"
-#include "chrome/browser/chrome_thread.h"
-
-class ChromeThreadRelay
-    : public base::RefCountedThreadSafe<ChromeThreadRelay> {
- public:
-  ChromeThreadRelay();
-
-  void Start(ChromeThread::ID target_thread_id,
-             const tracked_objects::Location& from_here);
-
- protected:
-  friend class base::RefCountedThreadSafe<ChromeThreadRelay>;
-  virtual ~ChromeThreadRelay() {}
-
-  // 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();
-  ChromeThread::ID origin_thread_id_;
-};
-
-#endif  // CHROME_BROWSER_CHROME_THREAD_RELAY_H_

chrome/browser/renderer_host/redirect_to_file_resource_handler.cc

@@ -5,10 +5,10 @@
 #include "chrome/browser/renderer_host/redirect_to_file_resource_handler.h"
 
 #include "base/file_util.h"
+#include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/task.h"
-#include "chrome/browser/file_system_proxy.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/common/resource_response.h"
 #include "net/base/file_stream.h"
@@ -70,7 +70,8 @@ bool RedirectToFileResourceHandler::OnWillStart(int request_id,
     // TODO(darin): This is sub-optimal.  We should not delay starting the
     // network request like this.
     *defer = true;
-    FileSystemProxy::CreateTemporary(
+    base::FileUtilProxy::CreateTemporary(
+        ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE),
         callback_factory_.NewCallback(
             &RedirectToFileResourceHandler::DidCreateTemporaryFile));
     return true;
@@ -142,7 +143,9 @@ void RedirectToFileResourceHandler::OnRequestClosed() {
   file_stream_->Close();
   file_stream_.reset();
 
-  FileSystemProxy::Delete(file_path_, NULL);
+  base::FileUtilProxy::Delete(
+        ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE),
+        file_path_, NULL);
 }
 
 RedirectToFileResourceHandler::~RedirectToFileResourceHandler() {

chrome/chrome_browser.gypi

@@ -353,8 +353,6 @@
         'browser/chrome_plugin_host.h',
         'browser/chrome_thread.cc',
         'browser/chrome_thread.h',
-        'browser/chrome_thread_relay.cc',
-        'browser/chrome_thread_relay.h',
         'browser/chromeos/notifications/balloon_collection_impl.cc',
         'browser/chromeos/notifications/balloon_collection_impl.h',
         'browser/chromeos/notifications/balloon_view.cc',
@@ -1457,8 +1455,6 @@
         'browser/file_path_watcher_inotify.cc',
         'browser/file_path_watcher_mac.cc',
         'browser/file_path_watcher_win.cc',
-        'browser/file_system_proxy.cc',
-        'browser/file_system_proxy.h',
         'browser/find_bar.h',
         'browser/find_bar_controller.cc',
         'browser/find_bar_controller.h',