[Refactor] to rename and re-layer the file_util stack layers.

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"
 
 namespace {
 
 class MessageLoopRelay
     : public base::RefCountedThreadSafe<MessageLoopRelay> {
  public:
   // FileSystemOperationContext is passed by value from the IO thread to the
   // File thread.
   explicit MessageLoopRelay(const fileapi::FileSystemOperationContext& context)
       : origin_message_loop_proxy_(
             base::MessageLoopProxy::current()),
         error_code_(base::PLATFORM_FILE_OK),
         context_(context),
-        file_system_file_util_(NULL) {
+        file_util_(NULL) {
   }
 
   bool Start(scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
              const tracked_objects::Location& from_here) {
     return message_loop_proxy->PostTask(
         from_here,
         NewRunnableMethod(this, &MessageLoopRelay::ProcessOnTargetThread));
   }
 
  protected:
@@ skipping 11 matching lines @@
   }
 
   base::PlatformFileError error_code() const {
     return error_code_;
   }
 
   fileapi::FileSystemOperationContext* context() {
     return &context_;
   }
 
-  fileapi::FileSystemFileUtil* file_system_file_util() const {
+  fileapi::FileSystemFileUtil* file_util() const {
     // TODO(ericu): Support calls that have two different FSFU subclasses.
-    return context_.src_file_system_file_util();
+    return context_.src_file_util();
   }
 
  private:
   void ProcessOnTargetThread() {
     RunWork();
     origin_message_loop_proxy_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &MessageLoopRelay::RunCallback));
   }
 
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   base::PlatformFileError error_code_;
   fileapi::FileSystemOperationContext context_;
-  fileapi::FileSystemFileUtil* file_system_file_util_;
+  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)
       : 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);
   }
 
  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_system_file_util()->CreateOrOpen(
-            context(), file_path_, file_flags_, &file_handle_, &created_));
+    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_;
   }
 
  private:
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
@@ skipping 31 matching lines @@
  public:
   RelayClose(const fileapi::FileSystemOperationContext& context,
              base::PlatformFile file_handle,
              fileapi::FileSystemFileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(context, callback),
         file_handle_(file_handle) {
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Close(context(), file_handle_));
+    set_error_code(file_util()->Close(context(), file_handle_));
   }
 
  private:
   base::PlatformFile file_handle_;
 };
 
 class RelayEnsureFileExists : public MessageLoopRelay {
  public:
   RelayEnsureFileExists(
       const fileapi::FileSystemOperationContext& context,
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const FilePath& file_path,
       fileapi::FileSystemFileUtilProxy::EnsureFileExistsCallback* callback)
       : MessageLoopRelay(context),
         message_loop_proxy_(message_loop_proxy),
         file_path_(file_path),
         callback_(callback),
         created_(false) {
     DCHECK(callback);
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->EnsureFileExists(
-            context(), file_path_, &created_));
+    set_error_code(file_util()->EnsureFileExists(
+        context(), file_path_, &created_));
   }
 
   virtual void RunCallback() {
     callback_->Run(error_code(), created_);
     delete callback_;
   }
 
  private:
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   FilePath file_path_;
   fileapi::FileSystemFileUtilProxy::EnsureFileExistsCallback* callback_;
   bool created_;
 };
 
 
 class RelayGetLocalPath : public MessageLoopRelay {
  public:
   RelayGetLocalPath(
       const fileapi::FileSystemOperationContext& context,
       const FilePath& virtual_path,
       fileapi::FileSystemFileUtilProxy::GetLocalPathCallback* callback)
       : MessageLoopRelay(context),
         callback_(callback),
         virtual_path_(virtual_path) {
     DCHECK(callback);
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->GetLocalFilePath(
-            context(), virtual_path_, &local_path_));
+    set_error_code(file_util()->GetLocalFilePath(
+        context(), virtual_path_, &local_path_));
   }
 
   virtual void RunCallback() {
     callback_->Run(error_code(), local_path_);
     delete callback_;
   }
 
  private:
   fileapi::FileSystemFileUtilProxy::GetLocalPathCallback* callback_;
   FilePath virtual_path_;
   FilePath local_path_;
 };
 
 class RelayGetFileInfo : public MessageLoopRelay {
  public:
   RelayGetFileInfo(
       const fileapi::FileSystemOperationContext& context,
       const FilePath& file_path,
       fileapi::FileSystemFileUtilProxy::GetFileInfoCallback* callback)
       : MessageLoopRelay(context),
         callback_(callback),
         file_path_(file_path) {
     DCHECK(callback);
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->GetFileInfo(
-            context(), file_path_, &file_info_, &platform_path_));
+    set_error_code(file_util()->GetFileInfo(
+        context(), file_path_, &file_info_, &platform_path_));
   }
 
   virtual void RunCallback() {
     callback_->Run(error_code(), file_info_, platform_path_);
     delete callback_;
   }
 
  private:
   fileapi::FileSystemFileUtilProxy::GetFileInfoCallback* callback_;
   FilePath file_path_;
   base::PlatformFileInfo file_info_;
   FilePath platform_path_;
 };
 
 class RelayReadDirectory : public MessageLoopRelay {
  public:
   RelayReadDirectory(
       const fileapi::FileSystemOperationContext& context,
       const FilePath& file_path,
       fileapi::FileSystemFileUtilProxy::ReadDirectoryCallback* callback)
       : MessageLoopRelay(context),
         callback_(callback), file_path_(file_path) {
     DCHECK(callback);
   }
 
  protected:
   virtual void RunWork() {
     // TODO(kkanetkar): Implement directory read in multiple chunks.
-    set_error_code(
-        file_system_file_util()->ReadDirectory(
-            context(), file_path_, &entries_));
+    set_error_code(file_util()->ReadDirectory(
+        context(), file_path_, &entries_));
   }
 
   virtual void RunCallback() {
     callback_->Run(error_code(), entries_);
     delete callback_;
   }
 
  private:
   fileapi::FileSystemFileUtilProxy::ReadDirectoryCallback* callback_;
   FilePath file_path_;
   std::vector<base::FileUtilProxy::Entry> entries_;
 };
 
 class RelayCreateDirectory : public RelayWithStatusCallback {
  public:
   RelayCreateDirectory(
       const fileapi::FileSystemOperationContext& context,
       const FilePath& file_path,
       bool exclusive,
       bool recursive,
       fileapi::FileSystemFileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(context, callback),
         file_path_(file_path),
         exclusive_(exclusive),
         recursive_(recursive) {
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->CreateDirectory(
-            context(), file_path_, exclusive_, recursive_));
+    set_error_code(file_util()->CreateDirectory(
+        context(), file_path_, exclusive_, recursive_));
   }
 
  private:
   FilePath file_path_;
   bool exclusive_;
   bool recursive_;
 };
 
 class RelayCopy : public RelayWithStatusCallback {
  public:
   RelayCopy(const fileapi::FileSystemOperationContext& context,
             const FilePath& src_file_path,
             const FilePath& dest_file_path,
             fileapi::FileSystemFileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(context, callback),
         src_file_path_(src_file_path),
         dest_file_path_(dest_file_path) {
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Copy(
-            context(), src_file_path_, dest_file_path_));
+    set_error_code(file_util()->Copy(
+        context(), src_file_path_, dest_file_path_));
   }
 
  private:
   FilePath src_file_path_;
   FilePath dest_file_path_;
 };
 
 class RelayMove : public RelayWithStatusCallback {
  public:
   RelayMove(const fileapi::FileSystemOperationContext& context,
             const FilePath& src_file_path,
             const FilePath& dest_file_path,
             fileapi::FileSystemFileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(context, callback),
         src_file_path_(src_file_path),
         dest_file_path_(dest_file_path) {
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Move(
-            context(), src_file_path_, dest_file_path_));
+    set_error_code(file_util()->Move(
+        context(), src_file_path_, dest_file_path_));
   }
 
  private:
   FilePath src_file_path_;
   FilePath dest_file_path_;
 };
 
 class RelayDelete : public RelayWithStatusCallback {
  public:
   RelayDelete(const fileapi::FileSystemOperationContext& context,
               const FilePath& file_path,
               bool recursive,
               fileapi::FileSystemFileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(context, callback),
         file_path_(file_path),
         recursive_(recursive) {
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Delete(
-            context(), file_path_, recursive_));
+    set_error_code(file_util()->Delete(context(), file_path_, recursive_));
   }
 
  private:
   FilePath file_path_;
   bool recursive_;
 };
 
 class RelayTouchFilePath : public RelayWithStatusCallback {
  public:
   RelayTouchFilePath(const fileapi::FileSystemOperationContext& context,
                      const FilePath& file_path,
                      const base::Time& last_access_time,
                      const base::Time& last_modified_time,
                      fileapi::FileSystemFileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(context, callback),
         file_path_(file_path),
         last_access_time_(last_access_time),
         last_modified_time_(last_modified_time) {
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Touch(
-            context(), file_path_, last_access_time_, last_modified_time_));
+    set_error_code(file_util()->Touch(
+        context(), file_path_, last_access_time_, last_modified_time_));
   }
 
  private:
   FilePath file_path_;
   base::Time last_access_time_;
   base::Time last_modified_time_;
 };
 
 class RelayTruncate : public RelayWithStatusCallback {
  public:
   RelayTruncate(const fileapi::FileSystemOperationContext& context,
                 const FilePath& file_path,
                 int64 length,
                 fileapi::FileSystemFileUtilProxy::StatusCallback* callback)
       : RelayWithStatusCallback(context, callback),
         file_path_(file_path),
         length_(length) {
   }
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Truncate(context(), file_path_, length_));
+    set_error_code(file_util()->Truncate(context(), file_path_, length_));
   }
 
  private:
   FilePath file_path_;
   int64 length_;
 };
 
 bool Start(const tracked_objects::Location& from_here,
            scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
            scoped_refptr<MessageLoopRelay> relay) {
@@ skipping 129 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