Bypassed Bytes UMAs

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/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 "net/base/host_port_pair.h"
 #include "net/base/network_change_notifier.h"
+#include "net/proxy/proxy_service.h"
 
 namespace data_reduction_proxy {
 
 class DataReductionProxyUsageStats
     : public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
   // MessageLoopProxy instances are owned by io_thread. |params| outlives
   // this class instance.
   DataReductionProxyUsageStats(DataReductionProxyParams* params,
                                base::MessageLoopProxy* ui_thread_proxy,
                                base::MessageLoopProxy* io_thread_proxy);
   virtual ~DataReductionProxyUsageStats();
 
-  /**
-   * Callback intended to be called from |ChromeNetworkDelegate| when a
-   * request completes. This method is used to gather usage stats.
-   */
+  // 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);
 
-  /**
-   * Determines whether the data reduction proxy is unreachable.
-   * Returns true if data reduction proxy is unreachable.
-   */
+  // Determines whether the data reduction proxy is unreachable.
+  // Returns true if data reduction proxy is unreachable.
   bool isDataReductionProxyUnreachable();
 
+  // Records the last bypass reason to |bypass_type_| and sets
+  // |triggering_request_| to true.
+  void SetBypassType(net::ProxyService::DataReductionProxyBypassType type);
+
+  // Records the number of bypassed bytes for various bypass reasons into their
+  // respective UMAs.
+  void RecordBypassedBytesHistograms(
+      const int64 content_length,

[Alexei Svitkine (slow), 2014/07/15 18:20:08]

Nit: No need for const on primitives.

Also, is this param necessary or can this function simply get its value via
request->received_response_content_length()?

+      const net::URLRequest* request,

[Alexei Svitkine (slow), 2014/07/15 18:20:08]

If |request| can never be NULL, which seems to be the case here, pass by const
ref instead.

[megjablon, 2014/07/16 00:00:59]

Done.

+      const BooleanPrefMember* data_reduction_proxy_enabled);
+
  private:
+  enum DataReductionProxyBypassedBytesType {
+    // Not bypassed.
+    NOT_BYPASSED = 0,
+
+    // Bypass due to SSL.
+    SSL,
+
+    // Bypass due to client-side bypass rules.
+    LOCAL_BYPASS_RULES,
+
+    // Audio/Video bypass.
+    AUDIO_VIDEO,
+
+    // Triggering request bypass.
+    TRIGGERING_REQUEST,
+
+    // This must always be last.
+    BYPASSED_BYTES_TYPE_MAX
+  };
+
   DataReductionProxyParams* data_reduction_proxy_params_;
+  net::ProxyService::DataReductionProxyBypassType bypass_type_;
+  bool triggering_request_;
   base::MessageLoopProxy* ui_thread_proxy_;
   base::MessageLoopProxy* io_thread_proxy_;
 
   // The following 2 fields are used to determine if data reduction proxy is
   // unreachable. We keep a count of requests which should go through
   // data request proxy, as well as those which actually do. The proxy is
   // unreachable if no successful requests are made through it despite a
   // non-zero number of requests being eligible.
 
   // Count of requests which will be tried to be sent through data reduction
   // proxy. The count is only based on the config and not the bad proxy list.
   // Explicit bypasses are not part of this count. This is the desired behavior
   // since otherwise both counts would be identical.
   unsigned long eligible_num_requests_through_proxy_;
   // Count of successfull requests through data reduction proxy.
   unsigned long actual_num_requests_through_proxy_;
 
   // NetworkChangeNotifier::NetworkChangeObserver:
   virtual void OnNetworkChanged(
       net::NetworkChangeNotifier::ConnectionType type) OVERRIDE;
 
   void IncRequestCountsOnUiThread(bool actual);
   void ClearRequestCountsOnUiThread();
 
   base::ThreadChecker thread_checker_;
 
+  void RecordTriggeringRequestBypassedBytes(
+      net::ProxyService::DataReductionProxyBypassType bypass_type,
+      int64 content_length);
+  void RecordNetworkErrorBypassedBytes(const net::URLRequest* request,

[Alexei Svitkine (slow), 2014/07/15 18:20:08]

Nit: Pass by const ref?

[megjablon, 2014/07/16 00:00:59]

We moved this logic into RecordBypassedBytes, deleted.

+                                       int64 content_length);
+  void RecordBypassedBytes(
+      net::ProxyService::DataReductionProxyBypassType bypass_type,
+      DataReductionProxyBypassedBytesType bypassed_bytes_type,
+      int64 content_length);
+
   DISALLOW_COPY_AND_ASSIGN(DataReductionProxyUsageStats);
 };
 
 }  // namespace data_reduction_proxy
 
 #endif  // COMPONENTS_DATA_REDUCTION_PROXY_BROWSER_DATA_REDUCTION_PROXY_USAGE_STATS_H_