gdata: Get rid of GDataFileSystem::GetCacheState()

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"
@@ skipping 193 matching lines @@
         io_thread_(content::BrowserThread::IO),
         sequence_token_(
             content::BrowserThread::GetBlockingPool()->GetSequenceToken()),
         cache_(NULL),
         file_system_(NULL),
         mock_doc_service_(NULL),
         num_callback_invocations_(0),
         expected_error_(base::PLATFORM_FILE_OK),
         expected_cache_state_(0),
         expected_sub_dir_type_(GDataCache::CACHE_TYPE_META),
+        expected_success_(true),
         expect_outgoing_symlink_(false),
         root_feed_changestamp_(0) {
   }
 
   virtual void SetUp() OVERRIDE {
     chromeos::CrosLibrary::Initialize(true /* use_stub */);
     io_thread_.StartIOThread();
 
     profile_.reset(new TestingProfile);
 
@@ skipping 500 matching lines @@
 
     cache_->UnpinOnUIThread(
         resource_id, md5,
         base::Bind(&GDataFileSystemTest::VerifyCacheFileState,
                    base::Unretained(this)));
 
     RunAllPendingForIO();  // Post Unpin() to blocking pool.
     RunAllPendingForIO();  // Post FreeDiskSpaceIfNeededFor to blocking pool.
   }
 
-  void TestGetCacheState(const std::string& resource_id, const std::string& md5,
-                         base::PlatformFileError expected_error,
-                         int expected_cache_state, GDataFile* expected_file) {
-    expected_error_ = expected_error;
+  void TestGetCacheState(const std::string& resource_id,
+                         const std::string& md5,
+                         bool expected_success,
+                         int expected_cache_state,
+                         GDataFile* expected_file) {
+    expected_success_ = expected_success;
     expected_cache_state_ = expected_cache_state;
 
-    file_system_->GetCacheState(resource_id, md5,
+    cache_->GetCacheEntryOnUIThread(resource_id, md5,
         base::Bind(&GDataFileSystemTest::VerifyGetCacheState,
                    base::Unretained(this)));
 
     RunAllPendingForIO();
   }
 
-  void VerifyGetCacheState(base::PlatformFileError error, int cache_state) {
+  void VerifyGetCacheState(bool success,
+                           const GDataCache::CacheEntry& cache_entry) {
     ++num_callback_invocations_;
 
-    EXPECT_EQ(expected_error_, error);
+    EXPECT_EQ(expected_success_, success);
 
-    if (error == base::PLATFORM_FILE_OK) {
-      EXPECT_EQ(expected_cache_state_, cache_state);
+    if (success) {
+      EXPECT_EQ(expected_cache_state_, cache_entry.cache_state);
     }
   }
 
   void TestMarkDirty(
       const std::string& resource_id,
       const std::string& md5,
       base::PlatformFileError expected_error,
       int expected_cache_state,
       GDataCache::CacheSubDirectoryType expected_sub_dir_type) {
     expected_error_ = expected_error;
@@ skipping 556 matching lines @@
   GDataFileSystem* file_system_;
   MockDocumentsService* mock_doc_service_;
   MockFreeDiskSpaceGetter* mock_free_disk_space_checker_;
   scoped_ptr<StrictMock<MockGDataSyncClient> > mock_sync_client_;
   scoped_ptr<StrictMock<MockDirectoryChangeObserver> > mock_directory_observer_;
 
   int num_callback_invocations_;
   base::PlatformFileError 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_;
   static bool cros_initialized_;
 };
 
 bool GDataFileSystemTest::cros_initialized_ = false;
 
 void AsyncInitializationCallback(
     int* counter,
@@ skipping 1623 matching lines @@
     std::string resource_id = file->resource_id();
     std::string md5 = file->file_md5();
 
     // Store a file corresponding to |resource_id| and |md5| to cache.
     TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                      base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
                      GDataCache::CACHE_TYPE_TMP);
 
     // Get its cache state.
     num_callback_invocations_ = 0;
-    TestGetCacheState(resource_id, md5, base::PLATFORM_FILE_OK,
+    TestGetCacheState(resource_id, md5, true,
                       GDataCache::CACHE_STATE_PRESENT, file);
     EXPECT_EQ(1, num_callback_invocations_);
   }
 
   {  // Test cache state of an existing pinned file.
     // Retrieve resource id and md5 of a file from file system.
     FilePath file_path(
         FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
     GDataEntry* entry = FindEntry(file_path);
     ASSERT_TRUE(entry != NULL);
     GDataFile* file = entry->AsGDataFile();
     ASSERT_TRUE(file != NULL);
     std::string resource_id = file->resource_id();
     std::string md5 = file->file_md5();
 
     EXPECT_CALL(*mock_sync_client_, OnCachePinned(resource_id, md5)).Times(1);
 
     // Store a file corresponding to |resource_id| and |md5| to cache, and pin
     // it.
     int expected_cache_state = GDataCache::CACHE_STATE_PRESENT |
                                GDataCache::CACHE_STATE_PINNED;
     TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                      base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
                      GDataCache::CACHE_TYPE_TMP);
     TestPin(resource_id, md5, base::PLATFORM_FILE_OK, expected_cache_state,
             GDataCache::CACHE_TYPE_PERSISTENT);
 
     // Get its cache state.
     num_callback_invocations_ = 0;
-    TestGetCacheState(resource_id, md5, base::PLATFORM_FILE_OK,
+    TestGetCacheState(resource_id, md5, true,
                       expected_cache_state, file);
     EXPECT_EQ(1, num_callback_invocations_);
   }
 
   {  // Test cache state of a non-existent file.
     num_callback_invocations_ = 0;
-    TestGetCacheState("pdf:12345", "abcd", base::PLATFORM_FILE_ERROR_NOT_FOUND,
+    TestGetCacheState("pdf:12345", "abcd", false,
                       0, NULL);
     EXPECT_EQ(1, num_callback_invocations_);
   }
 }
 
 TEST_F(GDataFileSystemTest, InitializeCache) {
   PrepareForInitCacheTest();
   TestInitializeCache();
 }
 
@@ skipping 672 matching lines @@
 
   // Try to close the same file twice.
   file_system_->CloseFile(kFileInRoot, close_file_callback);
   message_loop_.Run();
 
   // It must fail.
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, callback_helper_->last_error_);
 }
 
 }   // namespace gdata