drive: Use ResourceMetadataStorage from FileCache

chrome/browser/chromeos/drive/file_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_DRIVE_FILE_CACHE_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_FILE_CACHE_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 23 matching lines @@
 typedef base::Callback<void(bool success, const FileCacheEntry& cache_entry)>
     GetCacheEntryCallback;
 
 // Callback for Iterate().
 typedef base::Callback<void(const std::string& resource_id,
                             const FileCacheEntry& cache_entry)>
     CacheIterateCallback;
 
 namespace internal {
 
-class FileCacheMetadata;
+class ResourceMetadataStorage;
 
 // Callback for GetFileFromCache.
 typedef base::Callback<void(FileError error,
                             const base::FilePath& cache_file_path)>
     GetFileFromCacheCallback;
 
 // Callback for RequestInitialize.
 // |success| indicates if the operation was successful.
 // TODO(satorux): Change this to FileError when it becomes necessary.
 typedef base::Callback<void(bool success)>
@@ skipping 12 matching lines @@
 // All non-static public member functions, unless mentioned otherwise (see
 // GetCacheFilePath() for example), should be run with |blocking_task_runner|.
 class FileCache {
  public:
   // Enum defining type of file operation e.g. copy or move, etc.
   enum FileOperationType {
     FILE_OPERATION_MOVE = 0,
     FILE_OPERATION_COPY,
   };
 
-  // |metadata_directory| stores the metadata and |cache_file_directory| stores
-  // cached files.
+  // Name of the cache metadata DB previously used.
+  // TODO(hashimoto): Remove this at some point.
+  static const base::FilePath::CharType kOldCacheMetadataDBName[];
+
+  // |cache_file_directory| stores cached files.
   //
   // |blocking_task_runner| is used to post a task to the blocking worker
   // pool for file operations. Must not be null.
   //
   // |free_disk_space_getter| is used to inject a custom free disk space
   // getter for testing. NULL must be passed for production code.
   //
   // Must be called on the UI thread.
-  FileCache(const base::FilePath& metadata_directory,
+  FileCache(ResourceMetadataStorage* storage,
             const base::FilePath& cache_file_directory,
             base::SequencedTaskRunner* blocking_task_runner,
             FreeDiskSpaceGetterInterface* free_disk_space_getter);
 
   // Returns true if the given path is under drive cache directory, i.e.
   // <user_profile_dir>/GCache/v1
   //
   // Can be called on any thread.
   bool IsUnderFileCacheDirectory(const base::FilePath& path) const;
 
@@ skipping 189 matching lines @@
   FileError MarkAsUnmounted(const base::FilePath& file_path);
 
   // Used to implement ClearAllOnUIThread.
   bool ClearAll();
 
   // Returns true if we have sufficient space to store the given number of
   // bytes, while keeping kMinFreeSpace bytes on the disk.
   bool HasEnoughSpaceFor(int64 num_bytes, const base::FilePath& path);
 
   // Imports old format DB from |old_db_path| and deletes it.
-  void ImportOldDB(const base::FilePath& old_db_path);
+  // TODO(hashimoto): Remove this method and FileCacheMetadata at some point.
+  bool ImportOldDB(const base::FilePath& old_db_path);
 
-  const base::FilePath metadata_directory_;
   const base::FilePath cache_file_directory_;
 
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 
-  // The cache state data. This member must be access only on the blocking pool.
-  scoped_ptr<FileCacheMetadata> metadata_;
+  ResourceMetadataStorage* storage_;
 
   FreeDiskSpaceGetterInterface* free_disk_space_getter_;  // Not owned.
 
   // Resource IDs of files marked mounted.
   std::set<std::string> mounted_files_;
 
   // 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<FileCache> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(FileCache);
 };
 
 // The minimum free space to keep. FileSystem::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;
 
 }  // namespace internal
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_FILE_CACHE_H_