drive: Get rid of use of MockDriveUploader from c/b/c/drive

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 12 matching lines @@
 #include "chrome/browser/chromeos/drive/drive_test_util.h"
 #include "chrome/browser/chromeos/drive/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/drive/file_system/remove_operation.h"
 #include "chrome/browser/chromeos/drive/mock_directory_change_observer.h"
 #include "chrome/browser/chromeos/drive/mock_drive_cache_observer.h"
 #include "chrome/browser/chromeos/drive/mock_drive_web_apps_registry.h"
 #include "chrome/browser/chromeos/drive/mock_free_disk_space_getter.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/drive_uploader.h"
 #include "chrome/browser/google_apis/mock_drive_service.h"
-#include "chrome/browser/google_apis/mock_drive_uploader.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::Eq;
@@ skipping 40 matching lines @@
 }
 
 // Action used to set mock expectations for
 // DriveServiceInterface::GetDocumentEntry().
 ACTION_P2(MockGetDocumentEntry, status, value) {
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(arg1, status, base::Passed(value)));
 }
 
 // Action used to set mock expectations for
-// DriveUploaderInterface::UploadExistingFile().
-ACTION_P4(MockUploadExistingFile,
-          error, drive_path, local_file_path, document_entry) {
-  scoped_ptr<google_apis::DocumentEntry> scoped_document_entry(document_entry);
-  base::MessageLoopProxy::current()->PostTask(FROM_HERE,
-      base::Bind(arg5,
-                 error,
-                 drive_path,
-                 local_file_path,
-                 base::Passed(&scoped_document_entry)));
-
-  const int kUploadId = 123;
-  return kUploadId;
-}
-
-// Action used to set mock expectations for
-// DriveUploaderInterface::UploadNewFile().
-ACTION(MockUploadNewFile) {
-  scoped_ptr<base::Value> value =
-      google_apis::test_util::LoadJSONFile("gdata/uploaded_file.json");
-  scoped_ptr<google_apis::DocumentEntry> document_entry(
-      google_apis::DocumentEntry::ExtractAndParse(*value));
-
-  base::MessageLoopProxy::current()->PostTask(FROM_HERE,
-      base::Bind(arg7,
-                 google_apis::DRIVE_UPLOAD_OK,
-                 arg1,
-                 arg2,
-                 base::Passed(&document_entry)));
-
-  const int kUploadId = 123;
-  return kUploadId;
-}
-
-// Action used to set mock expectations for
 // DriveFileSystem::CopyDocument().
 ACTION_P2(MockCopyDocument, status, value) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(arg2, status, base::Passed(value)));
 }
 
 ACTION(MockFailingGetDocuments) {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(arg5, google_apis::GDATA_NO_CONNECTION,
                  base::Passed(scoped_ptr<base::Value>())));
 }
 
 // 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;
 }
 
 }  // namespace
 
