Renamed FileSystemOperation to LocalFileSystemOperation.

BUG=138020
TEST=content_unittests


Review URL: https://chromiumcodereview.appspot.com/10790096

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

20 files changed, 308 insertions, 288 deletions

diff --git a/webkit/fileapi/file_system_dir_url_request_job.cc b/webkit/fileapi/file_system_dir_url_request_job.cc
index 182f1a9..642887d 100644
--- a/webkit/fileapi/file_system_dir_url_request_job.cc
+++ b/webkit/fileapi/file_system_dir_url_request_job.cc
@@ -22,7 +22,7 @@
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_context.h"
-#include "webkit/fileapi/file_system_operation.h"
+#include "webkit/fileapi/file_system_operation_interface.h"
 #include "webkit/fileapi/file_system_url.h"
 
 using net::URLRequest;
diff --git a/webkit/fileapi/file_system_file_util_unittest.cc b/webkit/fileapi/file_system_file_util_unittest.cc
index 6ce5ee6..e0bbb66 100644
--- a/webkit/fileapi/file_system_file_util_unittest.cc
+++ b/webkit/fileapi/file_system_file_util_unittest.cc
@@ -11,8 +11,8 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_util_helper.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/native_file_util.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/test_file_set.h"
@@ -35,7 +35,8 @@ class FileSystemFileUtilTest : public testing::Test {
   void SetUp() {
   }
 
-  FileSystemOperationContext* NewContext(FileSystemTestOriginHelper* helper) {
+  FileSystemOperationContext* NewContext(
+      LocalFileSystemTestOriginHelper* helper) {
     FileSystemOperationContext* context = helper->NewOperationContext();
     // We need to allocate quota for paths for
     // TestCrossFileSystemCopyMoveHelper, since it calls into OFSFU, which
@@ -52,13 +53,13 @@ class FileSystemFileUtilTest : public testing::Test {
     ASSERT_TRUE(base_dir.CreateUniqueTempDir());
     scoped_ptr<ObfuscatedFileUtil> file_util(
         new ObfuscatedFileUtil(base_dir.path()));
-    FileSystemTestOriginHelper src_helper(src_origin, src_type);
+    LocalFileSystemTestOriginHelper src_helper(src_origin, src_type);
     src_helper.SetUp(base_dir.path(),
                      false,  // unlimited quota
                      NULL,  // quota::QuotaManagerProxy
                      file_util.get());
 
-    FileSystemTestOriginHelper dest_helper(dest_origin, dest_type);
+    LocalFileSystemTestOriginHelper dest_helper(dest_origin, dest_type);
     dest_helper.SetUp(src_helper.file_system_context(), file_util.get());
 
     // Set up all the source data.
diff --git a/webkit/fileapi/file_system_operation_interface.h b/webkit/fileapi/file_system_operation_interface.h
index 9196f96..404c9f7 100644
--- a/webkit/fileapi/file_system_operation_interface.h
+++ b/webkit/fileapi/file_system_operation_interface.h
@@ -30,7 +30,7 @@ class GURL;
 namespace fileapi {
 
 class FileSystemURL;
-class FileSystemOperation;
+class LocalFileSystemOperation;
 
 // The interface class for FileSystemOperation implementations.
 //
@@ -236,7 +236,7 @@ class FileSystemOperationInterface {
   // For downcasting to FileSystemOperation.
   // TODO(kinuko): this hack should go away once appropriate upload-stream
   // handling based on element types is supported.
-  virtual FileSystemOperation* AsFileSystemOperation() = 0;
+  virtual LocalFileSystemOperation* AsLocalFileSystemOperation() = 0;
 
   // Creates a local snapshot file for a given |path| and returns the
   // metadata and platform path of the snapshot file via |callback|.
diff --git a/webkit/fileapi/file_system_url_request_job.cc b/webkit/fileapi/file_system_url_request_job.cc
index ea3aaf2..72269db 100644
--- a/webkit/fileapi/file_system_url_request_job.cc
+++ b/webkit/fileapi/file_system_url_request_job.cc
@@ -29,8 +29,8 @@
 #include "net/url_request/url_request_context.h"
 #include "webkit/blob/file_stream_reader.h"
 #include "webkit/fileapi/file_system_context.h"
-#include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/local_file_system_operation.h"
 
 using net::URLRequest;
 using net::URLRequestJob;
diff --git a/webkit/fileapi/file_writer_delegate_unittest.cc b/webkit/fileapi/file_writer_delegate_unittest.cc
index 8758d2b..d20c9b8 100644
--- a/webkit/fileapi/file_writer_delegate_unittest.cc
+++ b/webkit/fileapi/file_writer_delegate_unittest.cc
@@ -17,9 +17,9 @@
 #include "net/url_request/url_request_status.h"
 #include "testing/platform_test.h"
 #include "webkit/fileapi/file_system_context.h"
-#include "webkit/fileapi/file_system_operation.h"
-#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_writer_delegate.h"
+#include "webkit/fileapi/local_file_system_operation.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/sandbox_file_stream_writer.h"
 
 namespace fileapi {
@@ -127,7 +127,7 @@ class FileWriterDelegateTest : public PlatformTest {
   scoped_ptr<FileWriterDelegate> file_writer_delegate_;
   scoped_ptr<net::URLRequest> request_;
   scoped_ptr<Result> result_;
-  FileSystemTestOriginHelper test_helper_;
+  LocalFileSystemTestOriginHelper test_helper_;
 
   ScopedTempDir dir_;
 
diff --git a/webkit/fileapi/isolated_file_util_unittest.cc b/webkit/fileapi/isolated_file_util_unittest.cc
index 33bf010..c7e17b0 100644
--- a/webkit/fileapi/isolated_file_util_unittest.cc
+++ b/webkit/fileapi/isolated_file_util_unittest.cc
@@ -16,10 +16,10 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_util_helper.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/isolated_file_util.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/fileapi/native_file_util.h"
@@ -223,7 +223,7 @@ class IsolatedFileUtilTest : public testing::Test {
   std::map<FilePath, FilePath> toplevel_root_map_;
   scoped_ptr<IsolatedFileUtil> file_util_;
   scoped_ptr<LocalFileUtil> other_file_util_;
-  FileSystemTestOriginHelper other_file_util_helper_;
+  LocalFileSystemTestOriginHelper other_file_util_helper_;
   DISALLOW_COPY_AND_ASSIGN(IsolatedFileUtilTest);
 };
 
diff --git a/webkit/fileapi/isolated_mount_point_provider.cc b/webkit/fileapi/isolated_mount_point_provider.cc
index 35cbcf3..770bbfe 100644
--- a/webkit/fileapi/isolated_mount_point_provider.cc
+++ b/webkit/fileapi/isolated_mount_point_provider.cc
@@ -15,12 +15,12 @@
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_stream_reader.h"
-#include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/isolated_file_util.h"
 #include "webkit/fileapi/local_file_stream_writer.h"
+#include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/native_file_util.h"
 
 namespace fileapi {
@@ -109,7 +109,7 @@ FileSystemOperationInterface*
 IsolatedMountPointProvider::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context) const {
-  return new FileSystemOperation(context);
+  return new LocalFileSystemOperation(context);
 }
 
 webkit_blob::FileStreamReader*
diff --git a/webkit/fileapi/file_system_operation.cc b/webkit/fileapi/local_file_system_operation.cc
index 2d35868..048a75e 100644
--- a/webkit/fileapi/file_system_operation.cc
+++ b/webkit/fileapi/local_file_system_operation.cc
@@ -2,7 +2,7 @@
 // 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_operation.h"
+#include "webkit/fileapi/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/sequenced_task_runner.h"
@@ -26,7 +26,7 @@
 
 namespace fileapi {
 
-class FileSystemOperation::ScopedQuotaNotifier {
+class LocalFileSystemOperation::ScopedQuotaNotifier {
  public:
   ScopedQuotaNotifier(FileSystemContext* context,
                       const GURL& origin_url,
@@ -34,14 +34,15 @@ class FileSystemOperation::ScopedQuotaNotifier {
   ~ScopedQuotaNotifier();
 
  private:
-  // Not owned; owned by the owner of this instance (i.e. FileSystemOperation).
+  // Not owned; owned by the owner of this instance
+  // (i.e. LocalFileSystemOperation).
   FileSystemQuotaUtil* quota_util_;
   const GURL origin_url_;
   FileSystemType type_;
   DISALLOW_COPY_AND_ASSIGN(ScopedQuotaNotifier);
 };
 
-FileSystemOperation::ScopedQuotaNotifier::ScopedQuotaNotifier(
+LocalFileSystemOperation::ScopedQuotaNotifier::ScopedQuotaNotifier(
     FileSystemContext* context, const GURL& origin_url, FileSystemType type)
     : origin_url_(origin_url), type_(type) {
   DCHECK(context);
@@ -53,22 +54,25 @@ FileSystemOperation::ScopedQuotaNotifier::ScopedQuotaNotifier(
   }
 }
 
-FileSystemOperation::ScopedQuotaNotifier::~ScopedQuotaNotifier() {
+LocalFileSystemOperation::ScopedQuotaNotifier::~ScopedQuotaNotifier() {
   if (quota_util_) {
     DCHECK(quota_util_->proxy());
     quota_util_->proxy()->EndUpdateOrigin(origin_url_, type_);
   }
 }
 
-FileSystemOperation::TaskParamsForDidGetQuota::TaskParamsForDidGetQuota() {}
-FileSystemOperation::TaskParamsForDidGetQuota::~TaskParamsForDidGetQuota() {}
+LocalFileSystemOperation::TaskParamsForDidGetQuota::TaskParamsForDidGetQuota() {
+}
+
+LocalFileSystemOperation::TaskParamsForDidGetQuota::~TaskParamsForDidGetQuota(
+    ) {}
 
-FileSystemOperation::~FileSystemOperation() {
+LocalFileSystemOperation::~LocalFileSystemOperation() {
 }
 
-void FileSystemOperation::CreateFile(const FileSystemURL& url,
-                                     bool exclusive,
-                                     const StatusCallback& callback) {
+void LocalFileSystemOperation::CreateFile(const FileSystemURL& url,
+                                          bool exclusive,
+                                          const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateFile));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_CREATE);
@@ -80,15 +84,15 @@ void FileSystemOperation::CreateFile(const FileSystemURL& url,
 
   GetUsageAndQuotaThenRunTask(
       url,
-      base::Bind(&FileSystemOperation::DoCreateFile,
+      base::Bind(&LocalFileSystemOperation::DoCreateFile,
                  base::Unretained(this), url, callback, exclusive),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
-void FileSystemOperation::CreateDirectory(const FileSystemURL& url,
-                                          bool exclusive,
-                                          bool recursive,
-                                          const StatusCallback& callback) {
+void LocalFileSystemOperation::CreateDirectory(const FileSystemURL& url,
+                                               bool exclusive,
+                                               bool recursive,
+                                               const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateDirectory));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_CREATE);
@@ -99,14 +103,14 @@ void FileSystemOperation::CreateDirectory(const FileSystemURL& url,
   }
   GetUsageAndQuotaThenRunTask(
       url,
-      base::Bind(&FileSystemOperation::DoCreateDirectory,
+      base::Bind(&LocalFileSystemOperation::DoCreateDirectory,
                  base::Unretained(this), url, callback, exclusive, recursive),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
-void FileSystemOperation::Copy(const FileSystemURL& src_url,
-                               const FileSystemURL& dest_url,
-                               const StatusCallback& callback) {
+void LocalFileSystemOperation::Copy(const FileSystemURL& src_url,
+                                    const FileSystemURL& dest_url,
+                                    const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopy));
 
   base::PlatformFileError result = SetUp(src_url, &src_util_, SETUP_FOR_READ);
@@ -120,16 +124,16 @@ void FileSystemOperation::Copy(const FileSystemURL& src_url,
 
   GetUsageAndQuotaThenRunTask(
       dest_url,
-      base::Bind(&FileSystemOperation::DoCopy,
+      base::Bind(&LocalFileSystemOperation::DoCopy,
                  base::Unretained(this), src_url, dest_url, callback),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
-void FileSystemOperation::Move(const FileSystemURL& src_url,
-                               const FileSystemURL& dest_url,
-                               const StatusCallback& callback) {
+void LocalFileSystemOperation::Move(const FileSystemURL& src_url,
+                                    const FileSystemURL& dest_url,
+                                    const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationMove));
-  scoped_ptr<FileSystemOperation> deleter(this);
+  scoped_ptr<LocalFileSystemOperation> deleter(this);
 
   base::PlatformFileError result = SetUp(src_url, &src_util_, SETUP_FOR_WRITE);
   if (result == base::PLATFORM_FILE_OK)
@@ -152,14 +156,14 @@ void FileSystemOperation::Move(const FileSystemURL& src_url,
 
   GetUsageAndQuotaThenRunTask(
       dest_url,
-      base::Bind(&FileSystemOperation::DoMove,
+      base::Bind(&LocalFileSystemOperation::DoMove,
                  base::Unretained(deleter.release()),
                  src_url, dest_url, callback),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
-void FileSystemOperation::DirectoryExists(const FileSystemURL& url,
-                                          const StatusCallback& callback) {
+void LocalFileSystemOperation::DirectoryExists(const FileSystemURL& url,
+                                               const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationDirectoryExists));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
@@ -171,12 +175,12 @@ void FileSystemOperation::DirectoryExists(const FileSystemURL& url,
 
   FileSystemFileUtilProxy::GetFileInfo(
       &operation_context_, src_util_, url,
-      base::Bind(&FileSystemOperation::DidDirectoryExists,
+      base::Bind(&LocalFileSystemOperation::DidDirectoryExists,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::FileExists(const FileSystemURL& url,
-                                     const StatusCallback& callback) {
+void LocalFileSystemOperation::FileExists(const FileSystemURL& url,
+                                          const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationFileExists));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
@@ -188,12 +192,12 @@ void FileSystemOperation::FileExists(const FileSystemURL& url,
 
   FileSystemFileUtilProxy::GetFileInfo(
       &operation_context_, src_util_, url,
-      base::Bind(&FileSystemOperation::DidFileExists,
+      base::Bind(&LocalFileSystemOperation::DidFileExists,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::GetMetadata(const FileSystemURL& url,
-                                      const GetMetadataCallback& callback) {
+void LocalFileSystemOperation::GetMetadata(
+    const FileSystemURL& url, const GetMetadataCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationGetMetadata));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
@@ -205,12 +209,12 @@ void FileSystemOperation::GetMetadata(const FileSystemURL& url,
 
   FileSystemFileUtilProxy::GetFileInfo(
       &operation_context_, src_util_, url,
-      base::Bind(&FileSystemOperation::DidGetMetadata,
+      base::Bind(&LocalFileSystemOperation::DidGetMetadata,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::ReadDirectory(const FileSystemURL& url,
-                                        const ReadDirectoryCallback& callback) {
+void LocalFileSystemOperation::ReadDirectory(
+    const FileSystemURL& url, const ReadDirectoryCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationReadDirectory));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
@@ -222,12 +226,13 @@ void FileSystemOperation::ReadDirectory(const FileSystemURL& url,
 
   FileSystemFileUtilProxy::ReadDirectory(
       &operation_context_, src_util_, url,
-      base::Bind(&FileSystemOperation::DidReadDirectory,
+      base::Bind(&LocalFileSystemOperation::DidReadDirectory,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::Remove(const FileSystemURL& url, bool recursive,
-                                 const StatusCallback& callback) {
+void LocalFileSystemOperation::Remove(const FileSystemURL& url,
+                                      bool recursive,
+                                      const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_WRITE);
@@ -242,11 +247,11 @@ void FileSystemOperation::Remove(const FileSystemURL& url, bool recursive,
 
   FileSystemFileUtilProxy::Delete(
       &operation_context_, src_util_, url, recursive,
-      base::Bind(&FileSystemOperation::DidFinishFileOperation,
+      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::Write(
+void LocalFileSystemOperation::Write(
     const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     const GURL& blob_url,
@@ -276,7 +281,8 @@ void FileSystemOperation::Write(
 
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(
-      base::Bind(&FileSystemOperation::DidWrite, weak_factory_.GetWeakPtr()),
+      base::Bind(&LocalFileSystemOperation::DidWrite,
+                 weak_factory_.GetWeakPtr()),
       writer.Pass()));
 
   set_write_callback(callback);
@@ -288,8 +294,8 @@ void FileSystemOperation::Write(
   file_writer_delegate_->Start(blob_request.Pass());
 }
 
-void FileSystemOperation::Truncate(const FileSystemURL& url, int64 length,
-                                   const StatusCallback& callback) {
+void LocalFileSystemOperation::Truncate(const FileSystemURL& url, int64 length,
+                                        const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_WRITE);
@@ -300,15 +306,15 @@ void FileSystemOperation::Truncate(const FileSystemURL& url, int64 length,
   }
   GetUsageAndQuotaThenRunTask(
       url,
-      base::Bind(&FileSystemOperation::DoTruncate,
+      base::Bind(&LocalFileSystemOperation::DoTruncate,
                  base::Unretained(this), url, callback, length),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
-void FileSystemOperation::TouchFile(const FileSystemURL& url,
-                                    const base::Time& last_access_time,
-                                    const base::Time& last_modified_time,
-                                    const StatusCallback& callback) {
+void LocalFileSystemOperation::TouchFile(const FileSystemURL& url,
+                                         const base::Time& last_access_time,
+                                         const base::Time& last_modified_time,
+                                         const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTouchFile));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_WRITE);
@@ -321,16 +327,16 @@ void FileSystemOperation::TouchFile(const FileSystemURL& url,
   FileSystemFileUtilProxy::Touch(
       &operation_context_, src_util_, url,
       last_access_time, last_modified_time,
-      base::Bind(&FileSystemOperation::DidTouchFile,
+      base::Bind(&LocalFileSystemOperation::DidTouchFile,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::OpenFile(const FileSystemURL& url,
-                                   int file_flags,
-                                   base::ProcessHandle peer_handle,
-                                   const OpenFileCallback& callback) {
+void LocalFileSystemOperation::OpenFile(const FileSystemURL& url,
+                                        int file_flags,
+                                        base::ProcessHandle peer_handle,
+                                        const OpenFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationOpenFile));
-  scoped_ptr<FileSystemOperation> deleter(this);
+  scoped_ptr<LocalFileSystemOperation> deleter(this);
 
   peer_handle_ = peer_handle;
 
@@ -361,7 +367,7 @@ void FileSystemOperation::OpenFile(const FileSystemURL& url,
   }
   GetUsageAndQuotaThenRunTask(
       url,
-      base::Bind(&FileSystemOperation::DoOpenFile,
+      base::Bind(&LocalFileSystemOperation::DoOpenFile,
                  base::Unretained(deleter.release()),
                  url, callback, file_flags),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED,
@@ -369,7 +375,7 @@ void FileSystemOperation::OpenFile(const FileSystemURL& url,
                  base::kNullProcessHandle));
 }
 
-void FileSystemOperation::NotifyCloseFile(const FileSystemURL& url) {
+void LocalFileSystemOperation::NotifyCloseFile(const FileSystemURL& url) {
   // No particular task to do. This method is for remote file systems that
   // need synchronization with remote server.
   delete this;
@@ -377,7 +383,7 @@ void FileSystemOperation::NotifyCloseFile(const FileSystemURL& url) {
 
 // We can only get here on a write or truncate that's not yet completed.
 // We don't support cancelling any other operation at this time.
-void FileSystemOperation::Cancel(const StatusCallback& cancel_callback) {
+void LocalFileSystemOperation::Cancel(const StatusCallback& cancel_callback) {
   if (file_writer_delegate_.get()) {
     DCHECK_EQ(kOperationWrite, pending_operation_);
 
@@ -408,12 +414,13 @@ void FileSystemOperation::Cancel(const StatusCallback& cancel_callback) {
   }
 }
 
-FileSystemOperation* FileSystemOperation::AsFileSystemOperation() {
+LocalFileSystemOperation*
+LocalFileSystemOperation::AsLocalFileSystemOperation() {
   return this;
 }
 
-void FileSystemOperation::SyncGetPlatformPath(const FileSystemURL& url,
-                                              FilePath* platform_path) {
+void LocalFileSystemOperation::SyncGetPlatformPath(const FileSystemURL& url,
+                                                   FilePath* platform_path) {
   DCHECK(SetPendingOperationType(kOperationGetLocalPath));
 
   base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
@@ -427,7 +434,7 @@ void FileSystemOperation::SyncGetPlatformPath(const FileSystemURL& url,
   delete this;
 }
 
-void FileSystemOperation::CreateSnapshotFile(
+void LocalFileSystemOperation::CreateSnapshotFile(
     const FileSystemURL& url,
     const SnapshotFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateSnapshotFile));
@@ -441,11 +448,11 @@ void FileSystemOperation::CreateSnapshotFile(
 
   FileSystemFileUtilProxy::CreateSnapshotFile(
       &operation_context_, src_util_, url,
-      base::Bind(&FileSystemOperation::DidCreateSnapshotFile,
+      base::Bind(&LocalFileSystemOperation::DidCreateSnapshotFile,
                  base::Owned(this), callback));
 }
 
-FileSystemOperation::FileSystemOperation(
+LocalFileSystemOperation::LocalFileSystemOperation(
     FileSystemContext* file_system_context)
     : operation_context_(file_system_context),
       src_util_(NULL),
@@ -455,7 +462,7 @@ FileSystemOperation::FileSystemOperation(
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
-void FileSystemOperation::GetUsageAndQuotaThenRunTask(
+void LocalFileSystemOperation::GetUsageAndQuotaThenRunTask(
     const FileSystemURL& url,
     const base::Closure& task,
     const base::Closure& error_callback) {
@@ -480,11 +487,11 @@ void FileSystemOperation::GetUsageAndQuotaThenRunTask(
   quota_manager_proxy->quota_manager()->GetUsageAndQuota(
       url.origin(),
       FileSystemTypeToQuotaStorageType(url.type()),
-      base::Bind(&FileSystemOperation::DidGetUsageAndQuotaAndRunTask,
+      base::Bind(&LocalFileSystemOperation::DidGetUsageAndQuotaAndRunTask,
                  weak_factory_.GetWeakPtr(), params));
 }
 
-void FileSystemOperation::DidGetUsageAndQuotaAndRunTask(
+void LocalFileSystemOperation::DidGetUsageAndQuotaAndRunTask(
     const TaskParamsForDidGetQuota& params,
     quota::QuotaStatusCode status,
     int64 usage, int64 quota) {
@@ -501,7 +508,7 @@ void FileSystemOperation::DidGetUsageAndQuotaAndRunTask(
   params.task.Run();
 }
 
-void FileSystemOperation::DoCreateFile(
+void LocalFileSystemOperation::DoCreateFile(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive) {
@@ -509,63 +516,64 @@ void FileSystemOperation::DoCreateFile(
       &operation_context_,
       src_util_, url,
       base::Bind(
-          exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
-                    : &FileSystemOperation::DidEnsureFileExistsNonExclusive,
+          exclusive ?
+              &LocalFileSystemOperation::DidEnsureFileExistsExclusive :
+              &LocalFileSystemOperation::DidEnsureFileExistsNonExclusive,
           base::Owned(this), callback));
 }
 
-void FileSystemOperation::DoCreateDirectory(
+void LocalFileSystemOperation::DoCreateDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive, bool recursive) {
   FileSystemFileUtilProxy::CreateDirectory(
       &operation_context_,
       src_util_, url, exclusive, recursive,
-      base::Bind(&FileSystemOperation::DidFinishFileOperation,
+      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::DoCopy(const FileSystemURL& src_url,
-                                 const FileSystemURL& dest_url,
-                                 const StatusCallback& callback) {
+void LocalFileSystemOperation::DoCopy(const FileSystemURL& src_url,
+                                      const FileSystemURL& dest_url,
+                                      const StatusCallback& callback) {
   FileSystemFileUtilProxy::Copy(
       &operation_context_,
       src_util_, dest_util_,
       src_url, dest_url,
-      base::Bind(&FileSystemOperation::DidFinishFileOperation,
+      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::DoMove(const FileSystemURL& src_url,
-                                 const FileSystemURL& dest_url,
-                                 const StatusCallback& callback) {
+void LocalFileSystemOperation::DoMove(const FileSystemURL& src_url,
+                                      const FileSystemURL& dest_url,
+                                      const StatusCallback& callback) {
   FileSystemFileUtilProxy::Move(
       &operation_context_,
       src_util_, dest_util_,
       src_url, dest_url,
-      base::Bind(&FileSystemOperation::DidFinishFileOperation,
+      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::DoTruncate(const FileSystemURL& url,
-                                     const StatusCallback& callback,
-                                     int64 length) {
+void LocalFileSystemOperation::DoTruncate(const FileSystemURL& url,
+                                          const StatusCallback& callback,
+                                          int64 length) {
   FileSystemFileUtilProxy::Truncate(
       &operation_context_, src_util_, url, length,
-      base::Bind(&FileSystemOperation::DidFinishFileOperation,
+      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::DoOpenFile(const FileSystemURL& url,
-                                     const OpenFileCallback& callback,
-                                     int file_flags) {
+void LocalFileSystemOperation::DoOpenFile(const FileSystemURL& url,
+                                          const OpenFileCallback& callback,
+                                          int file_flags) {
   FileSystemFileUtilProxy::CreateOrOpen(
       &operation_context_, src_util_, url, file_flags,
-      base::Bind(&FileSystemOperation::DidOpenFile,
+      base::Bind(&LocalFileSystemOperation::DidOpenFile,
                  base::Owned(this), callback));
 }
 
-void FileSystemOperation::DidEnsureFileExistsExclusive(
+void LocalFileSystemOperation::DidEnsureFileExistsExclusive(
     const StatusCallback& callback,
     base::PlatformFileError rv, bool created) {
   if (rv == base::PLATFORM_FILE_OK && !created) {
@@ -575,13 +583,13 @@ void FileSystemOperation::DidEnsureFileExistsExclusive(
   }
 }
 
-void FileSystemOperation::DidEnsureFileExistsNonExclusive(
+void LocalFileSystemOperation::DidEnsureFileExistsNonExclusive(
     const StatusCallback& callback,
     base::PlatformFileError rv, bool /* created */) {
   DidFinishFileOperation(callback, rv);
 }
 
-void FileSystemOperation::DidFinishFileOperation(
+void LocalFileSystemOperation::DidFinishFileOperation(
     const StatusCallback& callback,
     base::PlatformFileError rv) {
   if (!cancel_callback_.is_null()) {
@@ -595,7 +603,7 @@ void FileSystemOperation::DidFinishFileOperation(
   }
 }
 
-void FileSystemOperation::DidDirectoryExists(
+void LocalFileSystemOperation::DidDirectoryExists(
     const StatusCallback& callback,
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
@@ -605,7 +613,7 @@ void FileSystemOperation::DidDirectoryExists(
   callback.Run(rv);
 }
 
-void FileSystemOperation::DidFileExists(
+void LocalFileSystemOperation::DidFileExists(
     const StatusCallback& callback,
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
@@ -615,7 +623,7 @@ void FileSystemOperation::DidFileExists(
   callback.Run(rv);
 }
 
-void FileSystemOperation::DidGetMetadata(
+void LocalFileSystemOperation::DidGetMetadata(
     const GetMetadataCallback& callback,
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
@@ -623,7 +631,7 @@ void FileSystemOperation::DidGetMetadata(
   callback.Run(rv, file_info, platform_path);
 }
 
-void FileSystemOperation::DidReadDirectory(
+void LocalFileSystemOperation::DidReadDirectory(
     const ReadDirectoryCallback& callback,
     base::PlatformFileError rv,
     const std::vector<base::FileUtilProxy::Entry>& entries,
@@ -631,7 +639,7 @@ void FileSystemOperation::DidReadDirectory(
   callback.Run(rv, entries, has_more);
 }
 
-void FileSystemOperation::DidWrite(
+void LocalFileSystemOperation::DidWrite(
     base::PlatformFileError rv,
     int64 bytes,
     bool complete) {
@@ -646,12 +654,12 @@ void FileSystemOperation::DidWrite(
     delete this;
 }
 
-void FileSystemOperation::DidTouchFile(const StatusCallback& callback,
-                                       base::PlatformFileError rv) {
+void LocalFileSystemOperation::DidTouchFile(const StatusCallback& callback,
+                                            base::PlatformFileError rv) {
   callback.Run(rv);
 }
 
-void FileSystemOperation::DidOpenFile(
+void LocalFileSystemOperation::DidOpenFile(
     const OpenFileCallback& callback,
     base::PlatformFileError rv,
     base::PassPlatformFile file,
@@ -661,7 +669,7 @@ void FileSystemOperation::DidOpenFile(
   callback.Run(rv, file.ReleaseValue(), peer_handle_);
 }
 
-void FileSystemOperation::DidCreateSnapshotFile(
+void LocalFileSystemOperation::DidCreateSnapshotFile(
     const SnapshotFileCallback& callback,
     base::PlatformFileError result,
     const base::PlatformFileInfo& file_info,
@@ -670,7 +678,7 @@ void FileSystemOperation::DidCreateSnapshotFile(
   callback.Run(result, file_info, platform_path, file_ref);
 }
 
-base::PlatformFileError FileSystemOperation::SetUp(
+base::PlatformFileError LocalFileSystemOperation::SetUp(
     const FileSystemURL& url,
     FileSystemFileUtil** file_util,
     SetUpMode mode) {
@@ -721,7 +729,7 @@ base::PlatformFileError FileSystemOperation::SetUp(
   return base::PLATFORM_FILE_OK;
 }
 
-bool FileSystemOperation::SetPendingOperationType(OperationType type) {
+bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
diff --git a/webkit/fileapi/file_system_operation.h b/webkit/fileapi/local_file_system_operation.h
index b711cd5..94376d430 100644
--- a/webkit/fileapi/file_system_operation.h
+++ b/webkit/fileapi/local_file_system_operation.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_
-#define WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_
+#ifndef WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_OPERATION_H_
+#define WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_OPERATION_H_
 
 #include <string>
 #include <vector>
@@ -43,10 +43,10 @@ class FileSystemURL;
 class FileWriterDelegate;
 
 // FileSystemOperation implementation for local file systems.
-class FILEAPI_EXPORT FileSystemOperation
+class FILEAPI_EXPORT LocalFileSystemOperation
     : public NON_EXPORTED_BASE(FileSystemOperationInterface) {
  public:
-  virtual ~FileSystemOperation();
+  virtual ~LocalFileSystemOperation();
 
   // FileSystemOperation overrides.
   virtual void CreateFile(const FileSystemURL& url,
@@ -89,7 +89,7 @@ class FILEAPI_EXPORT FileSystemOperation
                         const OpenFileCallback& callback) OVERRIDE;
   virtual void NotifyCloseFile(const FileSystemURL& url) OVERRIDE;
   virtual void Cancel(const StatusCallback& cancel_callback) OVERRIDE;
-  virtual FileSystemOperation* AsFileSystemOperation() OVERRIDE;
+  virtual LocalFileSystemOperation* AsLocalFileSystemOperation() OVERRIDE;
   virtual void CreateSnapshotFile(
       const FileSystemURL& path,
       const SnapshotFileCallback& callback) OVERRIDE;
@@ -127,10 +127,10 @@ class FILEAPI_EXPORT FileSystemOperation
   friend class FileSystemOperationTest;
   friend class FileSystemOperationWriteTest;
   friend class FileWriterDelegateTest;
-  friend class FileSystemTestOriginHelper;
   friend class FileSystemQuotaTest;
+  friend class LocalFileSystemTestOriginHelper;
 
-  explicit FileSystemOperation(FileSystemContext* file_system_context);
+  explicit LocalFileSystemOperation(FileSystemContext* file_system_context);
 
   FileSystemContext* file_system_context() const {
     return operation_context_.file_system_context();
@@ -271,13 +271,13 @@ class FILEAPI_EXPORT FileSystemOperation
   // A flag to make sure we call operation only once per instance.
   OperationType pending_operation_;
 
-  // FileSystemOperation instance is usually deleted upon completion but
+  // LocalFileSystemOperation instance is usually deleted upon completion but
   // could be deleted while it has inflight callbacks when Cancel is called.
-  base::WeakPtrFactory<FileSystemOperation> weak_factory_;
+  base::WeakPtrFactory<LocalFileSystemOperation> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(FileSystemOperation);
+  DISALLOW_COPY_AND_ASSIGN(LocalFileSystemOperation);
 };
 
 }  // namespace fileapi
 
-#endif  // WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_
+#endif  // WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_OPERATION_H_
diff --git a/webkit/fileapi/file_system_operation_unittest.cc b/webkit/fileapi/local_file_system_operation_unittest.cc
index f50f754..e801590 100644
--- a/webkit/fileapi/file_system_operation_unittest.cc
+++ b/webkit/fileapi/local_file_system_operation_unittest.cc
@@ -2,7 +2,7 @@
 // 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_operation.h"
+#include "webkit/fileapi/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ -18,8 +18,8 @@
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_quota_util.h"
-#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/quota/quota_manager.h"
 
 using quota::QuotaClient;
@@ -159,18 +159,18 @@ FilePath ASCIIToFilePath(const std::string& str) {
 
 }  // namespace (anonymous)
 
-// Test class for FileSystemOperation.
-class FileSystemOperationTest
+// Test class for LocalFileSystemOperation.
+class LocalFileSystemOperationTest
     : public testing::Test,
-      public base::SupportsWeakPtr<FileSystemOperationTest> {
+      public base::SupportsWeakPtr<LocalFileSystemOperationTest> {
  public:
-  FileSystemOperationTest()
+  LocalFileSystemOperationTest()
       : status_(kFileOperationStatusNotSet),
         next_unique_path_suffix_(0) {
     EXPECT_TRUE(base_.CreateUniqueTempDir());
   }
 
-  FileSystemOperation* operation();
+  LocalFileSystemOperation* operation();
 
   int status() const { return status_; }
   const base::PlatformFileInfo& info() const { return info_; }
@@ -258,25 +258,27 @@ class FileSystemOperationTest
     return CreateUniqueDirInDir(FilePath());
   }
 
-  FileSystemTestOriginHelper test_helper_;
+  LocalFileSystemTestOriginHelper test_helper_;
 
   // Callbacks for recording test results.
   FileSystemOperationInterface::StatusCallback RecordStatusCallback() {
-    return base::Bind(&FileSystemOperationTest::DidFinish, AsWeakPtr());
+    return base::Bind(&LocalFileSystemOperationTest::DidFinish, AsWeakPtr());
   }
 
   FileSystemOperationInterface::ReadDirectoryCallback
   RecordReadDirectoryCallback() {
-    return base::Bind(&FileSystemOperationTest::DidReadDirectory, AsWeakPtr());
+    return base::Bind(&LocalFileSystemOperationTest::DidReadDirectory,
+                      AsWeakPtr());
   }
 
   FileSystemOperationInterface::GetMetadataCallback RecordMetadataCallback() {
-    return base::Bind(&FileSystemOperationTest::DidGetMetadata, AsWeakPtr());
+    return base::Bind(&LocalFileSystemOperationTest::DidGetMetadata,
+                      AsWeakPtr());
   }
 
   FileSystemOperationInterface::SnapshotFileCallback
       RecordSnapshotFileCallback() {
-    return base::Bind(&FileSystemOperationTest::DidCreateSnapshotFile,
+    return base::Bind(&LocalFileSystemOperationTest::DidCreateSnapshotFile,
                       AsWeakPtr());
   }
 
@@ -332,7 +334,7 @@ class FileSystemOperationTest
     quota_manager_->GetUsageAndQuota(
         test_helper_.origin(),
         test_helper_.storage_type(),
-        base::Bind(&FileSystemOperationTest::DidGetUsageAndQuota,
+        base::Bind(&LocalFileSystemOperationTest::DidGetUsageAndQuota,
                    &status, usage, quota));
     MessageLoop::current()->RunAllPending();
     ASSERT_EQ(quota::kQuotaStatusOk, status);
@@ -385,10 +387,10 @@ class FileSystemOperationTest
 
   int next_unique_path_suffix_;
 
-  DISALLOW_COPY_AND_ASSIGN(FileSystemOperationTest);
+  DISALLOW_COPY_AND_ASSIGN(LocalFileSystemOperationTest);
 };
 
-void FileSystemOperationTest::SetUp() {
+void LocalFileSystemOperationTest::SetUp() {
   FilePath base_dir = base_.path().AppendASCII("filesystem");
   quota_manager_ = new MockQuotaManager(
       base_dir, test_helper_.origin(), test_helper_.storage_type());
@@ -399,7 +401,7 @@ void FileSystemOperationTest::SetUp() {
                      NULL);
 }
 
-void FileSystemOperationTest::TearDown() {
+void LocalFileSystemOperationTest::TearDown() {
   // Let the client go away before dropping a ref of the quota manager proxy.
   quota_manager_proxy()->SimulateQuotaManagerDestroyed();
   quota_manager_ = NULL;
@@ -407,11 +409,11 @@ void FileSystemOperationTest::TearDown() {
   test_helper_.TearDown();
 }
 
-FileSystemOperation* FileSystemOperationTest::operation() {
+LocalFileSystemOperation* LocalFileSystemOperationTest::operation() {
   return test_helper_.NewOperation();
 }
 
-TEST_F(FileSystemOperationTest, TestMoveFailureSrcDoesntExist) {
+TEST_F(LocalFileSystemOperationTest, TestMoveFailureSrcDoesntExist) {
   FileSystemURL src(URLForPath(FilePath(FILE_PATH_LITERAL("a"))));
   FileSystemURL dest(URLForPath(FilePath(FILE_PATH_LITERAL("b"))));
   operation()->Move(src, dest, RecordStatusCallback());
@@ -419,7 +421,7 @@ TEST_F(FileSystemOperationTest, TestMoveFailureSrcDoesntExist) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
-TEST_F(FileSystemOperationTest, TestMoveFailureContainsPath) {
+TEST_F(LocalFileSystemOperationTest, TestMoveFailureContainsPath) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDirInDir(src_dir_path));
   operation()->Move(URLForPath(src_dir_path), URLForPath(dest_dir_path),
@@ -428,7 +430,7 @@ TEST_F(FileSystemOperationTest, TestMoveFailureContainsPath) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
 }
 
-TEST_F(FileSystemOperationTest, TestMoveFailureSrcDirExistsDestFile) {
+TEST_F(LocalFileSystemOperationTest, TestMoveFailureSrcDirExistsDestFile) {
   // Src exists and is dir. Dest is a file.
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDir());
@@ -440,7 +442,8 @@ TEST_F(FileSystemOperationTest, TestMoveFailureSrcDirExistsDestFile) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
 }
 
-TEST_F(FileSystemOperationTest, TestMoveFailureSrcFileExistsDestNonEmptyDir) {
+TEST_F(LocalFileSystemOperationTest,
+       TestMoveFailureSrcFileExistsDestNonEmptyDir) {
   // Src exists and is a directory. Dest is a non-empty directory.
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDir());
@@ -452,7 +455,7 @@ TEST_F(FileSystemOperationTest, TestMoveFailureSrcFileExistsDestNonEmptyDir) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_EMPTY, status());
 }
 
-TEST_F(FileSystemOperationTest, TestMoveFailureSrcFileExistsDestDir) {
+TEST_F(LocalFileSystemOperationTest, TestMoveFailureSrcFileExistsDestDir) {
   // Src exists and is a file. Dest is a directory.
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
@@ -464,7 +467,7 @@ TEST_F(FileSystemOperationTest, TestMoveFailureSrcFileExistsDestDir) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
 }
 
-TEST_F(FileSystemOperationTest, TestMoveFailureDestParentDoesntExist) {
+TEST_F(LocalFileSystemOperationTest, TestMoveFailureDestParentDoesntExist) {
   // Dest. parent path does not exist.
   FilePath src_dir_path(CreateUniqueDir());
   FilePath nonexisting_file = FilePath(FILE_PATH_LITERAL("NonexistingDir")).
@@ -476,7 +479,7 @@ TEST_F(FileSystemOperationTest, TestMoveFailureDestParentDoesntExist) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
-TEST_F(FileSystemOperationTest, TestMoveSuccessSrcFileAndOverwrite) {
+TEST_F(LocalFileSystemOperationTest, TestMoveSuccessSrcFileAndOverwrite) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateUniqueDir());
@@ -493,7 +496,7 @@ TEST_F(FileSystemOperationTest, TestMoveSuccessSrcFileAndOverwrite) {
   EXPECT_EQ(0, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestMoveSuccessSrcFileAndNew) {
+TEST_F(LocalFileSystemOperationTest, TestMoveSuccessSrcFileAndNew) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateUniqueDir());
@@ -506,7 +509,7 @@ TEST_F(FileSystemOperationTest, TestMoveSuccessSrcFileAndNew) {
   EXPECT_TRUE(FileExists(dest_file_path));
 }
 
-TEST_F(FileSystemOperationTest, TestMoveSuccessSrcDirAndOverwrite) {
+TEST_F(LocalFileSystemOperationTest, TestMoveSuccessSrcDirAndOverwrite) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDir());
 
@@ -522,7 +525,7 @@ TEST_F(FileSystemOperationTest, TestMoveSuccessSrcDirAndOverwrite) {
       dest_dir_path.Append(VirtualPath::BaseName(src_dir_path))));
 }
 
-TEST_F(FileSystemOperationTest, TestMoveSuccessSrcDirAndNew) {
+TEST_F(LocalFileSystemOperationTest, TestMoveSuccessSrcDirAndNew) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_parent_dir_path(CreateUniqueDir());
   FilePath dest_child_dir_path(dest_parent_dir_path.
@@ -536,7 +539,7 @@ TEST_F(FileSystemOperationTest, TestMoveSuccessSrcDirAndNew) {
   EXPECT_TRUE(DirectoryExists(dest_child_dir_path));
 }
 
-TEST_F(FileSystemOperationTest, TestMoveSuccessSrcDirRecursive) {
+TEST_F(LocalFileSystemOperationTest, TestMoveSuccessSrcDirRecursive) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath child_dir_path(CreateUniqueDirInDir(src_dir_path));
   FilePath grandchild_file_path(
@@ -555,7 +558,7 @@ TEST_F(FileSystemOperationTest, TestMoveSuccessSrcDirRecursive) {
       VirtualPath::BaseName(grandchild_file_path))));
 }
 
-TEST_F(FileSystemOperationTest, TestCopyFailureSrcDoesntExist) {
+TEST_F(LocalFileSystemOperationTest, TestCopyFailureSrcDoesntExist) {
   operation()->Copy(URLForPath(FilePath(FILE_PATH_LITERAL("a"))),
                     URLForPath(FilePath(FILE_PATH_LITERAL("b"))),
                     RecordStatusCallback());
@@ -563,7 +566,7 @@ TEST_F(FileSystemOperationTest, TestCopyFailureSrcDoesntExist) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCopyFailureContainsPath) {
+TEST_F(LocalFileSystemOperationTest, TestCopyFailureContainsPath) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDirInDir(src_dir_path));
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_dir_path),
@@ -572,7 +575,7 @@ TEST_F(FileSystemOperationTest, TestCopyFailureContainsPath) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCopyFailureSrcDirExistsDestFile) {
+TEST_F(LocalFileSystemOperationTest, TestCopyFailureSrcDirExistsDestFile) {
   // Src exists and is dir. Dest is a file.
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDir());
@@ -584,7 +587,8 @@ TEST_F(FileSystemOperationTest, TestCopyFailureSrcDirExistsDestFile) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCopyFailureSrcFileExistsDestNonEmptyDir) {
+TEST_F(LocalFileSystemOperationTest,
+       TestCopyFailureSrcFileExistsDestNonEmptyDir) {
   // Src exists and is a directory. Dest is a non-empty directory.
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDir());
@@ -596,7 +600,7 @@ TEST_F(FileSystemOperationTest, TestCopyFailureSrcFileExistsDestNonEmptyDir) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_EMPTY, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCopyFailureSrcFileExistsDestDir) {
+TEST_F(LocalFileSystemOperationTest, TestCopyFailureSrcFileExistsDestDir) {
   // Src exists and is a file. Dest is a directory.
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
@@ -608,7 +612,7 @@ TEST_F(FileSystemOperationTest, TestCopyFailureSrcFileExistsDestDir) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCopyFailureDestParentDoesntExist) {
+TEST_F(LocalFileSystemOperationTest, TestCopyFailureDestParentDoesntExist) {
   // Dest. parent path does not exist.
   FilePath src_dir_path(CreateUniqueDir());
   FilePath nonexisting_path = FilePath(FILE_PATH_LITERAL("DontExistDir"));
@@ -623,7 +627,7 @@ TEST_F(FileSystemOperationTest, TestCopyFailureDestParentDoesntExist) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCopyFailureByQuota) {
+TEST_F(LocalFileSystemOperationTest, TestCopyFailureByQuota) {
   base::PlatformFileInfo info;
 
   FilePath src_dir_path(CreateUniqueDir());
@@ -654,7 +658,7 @@ TEST_F(FileSystemOperationTest, TestCopyFailureByQuota) {
   EXPECT_FALSE(FileExists(dest_file_path));
 }
 
-TEST_F(FileSystemOperationTest, TestCopySuccessSrcFileAndOverwrite) {
+TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcFileAndOverwrite) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateUniqueDir());
@@ -668,7 +672,7 @@ TEST_F(FileSystemOperationTest, TestCopySuccessSrcFileAndOverwrite) {
   EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestCopySuccessSrcFileAndNew) {
+TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcFileAndNew) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateUniqueDir());
@@ -682,7 +686,7 @@ TEST_F(FileSystemOperationTest, TestCopySuccessSrcFileAndNew) {
   EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirAndOverwrite) {
+TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcDirAndOverwrite) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDir());
 
@@ -698,7 +702,7 @@ TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirAndOverwrite) {
   EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirAndNew) {
+TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcDirAndNew) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_parent_dir_path(CreateUniqueDir());
   FilePath dest_child_dir_path(dest_parent_dir_path.
@@ -712,7 +716,7 @@ TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirAndNew) {
   EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirRecursive) {
+TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcDirRecursive) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath child_dir_path(CreateUniqueDirInDir(src_dir_path));
   FilePath grandchild_file_path(
@@ -732,7 +736,7 @@ TEST_F(FileSystemOperationTest, TestCopySuccessSrcDirRecursive) {
   EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestCreateFileFailure) {
+TEST_F(LocalFileSystemOperationTest, TestCreateFileFailure) {
   // Already existing file and exclusive true.
   FilePath dir_path(CreateUniqueDir());
   FilePath file_path(CreateUniqueFileInDir(dir_path));
@@ -742,7 +746,7 @@ TEST_F(FileSystemOperationTest, TestCreateFileFailure) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCreateFileSuccessFileExists) {
+TEST_F(LocalFileSystemOperationTest, TestCreateFileSuccessFileExists) {
   // Already existing file and exclusive false.
   FilePath dir_path(CreateUniqueDir());
   FilePath file_path(CreateUniqueFileInDir(dir_path));
@@ -753,7 +757,7 @@ TEST_F(FileSystemOperationTest, TestCreateFileSuccessFileExists) {
   EXPECT_TRUE(FileExists(file_path));
 }
 
-TEST_F(FileSystemOperationTest, TestCreateFileSuccessExclusive) {
+TEST_F(LocalFileSystemOperationTest, TestCreateFileSuccessExclusive) {
   // File doesn't exist but exclusive is true.
   FilePath dir_path(CreateUniqueDir());
   FilePath file_path(dir_path.Append(FILE_PATH_LITERAL("FileDoesntExist")));
@@ -764,7 +768,7 @@ TEST_F(FileSystemOperationTest, TestCreateFileSuccessExclusive) {
   EXPECT_TRUE(FileExists(file_path));
 }
 
-TEST_F(FileSystemOperationTest, TestCreateFileSuccessFileDoesntExist) {
+TEST_F(LocalFileSystemOperationTest, TestCreateFileSuccessFileDoesntExist) {
   // Non existing file.
   FilePath dir_path(CreateUniqueDir());
   FilePath file_path(dir_path.Append(FILE_PATH_LITERAL("FileDoesntExist")));
@@ -774,7 +778,7 @@ TEST_F(FileSystemOperationTest, TestCreateFileSuccessFileDoesntExist) {
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 }
 
-TEST_F(FileSystemOperationTest,
+TEST_F(LocalFileSystemOperationTest,
        TestCreateDirFailureDestParentDoesntExist) {
   // Dest. parent path does not exist.
   FilePath nonexisting_path(FilePath(
@@ -787,7 +791,7 @@ TEST_F(FileSystemOperationTest,
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCreateDirFailureDirExists) {
+TEST_F(LocalFileSystemOperationTest, TestCreateDirFailureDirExists) {
   // Exclusive and dir existing at path.
   FilePath src_dir_path(CreateUniqueDir());
   operation()->CreateDirectory(URLForPath(src_dir_path), true, false,
@@ -796,7 +800,7 @@ TEST_F(FileSystemOperationTest, TestCreateDirFailureDirExists) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCreateDirFailureFileExists) {
+TEST_F(LocalFileSystemOperationTest, TestCreateDirFailureFileExists) {
   // Exclusive true and file existing at path.
   FilePath dir_path(CreateUniqueDir());
   FilePath file_path(CreateUniqueFileInDir(dir_path));
@@ -806,7 +810,7 @@ TEST_F(FileSystemOperationTest, TestCreateDirFailureFileExists) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, status());
 }
 
-TEST_F(FileSystemOperationTest, TestCreateDirSuccess) {
+TEST_F(LocalFileSystemOperationTest, TestCreateDirSuccess) {
   // Dir exists and exclusive is false.
   FilePath dir_path(CreateUniqueDir());
   operation()->CreateDirectory(URLForPath(dir_path), false, false,
@@ -824,7 +828,7 @@ TEST_F(FileSystemOperationTest, TestCreateDirSuccess) {
   EXPECT_TRUE(DirectoryExists(nonexisting_dir_path));
 }
 
-TEST_F(FileSystemOperationTest, TestCreateDirSuccessExclusive) {
+TEST_F(LocalFileSystemOperationTest, TestCreateDirSuccessExclusive) {
   // Dir doesn't exist.
   FilePath nonexisting_dir_path(FilePath(
       FILE_PATH_LITERAL("nonexistingdir")));
@@ -836,7 +840,7 @@ TEST_F(FileSystemOperationTest, TestCreateDirSuccessExclusive) {
   EXPECT_TRUE(DirectoryExists(nonexisting_dir_path));
 }
 
-TEST_F(FileSystemOperationTest, TestExistsAndMetadataFailure) {
+TEST_F(LocalFileSystemOperationTest, TestExistsAndMetadataFailure) {
   FilePath nonexisting_dir_path(FilePath(
       FILE_PATH_LITERAL("nonexistingdir")));
   operation()->GetMetadata(URLForPath(nonexisting_dir_path),
@@ -856,7 +860,7 @@ TEST_F(FileSystemOperationTest, TestExistsAndMetadataFailure) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
-TEST_F(FileSystemOperationTest, TestExistsAndMetadataSuccess) {
+TEST_F(LocalFileSystemOperationTest, TestExistsAndMetadataSuccess) {
   FilePath dir_path(CreateUniqueDir());
   int read_access = 0;
 
@@ -889,7 +893,7 @@ TEST_F(FileSystemOperationTest, TestExistsAndMetadataSuccess) {
   EXPECT_EQ(read_access, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestTypeMismatchErrors) {
+TEST_F(LocalFileSystemOperationTest, TestTypeMismatchErrors) {
   FilePath dir_path(CreateUniqueDir());
   operation()->FileExists(URLForPath(dir_path), RecordStatusCallback());
   MessageLoop::current()->RunAllPending();
@@ -902,7 +906,7 @@ TEST_F(FileSystemOperationTest, TestTypeMismatchErrors) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY, status());
 }
 
-TEST_F(FileSystemOperationTest, TestReadDirFailure) {
+TEST_F(LocalFileSystemOperationTest, TestReadDirFailure) {
   // Path doesn't exist
   FilePath nonexisting_dir_path(FilePath(
       FILE_PATH_LITERAL("NonExistingDir")));
@@ -922,7 +926,7 @@ TEST_F(FileSystemOperationTest, TestReadDirFailure) {
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
 
-TEST_F(FileSystemOperationTest, TestReadDirSuccess) {
+TEST_F(LocalFileSystemOperationTest, TestReadDirSuccess) {
   //      parent_dir
   //       |       |
   //  child_dir  child_file
@@ -950,7 +954,7 @@ TEST_F(FileSystemOperationTest, TestReadDirSuccess) {
   EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestRemoveFailure) {
+TEST_F(LocalFileSystemOperationTest, TestRemoveFailure) {
   // Path doesn't exist.
   FilePath nonexisting_path(FilePath(
       FILE_PATH_LITERAL("NonExistingDir")));
@@ -979,7 +983,7 @@ TEST_F(FileSystemOperationTest, TestRemoveFailure) {
             status());
 }
 
-TEST_F(FileSystemOperationTest, TestRemoveSuccess) {
+TEST_F(LocalFileSystemOperationTest, TestRemoveSuccess) {
   FilePath empty_dir_path(CreateUniqueDir());
   EXPECT_TRUE(DirectoryExists(empty_dir_path));
 
@@ -1009,7 +1013,7 @@ TEST_F(FileSystemOperationTest, TestRemoveSuccess) {
   EXPECT_EQ(0, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestTruncate) {
+TEST_F(LocalFileSystemOperationTest, TestTruncate) {
   FilePath dir_path(CreateUniqueDir());
   FilePath file_path(CreateUniqueFileInDir(dir_path));
 
@@ -1065,7 +1069,7 @@ TEST_F(FileSystemOperationTest, TestTruncate) {
   EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
 }
 
-TEST_F(FileSystemOperationTest, TestTruncateFailureByQuota) {
+TEST_F(LocalFileSystemOperationTest, TestTruncateFailureByQuota) {
   base::PlatformFileInfo info;
 
   FilePath dir_path(CreateUniqueDir());
@@ -1089,7 +1093,7 @@ TEST_F(FileSystemOperationTest, TestTruncateFailureByQuota) {
   EXPECT_EQ(10, info.size);
 }
 
-TEST_F(FileSystemOperationTest, TestTouchFile) {
+TEST_F(LocalFileSystemOperationTest, TestTouchFile) {
   FilePath file_path(CreateUniqueFileInDir(FilePath()));
   FilePath platform_path = PlatformPath(file_path);
 
@@ -1121,7 +1125,7 @@ TEST_F(FileSystemOperationTest, TestTouchFile) {
   EXPECT_EQ(new_accessed_time.ToTimeT(), info.last_accessed.ToTimeT());
 }
 
-TEST_F(FileSystemOperationTest, TestCreateSnapshotFile) {
+TEST_F(LocalFileSystemOperationTest, TestCreateSnapshotFile) {
   FilePath dir_path(CreateUniqueDir());
 
   // Create a file for the testing.
@@ -1133,9 +1137,9 @@ TEST_F(FileSystemOperationTest, TestCreateSnapshotFile) {
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 
   // See if we can get a 'snapshot' file info for the file.
-  // Since FileSystemOperation assumes the file exists in the local directory
-  // it should just returns the same metadata and platform_path as
-  // the file itself.
+  // Since LocalFileSystemOperation assumes the file exists in the local
+  // directory it should just returns the same metadata and platform_path
+  // as the file itself.
   operation()->CreateSnapshotFile(URLForPath(file_path),
                                   RecordSnapshotFileCallback());
   MessageLoop::current()->RunAllPending();
diff --git a/webkit/fileapi/file_system_operation_write_unittest.cc b/webkit/fileapi/local_file_system_operation_write_unittest.cc
index 156b3ec..3851da3 100644
--- a/webkit/fileapi/file_system_operation_write_unittest.cc
+++ b/webkit/fileapi/local_file_system_operation_write_unittest.cc
@@ -20,9 +20,9 @@
 #include "webkit/blob/blob_url_request_job.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
-#include "webkit/fileapi/file_system_operation.h"
-#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/local_file_system_operation.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/local_file_util.h"
 #include "webkit/quota/quota_manager.h"
 
@@ -66,11 +66,11 @@ class MockQuotaManager : public QuotaManager {
 
 }  // namespace
 
-class FileSystemOperationWriteTest
+class LocalFileSystemOperationWriteTest
     : public testing::Test,
-      public base::SupportsWeakPtr<FileSystemOperationWriteTest> {
+      public base::SupportsWeakPtr<LocalFileSystemOperationWriteTest> {
  public:
-  FileSystemOperationWriteTest()
+  LocalFileSystemOperationWriteTest()
       : test_helper_(GURL("http://example.com"), kFileSystemTypeTest),
         loop_(MessageLoop::TYPE_IO),
         status_(base::PLATFORM_FILE_OK),
@@ -78,7 +78,7 @@ class FileSystemOperationWriteTest
         bytes_written_(0),
         complete_(false) {}
 
-  FileSystemOperation* operation();
+  LocalFileSystemOperation* operation();
 
   base::PlatformFileError status() const { return status_; }
   base::PlatformFileError cancel_status() const { return cancel_status_; }
@@ -100,11 +100,13 @@ class FileSystemOperationWriteTest
 
   // Callback function for recording test results.
   FileSystemOperationInterface::WriteCallback RecordWriteCallback() {
-    return base::Bind(&FileSystemOperationWriteTest::DidWrite, AsWeakPtr());
+    return base::Bind(&LocalFileSystemOperationWriteTest::DidWrite,
+                      AsWeakPtr());
   }
 
   FileSystemOperationInterface::StatusCallback RecordCancelCallback() {
-    return base::Bind(&FileSystemOperationWriteTest::DidCancel, AsWeakPtr());
+    return base::Bind(&LocalFileSystemOperationWriteTest::DidCancel,
+                      AsWeakPtr());
   }
 
   void DidWrite(base::PlatformFileError status, int64 bytes, bool complete) {
@@ -131,7 +133,7 @@ class FileSystemOperationWriteTest
   }
 
   scoped_refptr<MockQuotaManager> quota_manager_;
-  FileSystemTestOriginHelper test_helper_;
+  LocalFileSystemTestOriginHelper test_helper_;
 
   MessageLoop loop_;
 
@@ -144,7 +146,7 @@ class FileSystemOperationWriteTest
   int64 bytes_written_;
   bool complete_;
 
-  DISALLOW_COPY_AND_ASSIGN(FileSystemOperationWriteTest);
+  DISALLOW_COPY_AND_ASSIGN(LocalFileSystemOperationWriteTest);
 };
 
 namespace {
@@ -196,7 +198,7 @@ class TestURLRequestContext : public net::URLRequestContext {
 
 }  // namespace (anonymous)
 
-void FileSystemOperationWriteTest::SetUp() {
+void LocalFileSystemOperationWriteTest::SetUp() {
   ASSERT_TRUE(dir_.CreateUniqueTempDir());
   FilePath base_dir = dir_.path().AppendASCII("filesystem");
 
@@ -212,16 +214,16 @@ void FileSystemOperationWriteTest::SetUp() {
       base::Bind(&AssertStatusEq, base::PLATFORM_FILE_OK));
 }
 
-void FileSystemOperationWriteTest::TearDown() {
+void LocalFileSystemOperationWriteTest::TearDown() {
   quota_manager_ = NULL;
   test_helper_.TearDown();
 }
 
-FileSystemOperation* FileSystemOperationWriteTest::operation() {
+LocalFileSystemOperation* LocalFileSystemOperationWriteTest::operation() {
   return test_helper_.NewOperation();
 }
 
-TEST_F(FileSystemOperationWriteTest, TestWriteSuccess) {
+TEST_F(LocalFileSystemOperationWriteTest, TestWriteSuccess) {
   GURL blob_url("blob:success");
   scoped_refptr<webkit_blob::BlobData> blob_data(new webkit_blob::BlobData());
   blob_data->AppendData("Hello, world!\n");
@@ -241,7 +243,7 @@ TEST_F(FileSystemOperationWriteTest, TestWriteSuccess) {
   EXPECT_TRUE(complete());
 }
 
-TEST_F(FileSystemOperationWriteTest, TestWriteZero) {
+TEST_F(LocalFileSystemOperationWriteTest, TestWriteZero) {
   GURL blob_url("blob:zero");
   scoped_refptr<webkit_blob::BlobData> blob_data(new webkit_blob::BlobData());
 
@@ -260,7 +262,7 @@ TEST_F(FileSystemOperationWriteTest, TestWriteZero) {
   EXPECT_TRUE(complete());
 }
 
-TEST_F(FileSystemOperationWriteTest, TestWriteInvalidBlobUrl) {
+TEST_F(LocalFileSystemOperationWriteTest, TestWriteInvalidBlobUrl) {
   TestURLRequestContext url_request_context;
 
   operation()->Write(&url_request_context, URLForPath(virtual_path_),
@@ -272,7 +274,7 @@ TEST_F(FileSystemOperationWriteTest, TestWriteInvalidBlobUrl) {
   EXPECT_TRUE(complete());
 }
 
-TEST_F(FileSystemOperationWriteTest, TestWriteInvalidFile) {
+TEST_F(LocalFileSystemOperationWriteTest, TestWriteInvalidFile) {
   GURL blob_url("blob:writeinvalidfile");
   scoped_refptr<webkit_blob::BlobData> blob_data(new webkit_blob::BlobData());
   blob_data->AppendData("It\'ll not be written.");
@@ -293,7 +295,7 @@ TEST_F(FileSystemOperationWriteTest, TestWriteInvalidFile) {
   EXPECT_TRUE(complete());
 }
 
-TEST_F(FileSystemOperationWriteTest, TestWriteDir) {
+TEST_F(LocalFileSystemOperationWriteTest, TestWriteDir) {
   FilePath virtual_dir_path(FILE_PATH_LITERAL("d"));
   operation()->CreateDirectory(
       URLForPath(virtual_dir_path),
@@ -323,7 +325,7 @@ TEST_F(FileSystemOperationWriteTest, TestWriteDir) {
   EXPECT_TRUE(complete());
 }
 
-TEST_F(FileSystemOperationWriteTest, TestWriteFailureByQuota) {
+TEST_F(LocalFileSystemOperationWriteTest, TestWriteFailureByQuota) {
   GURL blob_url("blob:success");
   scoped_refptr<webkit_blob::BlobData> blob_data(new webkit_blob::BlobData());
   blob_data->AppendData("Hello, world!\n");
@@ -344,7 +346,7 @@ TEST_F(FileSystemOperationWriteTest, TestWriteFailureByQuota) {
   EXPECT_TRUE(complete());
 }
 
-TEST_F(FileSystemOperationWriteTest, TestImmediateCancelSuccessfulWrite) {
+TEST_F(LocalFileSystemOperationWriteTest, TestImmediateCancelSuccessfulWrite) {
   GURL blob_url("blob:success");
   scoped_refptr<webkit_blob::BlobData> blob_data(new webkit_blob::BlobData());
   blob_data->AppendData("Hello, world!\n");
@@ -372,7 +374,7 @@ TEST_F(FileSystemOperationWriteTest, TestImmediateCancelSuccessfulWrite) {
   EXPECT_TRUE(complete());
 }
 
-TEST_F(FileSystemOperationWriteTest, TestImmediateCancelFailingWrite) {
+TEST_F(LocalFileSystemOperationWriteTest, TestImmediateCancelFailingWrite) {
   GURL blob_url("blob:writeinvalidfile");
   scoped_refptr<webkit_blob::BlobData> blob_data(new webkit_blob::BlobData());
   blob_data->AppendData("It\'ll not be written.");
diff --git a/webkit/fileapi/file_system_quota_unittest.cc b/webkit/fileapi/local_file_system_quota_unittest.cc
index 665a274..f673ae8 100644
--- a/webkit/fileapi/file_system_quota_unittest.cc
+++ b/webkit/fileapi/local_file_system_quota_unittest.cc
@@ -16,10 +16,10 @@
 #include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/fileapi/file_system_operation.h"
-#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/local_file_system_operation.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/quota/quota_manager.h"
 
 namespace fileapi {
@@ -35,11 +35,11 @@ void AssertFileErrorEq(base::PlatformFileError expected,
 
 } // namespace
 
-class FileSystemQuotaTest
+class LocalFileSystemQuotaTest
     : public testing::Test,
-      public base::SupportsWeakPtr<FileSystemQuotaTest> {
+      public base::SupportsWeakPtr<LocalFileSystemQuotaTest> {
  public:
-  FileSystemQuotaTest()
+  LocalFileSystemQuotaTest()
       : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         next_unique_path_suffix_(0),
         status_(kFileOperationStatusNotSet),
@@ -47,7 +47,7 @@ class FileSystemQuotaTest
         usage_(-1),
         quota_(-1) {}
 
-  FileSystemOperation* operation();
+  LocalFileSystemOperation* operation();
 
   int status() const { return status_; }
   quota::QuotaStatusCode quota_status() const { return quota_status_; }
@@ -93,7 +93,7 @@ class FileSystemQuotaTest
   void GetUsageAndQuotaFromQuotaManager() {
     quota_manager_->GetUsageAndQuota(
         test_helper_.origin(), test_helper_.storage_type(),
-        base::Bind(&FileSystemQuotaTest::OnGetUsageAndQuota,
+        base::Bind(&LocalFileSystemQuotaTest::OnGetUsageAndQuota,
                    weak_factory_.GetWeakPtr()));
     MessageLoop::current()->RunAllPending();
   }
@@ -152,20 +152,20 @@ class FileSystemQuotaTest
  protected:
   // Callback for recording test results.
   FileSystemOperationInterface::StatusCallback RecordStatusCallback() {
-    return base::Bind(&FileSystemQuotaTest::DidFinish, AsWeakPtr());
+    return base::Bind(&LocalFileSystemQuotaTest::DidFinish, AsWeakPtr());
   }
 
   void DidFinish(base::PlatformFileError status) {
     status_ = status;
   }
 
-  FileSystemTestOriginHelper test_helper_;
+  LocalFileSystemTestOriginHelper test_helper_;
 
   ScopedTempDir work_dir_;
   MessageLoop message_loop_;
   scoped_refptr<quota::QuotaManager> quota_manager_;
 
-  base::WeakPtrFactory<FileSystemQuotaTest> weak_factory_;
+  base::WeakPtrFactory<LocalFileSystemQuotaTest> weak_factory_;
 
   int next_unique_path_suffix_;
 
@@ -175,10 +175,10 @@ class FileSystemQuotaTest
   int64 usage_;
   int64 quota_;
 
-  DISALLOW_COPY_AND_ASSIGN(FileSystemQuotaTest);
+  DISALLOW_COPY_AND_ASSIGN(LocalFileSystemQuotaTest);
 };
 
-void FileSystemQuotaTest::SetUp() {
+void LocalFileSystemQuotaTest::SetUp() {
   ASSERT_TRUE(work_dir_.CreateUniqueTempDir());
   FilePath filesystem_dir_path = work_dir_.path().AppendASCII("filesystem");
   ASSERT_TRUE(file_util::CreateDirectory(filesystem_dir_path));
@@ -196,23 +196,23 @@ void FileSystemQuotaTest::SetUp() {
                      NULL);
 }
 
-void FileSystemQuotaTest::TearDown() {
+void LocalFileSystemQuotaTest::TearDown() {
   quota_manager_ = NULL;
   test_helper_.TearDown();
 }
 
-FileSystemOperation* FileSystemQuotaTest::operation() {
+LocalFileSystemOperation* LocalFileSystemQuotaTest::operation() {
   return test_helper_.NewOperation();
 }
 
-void FileSystemQuotaTest::OnGetUsageAndQuota(
+void LocalFileSystemQuotaTest::OnGetUsageAndQuota(
     quota::QuotaStatusCode status, int64 usage, int64 quota) {
   quota_status_ = status;
   usage_ = usage;
   quota_ = quota;
 }
 
-void FileSystemQuotaTest::PrepareFileSet(const FilePath& virtual_path) {
+void LocalFileSystemQuotaTest::PrepareFileSet(const FilePath& virtual_path) {
   int64 usage = SizeByQuotaUtil();
   child_dir_path_ = CreateUniqueDirInDir(virtual_path);
   child_file1_path_ = CreateUniqueFileInDir(virtual_path);
@@ -225,7 +225,7 @@ void FileSystemQuotaTest::PrepareFileSet(const FilePath& virtual_path) {
   grandchild_path_cost_ = SizeByQuotaUtil() - usage;
 }
 
-TEST_F(FileSystemQuotaTest, TestMoveSuccessSrcDirRecursive) {
+TEST_F(LocalFileSystemQuotaTest, TestMoveSuccessSrcDirRecursive) {
   FilePath src_dir_path(CreateUniqueDir());
   int src_path_cost = SizeByQuotaUtil();
   PrepareFileSet(src_dir_path);
@@ -273,7 +273,7 @@ TEST_F(FileSystemQuotaTest, TestMoveSuccessSrcDirRecursive) {
   ASSERT_LT(all_file_size + total_path_cost - src_path_cost, quota());
 }
 
-TEST_F(FileSystemQuotaTest, TestCopySuccessSrcDirRecursive) {
+TEST_F(LocalFileSystemQuotaTest, TestCopySuccessSrcDirRecursive) {
   FilePath src_dir_path(CreateUniqueDir());
   PrepareFileSet(src_dir_path);
   FilePath dest_dir1_path(CreateUniqueDir());
diff --git a/webkit/fileapi/file_system_test_helper.cc b/webkit/fileapi/local_file_system_test_helper.cc
index 477ebfd..1116d0c 100644
--- a/webkit/fileapi/file_system_test_helper.cc
+++ b/webkit/fileapi/local_file_system_test_helper.cc
@@ -2,18 +2,18 @@
 // 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_test_helper.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/fileapi/file_system_context.h"
-#include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_util_helper.h"
+#include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/fileapi/test_mount_point_provider.h"
@@ -21,26 +21,26 @@
 
 namespace fileapi {
 
-FileSystemTestOriginHelper::FileSystemTestOriginHelper(
+LocalFileSystemTestOriginHelper::LocalFileSystemTestOriginHelper(
     const GURL& origin, FileSystemType type)
     : origin_(origin), type_(type), file_util_(NULL) {
 }
 
-FileSystemTestOriginHelper::FileSystemTestOriginHelper()
+LocalFileSystemTestOriginHelper::LocalFileSystemTestOriginHelper()
     : origin_(GURL("http://foo.com")),
       type_(kFileSystemTypeTemporary),
       file_util_(NULL) {
 }
 
-FileSystemTestOriginHelper::~FileSystemTestOriginHelper() {
+LocalFileSystemTestOriginHelper::~LocalFileSystemTestOriginHelper() {
 }
 
-void FileSystemTestOriginHelper::SetUp(
+void LocalFileSystemTestOriginHelper::SetUp(
     const FilePath& base_dir, FileSystemFileUtil* file_util) {
   SetUp(base_dir, false, NULL, file_util);
 }
 
-void FileSystemTestOriginHelper::SetUp(
+void LocalFileSystemTestOriginHelper::SetUp(
     FileSystemContext* file_system_context, FileSystemFileUtil* file_util) {
   file_util_ = file_util;
   file_system_context_ = file_system_context;
@@ -59,7 +59,7 @@ void FileSystemTestOriginHelper::SetUp(
     FileSystemUsageCache::UpdateUsage(usage_cache_path, 0);
 }
 
-void FileSystemTestOriginHelper::SetUp(
+void LocalFileSystemTestOriginHelper::SetUp(
     const FilePath& base_dir,
     bool unlimited_quota,
     quota::QuotaManagerProxy* quota_manager_proxy,
@@ -101,18 +101,18 @@ void FileSystemTestOriginHelper::SetUp(
     FileSystemUsageCache::UpdateUsage(usage_cache_path, 0);
 }
 
-void FileSystemTestOriginHelper::TearDown() {
+void LocalFileSystemTestOriginHelper::TearDown() {
   file_system_context_ = NULL;
   MessageLoop::current()->RunAllPending();
 }
 
-FilePath FileSystemTestOriginHelper::GetOriginRootPath() const {
+FilePath LocalFileSystemTestOriginHelper::GetOriginRootPath() const {
   return file_system_context_->GetMountPointProvider(type_)->
       GetFileSystemRootPathOnFileThread(
           origin_, type_, FilePath(), false);
 }
 
-FilePath FileSystemTestOriginHelper::GetLocalPath(const FilePath& path) {
+FilePath LocalFileSystemTestOriginHelper::GetLocalPath(const FilePath& path) {
   DCHECK(file_util_);
   FilePath local_path;
   scoped_ptr<FileSystemOperationContext> context(NewOperationContext());
@@ -120,12 +120,12 @@ FilePath FileSystemTestOriginHelper::GetLocalPath(const FilePath& path) {
   return local_path;
 }
 
-FilePath FileSystemTestOriginHelper::GetLocalPathFromASCII(
+FilePath LocalFileSystemTestOriginHelper::GetLocalPathFromASCII(
     const std::string& path) {
   return GetLocalPath(FilePath().AppendASCII(path));
 }
 
-FilePath FileSystemTestOriginHelper::GetUsageCachePath() const {
+FilePath LocalFileSystemTestOriginHelper::GetUsageCachePath() const {
   if (type_ != kFileSystemTypeTemporary &&
       type_ != kFileSystemTypePersistent)
     return FilePath();
@@ -133,52 +133,54 @@ FilePath FileSystemTestOriginHelper::GetUsageCachePath() const {
       sandbox_provider()->GetUsageCachePathForOriginAndType(origin_, type_);
 }
 
-FileSystemURL FileSystemTestOriginHelper::CreateURL(const FilePath& path)
+FileSystemURL LocalFileSystemTestOriginHelper::CreateURL(const FilePath& path)
     const {
   return FileSystemURL(origin_, type_, path);
 }
 
-base::PlatformFileError FileSystemTestOriginHelper::SameFileUtilCopy(
+base::PlatformFileError LocalFileSystemTestOriginHelper::SameFileUtilCopy(
     FileSystemOperationContext* context,
     const FileSystemURL& src,
     const FileSystemURL& dest) const {
   return FileUtilHelper::Copy(context, file_util(), file_util(), src, dest);
 }
 
-base::PlatformFileError FileSystemTestOriginHelper::SameFileUtilMove(
+base::PlatformFileError LocalFileSystemTestOriginHelper::SameFileUtilMove(
     FileSystemOperationContext* context,
     const FileSystemURL& src,
     const FileSystemURL& dest) const {
   return FileUtilHelper::Move(context, file_util(), file_util(), src, dest);
 }
 
-int64 FileSystemTestOriginHelper::GetCachedOriginUsage() const {
+int64 LocalFileSystemTestOriginHelper::GetCachedOriginUsage() const {
   return file_system_context_->GetQuotaUtil(type_)->GetOriginUsageOnFileThread(
       file_system_context_, origin_, type_);
 }
 
-int64 FileSystemTestOriginHelper::ComputeCurrentOriginUsage() const {
+int64 LocalFileSystemTestOriginHelper::ComputeCurrentOriginUsage() const {
   int64 size = file_util::ComputeDirectorySize(GetOriginRootPath());
   if (file_util::PathExists(GetUsageCachePath()))
     size -= FileSystemUsageCache::kUsageFileSize;
   return size;
 }
 
-int64 FileSystemTestOriginHelper::ComputeCurrentDirectoryDatabaseUsage() const {
+int64
+LocalFileSystemTestOriginHelper::ComputeCurrentDirectoryDatabaseUsage() const {
   return file_util::ComputeDirectorySize(
       GetOriginRootPath().AppendASCII("Paths"));
 }
 
-FileSystemOperation* FileSystemTestOriginHelper::NewOperation() {
+LocalFileSystemOperation* LocalFileSystemTestOriginHelper::NewOperation() {
   DCHECK(file_system_context_.get());
   DCHECK(file_util_);
-  FileSystemOperation* operation =
-    new FileSystemOperation(file_system_context_.get());
+  LocalFileSystemOperation* operation =
+    new LocalFileSystemOperation(file_system_context_.get());
   operation->set_override_file_util(file_util_);
   return operation;
 }
 
-FileSystemOperationContext* FileSystemTestOriginHelper::NewOperationContext() {
+FileSystemOperationContext*
+LocalFileSystemTestOriginHelper::NewOperationContext() {
   DCHECK(file_system_context_.get());
   FileSystemOperationContext* context =
     new FileSystemOperationContext(file_system_context_.get());
diff --git a/webkit/fileapi/file_system_test_helper.h b/webkit/fileapi/local_file_system_test_helper.h
index 4406c7e..1e5da76 100644
--- a/webkit/fileapi/file_system_test_helper.h
+++ b/webkit/fileapi/local_file_system_test_helper.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef WEBKIT_FILEAPI_FILE_SYSTEM_TEST_HELPER_H_
-#define WEBKIT_FILEAPI_FILE_SYSTEM_TEST_HELPER_H_
+#ifndef WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_TEST_HELPER_H_
+#define WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_TEST_HELPER_H_
 
 #include <string>
 
@@ -25,22 +25,22 @@ namespace fileapi {
 
 class FileSystemContext;
 class FileSystemFileUtil;
-class FileSystemOperation;
 class FileSystemOperationContext;
+class LocalFileSystemOperation;
 
 // Filesystem test helper class that encapsulates test environment for
 // a given {origin, type} pair.
-class FileSystemTestOriginHelper {
+class LocalFileSystemTestOriginHelper {
  public:
-  FileSystemTestOriginHelper(const GURL& origin, FileSystemType type);
-  FileSystemTestOriginHelper();
-  ~FileSystemTestOriginHelper();
+  LocalFileSystemTestOriginHelper(const GURL& origin, FileSystemType type);
+  LocalFileSystemTestOriginHelper();
+  ~LocalFileSystemTestOriginHelper();
 
   void SetUp(const FilePath& base_dir, FileSystemFileUtil* file_util);
-  // If you want to use more than one FileSystemTestOriginHelper in a single
-  // base directory, they have to share a context, so that they don't have
-  // multiple databases fighting over the lock to the origin directory [deep
-  // down inside ObfuscatedFileUtil].
+  // If you want to use more than one LocalFileSystemTestOriginHelper in
+  // a single base directory, they have to share a context, so that they don't
+  // have multiple databases fighting over the lock to the origin directory
+  // [deep down inside ObfuscatedFileUtil].
   void SetUp(FileSystemContext* file_system_context,
              FileSystemFileUtil* file_util);
   void SetUp(const FilePath& base_dir,
@@ -79,7 +79,7 @@ class FileSystemTestOriginHelper {
 
   int64 ComputeCurrentDirectoryDatabaseUsage() const;
 
-  FileSystemOperation* NewOperation();
+  LocalFileSystemOperation* NewOperation();
   FileSystemOperationContext* NewOperationContext();
 
   FileSystemContext* file_system_context() const {
@@ -102,4 +102,4 @@ class FileSystemTestOriginHelper {
 
 }  // namespace fileapi
 
-#endif  // WEBKIT_FILEAPI_FILE_SYSTEM_TEST_HELPER_H_
+#endif  // WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_TEST_HELPER_H_
diff --git a/webkit/fileapi/local_file_util_unittest.cc b/webkit/fileapi/local_file_util_unittest.cc
index 53ef7b4..dc460b5 100644
--- a/webkit/fileapi/local_file_util_unittest.cc
+++ b/webkit/fileapi/local_file_util_unittest.cc
@@ -15,8 +15,8 @@
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_types.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/native_file_util.h"
 
@@ -91,7 +91,7 @@ class LocalFileUtilTest : public testing::Test {
         Path(file_name), created);
   }
 
-  const FileSystemTestOriginHelper& test_helper() const {
+  const LocalFileSystemTestOriginHelper& test_helper() const {
     return test_helper_;
   }
 
@@ -99,7 +99,7 @@ class LocalFileUtilTest : public testing::Test {
   scoped_ptr<LocalFileUtil> local_file_util_;
   ScopedTempDir data_dir_;
   MessageLoop message_loop_;
-  FileSystemTestOriginHelper test_helper_;
+  LocalFileSystemTestOriginHelper test_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalFileUtilTest);
 };
diff --git a/webkit/fileapi/obfuscated_file_util_unittest.cc b/webkit/fileapi/obfuscated_file_util_unittest.cc
index ec42a00..55d0bf5 100644
--- a/webkit/fileapi/obfuscated_file_util_unittest.cc
+++ b/webkit/fileapi/obfuscated_file_util_unittest.cc
@@ -17,9 +17,9 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_util_helper.h"
+#include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/test_file_set.h"
@@ -152,7 +152,8 @@ class ObfuscatedFileUtilTest : public testing::Test {
     return LimitedContext(kint64max);
   }
 
-  FileSystemOperationContext* NewContext(FileSystemTestOriginHelper* helper) {
+  FileSystemOperationContext* NewContext(
+      LocalFileSystemTestOriginHelper* helper) {
     FileSystemOperationContext* context;
     if (helper)
       context = helper->NewOperationContext();
@@ -166,10 +167,10 @@ class ObfuscatedFileUtilTest : public testing::Test {
   // and obfuscated_file_util_.
   // Use this for tests which need to run in multiple origins; we need a test
   // helper per origin.
-  FileSystemTestOriginHelper* NewHelper(
+  LocalFileSystemTestOriginHelper* NewHelper(
       const GURL& origin, fileapi::FileSystemType type) {
-    FileSystemTestOriginHelper* helper =
-        new FileSystemTestOriginHelper(origin, type);
+    LocalFileSystemTestOriginHelper* helper =
+        new LocalFileSystemTestOriginHelper(origin, type);
 
     helper->SetUp(file_system_context_.get(),
                   obfuscated_file_util_);
@@ -323,7 +324,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
   class UsageVerifyHelper {
    public:
     UsageVerifyHelper(scoped_ptr<FileSystemOperationContext> context,
-                      FileSystemTestOriginHelper* test_helper,
+                      LocalFileSystemTestOriginHelper* test_helper,
                       int64 expected_usage)
         : context_(context.Pass()),
           test_helper_(test_helper),
@@ -344,7 +345,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
     }
 
     scoped_ptr<FileSystemOperationContext> context_;
-    FileSystemTestOriginHelper* test_helper_;
+    LocalFileSystemTestOriginHelper* test_helper_;
     int64 expected_usage_;
   };
 
@@ -597,7 +598,9 @@ class ObfuscatedFileUtilTest : public testing::Test {
         test_helper().ComputeCurrentDirectoryDatabaseUsage();
   }
 
-  const FileSystemTestOriginHelper& test_helper() const { return test_helper_; }
+  const LocalFileSystemTestOriginHelper& test_helper() const {
+    return test_helper_;
+  }
 
  private:
   ScopedTempDir data_dir_;
@@ -608,7 +611,7 @@ class ObfuscatedFileUtilTest : public testing::Test {
   GURL origin_;
   fileapi::FileSystemType type_;
   base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_;
-  FileSystemTestOriginHelper test_helper_;
+  LocalFileSystemTestOriginHelper test_helper_;
   quota::QuotaStatusCode quota_status_;
   int64 usage_;
 
@@ -1416,7 +1419,7 @@ TEST_F(ObfuscatedFileUtilTest, TestOriginEnumerator) {
     GURL origin_url(record.origin_url);
     origins_expected.insert(origin_url);
     if (record.has_temporary) {
-      scoped_ptr<FileSystemTestOriginHelper> helper(
+      scoped_ptr<LocalFileSystemTestOriginHelper> helper(
           NewHelper(origin_url, kFileSystemTypeTemporary));
       scoped_ptr<FileSystemOperationContext> context(NewContext(helper.get()));
       bool created = false;
@@ -1428,7 +1431,7 @@ TEST_F(ObfuscatedFileUtilTest, TestOriginEnumerator) {
       EXPECT_TRUE(created);
     }
     if (record.has_persistent) {
-      scoped_ptr<FileSystemTestOriginHelper> helper(
+      scoped_ptr<LocalFileSystemTestOriginHelper> helper(
           NewHelper(origin_url, kFileSystemTypePersistent));
       scoped_ptr<FileSystemOperationContext> context(NewContext(helper.get()));
       bool created = false;
diff --git a/webkit/fileapi/sandbox_mount_point_provider.cc b/webkit/fileapi/sandbox_mount_point_provider.cc
index 1734da4..63c5eab 100644
--- a/webkit/fileapi/sandbox_mount_point_provider.cc
+++ b/webkit/fileapi/sandbox_mount_point_provider.cc
@@ -16,12 +16,12 @@
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "webkit/fileapi/file_system_file_stream_reader.h"
-#include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_options.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/native_file_util.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/sandbox_file_stream_writer.h"
@@ -434,7 +434,7 @@ FileSystemOperationInterface*
 SandboxMountPointProvider::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context) const {
-  return new FileSystemOperation(context);
+  return new LocalFileSystemOperation(context);
 }
 
 webkit_blob::FileStreamReader*
diff --git a/webkit/fileapi/sandbox_mount_point_provider.h b/webkit/fileapi/sandbox_mount_point_provider.h
index 9fa1a22..e1df851 100644
--- a/webkit/fileapi/sandbox_mount_point_provider.h
+++ b/webkit/fileapi/sandbox_mount_point_provider.h
@@ -177,7 +177,7 @@ class FILEAPI_EXPORT SandboxMountPointProvider
   // filesystem.
   bool IsAllowedScheme(const GURL& url) const;
 
-  friend class FileSystemTestOriginHelper;
+  friend class LocalFileSystemTestOriginHelper;
   friend class SandboxMountPointProviderMigrationTest;
   friend class SandboxMountPointProviderOriginEnumeratorTest;
 
diff --git a/webkit/fileapi/test_mount_point_provider.cc b/webkit/fileapi/test_mount_point_provider.cc
index bb70ce2..6ceb914 100644
--- a/webkit/fileapi/test_mount_point_provider.cc
+++ b/webkit/fileapi/test_mount_point_provider.cc
@@ -11,9 +11,9 @@
 #include "base/file_util.h"
 #include "base/sequenced_task_runner.h"
 #include "webkit/fileapi/file_system_file_stream_reader.h"
-#include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/native_file_util.h"
 #include "webkit/fileapi/sandbox_file_stream_writer.h"
@@ -137,7 +137,7 @@ FileSystemOperationInterface*
 TestMountPointProvider::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context) const {
-  return new FileSystemOperation(context);
+  return new LocalFileSystemOperation(context);
 }
 
 webkit_blob::FileStreamReader* TestMountPointProvider::CreateFileStreamReader(
diff --git a/webkit/fileapi/webkit_fileapi.gypi b/webkit/fileapi/webkit_fileapi.gypi
index 4d18458..6df08f1 100644
--- a/webkit/fileapi/webkit_fileapi.gypi
+++ b/webkit/fileapi/webkit_fileapi.gypi
@@ -34,8 +34,6 @@
         'file_system_file_util_proxy.cc',
         'file_system_file_util_proxy.h',
         'file_system_mount_point_provider.h',
-        'file_system_operation.cc',
-        'file_system_operation.h',
         'file_system_operation_context.cc',
         'file_system_operation_context.h',
         'file_system_operation_interface.h',
@@ -72,6 +70,8 @@
         'local_file_util.h',
         'local_file_stream_writer.cc',
         'local_file_stream_writer.h',
+        'local_file_system_operation.cc',
+        'local_file_system_operation.h',
         'native_file_util.cc',
         'native_file_util.h',
         'obfuscated_file_util.cc',