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

Use the in-memory version for GDataFileSystemTest.


BUG=137945
TEST=unit_tests   --gtest_filter='GDataFileSystemTest*'

Review URL: https://chromiumcodereview.appspot.com/10830181

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@151013 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/chromeos/gdata/gdata_cache.cc

@@ -697,6 +697,14 @@ void GDataCache::RequestInitializeOnUIThread() {
       base::Bind(&GDataCache::Initialize, base::Unretained(this)));
 }
 
+void GDataCache::RequestInitializeOnUIThreadForTesting() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GDataCache::InitializeForTesting, base::Unretained(this)));
+}
+
 void GDataCache::ForceRescanOnUIThreadForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ -743,6 +751,15 @@ void GDataCache::Initialize() {
   metadata_->Initialize(cache_paths_);
 }
 
+void GDataCache::InitializeForTesting() {
+  AssertOnSequencedWorkerPool();
+
+  InitCachePaths(cache_paths_);
+  metadata_ = GDataCacheMetadata::CreateGDataCacheMetadataForTesting(
+      blocking_task_runner_).Pass();
+  metadata_->Initialize(cache_paths_);
+}
+
 void GDataCache::Destroy() {
   AssertOnSequencedWorkerPool();
   delete this;

chrome/browser/chromeos/gdata/gdata_cache.h

@@ -272,6 +272,9 @@ class GDataCache {
   // Utility method to call Initialize on UI thread.
   void RequestInitializeOnUIThread();
 
+  // Utility method to call InitializeForTesting on UI thread.
+  void RequestInitializeOnUIThreadForTesting();
+
   // Force a rescan of cache files, for testing.
   void ForceRescanOnUIThreadForTesting();
 
@@ -329,6 +332,10 @@ class GDataCache {
   // Initializes the cache.
   void Initialize();
 
+  // Initializes the cache with in-memory cache for testing.
+  // The in-memory cache is used since it's faster than the db.
+  void InitializeForTesting();
+
   // Deletes the cache.
   void Destroy();
 

chrome/browser/chromeos/gdata/gdata_cache_metadata.cc

@@ -287,14 +287,15 @@ bool CheckIfMd5Matches(
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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;
@@ -312,27 +313,27 @@ class GDataCacheMetadataMap : public GDataCacheMetadata {
 
   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();
@@ -345,7 +346,7 @@ void GDataCacheMetadataMap::AddOrUpdateCacheEntry(
   }
 }
 
-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);
@@ -355,7 +356,7 @@ void GDataCacheMetadataMap::RemoveCacheEntry(const std::string& resource_id) {
   }
 }
 
-bool GDataCacheMetadataMap::GetCacheEntry(const std::string& resource_id,
+bool FakeGDataCacheMetadata::GetCacheEntry(const std::string& resource_id,
                                           const std::string& md5,
                                           GDataCacheEntry* entry) {
   DCHECK(entry);
@@ -377,7 +378,7 @@ bool GDataCacheMetadataMap::GetCacheEntry(const std::string& resource_id,
   return true;
 }
 
-void GDataCacheMetadataMap::RemoveTemporaryFiles() {
+void FakeGDataCacheMetadata::RemoveTemporaryFiles() {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.begin();
@@ -391,7 +392,7 @@ void GDataCacheMetadataMap::RemoveTemporaryFiles() {
   }
 }
 
-void GDataCacheMetadataMap::Iterate(const IterateCallback& callback) {
+void FakeGDataCacheMetadata::Iterate(const IterateCallback& callback) {
   AssertOnSequencedWorkerPool();
 
   for (CacheMap::const_iterator iter = cache_map_.begin();
@@ -400,7 +401,7 @@ void GDataCacheMetadataMap::Iterate(const IterateCallback& callback) {
   }
 }
 
-void GDataCacheMetadataMap::ForceRescanForTesting(
+void FakeGDataCacheMetadata::ForceRescanForTesting(
     const std::vector<FilePath>& cache_paths) {
   AssertOnSequencedWorkerPool();
 
@@ -596,6 +597,14 @@ scoped_ptr<GDataCacheMetadata> GDataCacheMetadata::CreateGDataCacheMetadata(
       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());

chrome/browser/chromeos/gdata/gdata_cache_metadata.h

@@ -31,14 +31,15 @@ class GDataCacheMetadata {
 
   virtual ~GDataCacheMetadata();
 
-  // |pool| and |sequence_token| are used to assert that the functions are
-  // called on the right sequenced worker pool with the right sequence token.
-  //
-  // For testing, the thread assertion can be disabled by passing NULL and
-  // the default value of SequenceToken.
+  // Creates GDataCacheMetadata instance.
   static scoped_ptr<GDataCacheMetadata> CreateGDataCacheMetadata(
       base::SequencedTaskRunner* blocking_task_runner);
 
+  // Creates GDataCacheMetadata instance. This uses FakeGDataCacheMetadata,
+  // which is an in-memory implmentation and faster than GDataCacheMetadataDB.
+  static scoped_ptr<GDataCacheMetadata> CreateGDataCacheMetadataForTesting(
+      base::SequencedTaskRunner* blocking_task_runner);
+
   // Initialize the cache metadata store.
   virtual void Initialize(const std::vector<FilePath>& cache_paths) = 0;
   // Adds a new cache entry corresponding to |resource_id| if it doesn't

chrome/browser/chromeos/gdata/gdata_file_system_unittest.cc

@@ -257,7 +257,7 @@ class GDataFileSystemTest : public testing::Test {
     file_system_->AddObserver(mock_directory_observer_.get());
 
     file_system_->Initialize();
-    cache_->RequestInitializeOnUIThread();
+    cache_->RequestInitializeOnUIThreadForTesting();
     test_util::RunBlockingPoolTask();
   }