Use request start time for estimating network quality.

net/base/network_quality_estimator.cc

 // Copyright 2015 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/base/network_quality_estimator.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "net/base/load_timing_info.h"
 #include "net/base/net_util.h"
 #include "net/base/network_quality.h"
 #include "net/url_request/url_request.h"
 #include "url/gurl.h"
 
 namespace net {
 
 NetworkQualityEstimator::NetworkQualityEstimator()
     : NetworkQualityEstimator(false) {
 }
@@ skipping 24 matching lines @@
       (!allow_localhost_requests_ && IsLocalhost(request.url().host())) ||
       !request.url().SchemeIsHTTPOrHTTPS() ||
       // Verify that response headers are received, so it can be ensured that
       // response is not cached.
       request.response_info().response_time.is_null() || request.was_cached() ||
       request.creation_time() < last_connection_change_) {
     return;
   }
 
   base::TimeTicks now = base::TimeTicks::Now();
-  base::TimeDelta request_duration = now - request.creation_time();
-  DCHECK_GE(request_duration, base::TimeDelta());
+
+  LoadTimingInfo load_timing_info;
+  request.GetLoadTimingInfo(&load_timing_info);
+
+  // Time when the resource was requested. Use the timings from LoadTimingInfo,
+  // if it is available since it is recorded after DNS is resolved and secure

[bengr, 2015/06/11 00:22:58]

secure -> a secure

[tbansal1, 2015/06/11 03:01:36]

Done.

+  // connection is established.
+  base::TimeTicks request_start_time = !load_timing_info.send_start.is_null()
+                                           ? load_timing_info.send_start
+                                           : request.creation_time();
+  DCHECK(!request_start_time.is_null());
+
+  // Time when the headers were received. Use timings from LoadTimingInfo, if

[bengr, 2015/06/11 00:22:58]

Are they available at this point? When wouldn't they be?

[tbansal1, 2015/06/11 03:01:35]

I think they are MOSTLY available, except for one case (see
https://code.google.com/p/chromium/codesearch#chromium/src/net/base/load_timi...).
Also, AFAICT, there is no guarantee that these  will always be available in the
future for all cases.

I have taken conservative approach to fallback on |request.creation_time| or
|now|, both of which are guaranteed to be non-null.

+  // available.
+  base::TimeTicks headers_received_time =
+      !load_timing_info.receive_headers_end.is_null()
+          ? load_timing_info.receive_headers_end
+          : now;
+  DCHECK(!headers_received_time.is_null());
+
+  // Duration between when the resource was requested and when response headers
+  // were received.
+  base::TimeDelta observed_rtt = headers_received_time - request_start_time;
+  DCHECK_GE(observed_rtt, base::TimeDelta());
+
+  // Time since the resource was requested.
+  base::TimeDelta since_request_start = now - request_start_time;
+  DCHECK_GE(since_request_start, base::TimeDelta());
+
   if (!bytes_read_since_last_connection_change_)
-    fastest_RTT_since_last_connection_change_ = request_duration;
+    fastest_RTT_since_last_connection_change_ = observed_rtt;
 
   bytes_read_since_last_connection_change_ = true;
-  if (request_duration < fastest_RTT_since_last_connection_change_)
-    fastest_RTT_since_last_connection_change_ = request_duration;
+  if (observed_rtt < fastest_RTT_since_last_connection_change_)
+    fastest_RTT_since_last_connection_change_ = observed_rtt;
 
   // Ignore tiny transfers which will not produce accurate rates.
   // Ignore short duration transfers.
   if (prefilter_bytes_read >= kMinTransferSizeInBytes &&
-      request_duration >=
+      since_request_start >=
           base::TimeDelta::FromMicroseconds(kMinRequestDurationMicroseconds)) {
     uint64_t kbps = static_cast<uint64_t>(prefilter_bytes_read * 8 * 1000 /
-                                          request_duration.InMicroseconds());
+                                          since_request_start.InMicroseconds());
     if (kbps > peak_kbps_since_last_connection_change_)
       peak_kbps_since_last_connection_change_ = kbps;
   }
 }
 
 void NetworkQualityEstimator::OnConnectionTypeChanged(
     NetworkChangeNotifier::ConnectionType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (bytes_read_since_last_connection_change_) {
     switch (current_connection_type_) {
@@ skipping 90 matching lines @@
   }
   if (!peak_kbps_since_last_connection_change_) {
     return NetworkQuality(fastest_RTT_since_last_connection_change_, 0.1,
                           peak_kbps_since_last_connection_change_, 0);
   }
   return NetworkQuality(fastest_RTT_since_last_connection_change_, 0.1,
                         peak_kbps_since_last_connection_change_, 0.1);
 }
 
 }  // namespace net