+// A fake implementation of DriveUploaderInterface, which provides fake
+// behaviors for file uploading.
+class FakeDriveUploader : public google_apis::DriveUploaderInterface {
+ public:
+  FakeDriveUploader() {};

[kinaba, 2012/11/22 06:12:13]

semicolon not needed.

[satorux1, 2012/11/22 06:16:13]

Done.

+  virtual ~FakeDriveUploader() {};

[kinaba, 2012/11/22 06:12:13]

ditto.

[satorux1, 2012/11/22 06:16:13]

Done.

+
+  // DriveUploaderInterface overrides.
+
+  // Pretends that a new file was uploaded successfully, and returns the
+  // contents of "gdata/uploaded_file.json" to the caller.
+  virtual int UploadNewFile(
+      const GURL& upload_location,
+      const FilePath& drive_file_path,
+      const FilePath& local_file_path,
+      const std::string& title,
+      const std::string& content_type,
+      int64 content_length,
+      int64 file_size,
+      const google_apis::UploadCompletionCallback& completion_callback,
+      const google_apis::UploaderReadyCallback& ready_callback) OVERRIDE {
+    scoped_ptr<base::Value> value =
+        google_apis::test_util::LoadJSONFile("gdata/uploaded_file.json");
+    scoped_ptr<google_apis::DocumentEntry> document_entry(
+        google_apis::DocumentEntry::ExtractAndParse(*value));
+
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(completion_callback,
+                   google_apis::DRIVE_UPLOAD_OK,
+                   drive_file_path,
+                   local_file_path,
+                   base::Passed(&document_entry)));
+
+    const int kUploadId = 123;
+    return kUploadId;
+  }
+
+  virtual int StreamExistingFile(
+      const GURL& upload_location,
+      const FilePath& drive_file_path,
+      const FilePath& local_file_path,
+      const std::string& content_type,
+      int64 content_length,
+      int64 file_size,
+      const google_apis::UploadCompletionCallback& completion_callback,
+      const google_apis::UploaderReadyCallback& ready_callback) OVERRIDE {
+    NOTREACHED();
+    return 0;
+  }
+
+  // Pretends that an existing file ("drive/File 1.txt") was uploaded
+  // successfully, and returns an entry for the file in
+  // "gdata/root_feed.json" to the caller.
+  virtual int UploadExistingFile(
+      const GURL& upload_location,
+      const FilePath& drive_file_path,
+      const FilePath& local_file_path,
+      const std::string& content_type,
+      int64 file_size,
+      const google_apis::UploadCompletionCallback& completion_callback,
+      const google_apis::UploaderReadyCallback& ready_callback) {
+    // 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";
+
+    // Create a google_apis::DocumentEntry, which is needed to return a value
+    // from this function. TODO(satorux): This should be cleaned
+    // up. crbug.com/134240.
+    scoped_ptr<google_apis::DocumentEntry> document_entry;
+    scoped_ptr<base::Value> value =
+        google_apis::test_util::LoadJSONFile("gdata/root_feed.json");
+    if (!value.get())
+      return -1;
+
+    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 resource_id;
+        if (entry_list->GetDictionary(i, &entry) &&
+            entry->GetString("gd$resourceId.$t", &resource_id) &&
+            resource_id == kResourceId) {
+          document_entry = google_apis::DocumentEntry::CreateFrom(*entry);
+        }
+      }
+    }
+    if (!document_entry)
+      return -1;
+
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE,
+        base::Bind(completion_callback,
+                   google_apis::DRIVE_UPLOAD_OK,
+                   drive_file_path,
+                   local_file_path,
+                   base::Passed(&document_entry)));
+
+    const int kUploadId = 123;
+    return kUploadId;
+  }
+
+  virtual void UpdateUpload(int upload_id,
+                            content::DownloadItem* download) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual int64 GetUploadedBytes(int upload_id) const OVERRIDE {
+    NOTREACHED();
+    return 0;
+  }
+};
+
 class DriveFileSystemTest : public testing::Test {
  protected:
   DriveFileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
         cache_(NULL),
         file_system_(NULL),
         mock_drive_service_(NULL),
         mock_webapps_registry_(NULL),
         num_callback_invocations_(0),
@@ skipping 26 matching lines @@
     SetFreeDiskSpaceGetterForTesting(mock_free_disk_space_checker_);
 
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
 
     cache_ = DriveCache::CreateDriveCache(
         DriveCache::GetCacheRootPath(profile_.get()), blocking_task_runner_);
 
-    mock_uploader_.reset(new StrictMock<google_apis::MockDriveUploader>);
+    fake_uploader_.reset(new FakeDriveUploader);
     mock_webapps_registry_.reset(new StrictMock<MockDriveWebAppsRegistry>);
 
     ASSERT_FALSE(file_system_);
     file_system_ = new DriveFileSystem(profile_.get(),
                                        cache_,
                                        mock_drive_service_,
-                                       mock_uploader_.get(),
+                                       fake_uploader_.get(),
                                        mock_webapps_registry_.get(),
                                        blocking_task_runner_);
 
     mock_cache_observer_.reset(new StrictMock<MockDriveCacheObserver>);
     cache_->AddObserver(mock_cache_observer_.get());
 
     mock_directory_observer_.reset(new StrictMock<MockDirectoryChangeObserver>);
     file_system_->AddObserver(mock_directory_observer_.get());
 
     file_system_->Initialize();
@@ skipping 585 matching lines @@
 
   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_;
   content::TestBrowserThread io_thread_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<TestingProfile> profile_;
   scoped_refptr<CallbackHelper> callback_helper_;
   DriveCache* cache_;
-  scoped_ptr<StrictMock<google_apis::MockDriveUploader> > mock_uploader_;
+  scoped_ptr<FakeDriveUploader> fake_uploader_;
   DriveFileSystem* file_system_;
   StrictMock<google_apis::MockDriveService>* mock_drive_service_;
   scoped_ptr<StrictMock<MockDriveWebAppsRegistry> > mock_webapps_registry_;
   StrictMock<MockFreeDiskSpaceGetter>* mock_free_disk_space_checker_;
   scoped_ptr<StrictMock<MockDriveCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   int num_callback_invocations_;
   DriveFileError expected_error_;
   int expected_cache_state_;
@@ skipping 459 matching lines @@
 
   // Confirm that the remote file does not exist.
   const FilePath remote_dest_file_path(FILE_PATH_LITERAL("drive/remote.txt"));
   EXPECT_FALSE(EntryExists(remote_dest_file_path));
 
   scoped_ptr<base::Value> value =
       google_apis::test_util::LoadJSONFile("gdata/document_to_download.json");
   scoped_ptr<google_apis::DocumentEntry> document_entry(
       google_apis::DocumentEntry::ExtractAndParse(*value));
 
-  EXPECT_CALL(*mock_uploader_, UploadNewFile(_, _, _, _, _, _, _, _, _))
-      .WillOnce(MockUploadNewFile());
-
   // Transfer the local file to Drive.
   file_system_->TransferFileFromLocalToRemote(
       local_src_file_path, remote_dest_file_path, callback);
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, callback_helper_->last_error_);
 
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
@@ skipping 1089 matching lines @@
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   DriveCache::CACHE_TYPE_PERSISTENT);
   const FilePath outgoing_symlink_path =
       DriveCache::GetCacheRootPath(profile_.get())
       .AppendASCII("outgoing")
       .AppendASCII(kResourceId);
   ASSERT_TRUE(file_util::PathExists(dirty_cache_file_path));
   ASSERT_TRUE(file_util::PathExists(outgoing_symlink_path));
 
