drive: Drop "Drive" from FakeDriveFileSystem and MockDriveFileSystem

chrome/browser/chromeos/drive/file_system_proxy.cc

 // Copyright (c) 2012 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/chromeos/drive/file_system_proxy.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 175 matching lines @@
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    base::PlatformFileInfo(),
                    base::FilePath()));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::GetEntryInfoByPath,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnGetMetadata,
                                 this,
                                 file_path,
                                 callback))));
 }
 
 void FileSystemProxy::Copy(
     const FileSystemURL& src_file_url,
     const FileSystemURL& dest_file_url,
     const FileSystemOperation::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath src_file_path, dest_file_path;
   if (!ValidateUrl(src_file_url, &src_file_path) ||
       !ValidateUrl(dest_file_url, &dest_file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::Copy,
                  base::Unretained(file_system_),
                  src_file_path,
                  dest_file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnStatusCallback,
                                 this,
                                 callback))));
 }
 
 void FileSystemProxy::Move(
     const FileSystemURL& src_file_url,
     const FileSystemURL& dest_file_url,
     const FileSystemOperation::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath src_file_path, dest_file_path;
   if (!ValidateUrl(src_file_url, &src_file_path) ||
       !ValidateUrl(dest_file_url, &dest_file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::Move,
                  base::Unretained(file_system_),
                  src_file_path,
                  dest_file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnStatusCallback,
                                 this,
                                 callback))));
 }
 
 void FileSystemProxy::ReadDirectory(
     const FileSystemURL& file_url,
     const FileSystemOperation::ReadDirectoryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    std::vector<base::FileUtilProxy::Entry>(),
                    false));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::ReadDirectoryByPath,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnReadDirectory,
                                 this,
                                 callback))));
 }
 
 void FileSystemProxy::Remove(
     const FileSystemURL& file_url,
     bool recursive,
     const FileSystemOperation::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::Remove,
                  base::Unretained(file_system_),
                  file_path,
                  recursive,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnStatusCallback,
                                 this,
                                 callback))));
 }
 
 void FileSystemProxy::CreateDirectory(
     const FileSystemURL& file_url,
     bool exclusive,
     bool recursive,
     const FileSystemOperation::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::CreateDirectory,
                  base::Unretained(file_system_),
                  file_path,
                  exclusive,
                  recursive,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnStatusCallback,
                                 this,
                                 callback))));
 }
 
 void FileSystemProxy::CreateFile(
     const FileSystemURL& file_url,
     bool exclusive,
     const FileSystemOperation::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::CreateFile,
                  base::Unretained(file_system_),
                  file_path,
                  exclusive,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnStatusCallback,
                                 this,
                                 callback))));
 }
 
@@ skipping 14 matching lines @@
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, base::PLATFORM_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   // TODO(kinaba): http://crbug.com/132780.
   // Optimize the cases for small |length|, at least for |length| == 0.
   // CreateWritableSnapshotFile downloads the whole content unnecessarily.
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::OpenFile,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnFileOpenedForTruncate,
                                 this,
                                 file_path,
                                 length,
                                 callback))));
 }
@@ skipping 48 matching lines @@
     // if it really exists open it as truncated.
     file_flags &= ~base::PLATFORM_FILE_CREATE;
     file_flags &= ~base::PLATFORM_FILE_CREATE_ALWAYS;
     file_flags |= base::PLATFORM_FILE_OPEN_TRUNCATED;
   } else {
     callback.Run(create_result, base::kInvalidPlatformFileValue, peer_handle);
     return;
   }
 
   // Open created (or existing) file for writing.
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::OpenFile,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnOpenFileForWriting,
                                 this,
                                 file_flags,
                                 peer_handle,
                                 callback))));
 }
