gdata: Move GDataCache::CacheEntry out of GDataCache

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 "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/platform_file.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "chrome/browser/chromeos/gdata/gdata_cache_entry.h"
 
 class Profile;
 
 namespace gdata {
 
 class GDataCacheMetadata;
 
 // Callback for SetMountedStateOnUIThread.
 typedef base::Callback<void(base::PlatformFileError error,
                             const FilePath& file_path)> SetMountedStateCallback;
@@ skipping 14 matching lines @@
 // |to_fetch| is for resource IDs of pinned-but-not-fetched files.
 // |to_upload| is for resource IDs of dirty-but-not-uploaded files.
 typedef base::Callback<void(const std::vector<std::string>& to_fetch,
                             const std::vector<std::string>& to_upload)>
     GetResourceIdsOfBacklogCallback;
 
 // Callback for GetResourceIdsOfExistingPinnedFilesOnUIThread.
 typedef base::Callback<void(const std::vector<std::string>& resource_ids)>
     GetResourceIdsCallback;
 
+// Callback for GetCacheEntryOnUIThread.
+// |success| indicates if the operation was successful.
+// |cache_entry| is the obtained cache entry. On failure, |cache_state| is
+// set to CACHE_STATE_NONE.
+typedef base::Callback<void(bool success, const GDataCacheEntry& cache_entry)>
+    GetCacheEntryCallback;
+
 // GDataCache is used to maintain cache states of GDataFileSystem.
 //
 // All non-static public member functions, unless mentioned otherwise (see
 // GetCacheFilePath() for example), should be called from the sequenced
 // worker pool with the sequence token set by CreateGDataCacheOnUIThread(). This
 // threading model is enforced by AssertOnSequencedWorkerPool().
 //
 // TODO(hashimoto): Change threading model of this class to make public methods
 // being called on UI thread unless mentioned otherwise. crbug.com/132926
 class GDataCache {
  public:
   // Enum defining GCache subdirectory location.
   // This indexes into |GDataCache::cache_paths_| vector.
   enum CacheSubDirectoryType {
     CACHE_TYPE_META = 0,       // Downloaded feeds.
     CACHE_TYPE_PINNED,         // Symlinks to files in persistent dir that are
                                // pinned, or to /dev/null for non-existent
                                // files.
     CACHE_TYPE_OUTGOING,       // Symlinks to files in persistent or tmp dir to
                                // be uploaded.
     CACHE_TYPE_PERSISTENT,     // Files that are pinned or modified locally,
                                // not evictable, hopefully.
     CACHE_TYPE_TMP,            // Files that don't meet criteria to be in
                                // persistent dir, and hence evictable.
     CACHE_TYPE_TMP_DOWNLOADS,  // Downloaded files.
     CACHE_TYPE_TMP_DOCUMENTS,  // Temporary JSON files for hosted documents.
     NUM_CACHE_TYPES,           // This must be at the end.
   };
 
-  // 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,
-    CACHE_STATE_PERSISTENT = 0x1 << 4,
-  };
-
   // Enum defining origin of a cached file.
   enum CachedFileOrigin {
     CACHED_FILE_FROM_SERVER = 0,
     CACHED_FILE_LOCALLY_MODIFIED,
     CACHED_FILE_MOUNTED,
   };
 
   // Enum defining type of file operation e.g. copy or move, etc.
   enum FileOperationType {
     FILE_OPERATION_MOVE = 0,
@@ skipping 11 matching lines @@
     virtual void OnCacheUnpinned(const std::string& resource_id,
                                  const std::string& md5) {}
 
     // Triggered when a dirty file has been committed (saved) successfully.
     virtual void OnCacheCommitted(const std::string& resource_id) {}
 
    protected:
     virtual ~Observer() {}
   };
 
-  // Structure to store information of an existing cache file.
-  class CacheEntry {
-   public:
-    CacheEntry() : cache_state_(CACHE_STATE_NONE) {}
-
-    CacheEntry(const std::string& md5,
-               int cache_state)
-        : md5_(md5),
-          cache_state_(cache_state) {
-    }
-
-    // The MD5 of the cache file. This can be "local" if the file is
-    // locally modified.
-    const std::string& md5() const { return md5_; }
-
-    // The cache state represented as a bitmask of GDataCacheState.
-    int cache_state() const { return cache_state_; }
-
-    void set_md5(const std::string& md5) { md5_ = md5; }
-    void set_cache_state(int cache_state) { cache_state_ = cache_state; }
-
-    // Returns true if the file is present locally.
-    bool IsPresent() const { return cache_state_ & CACHE_STATE_PRESENT; }
-
-    // Returns true if the file is pinned (i.e. available offline).
-    bool IsPinned() const { return cache_state_ & CACHE_STATE_PINNED; }
-
-    // Returns true if the file is dirty (i.e. modified locally).
-    bool IsDirty() const { return cache_state_ & CACHE_STATE_DIRTY; }
-
-    // Returns true if the file is a mounted archive file.
-    bool IsMounted() const { return cache_state_ & CACHE_STATE_MOUNTED; }
-
-    // Returns true if the file is in the persistent directory.
-    bool IsPersistent() const { return cache_state_ & CACHE_STATE_PERSISTENT; }
-
-    // Setters for the states describe above.
-    void SetPresent(bool value) {
-      if (value)
-        cache_state_ |= CACHE_STATE_PRESENT;
-      else
-        cache_state_ &= ~CACHE_STATE_PRESENT;
-    }
-    void SetPinned(bool value) {
-      if (value)
-        cache_state_ |= CACHE_STATE_PINNED;
-      else
-        cache_state_ &= ~CACHE_STATE_PINNED;
-    }
-    void SetDirty(bool value) {
-      if (value)
-        cache_state_ |= CACHE_STATE_DIRTY;
-      else
-        cache_state_ &= ~CACHE_STATE_DIRTY;
-    }
-    void SetMounted(bool value) {
-      if (value)
-        cache_state_ |= CACHE_STATE_MOUNTED;
-      else
-        cache_state_ &= ~CACHE_STATE_MOUNTED;
-    }
-    void SetPersistent(bool value) {
-      if (value)
-        cache_state_ |= CACHE_STATE_PERSISTENT;
-      else
-        cache_state_ &= ~CACHE_STATE_PERSISTENT;
-    }
-
-    // Returns the type of the sub directory where the cache file is stored.
-    CacheSubDirectoryType GetSubDirectoryType() const {
-      return IsPersistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
-    }
-
-    // For debugging purposes.
-    std::string ToString() const;
-
-   private:
-    std::string md5_;
-    int cache_state_;
-  };
-
-  // Callback for GetCacheEntryOnUIThread.
-  // |success| indicates if the operation was successful.
-  // |cache_entry| is the obtained cache entry. On failure, |cache_state| is
-  // set to CACHE_STATE_NONE.
-  //
-  // TODO(satorux): Unlike other callback types, this has to be defined
-  // inside GDataCache as CacheEntry is inside GDataCache. We should get them
-  // outside of GDataCache.
-  typedef base::Callback<void(bool success, const CacheEntry& cache_entry)>
-      GetCacheEntryCallback;
-
   // Returns the sub-directory under gdata cache directory for the given sub
   // directory type. Example:  <user_profile_dir>/GCache/v1/tmp
   //
   // Can be called on any thread.
   FilePath GetCacheDirectoryPath(CacheSubDirectoryType sub_dir_type) const;
 
   // Returns absolute path of the file if it were cached or to be cached.
   //
   // Can be called on any thread.
   FilePath GetCacheFilePath(const std::string& resource_id,
@@ skipping 120 matching lines @@
                         const CacheOperationCallback& callback);
 
   // Utility method to call Initialize on UI thread.
   void RequestInitializeOnUIThread();
 
   // 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.
-  scoped_ptr<CacheEntry> GetCacheEntry(const std::string& resource_id,
-                                       const std::string& md5);
+  scoped_ptr<GDataCacheEntry> GetCacheEntry(const std::string& resource_id,
+                                            const std::string& md5);
 
   // Factory methods for GDataCache.
   // |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.
   static GDataCache* CreateGDataCacheOnUIThread(
       const FilePath& cache_root_path,
       base::SequencedWorkerPool* pool,
@@ skipping 11 matching lines @@
   // |cache_root_path|.
   static std::vector<FilePath> GetCachePaths(const FilePath& cache_root_path);
 
   // Creates cache directory and its sub-directories if they don't exist.
   // 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);
+
  private:
   GDataCache(
       const FilePath& cache_root_path,
       base::SequencedWorkerPool* pool_,
       const base::SequencedWorkerPool::SequenceToken& sequence_token);
   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();
@@ skipping 82 matching lines @@
   // Runs callback and notifies the observers when file is committed.
   void OnCommitDirty(base::PlatformFileError* error,
                      const std::string& resource_id,
                      const std::string& md5,
                      const CacheOperationCallback& callback);
 
   // Helper function to implement GetCacheEntryOnUIThread().
   void GetCacheEntryHelper(const std::string& resource_id,
                            const std::string& md5,
                            bool* success,
-                           GDataCache::CacheEntry* cache_entry);
+                           GDataCacheEntry* cache_entry);
 
   // The root directory of the cache (i.e. <user_profile_dir>/GCache/v1).
   const FilePath cache_root_path_;
   // Paths for all subdirectories of GCache, one for each
   // GDataCache::CacheSubDirectoryType enum.
   const std::vector<FilePath> cache_paths_;
   base::SequencedWorkerPool* pool_;
   const base::SequencedWorkerPool::SequenceToken sequence_token_;
 
   // The cache state data. This member must be access only on the blocking pool.
@@ skipping 26 matching lines @@
 };
 
 // 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_