Update from https://crrev.com/306655

net/disk_cache/simple/simple_index.cc

 // Copyright (c) 2013 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 "net/disk_cache/simple/simple_index.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 64 matching lines @@
 
 }  // namespace
 
 namespace disk_cache {
 
 EntryMetadata::EntryMetadata()
   : last_used_time_seconds_since_epoch_(0),
     entry_size_(0) {
 }
 
-EntryMetadata::EntryMetadata(base::Time last_used_time, int entry_size)
+EntryMetadata::EntryMetadata(base::Time last_used_time, uint64 entry_size)
     : last_used_time_seconds_since_epoch_(0),
-      entry_size_(entry_size) {
+      entry_size_(base::checked_cast<int32>(entry_size)) {
   SetLastUsedTime(last_used_time);
 }
 
 base::Time EntryMetadata::GetLastUsedTime() const {
   // Preserve nullity.
   if (last_used_time_seconds_since_epoch_ == 0)
     return base::Time();
 
   return base::Time::UnixEpoch() +
       base::TimeDelta::FromSeconds(last_used_time_seconds_since_epoch_);
 }
 
 void EntryMetadata::SetLastUsedTime(const base::Time& last_used_time) {
   // Preserve nullity.
   if (last_used_time.is_null()) {
     last_used_time_seconds_since_epoch_ = 0;
     return;
   }
 
   last_used_time_seconds_since_epoch_ = base::checked_cast<uint32>(
       (last_used_time - base::Time::UnixEpoch()).InSeconds());
   // Avoid accidental nullity.
   if (last_used_time_seconds_since_epoch_ == 0)
     last_used_time_seconds_since_epoch_ = 1;
 }
 
+uint64 EntryMetadata::GetEntrySize() const {
+  return entry_size_;
+}
+
+void EntryMetadata::SetEntrySize(uint64 entry_size) {
+  entry_size_ = base::checked_cast<int32>(entry_size);
+}
+
 void EntryMetadata::Serialize(Pickle* pickle) const {
   DCHECK(pickle);
   int64 internal_last_used_time = GetLastUsedTime().ToInternalValue();
   pickle->WriteInt64(internal_last_used_time);
   pickle->WriteUInt64(entry_size_);
 }
 
 bool EntryMetadata::Deserialize(PickleIterator* it) {
   DCHECK(it);
   int64 tmp_last_used_time;
   uint64 tmp_entry_size;
-  if (!it->ReadInt64(&tmp_last_used_time) || !it->ReadUInt64(&tmp_entry_size))
+  if (!it->ReadInt64(&tmp_last_used_time) || !it->ReadUInt64(&tmp_entry_size) ||
+      tmp_entry_size > static_cast<uint64>(std::numeric_limits<int32>::max()))
     return false;
   SetLastUsedTime(base::Time::FromInternalValue(tmp_last_used_time));
-  entry_size_ = tmp_entry_size;
+  entry_size_ = static_cast<int32>(tmp_entry_size);
   return true;
 }
 
 SimpleIndex::SimpleIndex(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
     SimpleIndexDelegate* delegate,
     net::CacheType cache_type,
     scoped_ptr<SimpleIndexFile> index_file)
     : delegate_(delegate),
       cache_type_(cache_type),
@@ skipping 33 matching lines @@
 
   SimpleIndexLoadResult* load_result = new SimpleIndexLoadResult();
   scoped_ptr<SimpleIndexLoadResult> load_result_scoped(load_result);
   base::Closure reply = base::Bind(
       &SimpleIndex::MergeInitializingSet,
       AsWeakPtr(),
       base::Passed(&load_result_scoped));
   index_file_->LoadIndexEntries(cache_mtime, reply, load_result);
 }
 
-bool SimpleIndex::SetMaxSize(int max_bytes) {
-  if (max_bytes < 0)
-    return false;
-
+void SimpleIndex::SetMaxSize(uint64 max_bytes) {
   // Zero size means use the default.
-  if (!max_bytes)
-    return true;
-
-  max_size_ = max_bytes;
-  high_watermark_ = max_size_ - max_size_ / kEvictionMarginDivisor;
-  low_watermark_ = max_size_ - 2 * (max_size_ / kEvictionMarginDivisor);
-  return true;
+  if (max_bytes) {
+    max_size_ = max_bytes;
+    high_watermark_ = max_size_ - max_size_ / kEvictionMarginDivisor;
+    low_watermark_ = max_size_ - 2 * (max_size_ / kEvictionMarginDivisor);
+  }
 }
 
 int SimpleIndex::ExecuteWhenReady(const net::CompletionCallback& task) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   if (initialized_)
     io_thread_->PostTask(FROM_HERE, base::Bind(task, net::OK));
   else
     to_run_when_initialized_.push_back(task);
   return net::ERR_IO_PENDING;
 }
@@ skipping 75 matching lines @@
   return true;
 }
 
 void SimpleIndex::StartEvictionIfNeeded() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   if (eviction_in_progress_ || cache_size_ <= high_watermark_)
     return;
   // Take all live key hashes from the index and sort them by time.
   eviction_in_progress_ = true;
   eviction_start_time_ = base::TimeTicks::Now();
