gdata: Remove sub_dir_type from CacheEntry for simplicity

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>
@@ skipping 62 matching lines @@
                                // 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_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.
@@ skipping 15 matching lines @@
 
     // 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.
   struct CacheEntry {
-    CacheEntry() : sub_dir_type(CACHE_TYPE_META),
-                   cache_state(0) {}
+    CacheEntry() : cache_state(0) {}
 
     CacheEntry(const std::string& md5,
-               CacheSubDirectoryType sub_dir_type,
                int cache_state)
         : md5(md5),
-          sub_dir_type(sub_dir_type),
           cache_state(cache_state) {
     }
 
     bool IsPresent() const { return IsCachePresent(cache_state); }
     bool IsPinned() const { return IsCachePinned(cache_state); }
     bool IsDirty() const { return IsCacheDirty(cache_state); }
-    bool IsMounted() const  { return IsCacheMounted(cache_state); }
+    bool IsMounted() const { return IsCacheMounted(cache_state); }
+    bool IsPersistent() const { return IsCachePersistent(cache_state); }
+
+    // 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;
 
     std::string md5;
-    CacheSubDirectoryType sub_dir_type;
     int cache_state;
   };
 
   // Callback for GetCacheEntryOnUIThread.
   // |success| indicates if the operation was successful.
   // |cache_entry| is the obtained cache entry.
   //
   // 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;
 
   static bool IsCachePresent(int cache_state) {
     return cache_state & CACHE_STATE_PRESENT;
   }
   static bool IsCachePinned(int cache_state) {
     return cache_state & CACHE_STATE_PINNED;
   }
   static bool IsCacheDirty(int cache_state) {
     return cache_state & CACHE_STATE_DIRTY;
   }
   static bool IsCacheMounted(int cache_state) {
     return cache_state & CACHE_STATE_MOUNTED;
   }
+  static bool IsCachePersistent(int cache_state) {
+    return cache_state & CACHE_STATE_PERSISTENT;
+  }
   static int SetCachePresent(int cache_state) {
     return cache_state |= CACHE_STATE_PRESENT;
   }
   static int SetCachePinned(int cache_state) {
     return cache_state |= CACHE_STATE_PINNED;
   }
   static int SetCacheDirty(int cache_state) {
     return cache_state |= CACHE_STATE_DIRTY;
   }
   static int SetCacheMounted(int cache_state) {
     return cache_state |= CACHE_STATE_MOUNTED;
   }
+  static int SetCachePersistent(int cache_state) {
+    return cache_state |= CACHE_STATE_PERSISTENT;
+  }
   static int ClearCachePresent(int cache_state) {
     return cache_state &= ~CACHE_STATE_PRESENT;
   }
   static int ClearCachePinned(int cache_state) {
     return cache_state &= ~CACHE_STATE_PINNED;
   }
   static int ClearCacheDirty(int cache_state) {
     return cache_state &= ~CACHE_STATE_DIRTY;
   }
   static int ClearCacheMounted(int cache_state) {
     return cache_state &= ~CACHE_STATE_MOUNTED;
   }
+  static int ClearCachePersistent(int cache_state) {
+    return cache_state &= ~CACHE_STATE_PERSISTENT;
+  }
 
   // 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.
@@ skipping 258 matching lines @@
                      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);
 
+  // Wrapper around GDataCacheMetadata::UpdateCache(). This function takes
+  // |sub_dir_type| and modifies |cache_state| per the sub directory type.
+  void UpdateCacheWithSubDirectoryType(const std::string& resource_id,
+                                       const std::string& md5,
+                                       CacheSubDirectoryType sub_dir_type,
+                                       int cache_state);
+
   // 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.
   scoped_ptr<GDataCacheMetadata> metadata_;
@@ skipping 25 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_