@@ skipping 26 matching lines @@
 }
 
 void FileSystemProxy::DidTruncate(
     const base::FilePath& virtual_path,
     const FileSystemOperation::StatusCallback& callback,
     base::PlatformFileError truncate_result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Truncation finished. We must close the file no matter |truncate_result|
   // indicates an error or not.
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::CloseFile,
                  base::Unretained(file_system_),
                  virtual_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&DidCloseFileForTruncate,
                                 callback,
                                 truncate_result))));
 }
 
 void FileSystemProxy::OpenFile(
@@ skipping 28 matching lines @@
   }
 
   if ((file_flags & base::PLATFORM_FILE_OPEN) ||
       (file_flags & base::PLATFORM_FILE_OPEN_ALWAYS) ||
       (file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED)) {
     if ((file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED) ||
         (file_flags & base::PLATFORM_FILE_OPEN_ALWAYS) ||
         (file_flags & base::PLATFORM_FILE_WRITE) ||
         (file_flags & base::PLATFORM_FILE_EXCLUSIVE_WRITE)) {
       // Open existing file for writing.
-      CallDriveFileSystemMethodOnUIThread(
+      CallFileSystemMethodOnUIThread(
           base::Bind(&DriveFileSystemInterface::OpenFile,
                      base::Unretained(file_system_),
                      file_path,
                      google_apis::CreateRelayCallback(
                          base::Bind(&FileSystemProxy::OnOpenFileForWriting,
                                     this,
                                     file_flags,
                                     peer_handle,
                                     callback))));
     } else {
       // Read-only file open.
-      CallDriveFileSystemMethodOnUIThread(
+      CallFileSystemMethodOnUIThread(
           base::Bind(&DriveFileSystemInterface::GetFileByPath,
                      base::Unretained(file_system_),
                      file_path,
                      google_apis::CreateRelayCallback(
                          base::Bind(&OnGetFileByPathForOpen,
                                     callback,
                                     file_flags,
                                     peer_handle))));
     }
   } else if ((file_flags & base::PLATFORM_FILE_CREATE) ||
              (file_flags & base::PLATFORM_FILE_CREATE_ALWAYS)) {
     // Open existing file for writing.
-    CallDriveFileSystemMethodOnUIThread(
+    CallFileSystemMethodOnUIThread(
         base::Bind(&DriveFileSystemInterface::CreateFile,
                    base::Unretained(file_system_),
                    file_path,
                    file_flags & base::PLATFORM_FILE_EXCLUSIVE_WRITE,
                    google_apis::CreateRelayCallback(
                        base::Bind(&FileSystemProxy::OnCreateFileForOpen,
                                   this,
                                   file_path,
                                   file_flags,
                                   peer_handle,
                                   callback))));
   } else {
     NOTREACHED() << "Unhandled file flags combination " << file_flags;
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_FAILED,
                    base::kInvalidPlatformFileValue,
                    peer_handle));
   }
 }
 
 void FileSystemProxy::NotifyCloseFile(const FileSystemURL& url) {
   base::FilePath file_path;
   if (!ValidateUrl(url, &file_path))
     return;
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::CloseFile,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&EmitDebugLogForCloseFile,
                                 file_path))));
 }
 
 void FileSystemProxy::TouchFile(
     const fileapi::FileSystemURL& url,
@@ skipping 19 matching lines @@
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    base::PlatformFileInfo(),
                    base::FilePath(),
                    scoped_refptr<ShareableFileReference>(NULL)));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::GetEntryInfoByPath,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnGetEntryInfoByPath,
                                 this,
                                 file_path,
                                 callback))));
 }
 
 void FileSystemProxy::OnGetEntryInfoByPath(
     const base::FilePath& entry_path,
     const FileSystemOperation::SnapshotFileCallback& callback,
     FileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (error != FILE_ERROR_OK || !entry_proto.get()) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND,
                  base::PlatformFileInfo(),
                  base::FilePath(),
                  scoped_refptr<ShareableFileReference>(NULL));
     return;
   }
 
   base::PlatformFileInfo file_info;
   util::ConvertProtoToPlatformFileInfo(entry_proto->file_info(), &file_info);
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::GetFileByPath,
                  base::Unretained(file_system_),
                  entry_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&CallSnapshotFileCallback,
                                 callback,
                                 file_info))));
 }
 
 void FileSystemProxy::CreateWritableSnapshotFile(
     const FileSystemURL& file_url,
     const fileapi::WritableSnapshotFile& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    base::FilePath(),
                    scoped_refptr<ShareableFileReference>(NULL)));
     return;
   }
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::OpenFile,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(
                          &FileSystemProxy::OnCreateWritableSnapshotFile,
                          this,
                          file_path,
                          callback))));
 }
 
 FileSystemProxy::~FileSystemProxy() {
   // Should be deleted from the CrosMountPointProvider on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 // static.
 bool FileSystemProxy::ValidateUrl(
     const FileSystemURL& url, base::FilePath* file_path) {
   *file_path = util::ExtractDrivePathFromFileSystemUrl(url);
   return !file_path->empty();
 }
 
-void FileSystemProxy::CallDriveFileSystemMethodOnUIThread(
+void FileSystemProxy::CallFileSystemMethodOnUIThread(
     const base::Closure& method_call) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
-          &FileSystemProxy::CallDriveFileSystemMethodOnUIThreadInternal,
+          &FileSystemProxy::CallFileSystemMethodOnUIThreadInternal,
           this,
           method_call));
 }
 
-void FileSystemProxy::CallDriveFileSystemMethodOnUIThreadInternal(
+void FileSystemProxy::CallFileSystemMethodOnUIThreadInternal(
     const base::Closure& method_call) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // If |file_system_| is NULL, it means the file system has already shut down.
   if (file_system_)
     method_call.Run();
 }
 
 void FileSystemProxy::OnStatusCallback(
     const fileapi::FileSystemOperation::StatusCallback& callback,
     FileError error) {
@@ skipping 73 matching lines @@
   }
 
   callback.Run(FileErrorToPlatformError(result), local_path, file_ref);
 }
 
 void FileSystemProxy::CloseWritableSnapshotFile(
     const base::FilePath& virtual_path,
     const base::FilePath& local_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  CallDriveFileSystemMethodOnUIThread(
+  CallFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::CloseFile,
                  base::Unretained(file_system_),
                  virtual_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&EmitDebugLogForCloseFile,
                                 virtual_path))));
 }
 
 }  // namespace drive