Record RTT prediction accuracy when using average algorithms

net/nqe/network_quality_estimator.h

 // 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.
 
 #ifndef NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_
 #define NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "base/optional.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/base/network_change_notifier.h"
 #include "net/nqe/cached_network_quality.h"
 #include "net/nqe/effective_connection_type.h"
 #include "net/nqe/event_creator.h"
 #include "net/nqe/external_estimate_provider.h"
 #include "net/nqe/network_id.h"
 #include "net/nqe/network_quality.h"
@@ skipping 283 matching lines @@
   // A protected constructor for testing that allows setting the value of
   // |add_default_platform_observations_|.
   NetworkQualityEstimator(
       std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
       const std::map<std::string, std::string>& variation_params,
       bool use_local_host_requests_for_tests,
       bool use_smaller_responses_for_tests,
       bool add_default_platform_observations,
       const NetLogWithSource& net_log);
 
+  // Different experimental statistic algorithms that can be used for computing
+  // the predictions.
+  enum Statistic {
+    STATISTIC_WEIGHTED_AVERAGE = 0,
+    STATISTIC_UNWEIGHTED_AVERAGE = 1,
+    // Last statistic. Not to be used.
+    STATISTIC_LAST = 2
+  };
+
   // NetworkChangeNotifier::ConnectionTypeObserver implementation:
   void OnConnectionTypeChanged(
       NetworkChangeNotifier::ConnectionType type) override;
 
   // ExternalEstimateProvider::UpdatedEstimateObserver implementation.
   void OnUpdatedEstimateAvailable(const base::TimeDelta& rtt,
                                   int32_t downstream_throughput_kbps,
                                   int32_t upstream_throughput_kbps) override;
 
   // Returns true if median RTT at the HTTP layer is available and sets |rtt|
@@ skipping 45 matching lines @@
       const base::TimeTicks& start_time,
       base::TimeDelta* http_rtt,
       base::TimeDelta* transport_rtt,
       int32_t* downstream_throughput_kbps) const;
 
   // Notifies |this| of a new transport layer RTT. Called by socket watchers.
   // Protected for testing.
   void OnUpdatedRTTAvailable(SocketPerformanceWatcherFactory::Protocol protocol,
                              const base::TimeDelta& rtt);
 
+  // Returns an estimate of network quality at the specified |percentile|.
+  // |disallowed_observation_sources| is the list of observation sources that
+  // should be excluded when computing the percentile.
+  // Only the observations later than |start_time| are taken into account.
+  // |percentile| must be between 0 and 100 (both inclusive) with higher
+  // percentiles indicating less performant networks. For example, if
+  // |percentile| is 90, then the network is expected to be faster than the
+  // returned estimate with 0.9 probability. Similarly, network is expected to
+  // be slower than the returned estimate with 0.1 probability. |statistic|
+  // is the statistic that should be used for computing the estimate. If unset,
+  // the default statistic is used. Virtualized for testing.
+  virtual base::TimeDelta GetRTTEstimateInternal(
+      const std::vector<NetworkQualityObservationSource>&
+          disallowed_observation_sources,
+      base::TimeTicks start_time,
+      const base::Optional<Statistic>& statistic,
+      int percentile) const;
+  int32_t GetDownlinkThroughputKbpsEstimateInternal(
+      const base::TimeTicks& start_time,
+      int percentile) const;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            AdaptiveRecomputationEffectiveConnectionType);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, StoreObservations);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, TestAddObservation);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            DefaultObservationsOverridden);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest,
                            ObtainAlgorithmToUseFromParams);
   FRIEND_TEST_ALL_PREFIXES(NetworkQualityEstimatorTest, HalfLifeParam);
