Move chromeos::GDataFileSystem::GetCacheDirectoryPath and GetCacheFilePath implementation to GDataC…

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_
 #pragma once
 
 #include <map>
 #include <string>
 
+#include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace gdata {
 
 class GDataCache {
  public:
   // Enum defining GCache subdirectory location.
   // This indexes into |GDataFileSystem::cache_paths_| vector.
   enum CacheSubDirectoryType {
     CACHE_TYPE_META = 0,       // Downloaded feeds.
@@ skipping 13 matching lines @@
 
   // This is used as a bitmask for the cache state.
   enum CacheState {
     CACHE_STATE_NONE    = 0x0,
     CACHE_STATE_PINNED  = 0x1 << 0,
     CACHE_STATE_PRESENT = 0x1 << 1,
     CACHE_STATE_DIRTY   = 0x1 << 2,
     CACHE_STATE_MOUNTED = 0x1 << 3,
   };
 
+  // Enum defining origin of a cached file.
+  enum CachedFileOrigin {
+    CACHED_FILE_FROM_SERVER = 0,
+    CACHED_FILE_LOCALLY_MODIFIED,
+    CACHED_FILE_MOUNTED,
+  };
+
+  static const char kMountedArchiveFileExtension[];
+
   // Structure to store information of an existing cache file.
   struct CacheEntry {
     CacheEntry(const std::string& md5,
               CacheSubDirectoryType sub_dir_type,
               int cache_state)
     : md5(md5),
       sub_dir_type(sub_dir_type),
       cache_state(cache_state) {
     }
 
@@ skipping 45 matching lines @@
   }
   static int ClearCacheMounted(int cache_state) {
     return cache_state &= ~CACHE_STATE_MOUNTED;
   }
 
   // A map table of cache file's resource id to its CacheEntry* entry.
   typedef std::map<std::string, CacheEntry> CacheMap;
 
   virtual ~GDataCache();
 
+  // Returns the sub-directory under gdata cache directory for the given sub
+  // directory type. Example:  <user_profile_dir>/GCache/v1/tmp
+  FilePath GetCacheDirectoryPath(CacheSubDirectoryType sub_dir_type) const;

[satorux1, 2012/06/08 15:10:54]

The class used to be a pure interface class where all non-static member
functions were virtual. I have feeling that having non-virtual functions in the
class is not desirable, but I don't have a bigger picture of how this class
should look like after the large code move from GDataFileSystem is complete.

That said, I'm ok with having a non-virtual function in this  class for now.
Once the code move is complete, we can do major refacotoring as needed.

+
+  // Returns absolute path of the file if it were cached or to be cached.
+  FilePath GetCacheFilePath(const std::string& resource_id,
+                            const std::string& md5,
+                            CacheSubDirectoryType sub_dir_type,
+                            CachedFileOrigin file_orign) const;
+
+  // TODO(hashimoto): Remove this method when crbug.com/131756 is fixed.
+  const std::vector<FilePath>& cache_paths() const { return cache_paths_; }
+
   // Sets |cache_map_| data member to formal parameter |new_cache_map|.
   virtual void SetCacheMap(const CacheMap& new_cache_map) = 0;
 
   // Updates cache map with entry corresponding to |resource_id|.
   // Creates new entry if it doesn't exist, otherwise update the entry.
   virtual void UpdateCache(const std::string& resource_id,
-                              const std::string& md5,
-                              CacheSubDirectoryType subdir,
-                              int cache_state) = 0;
+                           const std::string& md5,
+                           CacheSubDirectoryType subdir,
+                           int cache_state) = 0;
 
   // Removes entry corresponding to |resource_id| from cache map.
   virtual void RemoveFromCache(const std::string& resource_id) = 0;
 
   // Returns the cache entry for file corresponding to |resource_id| and |md5|
   // if entry exists in cache map.  Otherwise, returns NULL.
   // |md5| can be empty if only matching |resource_id| is desired, which may
   // happen when looking for pinned entries where symlinks' filenames have no
   // extension and hence no md5.
   virtual scoped_ptr<CacheEntry> GetCacheEntry(const std::string& resource_id,
                                                const std::string& md5) = 0;
 
   // Removes temporary files (files in CACHE_TYPE_TMP) from the cache map.
   virtual void RemoveTemporaryFiles() = 0;
 
   // Factory methods for GDataCache.
-  static scoped_ptr<GDataCache> CreateGDataCache();
+  static scoped_ptr<GDataCache> CreateGDataCache(
+      const FilePath& cache_root_path);
 
  protected:
-  GDataCache();
+  explicit GDataCache(const FilePath& cache_root_path);
 
  private:
+  // Paths for all subdirectories of GCache, one for each
+  // GDataCache::CacheSubDirectoryType enum.
+  std::vector<FilePath> cache_paths_;
+
   DISALLOW_COPY_AND_ASSIGN(GDataCache);
 };
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_