Let prefetched resources skip cache revalidation once for a short duration.

net/http/http_transaction_test_util.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 "net/http/http_transaction_test_util.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/time/clock.h"
+#include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 370 matching lines @@
   std::string resp_headers = t->response_headers;
   std::string resp_data = t->data;
   received_bytes_ = resp_status.size() + resp_headers.size() + resp_data.size();
   if (t->handler)
     (t->handler)(request, &resp_status, &resp_headers, &resp_data);
 
   std::string header_data = base::StringPrintf(
       "%s\n%s\n", resp_status.c_str(), resp_headers.c_str());
   std::replace(header_data.begin(), header_data.end(), '\n', '\0');
 
-  response_.request_time = base::Time::Now();
+  response_.request_time = transaction_factory_->clock()->Now();
   if (!t->request_time.is_null())
     response_.request_time = t->request_time;
 
   response_.was_cached = false;
   response_.network_accessed = true;
 
-  response_.response_time = base::Time::Now();
+  response_.response_time = transaction_factory_->clock()->Now();
   if (!t->response_time.is_null())
     response_.response_time = t->response_time;
 
   response_.headers = new net::HttpResponseHeaders(header_data);
   response_.vary_data.Init(*request, *response_.headers.get());
   response_.ssl_info.cert_status = t->cert_status;
   data_ = resp_data;
 
   if (net_log.net_log())
     socket_log_id_ = net_log.net_log()->NextID();
 
+  if (request_->load_flags & net::LOAD_PREFETCH)
+    response_.unused_since_prefetch = true;
+
   if (test_mode_ & TEST_MODE_SYNC_NET_START)
     return net::OK;
 
   CallbackLater(callback, net::OK);
   return net::ERR_IO_PENDING;
 }
 
 void MockNetworkTransaction::SetBeforeNetworkStartCallback(
     const BeforeNetworkStartCallback& callback) {
 }
@@ skipping 16 matching lines @@
 
 void MockNetworkTransaction::RunCallback(
     const net::CompletionCallback& callback, int result) {
   callback.Run(result);
 }
 
 MockNetworkLayer::MockNetworkLayer()
     : transaction_count_(0),
       done_reading_called_(false),
       stop_caching_called_(false),
-      last_create_transaction_priority_(net::DEFAULT_PRIORITY) {}
+      last_create_transaction_priority_(net::DEFAULT_PRIORITY),
+      default_clock_(new base::DefaultClock()),
+      clock_(default_clock_.get()) {
+}
 
 MockNetworkLayer::~MockNetworkLayer() {}
 
 void MockNetworkLayer::TransactionDoneReading() {
   done_reading_called_ = true;
 }
 
 void MockNetworkLayer::TransactionStopCaching() {
   stop_caching_called_ = true;
 }
@@ skipping 11 matching lines @@
 }
 
 net::HttpCache* MockNetworkLayer::GetCache() {
   return NULL;
 }
 
 net::HttpNetworkSession* MockNetworkLayer::GetSession() {
   return NULL;
 }
 
+void MockNetworkLayer::SetClock(base::Clock* clock) {
+  DCHECK(default_clock_);
+  clock_ = clock;
+  default_clock_.reset();

[rvargas (doing something else), 2014/12/24 02:15:25]

sounds like we need only one variable to store the clock.

[jkarlin, 2015/01/08 16:13:04]

Done.

+}
+
 //-----------------------------------------------------------------------------
 // helpers
 
 int ReadTransaction(net::HttpTransaction* trans, std::string* result) {
   int rv;
 
   net::TestCompletionCallback callback;
 
   std::string content;
   do {
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(256));
     rv = trans->Read(buf.get(), 256, callback.callback());
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
 
     if (rv > 0)
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return net::OK;
 }