Expose receive header end time for URLRequestRedirectJob

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 157 matching lines @@
 
   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 information in the case of a HSTS redirect occurred.
+void TestLoadTimingHSTSRedirectOccured(
+    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_TRUE(load_timing_info.proxy_resolve_start.is_null());
+  EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
+  EXPECT_EQ(load_timing_info.send_start, load_timing_info.receive_headers_end);
+  EXPECT_EQ(load_timing_info.send_end, load_timing_info.receive_headers_end);
+
+  EXPECT_FALSE(load_timing_info.receive_headers_end.is_null());

[mmenke, 2013/06/26 19:55:40]

This is basically equivalent to TestLoadTimingCacheHitNoNetwork, except the
EXPECT_EQ instead of EXPECT_LE for send/receive headers times.

Suggest just calling into TestLoadTimingCacheHitNoNetwork, with a comment along
the lines that HSTS redirects are similar to cache hits, so populate the same
times.

If you disagree, should at least match the order that we test the values in the
two functions.  And throw in an:

EXPECT_LE(load_timing_info.request_start, load_timing_info.send_start);

+}
+
 // 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());
@@ skipping 4709 matching lines @@
                  &context);
   req.set_method("POST");
   req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
 
   req.Start();
   base::MessageLoop::current()->Run();
 
   EXPECT_EQ("https", req.url().scheme());
   EXPECT_EQ("POST", req.method());
   EXPECT_EQ(kData, d.data_received());
+
+  LoadTimingInfo load_timing_info;
+  network_delegate.GetLoadTimingInfoBeforeRedirect(&load_timing_info);
+  TestLoadTimingHSTSRedirectOccured(load_timing_info);
 }
 
 TEST_F(HTTPSRequestTest, SSLv3Fallback) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_OK);
   ssl_options.tls_intolerant =
       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_ALL;
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
@@ skipping 935 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