NQE Cleanup in preparation for file splitting

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 194 matching lines @@
                               false,
                               false) {}
 
 NetworkQualityEstimator::NetworkQualityEstimator(
     scoped_ptr<ExternalEstimateProvider> external_estimates_provider,
     const std::map<std::string, std::string>& variation_params,
     bool allow_local_host_requests_for_tests,
     bool allow_smaller_responses_for_tests)
     : allow_localhost_requests_(allow_local_host_requests_for_tests),
       allow_small_responses_(allow_smaller_responses_for_tests),
+      weight_multiplier_per_second_(
+          GetWeightMultiplierPerSecond(variation_params)),
       last_connection_change_(base::TimeTicks::Now()),
       current_network_id_(
           NetworkID(NetworkChangeNotifier::ConnectionType::CONNECTION_UNKNOWN,
                     std::string())),
-      downstream_throughput_kbps_observations_(
-          GetWeightMultiplierPerSecond(variation_params)),
-      rtt_observations_(GetWeightMultiplierPerSecond(variation_params)),
+      downstream_throughput_kbps_observations_(weight_multiplier_per_second_),
+      rtt_observations_(weight_multiplier_per_second_),
       external_estimate_provider_(std::move(external_estimates_provider)),
       weak_ptr_factory_(this) {
   static_assert(kMinRequestDurationMicroseconds > 0,
                 "Minimum request duration must be > 0");
   static_assert(kDefaultHalfLifeSeconds > 0,
                 "Default half life duration must be > 0");
   static_assert(kMaximumNetworkQualityCacheSize > 0,
                 "Size of the network quality cache must be > 0");
   // This limit should not be increased unless the logic for removing the
   // oldest cache entry is rewritten to use a doubly-linked-list LRU queue.
@@ skipping 116 matching lines @@
   }
 
   // Time when the resource was requested.
   base::TimeTicks request_start_time = load_timing_info.send_start;
 
   // Time when the headers were received.
   base::TimeTicks headers_received_time = load_timing_info.receive_headers_end;
 
   // 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());
-    if (observed_rtt < peak_network_quality_.rtt()) {
-      peak_network_quality_ = NetworkQuality(
-          observed_rtt, peak_network_quality_.downstream_throughput_kbps());
-    }
+  base::TimeDelta observed_rtt = headers_received_time - request_start_time;
+  DCHECK_GE(observed_rtt, base::TimeDelta());
+  if (observed_rtt < peak_network_quality_.rtt()) {
+    peak_network_quality_ = NetworkQuality(
+        observed_rtt, peak_network_quality_.downstream_throughput_kbps());
+  }
 
-    RttObservation rtt_observation(observed_rtt, now, URL_REQUEST);
-    rtt_observations_.AddObservation(rtt_observation);
-    NotifyObserversOfRTT(rtt_observation);
+  RttObservation rtt_observation(observed_rtt, now, URL_REQUEST);
+  rtt_observations_.AddObservation(rtt_observation);
+  NotifyObserversOfRTT(rtt_observation);
 
-    // Compare the RTT observation with the estimated value and record it.
-    if (estimated_median_network_quality_.rtt() != InvalidRTT()) {
-      RecordRTTUMA(estimated_median_network_quality_.rtt().InMilliseconds(),
-                   observed_rtt.InMilliseconds());
-    }
+  // Compare the RTT observation with the estimated value and record it.
+  if (estimated_median_network_quality_.rtt() != InvalidRTT()) {
+    RecordRTTUMA(estimated_median_network_quality_.rtt().InMilliseconds(),
+                 observed_rtt.InMilliseconds());
+  }
 }
 
 void NetworkQualityEstimator::NotifyRequestCompleted(
     const URLRequest& request) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("net"),
                "NetworkQualityEstimator::NotifyRequestCompleted");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!RequestProvidesUsefulObservations(request))
     return;
@@ skipping 686 matching lines @@
 
 NetworkQualityEstimator::NetworkQuality&
     NetworkQualityEstimator::NetworkQuality::
     operator=(const NetworkQuality& other) {
   rtt_ = other.rtt_;
   downstream_throughput_kbps_ = other.downstream_throughput_kbps_;
   return *this;
 }
 
 }  // namespace net