avoid GCC content::CacheStorage::kSizeUnknown redeclaration error

content/browser/cache_storage/cache_storage_manager.cc

 // Copyright 2014 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 "content/browser/cache_storage/cache_storage_manager.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <set>
@@ skipping 33 matching lines @@
 void DeleteOriginDidDeleteDir(
     const storage::QuotaClient::DeletionCallback& callback,
     bool rv) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, rv ? storage::kQuotaStatusOk
                                          : storage::kQuotaErrorAbort));
 }
 
-// Calculate the sum of all cache sizes in this store, but only if all sizes are
-// known. If one or more sizes are not known then return kSizeUnknown.
+// Calculate the sum of all cache sizes in this store, but only if all
+// sizes are known. If one or more sizes are not known then return
+// kCacheStorageSizeUnknown.
 int64_t GetCacheStorageSize(const proto::CacheStorageIndex& index) {
   int64_t storage_size = 0;
   for (int i = 0, max = index.cache_size(); i < max; ++i) {
     const proto::CacheStorageIndex::Cache& cache = index.cache(i);
-    if (!cache.has_size() || cache.size() == CacheStorage::kSizeUnknown)
-      return CacheStorage::kSizeUnknown;
+    if (!cache.has_size() || cache.size() == kCacheStorageSizeUnknown)
+      return kCacheStorageSizeUnknown;
     storage_size += cache.size();
   }
   return storage_size;
 }
 
 // Open the various cache directories' index files and extract their origins,
 // sizes (if current), and last modified times.
 void ListOriginsAndLastModifiedOnTaskRunner(
     std::vector<CacheStorageUsageInfo>* usages,
     base::FilePath root_path) {
   base::FileEnumerator file_enum(root_path, false /* recursive */,
                                  base::FileEnumerator::DIRECTORIES);
 
   base::FilePath path;
   while (!(path = file_enum.Next()).empty()) {
     base::FilePath index_path = path.AppendASCII(CacheStorage::kIndexFileName);
     base::File::Info file_info;
     base::Time index_last_modified;
     if (GetFileInfo(index_path, &file_info))
       index_last_modified = file_info.last_modified;
     std::string protobuf;
     base::ReadFileToString(path.AppendASCII(CacheStorage::kIndexFileName),
                            &protobuf);
     proto::CacheStorageIndex index;
     if (index.ParseFromString(protobuf)) {
       if (index.has_origin()) {
         if (base::GetFileInfo(path, &file_info)) {
-          int64_t storage_size = CacheStorage::kSizeUnknown;
+          int64_t storage_size = kCacheStorageSizeUnknown;
           if (file_info.last_modified < index_last_modified)
             storage_size = GetCacheStorageSize(index);
           usages->push_back(CacheStorageUsageInfo(
               GURL(index.origin()), storage_size, file_info.last_modified));
         }
       }
     }
   }
 }
 
@@ skipping 30 matching lines @@
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(callback, *usages));
 }
 
 void OneOriginSizeReported(const base::Closure& callback,
                            CacheStorageUsageInfo* usage,
                            int64_t size) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  DCHECK_NE(size, CacheStorage::kSizeUnknown);
+  DCHECK_NE(size, kCacheStorageSizeUnknown);
   usage->total_size_bytes = size;
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<CacheStorageManager> CacheStorageManager::Create(
     const base::FilePath& path,
     scoped_refptr<base::SequencedTaskRunner> cache_task_runner,
@@ skipping 139 matching lines @@
         FROM_HERE, base::Bind(callback, *usages));
     return;
   }
 
   base::Closure barrier_closure = base::BarrierClosure(
       usages_ptr->size(),
       base::Bind(&AllOriginSizesReported, base::Passed(std::move(usages)),
                  callback));
 
   for (CacheStorageUsageInfo& usage : *usages_ptr) {
-    if (usage.total_size_bytes != CacheStorage::kSizeUnknown) {
+    if (usage.total_size_bytes != kCacheStorageSizeUnknown) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, barrier_closure);
       continue;
     }
     CacheStorage* cache_storage = FindOrCreateCacheStorage(usage.origin);
     cache_storage->Size(
         base::Bind(&OneOriginSizeReported, barrier_closure, &usage));
   }
 }
 
 void CacheStorageManager::GetOriginUsage(
@@ skipping 133 matching lines @@
     const base::FilePath& root_path,
     const GURL& origin) {
   const std::string identifier = storage::GetIdentifierFromOrigin(origin);
   const std::string origin_hash = base::SHA1HashString(identifier);
   const std::string origin_hash_hex = base::ToLowerASCII(
       base::HexEncode(origin_hash.c_str(), origin_hash.length()));
   return root_path.AppendASCII(origin_hash_hex);
 }
 
 }  // namespace content