gdata: Move ownership of GDataCache to GDataSystemService

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 148 matching lines @@
  public:
   virtual ~MockFreeDiskSpaceGetter() {}
   MOCK_CONST_METHOD0(AmountOfFreeDiskSpace, int64());
 };
 
 class GDataFileSystemTest : public testing::Test {
  protected:
   GDataFileSystemTest()
       : ui_thread_(content::BrowserThread::UI, &message_loop_),
         io_thread_(content::BrowserThread::IO),
+        sequence_token_(
+            content::BrowserThread::GetBlockingPool()->GetSequenceToken()),
         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),
         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);
 
     callback_helper_ = new CallbackHelper;
 
     // Allocate and keep a pointer to the mock, and inject it into the
     // GDataFileSystem object, which will own the mock object.
     mock_doc_service_ = new MockDocumentsService;
 
     EXPECT_CALL(*mock_doc_service_, Initialize(profile_.get())).Times(1);
 
     // Likewise, this will be owned by GDataFileSystem.
     mock_free_disk_space_checker_ = new MockFreeDiskSpaceGetter;
     SetFreeDiskSpaceGetterForTesting(mock_free_disk_space_checker_);
 
+    cache_.reset(GDataCache::CreateGDataCache(
+        GDataCache::GetCacheRootPath(profile_.get()),
+        content::BrowserThread::GetBlockingPool(),
+        sequence_token_).release());
+
     ASSERT_FALSE(file_system_);
     file_system_ = new GDataFileSystem(profile_.get(),
-                                       mock_doc_service_);
+                                       cache_.get(),
+                                       mock_doc_service_,
+                                       sequence_token_);
 
     mock_sync_client_.reset(new StrictMock<MockGDataSyncClient>);
     file_system_->AddObserver(mock_sync_client_.get());
 
     mock_directory_observer_.reset(new StrictMock<MockDirectoryChangeObserver>);
     file_system_->AddObserver(mock_directory_observer_.get());
 
     file_system_->Initialize();
     // Initialize() initiates the cache initialization on the blocking thread
     // pool. Block until it's done to ensure that the cache initialization is
     // done for every test. Otherwise, completion timing is nondeterministic.
     EXPECT_CALL(*mock_sync_client_, OnCacheInitialized()).Times(1);
     RunAllPendingForIO();
   }
 
   virtual void TearDown() OVERRIDE {
     ASSERT_TRUE(file_system_);
     EXPECT_CALL(*mock_doc_service_, CancelAll()).Times(1);
     delete file_system_;
     file_system_ = NULL;
     delete mock_doc_service_;
     mock_doc_service_ = NULL;
     SetFreeDiskSpaceGetterForTesting(NULL);
+    content::BrowserThread::GetBlockingPool()
+        ->GetSequencedTaskRunner(sequence_token_)->PostTask(
+            FROM_HERE,
+            base::Bind(&base::DeletePointer<GDataCache>, cache_.release()));
 
     // Run the remaining tasks on both the main thread and the IO thread, so
     // that all PostTaskAndReply round trip finish (that is, both the 1st and
     // the 2nd callbacks of PostTaskAndReply are run). Otherwise, there will be
     // a leak from PostTaskAndReply() as it deletes an internal object when the
     // reply task is run. Note that actual reply tasks on the file system will
     // be canceled, as these are bound to weak pointers, which are invalidated
     // in ShutdownOnUIThread().
     //
     // Note that looping only on the main thread here is not enough. The test
@@ skipping 67 matching lines @@
         largest_changestamp,
         root_feed_changestamp_++) == base::PLATFORM_FILE_OK;
   }
 
   bool RemoveEntry(const FilePath& file_path) {
     return file_system_->RemoveEntryFromFileSystem(file_path) ==
         base::PLATFORM_FILE_OK;
   }
 
   FilePath GetCachePathForFile(GDataFile* file) {
-    return file_system_->GetCacheFilePath(
-        file->resource_id(),
-        file->file_md5(),
-        GDataCache::CACHE_TYPE_TMP,
-        GDataCache::CACHED_FILE_FROM_SERVER);
+    return cache_->GetCacheFilePath(file->resource_id(),
+                                    file->file_md5(),
+                                    GDataCache::CACHE_TYPE_TMP,
+                                    GDataCache::CACHED_FILE_FROM_SERVER);
   }
 
   GDataEntry* FindEntry(const FilePath& file_path) {
     GDataEntry* entry = NULL;
     file_system_->root_->FindEntryByPath(
         file_path, base::Bind(&ReadOnlyFindEntryCallback, &entry));
     return entry;
   }
 
   void FindAndTestFilePath(const FilePath& file_path) {
@@ skipping 78 matching lines @@
 
     if (callback_helper_->last_error_ != base::PLATFORM_FILE_OK)
       return false;
 
     scoped_ptr<GDataDirectoryProto> directory_proto =
         callback_helper_->directory_proto_.Pass();
     return (directory->resource_id() ==
             directory_proto->gdata_entry().resource_id());
   }
 
