drive: Drop "Drive" from FakeDriveFileSystem and MockDriveFileSystem

chrome/browser/chromeos/drive/drive_url_request_job_unittest.cc

 // Copyright 2013 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/drive_url_request_job.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
-#include "chrome/browser/chromeos/drive/fake_drive_file_system.h"
+#include "chrome/browser/chromeos/drive/fake_file_system.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/google_apis/fake_drive_service.h"
 #include "chrome/browser/google_apis/task_util.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/test_completion_callback.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace {
 
 // A simple URLRequestJobFactory implementation to create DriveURLReuqestJob.
 class TestURLRequestJobFactory : public net::URLRequestJobFactory {
  public:
   TestURLRequestJobFactory(
-      const DriveURLRequestJob::DriveFileSystemGetter& file_system_getter)
+      const DriveURLRequestJob::FileSystemGetter& file_system_getter)
       : file_system_getter_(file_system_getter) {
   }
 
   virtual ~TestURLRequestJobFactory() {}
 
   // net::URLRequestJobFactory override:
   virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return new DriveURLRequestJob(file_system_getter_,
                                   request,
                                   network_delegate);
   }
 
   virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
     return scheme == chrome::kDriveScheme;
   }
 
   virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
     return url.is_valid() && IsHandledProtocol(url.scheme());
   }
 
  private:
-  const DriveURLRequestJob::DriveFileSystemGetter file_system_getter_;
+  const DriveURLRequestJob::FileSystemGetter file_system_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(TestURLRequestJobFactory);
 };
 
 class TestDelegate : public net::TestDelegate {
  public:
   TestDelegate() {}
 
   const GURL& redirect_url() const { return redirect_url_; }
 
@@ skipping 28 matching lines @@
     BrowserThread::PostTaskAndReply(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DriveURLRequestJobTest::SetUpOnUIThread,
                    base::Unretained(this)),
         base::MessageLoop::QuitClosure());
     message_loop_.Run();
 
     test_network_delegate_.reset(new net::TestNetworkDelegate);
     test_url_request_job_factory_.reset(new TestURLRequestJobFactory(
-        base::Bind(&DriveURLRequestJobTest::GetDriveFileSystem,
+        base::Bind(&DriveURLRequestJobTest::GetFileSystem,
                    base::Unretained(this))));
     url_request_context_.reset(new net::URLRequestContext());
     url_request_context_->set_job_factory(test_url_request_job_factory_.get());
     url_request_context_->set_network_delegate(test_network_delegate_.get());
     test_delegate_.reset(new TestDelegate);
   }
 
   virtual void TearDown() OVERRIDE {
     test_delegate_.reset();
     url_request_context_.reset();
@@ skipping 12 matching lines @@
   void SetUpOnUIThread() {
     // Initialize FakeDriveService.
     fake_drive_service_.reset(new google_apis::FakeDriveService);
     ASSERT_TRUE(fake_drive_service_->LoadResourceListForWapi(
         "chromeos/gdata/root_feed.json"));
     ASSERT_TRUE(fake_drive_service_->LoadAccountMetadataForWapi(
         "chromeos/gdata/account_metadata.json"));
     ASSERT_TRUE(fake_drive_service_->LoadAppListForDriveApi(
         "chromeos/drive/applist.json"));
 
-    // Initialize FakeDriveFileSystem.
-    fake_drive_file_system_.reset(
-        new test_util::FakeDriveFileSystem(fake_drive_service_.get()));
-    ASSERT_TRUE(fake_drive_file_system_->InitializeForTesting());
+    // Initialize FakeFileSystem.
+    fake_file_system_.reset(
+        new test_util::FakeFileSystem(fake_drive_service_.get()));
+    ASSERT_TRUE(fake_file_system_->InitializeForTesting());
   }
 
   void TearDownOnUIThread() {
-    fake_drive_file_system_.reset();
+    fake_file_system_.reset();
     fake_drive_service_.reset();
   }
 
-  DriveFileSystemInterface* GetDriveFileSystem() {
-    return fake_drive_file_system_.get();
+  DriveFileSystemInterface* GetFileSystem() {
+    return fake_file_system_.get();
   }
 
   std::string ReadDriveFileSync(const base::FilePath& file_path) {
     net::TestCompletionCallback callback;
     const int kBufferSize = 100;
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
     scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
-        base::Bind(&DriveURLRequestJobTest::GetDriveFileSystem,
+        base::Bind(&DriveURLRequestJobTest::GetFileSystem,
                    base::Unretained(this))));
 
     FileError error = FILE_ERROR_FAILED;
     scoped_ptr<DriveEntryProto> entry;
     reader->Initialize(
         file_path,
         google_apis::CreateComposedCallback(
             base::Bind(&google_apis::test_util::RunAndQuit),
             google_apis::test_util::CreateCopyResultCallback(
                 &error, &entry)));
     message_loop_.Run();
 
     // Read data from the reader.
     size_t content_size = entry->file_info().size();
     std::string content;
     while (content.size() < content_size) {
       int result = reader->Read(buffer.get(), kBufferSize, callback.callback());
       result = callback.GetResult(result);
       content.append(buffer->data(), result);
     }
 
     return content;
   }
 
   MessageLoopForIO message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
 
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
-  scoped_ptr<test_util::FakeDriveFileSystem> fake_drive_file_system_;
+  scoped_ptr<test_util::FakeFileSystem> fake_file_system_;
 
   scoped_ptr<net::TestNetworkDelegate> test_network_delegate_;
   scoped_ptr<TestURLRequestJobFactory> test_url_request_job_factory_;
   scoped_ptr<net::URLRequestContext> url_request_context_;
   scoped_ptr<TestDelegate> test_delegate_;
 };
 
 TEST_F(DriveURLRequestJobTest, NonGetMethod) {
   net::URLRequest request(
       GURL("drive:drive/root/File 1.txt"), test_delegate_.get(),
@@ skipping 26 matching lines @@
     std::string mime_type;
     request.GetMimeType(&mime_type);
     EXPECT_EQ("audio/mpeg", mime_type);
     // Reading file must be done after |request| runs, otherwise
     // it'll create a local cache file, and we cannot test correctly.
     EXPECT_EQ(ReadDriveFileSync(kTestFilePath),
               test_delegate_->data_received());
   }
 
   // For the second time, the locally cached file should be used.
-  // The caching emulation is done by FakeDriveFileSystem.
+  // The caching emulation is done by FakeFileSystem.
   {
     test_delegate_.reset(new TestDelegate);
     net::URLRequest request(
         GURL("drive:drive/root/File 1.txt"), test_delegate_.get(),
         url_request_context_.get(), test_network_delegate_.get());
     request.Start();
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
@@ skipping 79 matching lines @@
   // Start the request, and cancel it immediately after it.
   request.Start();
   request.Cancel();
 
   MessageLoop::current()->Run();
 
   EXPECT_EQ(net::URLRequestStatus::CANCELED, request.status().status());
 }
 
 }  // namespace drive