Write out CacheStorageCache size to index file.

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>
-#include <string>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
+#include "base/files/important_file_writer.h"

[jkarlin, 2016/10/21 18:04:19]

This is unused. I'm not sure we'd want an ImportantFileWriter here. Overall it's
probably better to risk a crash and determine size on next start (after doing
the modified time check) than to wait for a flush after every put/delete.

[cmumford, 2016/11/10 17:28:17]

Acknowledged.

 #include "base/id_map.h"
 #include "base/memory/ptr_util.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "content/browser/cache_storage/cache_storage.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_quota_client.h"
@@ skipping 16 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));
 }
 
-// Open the various cache directories' index files and extract their origins and
-// last modified times.
+// 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.
+int64_t GetCacheStorageSize(const CacheStorageIndex& index) {
+  int64_t storage_size = 0;
+  for (int i = 0, max = index.cache_size(); i < max; ++i) {
+    const content::CacheStorageIndex::Cache& cache = index.cache(i);
+    if (!cache.has_size() || cache.size() == CacheStorage::kSizeUnknown)
+      return CacheStorage::kSizeUnknown;
+    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);
     CacheStorageIndex index;
     if (index.ParseFromString(protobuf)) {
       if (index.has_origin()) {
-        base::File::Info file_info;
         if (base::GetFileInfo(path, &file_info)) {
+          int64_t storage_size = CacheStorage::kSizeUnknown;
+          if (file_info.last_modified < index_last_modified)
+            storage_size = GetCacheStorageSize(index);
           usages->push_back(CacheStorageUsageInfo(
-              GURL(index.origin()), 0 /* size */, file_info.last_modified));
+              GURL(index.origin()), storage_size, file_info.last_modified));
         }
       }
     }
   }
 }
 
 std::set<GURL> ListOriginsOnTaskRunner(base::FilePath root_path) {
   std::vector<CacheStorageUsageInfo> usages;
   ListOriginsAndLastModifiedOnTaskRunner(&usages, root_path);
 
@@ skipping 26 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);
   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 49 matching lines @@
     const std::string& cache_name,
     const CacheStorage::BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   CacheStorage* cache_storage = FindOrCreateCacheStorage(origin);
   cache_storage->DeleteCache(cache_name, callback);
 }
 
 void CacheStorageManager::EnumerateCaches(
     const GURL& origin,
-    const CacheStorage::StringsCallback& callback) {
+    const CacheStorage::CacheInfoCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   CacheStorage* cache_storage = FindOrCreateCacheStorage(origin);
 
   cache_storage->EnumerateCaches(callback);
 }
 
 void CacheStorageManager::MatchCache(
     const GURL& origin,
     const std::string& cache_name,
@@ skipping 69 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) {
+      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(
     const GURL& origin_url,
     const storage::QuotaClient::GetUsageCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 130 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