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

chrome/browser/chromeos/gdata/gdata_cache_metadata.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_metadata.h"
 
 #include <leveldb/db.h>
 
 #include "base/file_util.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 269 matching lines @@
     return true;
   } else if (md5 == cache_entry.md5()) {
     // Otherwise, compare the MD5.
     return true;
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GDataCacheMetadata implementation with std::map.
+// Used for testing.
 
-class GDataCacheMetadataMap : public GDataCacheMetadata {
+class FakeGDataCacheMetadata : public GDataCacheMetadata {
  public:
-  explicit GDataCacheMetadataMap(
+  explicit FakeGDataCacheMetadata(
       base::SequencedTaskRunner* blocking_task_runner);
 
  private:
-  virtual ~GDataCacheMetadataMap();
+  virtual ~FakeGDataCacheMetadata();
 
   // GDataCacheMetadata overrides:
   virtual void Initialize(const std::vector<FilePath>& cache_paths) OVERRIDE;
   virtual void AddOrUpdateCacheEntry(
       const std::string& resource_id,
       const GDataCacheEntry& cache_entry) OVERRIDE;
   virtual void RemoveCacheEntry(const std::string& resource_id) OVERRIDE;
   virtual bool GetCacheEntry(const std::string& resource_id,
                              const std::string& md5,
                              GDataCacheEntry* cache_entry) OVERRIDE;
   virtual void RemoveTemporaryFiles() OVERRIDE;
   virtual void Iterate(const IterateCallback& callback) OVERRIDE;
   virtual void ForceRescanForTesting(
       const std::vector<FilePath>& cache_paths) OVERRIDE;
 
   CacheMap cache_map_;
 
-  DISALLOW_COPY_AND_ASSIGN(GDataCacheMetadataMap);
+  DISALLOW_COPY_AND_ASSIGN(FakeGDataCacheMetadata);
 };
 
-GDataCacheMetadataMap::GDataCacheMetadataMap(
+FakeGDataCacheMetadata::FakeGDataCacheMetadata(
     base::SequencedTaskRunner* blocking_task_runner)
     : GDataCacheMetadata(blocking_task_runner) {
   AssertOnSequencedWorkerPool();
 }
 
-GDataCacheMetadataMap::~GDataCacheMetadataMap() {
+FakeGDataCacheMetadata::~FakeGDataCacheMetadata() {
   AssertOnSequencedWorkerPool();
 }
 
-void GDataCacheMetadataMap::Initialize(
+void FakeGDataCacheMetadata::Initialize(
     const std::vector<FilePath>& cache_paths) {
   AssertOnSequencedWorkerPool();
 
   ScanCachePaths(cache_paths, &cache_map_);
 }
 
-void GDataCacheMetadataMap::AddOrUpdateCacheEntry(
+void FakeGDataCacheMetadata::AddOrUpdateCacheEntry(
     const std::string& resource_id,
     const GDataCacheEntry& cache_entry) {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter == cache_map_.end()) {  // New resource, create new entry.
     cache_map_.insert(std::make_pair(resource_id, cache_entry));
   } else {  // Resource exists.
     cache_map_[resource_id] = cache_entry;
   }
 }
 
-void GDataCacheMetadataMap::RemoveCacheEntry(const std::string& resource_id) {
+void FakeGDataCacheMetadata::RemoveCacheEntry(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter != cache_map_.end()) {
     // Delete the CacheEntry and remove it from the map.
     cache_map_.erase(iter);
   }
 }
 
-bool GDataCacheMetadataMap::GetCacheEntry(const std::string& resource_id,
+bool FakeGDataCacheMetadata::GetCacheEntry(const std::string& resource_id,
                                           const std::string& md5,
                                           GDataCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter == cache_map_.end()) {
     DVLOG(1) << "Can't find " << resource_id << " in cache map";
     return false;
   }
 
   const GDataCacheEntry& cache_entry = iter->second;
 
   if (!CheckIfMd5Matches(md5, cache_entry)) {
     return false;
   }
 
   *entry = cache_entry;
   return true;
 }
 
-void GDataCacheMetadataMap::RemoveTemporaryFiles() {
+void FakeGDataCacheMetadata::RemoveTemporaryFiles() {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.begin();
   while (iter != cache_map_.end()) {
     if (!iter->second.is_persistent()) {
       // Post-increment the iterator to avoid iterator invalidation.
       cache_map_.erase(iter++);
     } else {
       ++iter;
     }
   }
 }
 
-void GDataCacheMetadataMap::Iterate(const IterateCallback& callback) {
+void FakeGDataCacheMetadata::Iterate(const IterateCallback& callback) {
   AssertOnSequencedWorkerPool();
 
   for (CacheMap::const_iterator iter = cache_map_.begin();
        iter != cache_map_.end(); ++iter) {
     callback.Run(iter->first, iter->second);
   }
 }
 
-void GDataCacheMetadataMap::ForceRescanForTesting(
+void FakeGDataCacheMetadata::ForceRescanForTesting(
     const std::vector<FilePath>& cache_paths) {
   AssertOnSequencedWorkerPool();
 
   ScanCachePaths(cache_paths, &cache_map_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GDataCacheMetadata implementation with level::db.
 
 class GDataCacheMetadataDB : public GDataCacheMetadata {
@@ skipping 175 matching lines @@
   AssertOnSequencedWorkerPool();
 }
 
 // static
 scoped_ptr<GDataCacheMetadata> GDataCacheMetadata::CreateGDataCacheMetadata(
     base::SequencedTaskRunner* blocking_task_runner) {
   return scoped_ptr<GDataCacheMetadata>(
       new GDataCacheMetadataDB(blocking_task_runner));
 }
 
+// static
+scoped_ptr<GDataCacheMetadata>
+GDataCacheMetadata::CreateGDataCacheMetadataForTesting(
+    base::SequencedTaskRunner* blocking_task_runner) {
+  return scoped_ptr<GDataCacheMetadata>(
+      new FakeGDataCacheMetadata(blocking_task_runner));
+}
+
 void GDataCacheMetadata::AssertOnSequencedWorkerPool() {
   DCHECK(!blocking_task_runner_ ||
          blocking_task_runner_->RunsTasksOnCurrentThread());
 }
 
 }  // namespace gdata