Http cache: Make sure we separate the infinite cache simulation from the real cache.

net/http/infinite_cache.cc

 // Copyright (c) 2012 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/http/infinite_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/bind.h"
@@ skipping 296 matching lines @@
             reinterpret_cast<const Bytef*>(data), data_len);
 }
 
 void InfiniteCacheTransaction::OnTruncatedResponse() {
   if (!cache_)
     return;
 
   resource_data_->details.flags |= TRUNCATED;
 }
 
-void InfiniteCacheTransaction::OnServedFromCache() {
+void InfiniteCacheTransaction::OnServedFromCache(
+    const HttpResponseInfo* response) {
   if (!cache_)
     return;
 
   resource_data_->details.flags |= CACHED;
+  if (!resource_data_->details.last_access)
+    OnResponseReceived(response);
 }
 
 void InfiniteCacheTransaction::Finish() {
   if (!cache_ || !resource_data_.get())
     return;
 
   if (!resource_data_->details.headers_size)
     return;
 
   cache_->ProcessResource(resource_data_.Pass());
@@ skipping 164 matching lines @@
   header_->num_requests++;
   KeyMap::iterator i = map_.find(data->key);
   if (i != map_.end()) {
     if (data->details.flags & DOOM_METHOD) {
       Remove(i->second);
       map_.erase(i);
       return;
     }
     data->details.use_count = i->second.use_count;
     data->details.update_count = i->second.update_count;
-    if (data->details.flags & CACHED) {
+    bool reused = CanReuse(i->second, data->details);
+    bool data_changed = DataChanged(i->second, data->details);
+    bool headers_changed = HeadersChanged(i->second, data->details);
+
+    if (reused && data_changed)
+      header_->num_bad_hits++;
+
+    if (reused)
       RecordHit(i->second, &data->details);
-    } else {
-      bool reused = CanReuse(i->second, data->details);
-      bool data_changed = DataChanged(i->second, data->details);
-      bool headers_changed = HeadersChanged(i->second, data->details);
 
-      if (reused && data_changed)
-        header_->num_bad_hits++;
+    if (headers_changed)
+      UMA_HISTOGRAM_BOOLEAN("InfiniteCache.HeadersChange", true);
 
-      if (reused)
-        RecordHit(i->second, &data->details);
-
-      if (headers_changed)
-        UMA_HISTOGRAM_BOOLEAN("InfiniteCache.HeadersChange", true);
-
-      if (data_changed)
-        RecordUpdate(i->second, &data->details);
-    }
+    if (data_changed)
+      RecordUpdate(i->second, &data->details);
 
     if (data->details.flags & NO_STORE) {
       Remove(i->second);
       map_.erase(i);
       return;
     }
 
     map_[data->key] = data->details;
     return;
   }
@@ skipping 354 matching lines @@
   bool have_to_drop  = (old.flags & TRUNCATED) && !(old.flags & RESUMABLE);
   if (reason && (old.flags & REVALIDATEABLE) && !have_to_drop)
     reason += REUSE_REVALIDATEABLE;
 
   UMA_HISTOGRAM_ENUMERATION("InfiniteCache.ReuseFailure", reason, 15);
   return !reason;
 }
 
 bool InfiniteCache::Worker::DataChanged(const Details& old,
                                         const Details& current) {
+  if (current.flags & CACHED)
+    return false;
+
   bool changed = false;
   if (old.response_size != current.response_size) {
     changed = true;
     UpdateSize(old.response_size, current.response_size);
   }
 
   if (old.response_hash != current.response_hash)
     changed = true;
 
   return changed;
@@ skipping 103 matching lines @@
 int InfiniteCache::FlushDataForTest(const CompletionCallback& callback) {
   DCHECK(worker_);
   int* result = new int;
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&InfiniteCache::Worker::Flush, worker_, result),
       base::Bind(&OnComplete, callback, base::Owned(result)));
   return net::ERR_IO_PENDING;
 }
 
 }  // namespace net