avoid GCC content::CacheStorage::kSizeUnknown redeclaration error

content/browser/cache_storage/cache_storage.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.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
@@ skipping 41 matching lines @@
                                 const CacheStorage::SizeCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, *accumulator));
 }
 
 void DoNothingWithBool(bool success) {}
 
 }  // namespace
 
 const char CacheStorage::kIndexFileName[] = "index.txt";
-const int64_t CacheStorage::kSizeUnknown;

[jkarlin, 2017/01/03 13:06:25]

Can this gcc issue be fixed by changing this const to constexpr?

[Mostyn Bramley-Moore, 2017/01/04 00:11:13]

Seems to work.  CQ dry run underway to confirm.

 
 struct CacheStorage::CacheMatchResponse {
   CacheMatchResponse() = default;
   ~CacheMatchResponse() = default;
 
   CacheStorageError error;
   std::unique_ptr<ServiceWorkerResponse> service_worker_response;
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle;
 };
 
@@ skipping 198 matching lines @@
 
   void PrepareNewCacheCreateCache(const std::string& cache_name,
                                   const CacheCallback& callback,
                                   const std::string& cache_dir) {
     if (cache_dir.empty()) {
       callback.Run(std::unique_ptr<CacheStorageCache>());
       return;
     }
 
     cache_name_to_cache_dir_[cache_name] = cache_dir;
-    callback.Run(CreateCache(cache_name, CacheStorage::kSizeUnknown));
+    callback.Run(CreateCache(cache_name, kCacheStorageSizeUnknown));
   }
 
   void CleanUpDeletedCache(CacheStorageCache* cache) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(base::ContainsKey(doomed_cache_to_path_, cache));
 
     base::FilePath cache_path =
         origin_path_.AppendASCII(doomed_cache_to_path_[cache]);
     doomed_cache_to_path_.erase(cache);
 
@@ skipping 15 matching lines @@
 
     proto::CacheStorageIndex protobuf_index;
     protobuf_index.set_origin(origin_.spec());
 
     for (const auto& cache_metadata : index.ordered_cache_metadata()) {
       DCHECK(base::ContainsKey(cache_name_to_cache_dir_, cache_metadata.name));
 
       proto::CacheStorageIndex::Cache* index_cache = protobuf_index.add_cache();
       index_cache->set_name(cache_metadata.name);
       index_cache->set_cache_dir(cache_name_to_cache_dir_[cache_metadata.name]);
-      if (cache_metadata.size == CacheStorage::kSizeUnknown)
+      if (cache_metadata.size == kCacheStorageSizeUnknown)
         index_cache->clear_size();
       else
         index_cache->set_size(cache_metadata.size);
     }
 
     std::string serialized;
     bool success = protobuf_index.SerializeToString(&serialized);
     DCHECK(success);
 
     base::FilePath tmp_path = origin_path_.AppendASCII("index.txt.tmp");
@@ skipping 35 matching lines @@
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     std::unique_ptr<std::set<std::string>> cache_dirs(
         new std::set<std::string>);
 
     auto index = base::MakeUnique<CacheStorageIndex>();
     for (int i = 0, max = protobuf_index.cache_size(); i < max; ++i) {
       const proto::CacheStorageIndex::Cache& cache = protobuf_index.cache(i);
       DCHECK(cache.has_cache_dir());
       int64_t cache_size =
-          cache.has_size() ? cache.size() : CacheStorage::kSizeUnknown;
+          cache.has_size() ? cache.size() : kCacheStorageSizeUnknown;
       index->Insert(CacheStorageIndex::CacheMetadata(cache.name(), cache_size));
       cache_name_to_cache_dir_[cache.name()] = cache.cache_dir();
       cache_dirs->insert(cache.cache_dir());
     }
 
     cache_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DeleteUnreferencedCachesInPool, origin_path_,
                               base::Passed(&cache_dirs)));
     callback.Run(std::move(index));
   }
@@ skipping 681 matching lines @@
                                        weak_factory_.GetWeakPtr(),
                                        base::Passed(std::move(cache_handle)),
                                        barrier_closure, accumulator_ptr));
   }
 }
 
 void CacheStorage::SizeImpl(const SizeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
-  if (cache_index_->GetStorageSize() != kSizeUnknown) {
+  if (cache_index_->GetStorageSize() != kCacheStorageSizeUnknown) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, cache_index_->GetStorageSize()));
     return;
   }
 
   std::unique_ptr<int64_t> accumulator(new int64_t(0));
   int64_t* accumulator_ptr = accumulator.get();
 
   base::Closure barrier_closure = base::BarrierClosure(
       cache_index_->num_entries(),
       base::Bind(&SizeRetrievedFromAllCaches,
                  base::Passed(std::move(accumulator)), callback));
 
   for (const auto& cache_metadata : cache_index_->ordered_cache_metadata()) {
-    if (cache_metadata.size != CacheStorage::kSizeUnknown) {
+    if (cache_metadata.size != kCacheStorageSizeUnknown) {
       *accumulator_ptr += cache_metadata.size;
       barrier_closure.Run();
       continue;
     }
     std::unique_ptr<CacheStorageCacheHandle> cache_handle =
         GetLoadedCache(cache_metadata.name);
     CacheStorageCache* cache = cache_handle->value();
     cache->Size(base::Bind(&CacheStorage::SizeRetrievedFromCache,
                            weak_factory_.GetWeakPtr(),
                            base::Passed(std::move(cache_handle)),
                            barrier_closure, accumulator_ptr));
   }
 }
 
 }  // namespace content