Adjust callers and networking delegates in net/ to modified APIs

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 788 matching lines @@
     const int estimated_observed_diff_milliseconds =
         external_estimate_provider_quality_.http_rtt().InMilliseconds() -
         recent_http_rtt.InMilliseconds();
 
     RecordRTTAccuracy("NQE.ExternalEstimateProvider.RTT.Accuracy",
                       estimated_observed_diff_milliseconds, measuring_duration,
                       recent_http_rtt);
   }
 }
 
-void NetworkQualityEstimator::NotifyRequestCompleted(
-    const URLRequest& request) {
+void NetworkQualityEstimator::NotifyRequestCompleted(const URLRequest& request,
+                                                     int net_error) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("net"),
                "NetworkQualityEstimator::NotifyRequestCompleted");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!RequestSchemeIsHTTPOrHTTPS(request))
     return;
 
   throughput_analyzer_->NotifyRequestCompleted(request);
-  RecordCorrelationMetric(request);
+  RecordCorrelationMetric(request, net_error);
 }
 
-void NetworkQualityEstimator::RecordCorrelationMetric(
-    const URLRequest& request) const {
+void NetworkQualityEstimator::RecordCorrelationMetric(const URLRequest& request,
+                                                      int net_error) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // The histogram is recorded with probability
   // |correlation_uma_logging_probability_| to reduce overhead involved with
   // sparse histograms. Also, recording the correlation on each request is
   // unnecessary.
   if (RandDouble() >= correlation_uma_logging_probability_)
     return;
 
   if (request.response_info().was_cached ||
       !request.response_info().network_accessed) {
     return;
   }
 
   LoadTimingInfo load_timing_info;
   request.GetLoadTimingInfo(&load_timing_info);
   // If the load timing info is unavailable, it probably means that the request
   // did not go over the network.
   if (load_timing_info.send_start.is_null() ||
       load_timing_info.receive_headers_end.is_null()) {
     return;
   }
 
   // Record UMA only for successful requests that have completed.
-  if (!request.status().is_success() || request.status().is_io_pending())
+  if (net_error != OK || net_error == ERR_IO_PENDING)

[mmenke, 2016/08/30 22:13:22]

The ERR_IO_PENDING part of this comparison is redundant.

This whole call seems a bit problematic (Even with the old code), but fixing it
seems beyond the scope of this CL.

[maksims (do not use this acc), 2016/09/01 12:22:30]

Do you mean all the paths here? Do you think they should be separate functions?

     return;
   if (request.GetResponseCode() != HTTP_OK)
     return;
   if (load_timing_info.receive_headers_end < last_main_frame_request_)
     return;
 
   const base::TimeTicks now = tick_clock_->NowTicks();
   // Record UMA only for requests that started recently.
   if (now - last_main_frame_request_ > base::TimeDelta::FromSeconds(15))
     return;
@@ skipping 845 matching lines @@
   if (effective_connection_type_ != EFFECTIVE_CONNECTION_TYPE_UNKNOWN) {
     network_quality_store_->Add(
         current_network_id_,
         nqe::internal::CachedNetworkQuality(
             tick_clock_->NowTicks(), estimated_quality_at_last_main_frame_,
             effective_connection_type_));
   }
 }
 
 }  // namespace net