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

chrome/browser/chromeos/gdata/gdata_cache.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 299 matching lines @@
   // TODO(glotov): take care of this when the setup and cleanup part is
   // landed, noting that these directories need to be created for development
   // in linux box and unittest. (http://crosbug.com/27577)
   static bool CreateCacheDirectories(
       const std::vector<FilePath>& paths_to_create);
 
   // Returns the type of the sub directory where the cache file is stored.
   static CacheSubDirectoryType GetSubDirectoryType(
       const GDataCacheEntry& cache_entry);
 
+  // Force std::map implementaition for metadata.

[achuithb, 2012/08/06 23:22:20]

spelling - implementation.

You could also add a param to RequestInitializeOnUIThread so mistakes are not
made with ordering this function wrt to RequestInitializeOnUIThread (as in, this
function must be called first).

[satorux1, 2012/08/07 10:50:08]

Yes, Ordering is nasty. Maybe we should add
RequestInitializeOnUIThreadForTesting()

[Haruki Sato, 2012/08/08 05:00:42]

Thank you for the advice!
Removed the flag and added *ForTesting methods.

Could you take a look?

+  // Must be called before Initialization.
+  // Used for testing.
+  void ForceMetadataMapForTesting();
+
  private:
   GDataCache(const FilePath& cache_root_path,
              base::SequencedTaskRunner* blocking_task_runner);
   virtual ~GDataCache();
 
   // Checks whether the current thread is on the right sequenced worker pool
   // with the right sequence ID. If not, DCHECK will fail.
   void AssertOnSequencedWorkerPool();
 
   // Initializes the cache.
@@ skipping 109 matching lines @@
   // The cache state data. This member must be access only on the blocking pool.
   scoped_ptr<GDataCacheMetadata> metadata_;
 
   // List of observers, this member must be accessed on UI thread.
   ObserverList<Observer> observers_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<GDataCache> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(GDataCache);
+
+  // Set to true when std::map cache implementation is desired.
+  // Used by tests.
+  bool force_metadata_map_for_testing_;
 };
 
 
 // The minimum free space to keep. GDataFileSystem::GetFileByPath() returns
 // GDATA_FILE_ERROR_NO_SPACE if the available space is smaller than
 // this value.
 //
 // Copied from cryptohome/homedirs.h.
 // TODO(satorux): Share the constant.
 const int64 kMinFreeSpace = 512 * 1LL << 20;
 
 // Interface class used for getting the free disk space. Only for testing.
 class FreeDiskSpaceGetterInterface {
  public:
   virtual ~FreeDiskSpaceGetterInterface() {}
   virtual int64 AmountOfFreeDiskSpace() const = 0;
 };
 
 // Sets the free disk space getter for testing.
 // The existing getter is deleted.
 void SetFreeDiskSpaceGetterForTesting(
     FreeDiskSpaceGetterInterface* getter);
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_