Trigger data reduction proxy unreachable message via on proxy fall back.

components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.cc

 // Copyright 2014 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 "components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
@@ skipping 10 matching lines @@
 using net::HostPortPair;
 using net::ProxyServer;
 using net::ProxyService;
 using net::NetworkChangeNotifier;
 using net::URLRequest;
 
 namespace data_reduction_proxy {
 
 namespace {
 
+const int kMinFailedRequestsWhenUnavailable = 1;
+const int kMaxSuccessfulRequestsWhenUnavailable = 0;
+const int kMaxFailedRequestsBeforeReset = 3;
+
 // Records a net error code that resulted in bypassing the data reduction
 // proxy (|is_primary| is true) or the data reduction proxy fallback.
 void RecordDataReductionProxyBypassOnNetworkError(
     bool is_primary,
     const ProxyServer& proxy_server,
     int net_error) {
   if (is_primary) {
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "DataReductionProxy.BypassOnNetworkErrorPrimary",
         std::abs(net_error));
@@ skipping 31 matching lines @@
   }
 }
 
 DataReductionProxyUsageStats::DataReductionProxyUsageStats(
     DataReductionProxyParams* params,
     MessageLoopProxy* ui_thread_proxy)
     : data_reduction_proxy_params_(params),
       last_bypass_type_(BYPASS_EVENT_TYPE_MAX),
       triggering_request_(true),
       ui_thread_proxy_(ui_thread_proxy),
-      eligible_num_requests_through_proxy_(0),
-      actual_num_requests_through_proxy_(0),
+      successful_requests_through_proxy_count_(0),
+      proxy_net_errors_count_(0),
       unavailable_(false) {
+  DCHECK(params);
+
   NetworkChangeNotifier::AddNetworkChangeObserver(this);
 };
 
 DataReductionProxyUsageStats::~DataReductionProxyUsageStats() {
   NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 };
 
 void DataReductionProxyUsageStats::OnUrlRequestCompleted(
     const net::URLRequest* request, bool started) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (request->status().status() == net::URLRequestStatus::SUCCESS) {
-    if (data_reduction_proxy_params_->IsDataReductionProxyEligible(request)) {
-      bool was_received_via_proxy =
-          data_reduction_proxy_params_->WasDataReductionProxyUsed(
-              request, NULL);
-      IncrementRequestCounts(was_received_via_proxy);
-    }
+  if (request->status().status() == net::URLRequestStatus::SUCCESS &&
+      data_reduction_proxy_params_->WasDataReductionProxyUsed(request, NULL)) {
+    successful_requests_through_proxy_count_++;
+    NotifyUnavailabilityIfChanged();
   }
 }
 
 void DataReductionProxyUsageStats::OnNetworkChanged(
     NetworkChangeNotifier::ConnectionType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ClearRequestCounts();
 }
 
-void DataReductionProxyUsageStats::IncrementRequestCounts(
-    bool was_received_via_proxy) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (was_received_via_proxy) {
-    actual_num_requests_through_proxy_++;
-  }
-  eligible_num_requests_through_proxy_++;
-
-  // To account for the case when the proxy works for a little while and then
-  // gets blocked, we reset the counts occasionally.
-  if (eligible_num_requests_through_proxy_ > 50
-      && actual_num_requests_through_proxy_ > 0) {
-    ClearRequestCounts();
-  } else {
-    MaybeNotifyUnavailability();
-  }
-}
-
 void DataReductionProxyUsageStats::ClearRequestCounts() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  eligible_num_requests_through_proxy_ = 0;
-  actual_num_requests_through_proxy_ = 0;
-  MaybeNotifyUnavailability();
+  successful_requests_through_proxy_count_ = 0;
+  proxy_net_errors_count_ = 0;
 }
 
-void DataReductionProxyUsageStats::MaybeNotifyUnavailability() {
+void DataReductionProxyUsageStats::NotifyUnavailabilityIfChanged() {
   bool prev_unavailable = unavailable_;
-  unavailable_ = (eligible_num_requests_through_proxy_ > 0 &&
-      actual_num_requests_through_proxy_ == 0);
+  unavailable_ =
+      (proxy_net_errors_count_ >= kMinFailedRequestsWhenUnavailable &&
+          successful_requests_through_proxy_count_ <=
+              kMaxSuccessfulRequestsWhenUnavailable);
   if (prev_unavailable != unavailable_) {
-     ui_thread_proxy_->PostTask(FROM_HERE, base::Bind(
-          &DataReductionProxyUsageStats::NotifyUnavailabilityOnUIThread,
-          base::Unretained(this),
-          unavailable_));
+    ui_thread_proxy_->PostTask(FROM_HERE, base::Bind(
+        &DataReductionProxyUsageStats::NotifyUnavailabilityOnUIThread,
+        base::Unretained(this),
+        unavailable_));
   }
 }
 
 void DataReductionProxyUsageStats::NotifyUnavailabilityOnUIThread(
     bool unavailable) {
   DCHECK(ui_thread_proxy_->BelongsToCurrentThread());
   if (!unavailable_callback_.is_null())
     unavailable_callback_.Run(unavailable);
 }
 
@@ skipping 77 matching lines @@
   }
 
   if (data_reduction_proxy_params_->AreDataReductionProxiesBypassed(request,
                                                                     NULL)) {
     RecordBypassedBytes(last_bypass_type_,
                         DataReductionProxyUsageStats::NETWORK_ERROR,
                         content_length);
   }
 }
 
-void DataReductionProxyUsageStats::RecordBypassEventHistograms(
+void DataReductionProxyUsageStats::OnProxyFallback(
     const net::ProxyServer& bypassed_proxy,
-    int net_error) const {
+    int net_error) {
   DataReductionProxyTypeInfo data_reduction_proxy_info;
   if (bypassed_proxy.is_valid() && !bypassed_proxy.is_direct() &&
       data_reduction_proxy_params_->IsDataReductionProxy(
       bypassed_proxy.host_port_pair(), &data_reduction_proxy_info)) {
     if (data_reduction_proxy_info.is_ssl)
       return;
+
+    proxy_net_errors_count_++;
+
+    // To account for the case when the proxy is reachable for sometime, and
+    // then gets blocked, we reset counts when number of errors exceed
+    // the threshold.
+    if (proxy_net_errors_count_ >= kMaxFailedRequestsBeforeReset &&
+        successful_requests_through_proxy_count_ >
+            kMaxSuccessfulRequestsWhenUnavailable) {
+      ClearRequestCounts();
+    } else {
+      NotifyUnavailabilityIfChanged();
+    }
+
     if (!data_reduction_proxy_info.is_fallback) {
       RecordDataReductionProxyBypassInfo(
           true, false, bypassed_proxy, BYPASS_EVENT_TYPE_NETWORK_ERROR);
       RecordDataReductionProxyBypassOnNetworkError(
           true, bypassed_proxy, net_error);
     } else {
       RecordDataReductionProxyBypassInfo(
           false, false, bypassed_proxy, BYPASS_EVENT_TYPE_NETWORK_ERROR);
       RecordDataReductionProxyBypassOnNetworkError(
           false, bypassed_proxy, net_error);
@@ skipping 112 matching lines @@
         default:
           break;
       }
       break;
   }
 }
 
 }  // namespace data_reduction_proxy