Adds UMA to measure when the data reduction proxy via header is missing

components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h

 // 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.
 
 #ifndef COMPONENTS_DATA_REDUCTION_PROXY_BROWSER_DATA_REDUCTION_PROXY_USAGE_STATS_H_
 #define COMPONENTS_DATA_REDUCTION_PROXY_BROWSER_DATA_REDUCTION_PROXY_USAGE_STATS_H_
 
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/prefs/pref_member.h"
 #include "base/threading/thread_checker.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_headers.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/network_change_notifier.h"
 #include "net/url_request/url_request.h"
 
 namespace net {
+class HttpResponseHeaders;
+class ProxyConfig;
 class ProxyServer;
 }
 
 namespace data_reduction_proxy {
 
 class DataReductionProxyUsageStats
     : public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
   // Records a data reduction proxy bypass event as a "BlockType" if
   // |bypass_all| is true and as a "BypassType" otherwise. Records the event as
   // "Primary" if |is_primary| is true and "Fallback" otherwise.
   static void RecordDataReductionProxyBypassInfo(
       bool is_primary,
       bool bypass_all,
       const net::ProxyServer& proxy_server,
       DataReductionProxyBypassType bypass_type);
 
+  // For the given response |headers| that are expected to include the data
+  // reduction proxy via header, records response code UMA if the data reduction
+  // proxy via header is not present.
+  static void DetectAndRecordMissingViaHeaderResponseCode(
+      bool is_primary,
+      const net::HttpResponseHeaders* headers);
+
   // MessageLoopProxy instance is owned by io_thread. |params| outlives
   // this class instance.
   DataReductionProxyUsageStats(DataReductionProxyParams* params,
                                base::MessageLoopProxy* ui_thread_proxy);
   virtual ~DataReductionProxyUsageStats();
 
   // Sets the callback to be called on the UI thread when the unavailability
   // status has changed.
   void set_unavailable_callback(
       const base::Callback<void(bool)>& unavailable_callback) {
     unavailable_callback_ = unavailable_callback;
   }
 
   // Callback intended to be called from |ChromeNetworkDelegate| when a
   // request completes. This method is used to gather usage stats.
   void OnUrlRequestCompleted(const net::URLRequest* request, bool started);
 
   // Records the last bypass reason to |bypass_type_| and sets
   // |triggering_request_| to true. A triggering request is the first request to
   // cause the current bypass.
   void SetBypassType(DataReductionProxyBypassType type);
 
-  // Given |data_reduction_proxy_enabled|, a |request|, and the
-  // |data_reduction_proxy_config| records the number of bypassed bytes for that
-  // |request| into UMAs based on bypass type. |data_reduction_proxy_enabled|
-  // tells us the state of the kDataReductionProxyEnabled preference.
-  void RecordBypassedBytesHistograms(
-      net::URLRequest& request,
+  // Records all the data reduction proxy bytes-related histograms for the
+  // completed URLRequest |request|.
+  void RecordBytesHistograms(
+      net::URLRequest* request,
       const BooleanPrefMember& data_reduction_proxy_enabled,
       const net::ProxyConfig& data_reduction_proxy_config);
 
   void RecordBypassEventHistograms(const net::ProxyServer& bypassed_proxy,
                                    int net_error) const;
 
  private:
+  friend class DataReductionProxyUsageStatsTest;
+  FRIEND_TEST_ALL_PREFIXES(DataReductionProxyUsageStatsTest,
+                           RecordMissingViaHeaderBytes);
+
   enum BypassedBytesType {
     NOT_BYPASSED = 0,         /* Not bypassed. */
     SSL,                      /* Bypass due to SSL. */
     LOCAL_BYPASS_RULES,       /* Bypass due to client-side bypass rules. */
     MANAGED_PROXY_CONFIG,     /* Bypass due to managed config. */
     AUDIO_VIDEO,              /* Audio/Video bypass. */
     TRIGGERING_REQUEST,       /* Triggering request bypass. */
     NETWORK_ERROR,            /* Network error. */
     BYPASSED_BYTES_TYPE_MAX   /* This must always be last.*/
   };
 
+  // Given |data_reduction_proxy_enabled|, a |request|, and the
+  // |data_reduction_proxy_config| records the number of bypassed bytes for that
+  // |request| into UMAs based on bypass type. |data_reduction_proxy_enabled|
+  // tells us the state of the kDataReductionProxyEnabled preference.
+  void RecordBypassedBytesHistograms(
+      net::URLRequest* request,
+      const BooleanPrefMember& data_reduction_proxy_enabled,
+      const net::ProxyConfig& data_reduction_proxy_config);
+
+  // Records UMA of the number of response bytes of responses that are expected
+  // to have the data reduction proxy via header, but where the data reduction
+  // proxy via header is not present.
+  void RecordMissingViaHeaderBytes(net::URLRequest* request);
+
   // NetworkChangeNotifier::NetworkChangeObserver:
   virtual void OnNetworkChanged(
       net::NetworkChangeNotifier::ConnectionType type) OVERRIDE;
 
   // Counts requests that went through the data reduction proxy and counts
   // requests that were eligible to go through the proxy.
   void IncrementRequestCounts(bool actual);
   void ClearRequestCounts();
 
   // Checks if the availability status of the data reduction proxy has changed,
@@ skipping 39 matching lines @@
 
   // Called when the unavailability status has changed. Runs on the UI thread.
   base::Callback<void(bool)> unavailable_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DataReductionProxyUsageStats);
 };
 
 }  // namespace data_reduction_proxy
 
 #endif  // COMPONENTS_DATA_REDUCTION_PROXY_BROWSER_DATA_REDUCTION_PROXY_USAGE_STATS_H_