net: Return LoadTiming information in the case of a cache hit

net/http/http_transaction_unittest.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/http_transaction_unittest.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
+#include "base/time.h"
 #include "net/base/net_errors.h"
 #include "net/base/load_flags.h"
+#include "net/base/load_timing_info.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"
 
 namespace {
 typedef base::hash_map<std::string, const MockTransaction*> MockTransactionMap;
 static MockTransactionMap mock_transactions;
@@ skipping 196 matching lines @@
       NOTREACHED();
   }
 }
 
 MockNetworkTransaction::MockNetworkTransaction(
     net::RequestPriority priority,
     MockNetworkLayer* factory)
     : weak_factory_(this),
       data_cursor_(0),
       priority_(priority),
-      transaction_factory_(factory->AsWeakPtr()) {
+      transaction_factory_(factory->AsWeakPtr()),
+      socket_log_id_(net::NetLog::Source::kInvalidId) {
 }
 
 MockNetworkTransaction::~MockNetworkTransaction() {}
 
 int MockNetworkTransaction::Start(const net::HttpRequestInfo* request,
                                   const net::CompletionCallback& callback,
                                   const net::BoundNetLog& net_log) {
   const MockTransaction* t = FindMockTransaction(request->url);
   if (!t)
     return net::ERR_FAILED;
 
   test_mode_ = t->test_mode;
 
-  // Return immediately if we're returning in error.
+  // Return immediately if we're returning an error.
   if (net::OK != t->return_code) {
     if (test_mode_ & TEST_MODE_SYNC_NET_START)
       return t->return_code;
     CallbackLater(callback, t->return_code);
     return net::ERR_IO_PENDING;
   }
 
   std::string resp_status = t->status;
   std::string resp_headers = t->response_headers;
   std::string resp_data = t->data;
@@ skipping 13 matching lines @@
 
   response_.response_time = base::Time::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);
   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 (test_mode_ & TEST_MODE_SYNC_NET_START)
     return net::OK;
 
   CallbackLater(callback, net::OK);
   return net::ERR_IO_PENDING;
 }
 
 int MockNetworkTransaction::RestartIgnoringLastError(
     const net::CompletionCallback& callback) {
   return net::ERR_FAILED;
@@ skipping 46 matching lines @@
     return net::LOAD_STATE_READING_RESPONSE;
   return net::LOAD_STATE_IDLE;
 }
 
 net::UploadProgress MockNetworkTransaction::GetUploadProgress() const {
   return net::UploadProgress();
 }
 
 bool MockNetworkTransaction::GetLoadTimingInfo(
     net::LoadTimingInfo* load_timing_info) const {
-  return false;
+  if (socket_log_id_ != net::NetLog::Source::kInvalidId) {
+    // The minimal set of times for a request that gets a response, assuming it
+    // gets a new socket.
+    load_timing_info->socket_reused = false;
+    load_timing_info->socket_log_id = socket_log_id_;
+    load_timing_info->connect_timing.connect_start = base::TimeTicks::Now();
+    load_timing_info->connect_timing.connect_end = base::TimeTicks::Now();
+    load_timing_info->send_start = base::TimeTicks::Now();
+    load_timing_info->send_end = base::TimeTicks::Now();
+  } else {
+    // If there's no valid socket ID, just use the generic socket reused values.
+    // No tests currently depend on this, just should not match the values set
+    // by a cache hit.
+    load_timing_info->socket_reused = true;
+    load_timing_info->send_start = base::TimeTicks::Now();
+    load_timing_info->send_end = base::TimeTicks::Now();
+  }
+  return true;
 }
 
 void MockNetworkTransaction::SetPriority(net::RequestPriority priority) {
   priority_ = priority;
 }
 
 void MockNetworkTransaction::CallbackLater(
     const net::CompletionCallback& callback, int result) {
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&MockNetworkTransaction::RunCallback,
@@ skipping 54 matching lines @@
 
     if (rv > 0)
       content.append(buf->data(), rv);
     else if (rv < 0)
       return rv;
   } while (rv > 0);
 
   result->swap(content);
   return net::OK;
 }