Remove fake uploader from Drive tests.

chrome/browser/chromeos/drive/drive_file_system_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/drive/drive_file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 74 matching lines @@
 // Counts the number of files (not directories) in |entries|.
 int CountFiles(const DriveEntryProtoVector& entries) {
   int num_files = 0;
   for (size_t i = 0; i < entries.size(); ++i) {
     if (!entries[i].file_info().is_directory())
       ++num_files;
   }
   return num_files;
 }
 
-// A fake implementation of DriveUploaderInterface, which provides fake
-// behaviors for file uploading.
-class FakeDriveUploader : public google_apis::DriveUploaderInterface {
- public:
-  FakeDriveUploader() {}
-  virtual ~FakeDriveUploader() {}
-
-  // DriveUploaderInterface overrides.
-
-  // Pretends that a new file was uploaded successfully, and returns the
-  // contents of "chromeos/gdata/uploaded_file.json" to the caller.
-  virtual void UploadNewFile(
-      const std::string& parent_resource_id,
-      const base::FilePath& drive_file_path,
-      const base::FilePath& local_file_path,
-      const std::string& title,
-      const std::string& content_type,
-      const google_apis::UploadCompletionCallback& callback) OVERRIDE {
-    DCHECK(!callback.is_null());
-
-    scoped_ptr<base::Value> value =
-        google_apis::test_util::LoadJSONFile(
-            "chromeos/gdata/uploaded_file.json");
-    scoped_ptr<google_apis::ResourceEntry> resource_entry(
-        google_apis::ResourceEntry::ExtractAndParse(*value));
-
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback,
-                   google_apis::DRIVE_UPLOAD_OK,
-                   drive_file_path,
-                   local_file_path,
-                   base::Passed(&resource_entry)));
-  }
-
-  // Pretends that an existing file ("drive/File 1.txt") was uploaded
-  // successfully, and returns an entry for the file in
-  // "chromeos/gdata/root_feed.json" to the caller.
-  virtual void UploadExistingFile(
-      const std::string& resource_id,
-      const base::FilePath& drive_file_path,
-      const base::FilePath& local_file_path,
-      const std::string& content_type,
-      const std::string& etag,
-      const google_apis::UploadCompletionCallback& callback) OVERRIDE {
-    DCHECK(!callback.is_null());
-
-    // This function can only handle "drive/File 1.txt" whose resource ID is
-    // "file:2_file_resource_id".
-    DCHECK_EQ("drive/File 1.txt", drive_file_path.value());
-    const std::string kResourceId = "file:2_file_resource_id";
-    EXPECT_EQ(kResourceId, resource_id);
-
-    // Create a google_apis::ResourceEntry, which is needed to return a value
-    // from this function. TODO(satorux): This should be cleaned
-    // up. crbug.com/134240.
-    scoped_ptr<google_apis::ResourceEntry> resource_entry;
-    scoped_ptr<base::Value> value =
-        google_apis::test_util::LoadJSONFile("chromeos/gdata/root_feed.json");
-    if (!value.get())
-      return;
-
-    base::DictionaryValue* as_dict = NULL;
-    base::ListValue* entry_list = NULL;
-    if (value->GetAsDictionary(&as_dict) &&
-        as_dict->GetList("feed.entry", &entry_list)) {
-      for (size_t i = 0; i < entry_list->GetSize(); ++i) {
-        base::DictionaryValue* entry = NULL;
-        std::string entry_resource_id;
-        if (entry_list->GetDictionary(i, &entry) &&
-            entry->GetString("gd$resourceId.$t", &entry_resource_id) &&
-            entry_resource_id == kResourceId) {
-          resource_entry = google_apis::ResourceEntry::CreateFrom(*entry);
-        }
-      }
-    }
-    if (!resource_entry)
-      return;
-
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback,
-                   google_apis::DRIVE_UPLOAD_OK,
-                   drive_file_path,
-                   local_file_path,
-                   base::Passed(&resource_entry)));
-  }
-};
-
 }  // namespace
 
 class DriveFileSystemTest : public testing::Test {
  protected:
   DriveFileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         expected_success_(true),
         // |root_feed_changestamp_| should be set to the largest changestamp in
         // account metadata feed. But we fake it by some non-zero positive
         // increasing value.  See |LoadFeed()|.
@@ skipping 15 matching lines @@
 
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
 
     cache_.reset(new DriveCache(DriveCache::GetCacheRootPath(profile_.get()),
                                 blocking_task_runner_,
                                 fake_free_disk_space_getter_.get()));
 
-    fake_uploader_.reset(new FakeDriveUploader);
+    uploader_.reset(new google_apis::DriveUploader(fake_drive_service_.get()));
     drive_webapps_registry_.reset(new DriveWebAppsRegistry);
 
 
     mock_cache_observer_.reset(new StrictMock<MockDriveCacheObserver>);
     cache_->AddObserver(mock_cache_observer_.get());
 
     mock_directory_observer_.reset(new StrictMock<MockDirectoryChangeObserver>);
 
     cache_->RequestInitializeForTesting();
     google_apis::test_util::RunBlockingPoolTask();
 
     SetUpResourceMetadataAndFileSystem();
   }
 
   void SetUpResourceMetadataAndFileSystem() {
     resource_metadata_.reset(new DriveResourceMetadata(
         fake_drive_service_->GetRootResourceId(),
         cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_META),
         blocking_task_runner_));
 
     file_system_.reset(new DriveFileSystem(profile_.get(),
                                            cache_.get(),
                                            fake_drive_service_.get(),
-                                           fake_uploader_.get(),
+                                           uploader_.get(),
                                            drive_webapps_registry_.get(),
                                            resource_metadata_.get(),
                                            blocking_task_runner_));
     file_system_->AddObserver(mock_directory_observer_.get());
     file_system_->Initialize();
 
     DriveFileError error = DRIVE_FILE_ERROR_FAILED;
     resource_metadata_->Initialize(
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
@@ skipping 283 matching lines @@
     EXPECT_EQ(entry_proto.resource_id(), resource_id);
   }
 
   MessageLoopForUI message_loop_;
   // The order of the test threads is important, do not change the order.
   // See also content/browser/browser_thread_impl.cc.
   content::TestBrowserThread ui_thread_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<DriveCache, test_util::DestroyHelperForTests> cache_;
-  scoped_ptr<FakeDriveUploader> fake_uploader_;
+  scoped_ptr<google_apis::DriveUploaderInterface> uploader_;
   scoped_ptr<DriveFileSystem> file_system_;
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
   scoped_ptr<DriveWebAppsRegistry> drive_webapps_registry_;
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
       resource_metadata_;
   scoped_ptr<FakeFreeDiskSpaceGetter> fake_free_disk_space_getter_;
   scoped_ptr<StrictMock<MockDriveCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   bool expected_success_;
@@ skipping 1657 matching lines @@
 
   // An app for foo.exe should now be found, as the registry was loaded.
   drive_webapps_registry_->GetWebAppsForFile(
       base::FilePath(FILE_PATH_LITERAL("foo.exe")),
       "" /* mime_type */,
       &apps);
   EXPECT_EQ(1U, apps.size());
 }
 
 }   // namespace drive