NQE: Exclude network observations from private networks

net/nqe/throughput_analyzer.cc

 // Copyright 2016 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/throughput_analyzer.h"
 
 #include <cmath>
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
+#include "net/base/host_port_pair.h"
 #include "net/base/network_activity_monitor.h"
 #include "net/base/url_util.h"
 #include "net/nqe/network_quality_estimator_params.h"
+#include "net/nqe/network_quality_estimator_util.h"
 #include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
 
 #if defined(OS_ANDROID)
 #include "net/android/traffic_stats.h"
 #endif  // OS_ANDROID
 
 namespace net {
 
+class HostResolver;
+
 namespace {
 
 // Maximum number of accuracy degrading requests, and requests that do not
 // degrade accuracy held in the memory.
 static const size_t kMaxRequestsSize = 300;
 
 // Tiny transfer sizes may give inaccurate throughput results.
 // Minimum size of the transfer over which the throughput is computed.
 static const int kMinTransferSizeInBits = 32 * 8 * 1000;
 
 }  // namespace
 
 namespace nqe {
 
 namespace internal {
 
 ThroughputAnalyzer::ThroughputAnalyzer(
     const NetworkQualityEstimatorParams* params,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     ThroughputObservationCallback throughput_observation_callback,
     bool use_local_host_requests_for_tests,
-    bool use_smaller_responses_for_tests)
+    bool use_smaller_responses_for_tests,
+    const NetLogWithSource& net_log)
     : params_(params),
       task_runner_(task_runner),
       throughput_observation_callback_(throughput_observation_callback),
       last_connection_change_(base::TimeTicks::Now()),
       window_start_time_(base::TimeTicks()),
       bits_received_at_window_start_(0),
       disable_throughput_measurements_(false),
       use_localhost_requests_for_tests_(use_local_host_requests_for_tests),
-      use_small_responses_for_tests_(use_smaller_responses_for_tests) {
+      use_small_responses_for_tests_(use_smaller_responses_for_tests),
+      net_log_(net_log) {
   DCHECK(params_);
   DCHECK(task_runner_);
   DCHECK(!IsCurrentlyTrackingThroughput());
 }
 
 ThroughputAnalyzer::~ThroughputAnalyzer() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void ThroughputAnalyzer::MaybeStartThroughputObservationWindow() {
@@ skipping 194 matching lines @@
   int64_t rx_bytes;
   if (android::traffic_stats::GetCurrentUidRxBytes(&rx_bytes))
     return static_cast<uint64_t>(rx_bytes * 8);
 #endif
   return NetworkActivityMonitor::GetInstance()->GetBytesReceived() * 8;
 }
 
 bool ThroughputAnalyzer::DegradesAccuracy(const URLRequest& request) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  return !(use_localhost_requests_for_tests_ ||
-           !IsLocalhost(request.url().host())) ||
+  bool private_network_request = nqe::internal::IsPrivateHost(
+      request.context() ? request.context()->host_resolver() : nullptr,
+      HostPortPair(request.url().host(), request.url().EffectiveIntPort()),
+      net_log_);
+
+  return !(use_localhost_requests_for_tests_ || !private_network_request) ||
          request.creation_time() < last_connection_change_;
 }
 
 void ThroughputAnalyzer::BoundRequestsSize() {
   if (accuracy_degrading_requests_.size() > kMaxRequestsSize) {
     // Clear |accuracy_degrading_requests_| since its size has exceeded its
     // capacity.
     accuracy_degrading_requests_.clear();
     // Disable throughput measurements since |this| has lost track of the
     // accuracy degrading requests.
@@ skipping 18 matching lines @@
     // TODO(tbansal): crbug.com/609174 Add UMA to record how frequently this
     // happens.
   }
 }
 
 }  // namespace internal
 
 }  // namespace nqe
 
 }  // namespace net