gdata: Move GDataCache::CacheEntry out of GDataCache

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 49 matching lines @@
     GDataCacheMetadataMap::CacheMap* cache_map) {
   for (GDataCacheMetadataMap::ResourceIdToFilePathMap::const_iterator iter =
            persistent_file_map.begin();
        iter != persistent_file_map.end(); ++iter) {
     const std::string& resource_id = iter->first;
     const FilePath& file_path = iter->second;
 
     GDataCacheMetadataMap::CacheMap::iterator cache_map_iter =
         cache_map->find(resource_id);
     if (cache_map_iter != cache_map->end()) {
-      const GDataCache::CacheEntry& cache_entry = cache_map_iter->second;
+      const GDataCacheEntry& cache_entry = cache_map_iter->second;
       // If the file is dirty but not committed, remove it.
       if (cache_entry.IsDirty() && outgoing_file_map.count(resource_id) == 0) {
         LOG(WARNING) << "Removing dirty-but-not-committed file: "
                      << file_path.value();
         file_util::Delete(file_path, false);
         cache_map->erase(cache_map_iter);
       } else if (!cache_entry.IsDirty() && !cache_entry.IsPinned()) {
         // If the file is neither dirty nor pinned, remove it.
         LOG(WARNING) << "Removing persistent-but-dangling file: "
                      << file_path.value();
@@ skipping 88 matching lines @@
                      &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 GDataCache::CacheEntry& cache_entry) {
+    const GDataCacheEntry& cache_entry) {
   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_entry.cache_state() != GDataCache::CACHE_STATE_NONE);
-    if (cache_entry.cache_state() != GDataCache::CACHE_STATE_NONE) {
+    DCHECK(cache_entry.cache_state() != CACHE_STATE_NONE);
+    if (cache_entry.cache_state() != CACHE_STATE_NONE) {
       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_entry.cache_state() == GDataCache::CACHE_STATE_NONE) {
+    if (cache_entry.cache_state() == 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.set_md5(cache_entry.md5());
       iter->second.set_cache_state(cache_entry.cache_state());
       DVLOG(1) << "Updated res_id=" << resource_id
                << ", " << iter->second.ToString();
     }
   }
 }
 
 void GDataCacheMetadataMap::RemoveFromCache(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter != cache_map_.end()) {
     // Delete the CacheEntry and remove it from the map.
     cache_map_.erase(iter);
   }
 }
 
-scoped_ptr<GDataCache::CacheEntry> GDataCacheMetadataMap::GetCacheEntry(
+scoped_ptr<GDataCacheEntry> GDataCacheMetadataMap::GetCacheEntry(
     const std::string& resource_id,
     const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   CacheMap::iterator iter = cache_map_.find(resource_id);
   if (iter == cache_map_.end()) {
     DVLOG(1) << "Can't find " << resource_id << " in cache map";
-    return scoped_ptr<GDataCache::CacheEntry>();
+    return scoped_ptr<GDataCacheEntry>();
   }
 
-  scoped_ptr<GDataCache::CacheEntry> cache_entry(
-      new GDataCache::CacheEntry(iter->second));
+  scoped_ptr<GDataCacheEntry> cache_entry(
+      new GDataCacheEntry(iter->second));
 
   if (!CheckIfMd5Matches(md5, *cache_entry)) {
     DVLOG(1) << "Non-matching md5: want=" << md5
              << ", found=[res_id=" << resource_id
              << ", " << cache_entry->ToString()
              << "]";
-    return scoped_ptr<GDataCache::CacheEntry>();
+    return scoped_ptr<GDataCacheEntry>();
   }
 
   DVLOG(1) << "Found entry for res_id=" << resource_id
            << ", " << cache_entry->ToString();
 
   return cache_entry.Pass();
 }
 
 void GDataCacheMetadataMap::RemoveTemporaryFiles() {
   AssertOnSequencedWorkerPool();
@@ skipping 36 matching lines @@
       util::kWildCard);
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     // 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.
-    GDataCache::CacheEntry cache_entry(md5, GDataCache::CACHE_STATE_NONE);
+    GDataCacheEntry cache_entry(md5, CACHE_STATE_NONE);
     // If we're scanning pinned directory and if entry already exists, just
     // update its pinned state.
     if (sub_dir_type == GDataCache::CACHE_TYPE_PINNED) {
       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;
       }
@@ skipping 71 matching lines @@
 
     // Create and insert new entry into cache map.
     cache_map->insert(std::make_pair(resource_id, cache_entry));
     processed_file_map->insert(std::make_pair(resource_id, current));
   }
 }
 
 // static
 bool GDataCacheMetadataMap::CheckIfMd5Matches(
     const std::string& md5,
-    const GDataCache::CacheEntry& cache_entry) {
+    const GDataCacheEntry& 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