gdata: Simplify semantics of sub_dir_type in CacheEntry.

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 276 matching lines @@
 
   file_util::FileEnumerator enumerator(
       cache_paths[sub_dir_type],
       false,  // not recursive
       static_cast<file_util::FileEnumerator::FileType>(
           file_util::FileEnumerator::FILES |
           file_util::FileEnumerator::SHOW_SYM_LINKS),
       util::kWildCard);
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
+    GDataCache::CacheSubDirectoryType real_sub_dir_type =
+        sub_dir_type;
     // Extract resource_id and md5 from filename.
     std::string resource_id;
     std::string md5;
     std::string extra_extension;
     util::ParseCacheFilePath(current, &resource_id, &md5, &extra_extension);
 
     // Determine cache state.
     int cache_state = GDataCache::CACHE_STATE_NONE;
     // If we're scanning pinned directory and if entry already exists, just
     // update its pinned state.
@@ skipping 11 matching lines @@
         iter->second.cache_state =
             GDataCache::SetCachePinned(iter->second.cache_state);
 
         processed_file_map->insert(std::make_pair(resource_id, current));
         continue;
       }
       // Entry doesn't exist, this is a special symlink that refers to
       // /dev/null; follow through to create an entry with the PINNED but not
       // PRESENT state.
       cache_state = GDataCache::SetCachePinned(cache_state);
+      // Change the real sub directory type to TMP, as the downloaded file
+      // will be stored in 'tmp' directory first.
+      real_sub_dir_type = GDataCache::CACHE_TYPE_TMP;
     } else if (sub_dir_type == GDataCache::CACHE_TYPE_OUTGOING) {
       std::string reason;
       if (!IsValidSymbolicLink(current, sub_dir_type, cache_paths, &reason)) {
         LOG(WARNING) << "Removing an invalid symlink: " << current.value()
                      << ": " << reason;
         file_util::Delete(current, false);
         continue;
       }
 
       // If we're scanning outgoing directory, entry must exist and be dirty.
@@ skipping 39 matching lines @@
             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, sub_dir_type, 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