Add network quality change events to net log

net/nqe/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/nqe/network_quality_estimator.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
@@ skipping 15 matching lines @@
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/trace_constants.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
+#include "net/nqe/event_creator.h"
 #include "net/nqe/network_quality_estimator_params.h"
 #include "net/nqe/socket_watcher_factory.h"
 #include "net/nqe/throughput_analyzer.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "net/android/cellular_signal_strength.h"
 #include "net/android/network_library.h"
@@ skipping 155 matching lines @@
       histogram_name, 0, EFFECTIVE_CONNECTION_TYPE_LAST,
       EFFECTIVE_CONNECTION_TYPE_LAST /* Number of buckets */,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(std::abs(metric));
 }
 
 }  // namespace
 
 NetworkQualityEstimator::NetworkQualityEstimator(
     std::unique_ptr<ExternalEstimateProvider> external_estimates_provider,
-    const std::map<std::string, std::string>& variation_params)
-    : NetworkQualityEstimator(std::move(external_estimates_provider),
-                              variation_params,
-                              false,
-                              false) {}
-
-NetworkQualityEstimator::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)
+    NetLog* net_log)
     : NetworkQualityEstimator(std::move(external_estimates_provider),
                               variation_params,
-                              use_local_host_requests_for_tests,
-                              use_smaller_responses_for_tests,
-                              true) {}
+                              false,
+                              false,
+                              net_log) {}
 
 NetworkQualityEstimator::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)
+    NetLog* net_log)
+    : NetworkQualityEstimator(
+          std::move(external_estimates_provider),
+          variation_params,
+          use_local_host_requests_for_tests,
+          use_smaller_responses_for_tests,
+          true,
+          NetLogWithSource::Make(
+              net_log,
+              net::NetLogSourceType::NETWORK_QUALITY_ESTIMATOR)) {}
+
+NetworkQualityEstimator::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)
     : algorithm_name_to_enum_({{"HttpRTTAndDownstreamThroughput",
                                 EffectiveConnectionTypeAlgorithm::
                                     HTTP_RTT_AND_DOWNSTREAM_THROUGHOUT},
                                {"TransportRTTOrDownstreamThroughput",
                                 EffectiveConnectionTypeAlgorithm::
                                     TRANSPORT_RTT_OR_DOWNSTREAM_THROUGHOUT}}),
       use_localhost_requests_(use_local_host_requests_for_tests),
       use_small_responses_(use_smaller_responses_for_tests),
       add_default_platform_observations_(add_default_platform_observations),
       weight_multiplier_per_second_(
@@ skipping 25 matching lines @@
       signal_strength_dbm_(INT32_MIN),
       min_signal_strength_since_connection_change_(INT32_MAX),
       max_signal_strength_since_connection_change_(INT32_MIN),
       correlation_uma_logging_probability_(
           nqe::internal::correlation_uma_logging_probability(variation_params)),
       forced_effective_connection_type_set_(
           nqe::internal::forced_effective_connection_type_set(
               variation_params)),
       forced_effective_connection_type_(
           nqe::internal::forced_effective_connection_type(variation_params)),
+      net_log_(net_log),
       weak_ptr_factory_(this) {
   // None of the algorithms can have an empty name.
   DCHECK(algorithm_name_to_enum_.end() ==
          algorithm_name_to_enum_.find(std::string()));
 
   DCHECK_EQ(algorithm_name_to_enum_.size(),
             static_cast<size_t>(EffectiveConnectionTypeAlgorithm::
                                     EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST));
   DCHECK_NE(EffectiveConnectionTypeAlgorithm::
                 EFFECTIVE_CONNECTION_TYPE_ALGORITHM_LAST,
@@ skipping 430 matching lines @@
 void NetworkQualityEstimator::SetUseSmallResponsesForTesting(
     bool use_small_responses) {
   DCHECK(thread_checker_.CalledOnValidThread());
   use_small_responses_ = use_small_responses;
   throughput_analyzer_->SetUseSmallResponsesForTesting(use_small_responses_);
 }
 
 void NetworkQualityEstimator::ReportEffectiveConnectionTypeForTesting(
     EffectiveConnectionType effective_connection_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  nqe::internal::AddEffectiveConnectionTypeChangedEventToNetLog(
+      net_log_, typical_network_quality_[effective_connection_type].http_rtt(),
+      typical_network_quality_[effective_connection_type].transport_rtt(),
+      typical_network_quality_[effective_connection_type]
+          .downstream_throughput_kbps(),
+      effective_connection_type);
+
   for (auto& observer : effective_connection_type_observer_list_)
     observer.OnEffectiveConnectionTypeChanged(effective_connection_type);
 
   network_quality_store_->Add(current_network_id_,
                               nqe::internal::CachedNetworkQuality(
                                   tick_clock_->NowTicks(), network_quality_,
                                   effective_connection_type));
 }
 
 bool NetworkQualityEstimator::RequestProvidesRTTObservation(
@@ skipping 809 matching lines @@
     return;
   }
   ComputeEffectiveConnectionType();
 }
 
 void NetworkQualityEstimator::
     NotifyObserversOfEffectiveConnectionTypeChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(EFFECTIVE_CONNECTION_TYPE_LAST, effective_connection_type_);
 
+  nqe::internal::AddEffectiveConnectionTypeChangedEventToNetLog(
+      net_log_, network_quality_.http_rtt(), network_quality_.transport_rtt(),
+      network_quality_.downstream_throughput_kbps(),
+      effective_connection_type_);
+
   // TODO(tbansal): Add hysteresis in the notification.
   for (auto& observer : effective_connection_type_observer_list_)
     observer.OnEffectiveConnectionTypeChanged(effective_connection_type_);
 
   // Add the estimates of the current network to the cache store.
   if (effective_connection_type_ != EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
     network_quality_store_->Add(current_network_id_,
                                 nqe::internal::CachedNetworkQuality(
                                     tick_clock_->NowTicks(), network_quality_,
                                     effective_connection_type_));
@@ skipping 115 matching lines @@
         NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_CACHED_ESTIMATE);
     downstream_throughput_kbps_observations_.AddObservation(
         throughput_observation);
     NotifyObserversOfThroughput(throughput_observation);
   }
 
   ComputeEffectiveConnectionType();
 }
 
 }  // namespace net