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

net/url_request/url_request_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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 138 matching lines @@
   EXPECT_LE(load_timing_info.request_start,
             load_timing_info.proxy_resolve_start);
   EXPECT_LE(load_timing_info.proxy_resolve_start,
             load_timing_info.proxy_resolve_end);
   EXPECT_LE(load_timing_info.proxy_resolve_end,
             load_timing_info.send_start);
   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 }
 
-// Tests load timing in the case that there is no underlying connection.  This
-// can be used to test in the case of cached responses, errors, or non-HTTP
-// requests.
-void TestLoadTimingNoHttpConnection(
+// Tests load timing information in the case of a cache hit, when no cache
+// validation request was sent over the wire.
+void TestLoadTimingCacheHitNoNetwork(
+    const net::LoadTimingInfo& load_timing_info) {
+  EXPECT_FALSE(load_timing_info.socket_reused);
+  EXPECT_EQ(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
+
+  EXPECT_FALSE(load_timing_info.request_start_time.is_null());
+  EXPECT_FALSE(load_timing_info.request_start.is_null());
+
+  ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
+  EXPECT_LE(load_timing_info.request_start, load_timing_info.send_start);
+  EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
+  EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
+
+  EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
+  EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
+}
+
+// Tests load timing in the case that there is no HTTP response.  This can be
+// used to test in the case of errors or non-HTTP requests.
+void TestLoadTimingNoHttpResponse(
     const net::LoadTimingInfo& load_timing_info) {
   EXPECT_FALSE(load_timing_info.socket_reused);
   EXPECT_EQ(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   // Only the request times should be non-null.
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 
@@ skipping 3843 matching lines @@
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
   }
 }
 
 TEST_F(URLRequestTestHTTP, VaryHeader) {
   ASSERT_TRUE(test_server_.Start());
 
-  // populate the cache
+  // Populate the cache.
   {
     TestDelegate d;
     URLRequest req(
         test_server_.GetURL("echoheadercache?foo"), &d, &default_context_);
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "1");
     req.SetExtraRequestHeaders(headers);
     req.Start();
     MessageLoop::current()->Run();
+
+    LoadTimingInfo load_timing_info;
+    req.GetLoadTimingInfo(&load_timing_info);
+    TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 
-  // expect a cache hit
+  // Expect a cache hit.
   {
     TestDelegate d;
     URLRequest req(
         test_server_.GetURL("echoheadercache?foo"), &d, &default_context_);
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "1");
     req.SetExtraRequestHeaders(headers);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(req.was_cached());
+
+    LoadTimingInfo load_timing_info;
+    req.GetLoadTimingInfo(&load_timing_info);
+    TestLoadTimingCacheHitNoNetwork(load_timing_info);
   }
 
-  // expect a cache miss
+  // Expect a cache miss.
   {
     TestDelegate d;
     URLRequest req(
         test_server_.GetURL("echoheadercache?foo"), &d, &default_context_);
     HttpRequestHeaders headers;
     headers.SetHeader("foo", "2");
     req.SetExtraRequestHeaders(headers);
     req.Start();
     MessageLoop::current()->Run();
 
     EXPECT_FALSE(req.was_cached());
+
+    LoadTimingInfo load_timing_info;
+    req.GetLoadTimingInfo(&load_timing_info);
+    TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 }
 
 TEST_F(URLRequestTestHTTP, BasicAuth) {
   ASSERT_TRUE(test_server_.Start());
 
   // populate the cache
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
@@ skipping 113 matching lines @@
     r.GetLoadTimingInfo(&load_timing_info);
     // The test server does not support keep alive sockets, so the second
     // request with auth should use a new socket.
     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
     EXPECT_NE(load_timing_info_before_auth.socket_log_id,
               load_timing_info.socket_log_id);
     EXPECT_LE(load_timing_info_before_auth.receive_headers_end,
               load_timing_info.connect_timing.connect_start);
   }
 
-  // repeat request with end-to-end validation.  since auth-basic results in a
-  // cachable page, we expect this test to result in a 304.  in which case, the
+  // Repeat request with end-to-end validation.  Since auth-basic results in a
+  // cachable page, we expect this test to result in a 304.  In which case, the
   // response should be fetched from the cache.
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
     URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_);
     r.set_load_flags(LOAD_VALIDATE_CACHE);
     r.Start();
 
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Should be the same cached document.
     EXPECT_TRUE(r.was_cached());
 
+    // Since there was a request that went over the wire, the load timing
+    // information should include connection times.
     LoadTimingInfo load_timing_info;
     r.GetLoadTimingInfo(&load_timing_info);
-    TestLoadTimingNoHttpConnection(load_timing_info);
+    TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
   }
 }
 
 // In this test, we do a POST which the server will 302 redirect.
 // The subsequent transaction should use GET, and should not send the
 // Content-Type header.
 // http://code.google.com/p/chromium/issues/detail?id=843
 TEST_F(URLRequestTestHTTP, Post302RedirectGet) {
   ASSERT_TRUE(test_server_.Start());
 
@@ skipping 1341 matching lines @@
     EXPECT_EQ(test_server_.host_port_pair().host(),
               r.GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
               r.GetSocketAddress().port());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
 
     LoadTimingInfo load_timing_info;
     r.GetLoadTimingInfo(&load_timing_info);
-    TestLoadTimingNoHttpConnection(load_timing_info);
+    TestLoadTimingNoHttpResponse(load_timing_info);
   }
 }
 
 // Flaky, see http://crbug.com/25045.
 TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongPassword) {
   ASSERT_TRUE(test_server_.Start());
 
   base::FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
   app_path = app_path.AppendASCII("LICENSE");
@@ skipping 216 matching lines @@
 
     EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net