-  SIMPLE_CACHE_UMA(MEMORY_KB,
-                   "Eviction.CacheSizeOnStart2", cache_type_,
-                   cache_size_ / kBytesInKb);
-  SIMPLE_CACHE_UMA(MEMORY_KB,
-                   "Eviction.MaxCacheSizeOnStart2", cache_type_,
-                   max_size_ / kBytesInKb);
+  SIMPLE_CACHE_UMA(
+      MEMORY_KB, "Eviction.CacheSizeOnStart2", cache_type_,
+      static_cast<base::HistogramBase::Sample>(cache_size_ / kBytesInKb));
+  SIMPLE_CACHE_UMA(
+      MEMORY_KB, "Eviction.MaxCacheSizeOnStart2", cache_type_,
+      static_cast<base::HistogramBase::Sample>(max_size_ / kBytesInKb));
   std::vector<uint64> entry_hashes;
   entry_hashes.reserve(entries_set_.size());
   for (EntrySet::const_iterator it = entries_set_.begin(),
        end = entries_set_.end(); it != end; ++it) {
     entry_hashes.push_back(it->first);
   }
   std::sort(entry_hashes.begin(), entry_hashes.end(),
             CompareHashesForTimestamp(entries_set_));
 
   // Remove as many entries from the index to get below |low_watermark_|.
   std::vector<uint64>::iterator it = entry_hashes.begin();
   uint64 evicted_so_far_size = 0;
   while (evicted_so_far_size < cache_size_ - low_watermark_) {
     DCHECK(it != entry_hashes.end());
     EntrySet::iterator found_meta = entries_set_.find(*it);
     DCHECK(found_meta != entries_set_.end());
-    uint64 to_evict_size = found_meta->second.GetEntrySize();
-    evicted_so_far_size += to_evict_size;
+    evicted_so_far_size += found_meta->second.GetEntrySize();
     ++it;
   }
 
   // Take out the rest of hashes from the eviction list.
   entry_hashes.erase(it, entry_hashes.end());
   SIMPLE_CACHE_UMA(COUNTS,
                    "Eviction.EntryCount", cache_type_, entry_hashes.size());
   SIMPLE_CACHE_UMA(TIMES,
                    "Eviction.TimeToSelectEntries", cache_type_,
                    base::TimeTicks::Now() - eviction_start_time_);
-  SIMPLE_CACHE_UMA(MEMORY_KB,
-                   "Eviction.SizeOfEvicted2", cache_type_,
-                   evicted_so_far_size / kBytesInKb);
+  SIMPLE_CACHE_UMA(
+      MEMORY_KB, "Eviction.SizeOfEvicted2", cache_type_,
+      static_cast<base::HistogramBase::Sample>(
+          evicted_so_far_size / kBytesInKb));
 
   delegate_->DoomEntries(&entry_hashes, base::Bind(&SimpleIndex::EvictionDone,
                                                    AsWeakPtr()));
 }
 
-bool SimpleIndex::UpdateEntrySize(uint64 entry_hash, int entry_size) {
+bool SimpleIndex::UpdateEntrySize(uint64 entry_hash, int64 entry_size) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   EntrySet::iterator it = entries_set_.find(entry_hash);
   if (it == entries_set_.end())
     return false;
 
   UpdateEntryIteratorSize(&it, entry_size);
   PostponeWritingToDisk();
   StartEvictionIfNeeded();
   return true;
 }
 
 void SimpleIndex::EvictionDone(int result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
 
   // Ignore the result of eviction. We did our best.
   eviction_in_progress_ = false;
   SIMPLE_CACHE_UMA(BOOLEAN, "Eviction.Result", cache_type_, result == net::OK);
   SIMPLE_CACHE_UMA(TIMES,
                    "Eviction.TimeToDone", cache_type_,
                    base::TimeTicks::Now() - eviction_start_time_);
-  SIMPLE_CACHE_UMA(MEMORY_KB,
-                   "Eviction.SizeWhenDone2", cache_type_,
-                   cache_size_ / kBytesInKb);
+  SIMPLE_CACHE_UMA(
+      MEMORY_KB, "Eviction.SizeWhenDone2", cache_type_,
+      static_cast<base::HistogramBase::Sample>(cache_size_ / kBytesInKb));
 }
 
 // static
 void SimpleIndex::InsertInEntrySet(
     uint64 entry_hash,
     const disk_cache::EntryMetadata& entry_metadata,
     EntrySet* entry_set) {
   DCHECK(entry_set);
   entry_set->insert(std::make_pair(entry_hash, entry_metadata));
 }
 
 void SimpleIndex::PostponeWritingToDisk() {
   if (!initialized_)
     return;
   const int delay = app_on_background_ ? kWriteToDiskOnBackgroundDelayMSecs
                                        : kWriteToDiskDelayMSecs;
   // If the timer is already active, Start() will just Reset it, postponing it.
   write_to_disk_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(delay), write_to_disk_cb_);
 }
 
 void SimpleIndex::UpdateEntryIteratorSize(EntrySet::iterator* it,
-                                          int entry_size) {
+                                          int64 entry_size) {
   // Update the total cache size with the new entry size.
   DCHECK(io_thread_checker_.CalledOnValidThread());
-  DCHECK_GE(cache_size_, implicit_cast<uint64>((*it)->second.GetEntrySize()));
+  DCHECK_GE(cache_size_, (*it)->second.GetEntrySize());
   cache_size_ -= (*it)->second.GetEntrySize();
   cache_size_ += entry_size;
   (*it)->second.SetEntrySize(entry_size);
 }
 
 void SimpleIndex::MergeInitializingSet(
     scoped_ptr<SimpleIndexLoadResult> load_result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(load_result->did_load);
 
@@ skipping 76 matching lines @@
                        start - last_write_to_disk_);
     }
   }
   last_write_to_disk_ = start;
 
   index_file_->WriteToDisk(entries_set_, cache_size_,
                            start, app_on_background_, base::Closure());
 }
 
 }  // namespace disk_cache