-  // Create a google_apis::DocumentEntry, which is needed to mock
-  // DriveUploaderInterface::UploadExistingFile().
-  // TODO(satorux): This should be cleaned up. crbug.com/134240.
-  scoped_ptr<google_apis::DocumentEntry> document_entry;
-  scoped_ptr<base::Value> value =
-      google_apis::test_util::LoadJSONFile("gdata/root_feed.json");
-  ASSERT_TRUE(value.get());
-  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 resource_id;
-      if (entry_list->GetDictionary(i, &entry) &&
-          entry->GetString("gd$resourceId.$t", &resource_id) &&
-          resource_id == kResourceId) {
-        // This will be deleted by UploadExistingFile().
-        document_entry = google_apis::DocumentEntry::CreateFrom(*entry);
-      }
-    }
-  }
-  ASSERT_TRUE(document_entry);
-
-  // The mock uploader will be used to simulate a file upload.
-  EXPECT_CALL(*mock_uploader_, UploadExistingFile(
-      GURL("https://file_link_resumable_edit_media/"),
-      kFilePath,
-      dirty_cache_file_path,
-      "audio/mpeg",
-      kDummyCacheContent.size(),  // The size after modification must be used.
-      _,   // Completion callback.
-      _))  // Ready callback.
-      .WillOnce(MockUploadExistingFile(
-          google_apis::DRIVE_UPLOAD_OK,
-          FilePath::FromUTF8Unsafe("drive/File1"),
-          dirty_cache_file_path,
-          document_entry.release()));
-
   // We'll notify the directory change to the observer upon completion.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(FilePath(kDriveRootDirectory)))).Times(1);
 
   // The callback will be called upon completion of
   // UpdateFileByResourceId().
   FileOperationCallback callback =
       base::Bind(&CallbackHelper::FileOperationCallback,
                  callback_helper_.get());
 
@@ skipping 244 matching lines @@
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace drive