Expose packet loss counts from QUIC to NetworkQualityEstimator

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 <float.h>
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ skipping 358 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   throughput_observer_list_.AddObserver(throughput_observer);
 }
 
 void NetworkQualityEstimator::RemoveThroughputObserver(
     ThroughputObserver* throughput_observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   throughput_observer_list_.RemoveObserver(throughput_observer);
 }
 
+void NetworkQualityEstimator::AddPacketCountObserver(
+    PacketCountObserver* packet_count_observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  packet_count_observer_list_.AddObserver(packet_count_observer);
+}
+
+void NetworkQualityEstimator::RemovePacketCountObserver(
+    PacketCountObserver* packet_count_observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  packet_count_observer_list_.RemoveObserver(packet_count_observer);
+}
+
 void NetworkQualityEstimator::RecordRTTUMA(int32_t estimated_value_msec,
                                            int32_t actual_value_msec) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Record the difference between the actual and the estimated value.
   if (estimated_value_msec >= actual_value_msec) {
     base::HistogramBase* difference_rtt =
         GetHistogram("DifferenceRTTEstimatedAndActual.",
                      current_network_id_.type, 10 * 1000);  // 10 seconds
     difference_rtt->Add(estimated_value_msec - actual_value_msec);
@@ skipping 33 matching lines @@
          !request.was_cached() &&
          request.creation_time() >= last_connection_change_;
 }
 
 void NetworkQualityEstimator::RecordExternalEstimateProviderMetrics(
     NQEExternalEstimateProviderStatus status) const {
   UMA_HISTOGRAM_ENUMERATION("NQE.ExternalEstimateProviderStatus", status,
                             EXTERNAL_ESTIMATE_PROVIDER_STATUS_BOUNDARY);
 }
 
+bool NetworkQualityEstimator::GetObservationSourceForProtocol(
+    Protocol protocol,
+    NetworkQualityEstimator::ObservationSource* observation_source) const {
+  switch (protocol) {
+    case PROTOCOL_TCP:
+      *observation_source = TCP;
+      return true;
+    case PROTOCOL_QUIC:
+      *observation_source = QUIC;
+      return true;
+  }
+  NOTREACHED();
+  return false;
+}
+
 void NetworkQualityEstimator::OnConnectionTypeChanged(
     NetworkChangeNotifier::ConnectionType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (peak_network_quality_.rtt() != InvalidRTT()) {
     switch (current_network_id_.type) {
       case NetworkChangeNotifier::CONNECTION_UNKNOWN:
         UMA_HISTOGRAM_TIMES("NQE.FastestRTT.Unknown",
                             peak_network_quality_.rtt());
         break;
       case NetworkChangeNotifier::CONNECTION_ETHERNET:
@@ skipping 451 matching lines @@
 
   return scoped_ptr<SocketPerformanceWatcher>(
       new SocketPerformanceWatcher(protocol, this));
 }
 
 void NetworkQualityEstimator::OnUpdatedRTTAvailable(
     const Protocol protocol,
     const base::TimeDelta& rtt) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  switch (protocol) {
-    case PROTOCOL_TCP:
-      NotifyObserversOfRTT(RttObservation(rtt, base::TimeTicks::Now(), TCP));
-      return;
-    case PROTOCOL_QUIC:
-      NotifyObserversOfRTT(RttObservation(rtt, base::TimeTicks::Now(), QUIC));
-      return;
-    default:
-      NOTREACHED();
-  }
+  ObservationSource observation_source;
+  if (!GetObservationSourceForProtocol(protocol, &observation_source))
+    return;
+
+  NotifyObserversOfRTT(
+      RttObservation(rtt, base::TimeTicks::Now(), observation_source));
+}
+
+void NetworkQualityEstimator::OnIncrementalPacketCountAvailable(
+    Protocol protocol,
+    size_t packets_missing,
+    size_t packets_received_in_order,
+    size_t packets_received_out_of_order) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  ObservationSource observation_source;
+  if (!GetObservationSourceForProtocol(protocol, &observation_source))
+    return;
+
+  // Consider it as a packet loss only if at least 3 packets are received after
+  // the missing packets.
+  // TODO(tbansal): Maintain a watcher specific buffer that keeps track of
+  // missing, and at most last N-1 in-order packets. If N (=3) packets with
+  // sequence number higher than the sequence number of a missing packet are
+  // received, then the missing packet should be marked as lost, and removed
+  // from the watcher specific buffer. If an out-of-order packet is received,
+  // then the state of the missing packet with lowest sequence number should be
+  // changed to received. This simple approach does not require going back in
+  // time, and changing the previously taken observations.
+  NotifyObserversOfIncrementalPacketCount(
+      packets_missing, packets_received_in_order, packets_received_out_of_order,
+      base::TimeTicks::Now(), observation_source);
 }
 
 void NetworkQualityEstimator::NotifyObserversOfRTT(
     const RttObservation& observation) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_NE(EXTERNAL_ESTIMATE, observation.source);
+
   FOR_EACH_OBSERVER(
       RTTObserver, rtt_observer_list_,
       OnRTTObservation(observation.value.InMilliseconds(),
                        observation.timestamp, observation.source));
 }
 
 void NetworkQualityEstimator::NotifyObserversOfThroughput(
     const ThroughputObservation& observation) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_NE(EXTERNAL_ESTIMATE, observation.source);
+
   FOR_EACH_OBSERVER(
       ThroughputObserver, throughput_observer_list_,
       OnThroughputObservation(observation.value, observation.timestamp,
                               observation.source));
 }
 
+void NetworkQualityEstimator::NotifyObserversOfIncrementalPacketCount(
+    size_t packets_missing,
+    size_t packets_received_in_order,
+    size_t packets_received_out_of_order,
+    const base::TimeTicks& timestamp,
+    ObservationSource source) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_NE(EXTERNAL_ESTIMATE, source);
+
+  FOR_EACH_OBSERVER(PacketCountObserver, packet_count_observer_list_,
+                    OnIncrementalPacketCountObservation(
+                        packets_missing, packets_received_in_order,
+                        packets_received_out_of_order, timestamp, source));
+}
+
 NetworkQualityEstimator::CachedNetworkQuality::CachedNetworkQuality(
     const NetworkQuality& network_quality)
     : last_update_time_(base::TimeTicks::Now()),
       network_quality_(network_quality) {
 }
 
 NetworkQualityEstimator::CachedNetworkQuality::CachedNetworkQuality(
     const CachedNetworkQuality& other)
     : last_update_time_(other.last_update_time_),
       network_quality_(other.network_quality_) {
@@ skipping 27 matching lines @@
 
 NetworkQualityEstimator::NetworkQuality&
     NetworkQualityEstimator::NetworkQuality::
     operator=(const NetworkQuality& other) {
   rtt_ = other.rtt_;
   downstream_throughput_kbps_ = other.downstream_throughput_kbps_;
   return *this;
 }
 
 }  // namespace net