@@ skipping 78 matching lines @@
   // the field trial parameters. For each effective connection type, a model
   // (currently composed of a RTT threshold and a downlink throughput threshold)
   // is provided by the field trial.
   void ObtainOperatingParams(
       const std::map<std::string, std::string>& variation_params);
 
   // Adds the default median RTT and downstream throughput estimate for the
   // current connection type to the observation buffer.
   void AddDefaultEstimates();
 
-  // Returns an estimate of network quality at the specified |percentile|.
-  // |disallowed_observation_sources| is the list of observation sources that
-  // should be excluded when computing the percentile.
-  // Only the observations later than |start_time| are taken into account.
-  // |percentile| must be between 0 and 100 (both inclusive) with higher
-  // percentiles indicating less performant networks. For example, if
-  // |percentile| is 90, then the network is expected to be faster than the
-  // returned estimate with 0.9 probability. Similarly, network is expected to
-  // be slower than the returned estimate with 0.1 probability.
-  base::TimeDelta GetRTTEstimateInternal(
-      const std::vector<NetworkQualityObservationSource>&
-          disallowed_observation_sources,
-      const base::TimeTicks& start_time,
-      int percentile) const;
-  int32_t GetDownlinkThroughputKbpsEstimateInternal(
-      const base::TimeTicks& start_time,
-      int percentile) const;
-
   // Returns the current network ID checking by calling the platform APIs.
   // Virtualized for testing.
   virtual nqe::internal::NetworkID GetCurrentNetworkID() const;
 
   // Notifies RTT observers of |observation|. May also trigger recomputation
   // of effective connection type.
   void NotifyObserversOfRTT(const RttObservation& observation);
 
   // Notifies throughput observers of |observation|. May also trigger
   // recomputation of effective connection type.
@@ skipping 85 matching lines @@
   // if there is a change in its value.
   void ComputeEffectiveConnectionType();
 
   // May update the network quality of the current network if |network_id|
   // matches the ID of the current network. |cached_network_quality| is the
   // cached network quality of the network with id |network_id|.
   void MaybeUpdateNetworkQualityFromCache(
       const nqe::internal::NetworkID& network_id,
       const nqe::internal::CachedNetworkQuality& cached_network_quality);
 
+  const char* GetNameForStatistic(int i) const;
+
   // Determines if the requests to local host can be used in estimating the
   // network quality. Set to true only for tests.
   bool use_localhost_requests_;
 
   // Determines if the responses smaller than |kMinTransferSizeInBytes|
   // or shorter than |kMinTransferSizeInBytes| can be used in estimating the
   // network quality. Set to true only for tests.
   bool use_small_responses_;
 
   // When set to true, the device offline check is disabled when computing the
@@ skipping 63 matching lines @@
       [EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_LAST];
 
   // Time when the transaction for the last main frame request was started.
   base::TimeTicks last_main_frame_request_;
 
   // Estimated network quality when the transaction for the last main frame
   // request was started.
   nqe::internal::NetworkQuality estimated_quality_at_last_main_frame_;
   EffectiveConnectionType effective_connection_type_at_last_main_frame_;
 
+  // Estimated RTT at HTTP layer when the last main frame transaction was
+  // started. Computed using different statistics.
+  base::TimeDelta http_rtt_at_last_main_frame_[STATISTIC_LAST];
+
   // Estimated network quality obtained from external estimate provider when the
   // external estimate provider was last queried.
   nqe::internal::NetworkQuality external_estimate_provider_quality_;
 
   // ExternalEstimateProvider that provides network quality using operating
   // system APIs. May be NULL.
   const std::unique_ptr<ExternalEstimateProvider> external_estimate_provider_;
 
   // Observer list for changes in effective connection type.
   base::ObserverList<EffectiveConnectionTypeObserver>
@@ skipping 81 matching lines @@
       disallowed_observation_sources_for_transport_;
 
   base::WeakPtrFactory<NetworkQualityEstimator> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkQualityEstimator);
 };
 
 }  // namespace net
 
 #endif  // NET_NQE_NETWORK_QUALITY_ESTIMATOR_H_