Implement initialization for GDataCache to use in-memory metadata for tests.

chrome/browser/chromeos/gdata/gdata_cache.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/gdata/gdata_cache.h"
 
 #include <vector>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/file_util.h"
@@ skipping 306 matching lines @@
     callback.Run(*success, *cache_entry);
 }
 
 }  // namespace
 
 GDataCache::GDataCache(const FilePath& cache_root_path,
                        base::SequencedTaskRunner* blocking_task_runner)
     : cache_root_path_(cache_root_path),
       cache_paths_(GetCachePaths(cache_root_path_)),
       blocking_task_runner_(blocking_task_runner),
-      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      force_metadata_map_for_testing_(false) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 GDataCache::~GDataCache() {
   AssertOnSequencedWorkerPool();
 }
 
 FilePath GDataCache::GetCacheDirectoryPath(
     CacheSubDirectoryType sub_dir_type) const {
   DCHECK_LE(0, sub_dir_type);
@@ skipping 403 matching lines @@
       FROM_HERE,
       base::Bind(&GDataCache::Destroy,
                  base::Unretained(this)));
 }
 
 void GDataCache::Initialize() {
   AssertOnSequencedWorkerPool();
 
   InitCachePaths(cache_paths_);
   metadata_ = GDataCacheMetadata::CreateGDataCacheMetadata(
-      blocking_task_runner_).Pass();
+      blocking_task_runner_, force_metadata_map_for_testing_).Pass();
   metadata_->Initialize(cache_paths_);
 }
 
 void GDataCache::Destroy() {
   AssertOnSequencedWorkerPool();
   delete this;
 }
 
 void GDataCache::ForceRescanForTesting() {
   AssertOnSequencedWorkerPool();
@@ skipping 755 matching lines @@
                                      const std::string& md5,
                                      bool* success,
                                      GDataCacheEntry* cache_entry) {
   AssertOnSequencedWorkerPool();
   DCHECK(success);
   DCHECK(cache_entry);
 
   *success = GetCacheEntry(resource_id, md5, cache_entry);
 }
 
+void GDataCache::ForceMetadataMapForTesting() {
+  force_metadata_map_for_testing_ = true;
+}
+
 // static
 FilePath GDataCache::GetCacheRootPath(Profile* profile) {
   FilePath cache_base_path;
   chrome::GetUserCacheDirectory(profile->GetPath(), &cache_base_path);
   FilePath cache_root_path =
       cache_base_path.Append(chrome::kGDataCacheDirname);
   return cache_root_path.Append(kGDataCacheVersionDir);
 }
 
 // static
@@ skipping 36 matching lines @@
     const GDataCacheEntry& cache_entry) {
   return cache_entry.is_persistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata