Revert 145933 - gdata: Remove sub_dir_type from CacheEntry for simplicity

chrome/browser/chromeos/gdata/gdata_cache_metadata.cc

 // 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.
 
 #include "chrome/browser/chromeos/gdata/gdata_cache_metadata.h"
 
 #include "base/file_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 
 namespace gdata {
@@ skipping 166 matching lines @@
                      &cache_map_,
                      &outgoing_file_map);
 
   RemoveInvalidFilesFromPersistentDirectory(persistent_file_map,
                                             outgoing_file_map,
                                             &cache_map_);
   DVLOG(1) << "Directory scan finished";
 }
 
 void GDataCacheMetadataMap::UpdateCache(const std::string& resource_id,
-                                        const std::string& md5,
-                                        int cache_state) {
+                                    const std::string& md5,
+                                    GDataCache::CacheSubDirectoryType subdir,
+                                    int cache_state) {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter == cache_map_.end()) {  // New resource, create new entry.
     // Makes no sense to create new entry if cache state is NONE.
     DCHECK(cache_state != GDataCache::CACHE_STATE_NONE);
     if (cache_state != GDataCache::CACHE_STATE_NONE) {
-      GDataCache::CacheEntry cache_entry(md5, cache_state);
+      GDataCache::CacheEntry cache_entry(md5, subdir, cache_state);
       cache_map_.insert(std::make_pair(resource_id, cache_entry));
       DVLOG(1) << "Added res_id=" << resource_id
                << ", " << cache_entry.ToString();
     }
   } else {  // Resource exists.
     // If cache state is NONE, delete entry from cache map.
     if (cache_state == GDataCache::CACHE_STATE_NONE) {
       DVLOG(1) << "Deleting res_id=" << resource_id
                << ", " << iter->second.ToString();
       cache_map_.erase(iter);
     } else {  // Otherwise, update entry in cache map.
       iter->second.md5 = md5;
+      iter->second.sub_dir_type = subdir;
       iter->second.cache_state = cache_state;
       DVLOG(1) << "Updated res_id=" << resource_id
                << ", " << iter->second.ToString();
     }
   }
 }
 
 void GDataCacheMetadataMap::RemoveFromCache(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
@@ skipping 30 matching lines @@
            << ", " << cache_entry->ToString();
 
   return cache_entry.Pass();
 }
 
 void GDataCacheMetadataMap::RemoveTemporaryFiles() {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.begin();
   while (iter != cache_map_.end()) {
-    if (!iter->second.IsPersistent()) {
+    if (iter->second.sub_dir_type == GDataCache::CACHE_TYPE_TMP) {
       // Post-increment the iterator to avoid iterator invalidation.
       cache_map_.erase(iter++);
     } else {
       ++iter;
     }
   }
 }
 
 void GDataCacheMetadataMap::Iterate(const IterateCallback& callback) {
   AssertOnSequencedWorkerPool();
@@ skipping 75 matching lines @@
         LOG(WARNING) << "Removing an symlink to a non-dirty file: "
                      << current.value();
         file_util::Delete(current, false);
         continue;
       }
 
       processed_file_map->insert(std::make_pair(resource_id, current));
       continue;
     } else if (sub_dir_type == GDataCache::CACHE_TYPE_PERSISTENT ||
                sub_dir_type == GDataCache::CACHE_TYPE_TMP) {
-      if (sub_dir_type == GDataCache::CACHE_TYPE_PERSISTENT)
-        cache_state = GDataCache::SetCachePersistent(cache_state);
-
       if (file_util::IsLink(current)) {
         LOG(WARNING) << "Removing a symlink in persistent/tmp directory"
                      << current.value();
         file_util::Delete(current, false);
         continue;
       }
       if (extra_extension == util::kMountedArchiveFileExtension) {
         // Mounted archives in cache should be unmounted upon logout/shutdown.
         // But if we encounter a mounted file at start, delete it and create an
         // entry with not PRESENT state.
         DCHECK(sub_dir_type == GDataCache::CACHE_TYPE_PERSISTENT);
         file_util::Delete(current, false);
       } else {
         // The cache file is present.
         cache_state = GDataCache::SetCachePresent(cache_state);
 
         // Adds the dirty bit if |md5| indicates that the file is dirty, and
         // the file is in the persistent directory.
         if (md5 == util::kLocallyModifiedFileExtension) {
           if (sub_dir_type == GDataCache::CACHE_TYPE_PERSISTENT) {
-            cache_state = GDataCache::SetCacheDirty(cache_state);
+            cache_state |= GDataCache::SetCacheDirty(cache_state);
           } else {
             LOG(WARNING) << "Removing a dirty file in tmp directory: "
                          << current.value();
             file_util::Delete(current, false);
             continue;
           }
         }
       }
     } else {
       NOTREACHED() << "Unexpected sub directory type: " << sub_dir_type;
     }
 
     // Create and insert new entry into cache map.
     cache_map->insert(std::make_pair(
-        resource_id, GDataCache::CacheEntry(md5, cache_state)));
+        resource_id, GDataCache::CacheEntry(
+            md5, real_sub_dir_type, cache_state)));
     processed_file_map->insert(std::make_pair(resource_id, current));
   }
 }
 
 // static
 bool GDataCacheMetadataMap::CheckIfMd5Matches(
     const std::string& md5,
     const GDataCache::CacheEntry& cache_entry) {
   if (cache_entry.IsDirty()) {
     // If the entry is dirty, its MD5 may have been replaced by "local"
     // during cache initialization, so we don't compare MD5.
     return true;
   } else if (cache_entry.IsPinned() && cache_entry.md5.empty()) {
     // If the entry is pinned, it's ok for the entry to have an empty
     // MD5. This can happen if the pinned file is not fetched. MD5 for pinned
     // files are collected from files in "persistent" directory, but the
     // persistent files do not exisit if these are not fetched yet.
     return true;
   } else if (md5.empty()) {
     // If the MD5 matching is not requested, don't check MD5.
     return true;
   } else if (md5 == cache_entry.md5) {
     // Otherwise, compare the MD5.
     return true;
   }
   return false;
 }
 
 }  // namespace gdata