[CacheStorage] Pad and bin opaque resource sizes.

content/browser/cache_storage/cache_storage.cc

Index: content/browser/cache_storage/cache_storage.cc
diff --git a/content/browser/cache_storage/cache_storage.cc b/content/browser/cache_storage/cache_storage.cc
index de76b56bf8df750e467cc9de040b9bc455b6523d..f3b986ee6d550215178ec74a58ee494beed926e7 100644
--- a/content/browser/cache_storage/cache_storage.cc
+++ b/content/browser/cache_storage/cache_storage.cc
@@ -102,7 +102,9 @@ class CacheStorage::CacheLoader {
   // load the backend, that happens lazily when the cache is used.
   virtual std::unique_ptr<CacheStorageCache> CreateCache(
       const std::string& cache_name,
-      int64_t cache_size) = 0;
+      int64_t cache_size,
+      int64_t cache_paddinge,

[jkarlin, 2017/06/08 18:58:48]

cache_padding

[cmumford, 2017/06/12 18:09:30]

Done.

+      const std::string& cache_padding_key) = 0;
 
   // Deletes any pre-existing cache of the same name and then loads it.
   virtual void PrepareNewCacheDestination(const std::string& cache_name,
@@ -164,8 +166,11 @@ class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
                     cache_storage,
                     origin) {}
 
-  std::unique_ptr<CacheStorageCache> CreateCache(const std::string& cache_name,
-                                                 int64_t cache_size) override {
+  std::unique_ptr<CacheStorageCache> CreateCache(
+      const std::string& cache_name,
+      int64_t cache_size,
+      int64_t cache_padding,
+      const std::string& cache_padding_key) override {
     return CacheStorageCache::CreateMemoryCache(
         origin_, cache_name, cache_storage_, request_context_getter_,
         quota_manager_proxy_, blob_context_);
@@ -174,7 +179,8 @@ class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
   void PrepareNewCacheDestination(const std::string& cache_name,
                                   const CacheCallback& callback) override {
     std::unique_ptr<CacheStorageCache> cache =
-        CreateCache(cache_name, 0 /*cache_size*/);
+        CreateCache(cache_name, 0 /*cache_size*/, 0 /* cache_padding */,
+                    CacheStorageCache::SessionPaddingHMACKey());
     callback.Run(std::move(cache));
   }
 
@@ -232,8 +238,11 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
-  std::unique_ptr<CacheStorageCache> CreateCache(const std::string& cache_name,
-                                                 int64_t cache_size) override {
+  std::unique_ptr<CacheStorageCache> CreateCache(
+      const std::string& cache_name,
+      int64_t cache_size,
+      int64_t cache_padding,
+      const std::string& cache_padding_key) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(base::ContainsKey(cache_name_to_cache_dir_, cache_name));
 
@@ -242,7 +251,7 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
     return CacheStorageCache::CreatePersistentCache(
         origin_, cache_name, cache_storage_, cache_path,
         request_context_getter_, quota_manager_proxy_, blob_context_,
-        cache_size);
+        cache_size, cache_padding, cache_padding_key);
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
@@ -279,7 +288,9 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
     }
 
     cache_name_to_cache_dir_[cache_name] = cache_dir;
-    callback.Run(CreateCache(cache_name, CacheStorage::kSizeUnknown));
+    callback.Run(CreateCache(cache_name, CacheStorage::kSizeUnknown,
+                             CacheStorage::kSizeUnknown,

[jkarlin, 2017/06/08 18:58:48]

Can't we use 0 for initial padding?

[cmumford, 2017/06/12 18:09:31]

In CacheStorageCache::InitGotCacheSize we will only traverse all entry metadata
if the padding is unknown (or known to be wrong), so we need to be able to know
the difference between a cache that has no padded resources, and one that is not
yet padded. 

+                             CacheStorageCache::SessionPaddingHMACKey()));
   }
 
   void CleanUpDeletedCache(CacheStorageCache* cache) override {
@@ -372,7 +383,14 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
       DCHECK(cache.has_cache_dir());
       int64_t cache_size =
           cache.has_size() ? cache.size() : CacheStorage::kSizeUnknown;
-      index->Insert(CacheStorageIndex::CacheMetadata(cache.name(), cache_size));
+      int64_t cache_padding =
+          cache.has_padding() ? cache.padding() : CacheStorage::kSizeUnknown;
+      std::string cache_padding_key =
+          cache.has_padding_key() ? cache.padding_key()
+                                  : CacheStorageCache::SessionPaddingHMACKey();
+
+      index->Insert(CacheStorageIndex::CacheMetadata(
+          cache.name(), cache_size, cache_padding, cache_padding_key));
       cache_name_to_cache_dir_[cache.name()] = cache.cache_dir();
       cache_dirs->insert(cache.cache_dir());
     }
@@ -779,8 +797,9 @@ void CacheStorage::CreateCacheDidCreateCache(
   CacheStorageCache* cache_ptr = cache.get();
 
   cache_map_.insert(std::make_pair(cache_name, std::move(cache)));
-  cache_index_->Insert(
-      CacheStorageIndex::CacheMetadata(cache_name, cache_ptr->cache_size()));
+  cache_index_->Insert(CacheStorageIndex::CacheMetadata(
+      cache_name, cache_ptr->cache_size(), cache_ptr->cache_padding(),
+      cache_ptr->cache_padding_key()));
 
   cache_loader_->WriteIndex(
       *cache_index_, base::Bind(&CacheStorage::CreateCacheDidWriteIndex,
@@ -1026,8 +1045,11 @@ std::unique_ptr<CacheStorageCacheHandle> CacheStorage::GetLoadedCache(
   CacheStorageCache* cache = map_iter->second.get();
 
   if (!cache) {
+    const CacheStorageIndex::CacheMetadata* metadata =
+        cache_index_->FindMetadata(cache_name);
+    DCHECK_NE(metadata, nullptr);

[jkarlin, 2017/06/08 18:58:48]

DCHECK(metadata);

[cmumford, 2017/06/12 18:09:31]

Done.

     std::unique_ptr<CacheStorageCache> new_cache = cache_loader_->CreateCache(
-        cache_name, cache_index_->GetCacheSize(cache_name));
+        cache_name, metadata->size, metadata->padding, metadata->padding_key);
     CacheStorageCache* cache_ptr = new_cache.get();
     map_iter->second = std::move(new_cache);
 
@@ -1073,9 +1095,9 @@ void CacheStorage::SizeImpl(const SizeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
-  if (cache_index_->GetStorageSize() != kSizeUnknown) {
+  if (cache_index_->GetPaddedStorageSize() != kSizeUnknown) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, cache_index_->GetStorageSize()));
+        FROM_HERE, base::Bind(callback, cache_index_->GetPaddedStorageSize()));
     return;
   }