-  FilePath GetCacheFilePath(
-      const std::string& resource_id,
-      const std::string& md5,
-      GDataCache::CacheSubDirectoryType sub_dir_type,
-      GDataCache::CachedFileOrigin file_origin) {
-    return file_system_->GetCacheFilePath(resource_id, md5, sub_dir_type,
-                                          file_origin);
+  FilePath GetCacheFilePath(const std::string& resource_id,
+                            const std::string& md5,
+                            GDataCache::CacheSubDirectoryType sub_dir_type,
+                            GDataCache::CachedFileOrigin file_origin) {
+    return cache_->GetCacheFilePath(resource_id, md5, sub_dir_type,
+                                    file_origin);
   }
 
   // Returns true if the cache entry exists for the given resource ID and MD5.
   bool CacheEntryExists(const std::string& resource_id,
                         const std::string& md5) {
     return file_system_->cache_->GetCacheEntry(resource_id, md5).get();
   }
 
   // Returns true if the cache file exists for the given resource ID and MD5.
   bool CacheFileExists(const std::string& resource_id,
                        const std::string& md5) {
-    const FilePath file_path = file_system_->GetCacheFilePath(
+    const FilePath file_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::CACHE_TYPE_TMP,
         GDataCache::CACHED_FILE_FROM_SERVER);
     return file_util::PathExists(file_path);
   }
 
   void TestGetCacheFilePath(const std::string& resource_id,
                             const std::string& md5,
                             const std::string& expected_filename) {
-    FilePath actual_path = file_system_->GetCacheFilePath(
+    FilePath actual_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::CACHE_TYPE_TMP,
         GDataCache::CACHED_FILE_FROM_SERVER);
     FilePath expected_path =
         file_system_->cache_->cache_paths()[GDataCache::CACHE_TYPE_TMP];
     expected_path = expected_path.Append(expected_filename);
     EXPECT_EQ(expected_path, actual_path);
 
     FilePath base_name = actual_path.BaseName();
@@ skipping 85 matching lines @@
     scoped_ptr<GDataCache::CacheEntry> cache_entry =
         file_system_->cache_->GetCacheEntry(resource_id, md5);
     if (cache_entry.get())
       EXPECT_TRUE(cache_entry->IsDirty());
 
     // If entry doesn't exist, verify that:
     // - no files with "<resource_id>.* exists in persistent and tmp dirs
     // - no "<resource_id>" symlink exists in pinned and outgoing dirs.
     std::vector<PathToVerify> paths_to_verify;
     paths_to_verify.push_back(  // Index 0: CACHE_TYPE_TMP.
-        PathToVerify(file_system_->GetCacheFilePath(resource_id, "*",
+        PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
                      GDataCache::CACHE_TYPE_TMP,
                      GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
     paths_to_verify.push_back(  // Index 1: CACHE_TYPE_PERSISTENT.
-        PathToVerify(file_system_->GetCacheFilePath(resource_id, "*",
+        PathToVerify(cache_->GetCacheFilePath(resource_id, "*",
                      GDataCache::CACHE_TYPE_PERSISTENT,
                      GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
     paths_to_verify.push_back(  // Index 2: CACHE_TYPE_PINNED.
-        PathToVerify(file_system_->GetCacheFilePath(resource_id, "",
+        PathToVerify(cache_->GetCacheFilePath(resource_id, "",
                      GDataCache::CACHE_TYPE_PINNED,
                      GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
     paths_to_verify.push_back(  // Index 3: CACHE_TYPE_OUTGOING.
-        PathToVerify(file_system_->GetCacheFilePath(resource_id, "",
+        PathToVerify(cache_->GetCacheFilePath(resource_id, "",
                      GDataCache::CACHE_TYPE_OUTGOING,
                      GDataCache::CACHED_FILE_FROM_SERVER), FilePath()));
     if (!cache_entry.get()) {
       for (size_t i = 0; i < paths_to_verify.size(); ++i) {
         file_util::FileEnumerator enumerator(
             paths_to_verify[i].path_to_scan.DirName(), false /* not recursive*/,
             static_cast<file_util::FileEnumerator::FileType>(
                 file_util::FileEnumerator::FILES |
                 file_util::FileEnumerator::SHOW_SYM_LINKS),
             paths_to_verify[i].path_to_scan.BaseName().value());
@@ skipping 209 matching lines @@
     VerifyCacheFileState(error, resource_id, md5);
   }
 
   void VerifySetMountedState(const std::string& resource_id,
                              const std::string& md5,
                              bool to_mount,
                              base::PlatformFileError error,
                              const FilePath& file_path) {
     ++num_callback_invocations_;
     EXPECT_TRUE(file_util::PathExists(file_path));
-    EXPECT_TRUE(file_path == file_system_->GetCacheFilePath(
+    EXPECT_TRUE(file_path == cache_->GetCacheFilePath(
         resource_id,
         md5,
         expected_sub_dir_type_,
         to_mount ?
             GDataCache::CACHED_FILE_MOUNTED :
             GDataCache::CACHED_FILE_FROM_SERVER));
   }
 
   void TestSetMountedState(
       const std::string& resource_id,
@@ skipping 31 matching lines @@
         file_system_->cache_->cache_paths()[GDataCache::CACHE_TYPE_OUTGOING]));
 
     // Dump some files into cache dirs so that
     // GDataFileSystem::InitializeCacheOnBlockingPool would scan through them
     // and populate cache map accordingly.
 
     // Copy files from data dir to cache dir to act as cached files.
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(initial_cache_resources); ++i) {
       const struct InitialCacheResource& resource = initial_cache_resources[i];
       // Determine gdata cache file absolute path according to cache state.
-      FilePath dest_path = file_system_->GetCacheFilePath(
+      FilePath dest_path = cache_->GetCacheFilePath(
           resource.resource_id,
           resource.md5,
           GDataCache::IsCachePinned(resource.cache_state) ||
               GDataCache::IsCacheDirty(resource.cache_state) ?
                   GDataCache::CACHE_TYPE_PERSISTENT :
                   GDataCache::CACHE_TYPE_TMP,
           GDataCache::IsCacheDirty(resource.cache_state) ?
               GDataCache::CACHED_FILE_LOCALLY_MODIFIED :
               GDataCache::CACHED_FILE_FROM_SERVER);
 
       // Copy file from data dir to cache subdir, naming it per cache files
       // convention.
       if (GDataCache::IsCachePresent(resource.cache_state)) {
         FilePath source_path = GetTestFilePath(resource.source_file);
         ASSERT_TRUE(file_util::CopyFile(source_path, dest_path));
       } else {
         dest_path = FilePath(FILE_PATH_LITERAL(kSymLinkToDevNull));
       }
 
       // Create symbolic link in pinned dir, naming it per cache files
       // convention.
       if (GDataCache::IsCachePinned(resource.cache_state)) {
-        FilePath link_path = file_system_->GetCacheFilePath(
+        FilePath link_path = cache_->GetCacheFilePath(
             resource.resource_id,
             "",
             GDataCache::CACHE_TYPE_PINNED,
             GDataCache::CACHED_FILE_FROM_SERVER);
         ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
       }
 
       // Create symbolic link in outgoing dir, naming it per cache files
       // convention.
       if (GDataCache::IsCacheDirty(resource.cache_state)) {
-        FilePath link_path = file_system_->GetCacheFilePath(
+        FilePath link_path = cache_->GetCacheFilePath(
             resource.resource_id,
             "",
             GDataCache::CACHE_TYPE_OUTGOING,
             GDataCache::CACHED_FILE_FROM_SERVER);
         ASSERT_TRUE(file_util::CreateSymbolicLink(dest_path, link_path));
       }
     }
     DVLOG(1) << "PrepareForInitCacheTest finished";
     // Temporarily remove the mock sync client while rescanning. Otherwise,
     // OnCacheInitialized() is called again here, which breaks the
@@ skipping 43 matching lines @@
     if (GDataCache::IsCachePresent(expected_cache_state_) ||
         GDataCache::IsCachePinned(expected_cache_state_)) {
       ASSERT_TRUE(cache_entry.get());
       EXPECT_EQ(expected_cache_state_, cache_entry->cache_state);
       EXPECT_EQ(expected_sub_dir_type_, cache_entry->sub_dir_type);
     } else {
       EXPECT_FALSE(cache_entry.get());
     }
 
     // Verify actual cache file.
-    FilePath dest_path = file_system_->GetCacheFilePath(
+    FilePath dest_path = cache_->GetCacheFilePath(
         resource_id,
         md5,
         GDataCache::IsCachePinned(expected_cache_state_) ||
             GDataCache::IsCacheDirty(expected_cache_state_) ?
                 GDataCache::CACHE_TYPE_PERSISTENT :
                 GDataCache::CACHE_TYPE_TMP,
         GDataCache::IsCacheDirty(expected_cache_state_) ?
             GDataCache::CACHED_FILE_LOCALLY_MODIFIED :
             GDataCache::CACHED_FILE_FROM_SERVER);
     bool exists = file_util::PathExists(dest_path);
     if (GDataCache::IsCachePresent(expected_cache_state_))
       EXPECT_TRUE(exists);
     else
       EXPECT_FALSE(exists);
 
     // Verify symlink in pinned dir.
-    FilePath symlink_path = file_system_->GetCacheFilePath(
+    FilePath symlink_path = cache_->GetCacheFilePath(
         resource_id,
         std::string(),
         GDataCache::CACHE_TYPE_PINNED,
         GDataCache::CACHED_FILE_FROM_SERVER);
     // Check that pin symlink exists, without deferencing to target path.
     exists = file_util::IsLink(symlink_path);
     if (GDataCache::IsCachePinned(expected_cache_state_)) {
       EXPECT_TRUE(exists);
       FilePath target_path;
       EXPECT_TRUE(file_util::ReadSymbolicLink(symlink_path, &target_path));
       if (GDataCache::IsCachePresent(expected_cache_state_))
         EXPECT_EQ(dest_path, target_path);
       else
         EXPECT_EQ(kSymLinkToDevNull, target_path.value());
     } else {
       EXPECT_FALSE(exists);
     }
 
     // Verify symlink in outgoing dir.
-    symlink_path = file_system_->GetCacheFilePath(
+    symlink_path = cache_->GetCacheFilePath(
         resource_id,
         std::string(),
         GDataCache::CACHE_TYPE_OUTGOING,
         GDataCache::CACHED_FILE_FROM_SERVER);
     // Check that outgoing symlink exists, without deferencing to target path.
     exists = file_util::IsLink(symlink_path);
     if (expect_outgoing_symlink_ &&
         GDataCache::IsCacheDirty(expected_cache_state_)) {
       EXPECT_TRUE(exists);
       FilePath target_path;
@@ skipping 231 matching lines @@
     scoped_ptr<GDataEntryProto> entry_proto_;
     scoped_ptr<GDataFileProto> file_proto_;
     scoped_ptr<GDataDirectoryProto> directory_proto_;
   };
 
   MessageLoopForUI message_loop_;
   // The order of the test threads is important, do not change the order.
   // See also content/browser/browser_thread_imple.cc.
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
+  const base::SequencedWorkerPool::SequenceToken sequence_token_;
   scoped_ptr<TestingProfile> profile_;
   scoped_refptr<CallbackHelper> callback_helper_;
+  scoped_ptr<GDataCache> cache_;
   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_;
@@ skipping 2455 matching lines @@
   std::string resource_id("pdf:1a2b");
   std::string md5("abcdef0123456789");
 
   // First store a file to cache in the tmp subdir.
   TestStoreToCache(resource_id, md5, GetTestFilePath("root_feed.json"),
                    base::PLATFORM_FILE_OK, GDataCache::CACHE_STATE_PRESENT,
                    GDataCache::CACHE_TYPE_TMP);
 
   // Mark the file mounted.
   num_callback_invocations_ = 0;
-  file_path = file_system_->GetCacheFilePath(
-      resource_id, md5,
-      GDataCache::CACHE_TYPE_TMP,
-      GDataCache::CACHED_FILE_FROM_SERVER);
+  file_path = cache_->GetCacheFilePath(resource_id, md5,
+                                       GDataCache::CACHE_TYPE_TMP,
+                                       GDataCache::CACHED_FILE_FROM_SERVER);
   TestSetMountedState(resource_id, md5, file_path, true,
                       base::PLATFORM_FILE_OK,
                       GDataCache::CACHE_STATE_PRESENT |
                       GDataCache::CACHE_STATE_MOUNTED,
                       GDataCache::CACHE_TYPE_PERSISTENT);
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Clear mounted state of the file.
   num_callback_invocations_ = 0;
-  file_path = file_system_->GetCacheFilePath(
-      resource_id,
-      md5,
-      GDataCache::CACHE_TYPE_PERSISTENT,
-      GDataCache::CACHED_FILE_MOUNTED);
+  file_path = cache_->GetCacheFilePath(resource_id,
+                                       md5,
+                                       GDataCache::CACHE_TYPE_PERSISTENT,
+                                       GDataCache::CACHED_FILE_MOUNTED);
   TestSetMountedState(resource_id, md5, file_path, false,
                       base::PLATFORM_FILE_OK,
                       GDataCache::CACHE_STATE_PRESENT,
                       GDataCache::CACHE_TYPE_TMP);
   EXPECT_EQ(1, num_callback_invocations_);
   EXPECT_TRUE(CacheEntryExists(resource_id, md5));
 
   // Try to remove the file.
   num_callback_invocations_ = 0;
   TestRemoveFromCache(resource_id, base::PLATFORM_FILE_OK);
@@ skipping 80 matching lines @@
   // Verify that the file was properly closed.
   EXPECT_EQ(base::PLATFORM_FILE_OK, callback_helper_->last_error_);
 
   // Verify that the cache state was changed as expected.
   VerifyCacheStateAfterCloseFile(callback_helper_->last_error_,
                                  file_resource_id,
                                  file_md5);
 }
 
 }   // namespace gdata