chromeos: Rename MockGDataSyncClient to MocKGDataCacheObserver

chrome/browser/chromeos/gdata/gdata_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 <errno.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
-#include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
-#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
-#include "base/string16.h"
-#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "base/time.h"
-#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system.h"
 #include "chrome/browser/chromeos/gdata/gdata_test_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
-#include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
 #include "chrome/browser/chromeos/gdata/mock_directory_change_observer.h"
+#include "chrome/browser/chromeos/gdata/mock_gdata_cache_observer.h"
 #include "chrome/browser/chromeos/gdata/mock_gdata_documents_service.h"
-#include "chrome/browser/chromeos/gdata/mock_gdata_sync_client.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;
-using ::testing::IsNull;
-using ::testing::Ne;
 using ::testing::NotNull;
 using ::testing::Return;
-using ::testing::ReturnNull;
 using ::testing::StrictMock;
 using ::testing::_;
 
-using base::Value;
-using base::DictionaryValue;
-using base::ListValue;
-using content::BrowserThread;
-
 namespace gdata {
 namespace {
 
 const char kSymLinkToDevNull[] = "/dev/null";
 
 const int64 kLotsOfSpace = kMinFreeSpace * 10;
 
-struct PathToVerify {
-  PathToVerify(const FilePath& in_path_to_scan,
-               const FilePath& in_expected_existing_path) :
-      path_to_scan(in_path_to_scan),
-      expected_existing_path(in_expected_existing_path) {
-  }
-
-  FilePath path_to_scan;
-  FilePath expected_existing_path;
-};
-
 struct SearchResultPair {
   const char* path;
   const bool is_directory;
 };
 
 // Callback to GDataFileSystem::Search used in ContentSearch tests.
 // Verifies returned vector of results.
 void DriveSearchCallback(
     MessageLoop* message_loop,
     const SearchResultPair* expected_results,
@@ skipping 183 matching lines @@
     mock_webapps_registry_.reset(new StrictMock<MockDriveWebAppsRegistry>);
 
     ASSERT_FALSE(file_system_);
     file_system_ = new GDataFileSystem(profile_.get(),
                                        cache_,
                                        mock_doc_service_,
                                        mock_uploader_.get(),
                                        mock_webapps_registry_.get(),
                                        blocking_task_runner_);
 
-    mock_sync_client_.reset(new StrictMock<MockGDataSyncClient>);
-    cache_->AddObserver(mock_sync_client_.get());
+    mock_cache_observer_.reset(new StrictMock<MockGDataCacheObserver>);
+    cache_->AddObserver(mock_cache_observer_.get());
 
     mock_directory_observer_.reset(new StrictMock<MockDirectoryChangeObserver>);
     file_system_->AddObserver(mock_directory_observer_.get());
 
     file_system_->Initialize();
     cache_->RequestInitializeOnUIThread();
     test_util::RunBlockingPoolTask();
   }
 
   virtual void TearDown() OVERRIDE {
@@ skipping 566 matching lines @@
   content::TestBrowserThread io_thread_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   scoped_ptr<TestingProfile> profile_;
   scoped_refptr<CallbackHelper> callback_helper_;
   GDataCache* cache_;
   scoped_ptr<StrictMock<MockGDataUploader> > mock_uploader_;
   GDataFileSystem* file_system_;
   StrictMock<MockDocumentsService>* mock_doc_service_;
   scoped_ptr<StrictMock<MockDriveWebAppsRegistry> > mock_webapps_registry_;
   StrictMock<MockFreeDiskSpaceGetter>* mock_free_disk_space_checker_;
-  scoped_ptr<StrictMock<MockGDataSyncClient> > mock_sync_client_;
+  scoped_ptr<StrictMock<MockGDataCacheObserver> > mock_cache_observer_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   int num_callback_invocations_;
   GDataFileError expected_error_;
   int expected_cache_state_;
   GDataCache::CacheSubDirectoryType expected_sub_dir_type_;
   bool expected_success_;
   bool expect_outgoing_symlink_;
   std::string expected_file_extension_;
   int root_feed_changestamp_;
@@ skipping 1398 matching lines @@
 
 TEST_F(GDataFileSystemTest, UpdateFileByResourceId_PersistentFile) {
   LoadRootFeedDocument("root_feed.json");
 
   // This is a file defined in root_feed.json.
   const FilePath kFilePath(FILE_PATH_LITERAL("drive/File 1.txt"));
   const std::string kResourceId("file:2_file_resource_id");
   const std::string kMd5("3b4382ebefec6e743578c76bbd0575ce");
 
   // Pin the file so it'll be store in "persistent" directory.
-  EXPECT_CALL(*mock_sync_client_, OnCachePinned(kResourceId, kMd5)).Times(1);
+  EXPECT_CALL(*mock_cache_observer_, OnCachePinned(kResourceId, kMd5)).Times(1);
   TestPin(kResourceId,
           kMd5,
           GDATA_FILE_OK,
           test_util::TEST_CACHE_STATE_PINNED,
           GDataCache::CACHE_TYPE_TMP);
 
   // First store a file to cache. A cache file will be created at:
   // GCache/v1/persistent/<kResourceId>.<kMd5>
   const FilePath original_cache_file_path =
       GDataCache::GetCacheRootPath(profile_.get())
@@ skipping 22 matching lines @@
   const FilePath dirty_cache_file_path =
       GDataCache::GetCacheRootPath(profile_.get())
       .AppendASCII("persistent")
       .AppendASCII(kResourceId + ".local");
   ASSERT_FALSE(file_util::PathExists(original_cache_file_path));
   ASSERT_TRUE(file_util::PathExists(dirty_cache_file_path));
 
   // Commit the dirty bit. The cache file name remains the same
   // but a symlink will be created at:
   // GCache/v1/outgoing/<kResourceId>
-  EXPECT_CALL(*mock_sync_client_, OnCacheCommitted(kResourceId)).Times(1);
+  EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(kResourceId)).Times(1);
   TestCommitDirty(kResourceId,
                   kMd5,
                   GDATA_FILE_OK,
                   test_util::TEST_CACHE_STATE_PRESENT |
                   test_util::TEST_CACHE_STATE_PINNED |
                   test_util::TEST_CACHE_STATE_DIRTY |
                   test_util::TEST_CACHE_STATE_PERSISTENT,
                   GDataCache::CACHE_TYPE_PERSISTENT);
   const FilePath outgoing_symlink_path =
       GDataCache::GetCacheRootPath(profile_.get())
@@ skipping 167 matching lines @@
   scoped_ptr<GDataEntryProto> entry_proto(GetEntryInfoByPathSync(kFileInRoot));
   FilePath downloaded_file = GetCachePathForFile(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5());
   const int64 file_size = entry_proto->file_info().size();
   const std::string& file_resource_id =
       entry_proto->resource_id();
   const std::string& file_md5 = entry_proto->file_specific_info().file_md5();
 
   // A dirty file is created on close.
-  EXPECT_CALL(*mock_sync_client_, OnCacheCommitted(file_resource_id)).Times(1);
+  EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(file_resource_id))
+      .Times(1);
 
   // Pretend we have enough space.
   EXPECT_CALL(*mock_free_disk_space_checker_, AmountOfFreeDiskSpace())
       .Times(2).WillRepeatedly(Return(file_size + kMinFreeSpace));
 
   const std::string kExpectedFileData = "test file data";
   mock_doc_service_->set_file_data(new std::string(kExpectedFileData));
 
   // Before Download starts metadata from server will be fetched.
   // We will read content url from the result.
@@ skipping 48 matching lines @@
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(GDATA_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace gdata