Record UMA for total data usage consumed by Chromium

components/data_use_measurement/content/data_use_measurement.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 "components/data_use_measurement/content/data_use_measurement.h"
 
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "content/public/browser/resource_request_info.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 
+#if defined(OS_ANDROID)
+#include "net/android/traffic_stats.h"
+#endif
+
 namespace data_use_measurement {
 
 namespace {
 
 // Records the occurrence of |sample| in |name| histogram. Conventional UMA
 // histograms are not used because the |name| is not static.
 void RecordUMAHistogramCount(const std::string& name, int64_t sample) {
   base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
       name,
       1,        // Minimum sample size in bytes.
@@ skipping 18 matching lines @@
 }  // namespace
 
 DataUseMeasurement::DataUseMeasurement(
     const metrics::UpdateUsagePrefCallbackType& metrics_data_use_forwarder)
     : metrics_data_use_forwarder_(metrics_data_use_forwarder)
 #if defined(OS_ANDROID)
       ,
       app_state_(base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES),
       app_listener_(new base::android::ApplicationStatusListener(
           base::Bind(&DataUseMeasurement::OnApplicationStateChange,
-                     base::Unretained(this))))
+                     base::Unretained(this)))),
+      rx_bytes_os_(0),
+      tx_bytes_os_(0)
 #endif
 {
 }
 
 DataUseMeasurement::~DataUseMeasurement(){};
 
 void DataUseMeasurement::OnBeforeRedirect(const net::URLRequest& request,
                                           const GURL& new_location) {
   // Recording data use of request on redirects.
   ReportDataUseUMA(request);
 }
 
+void DataUseMeasurement::OnNetworkBytesReceived(const net::URLRequest& request,
+                                                int64_t bytes_received) {
+  UMA_HISTOGRAM_COUNTS("DataUse.BytesReceived.Delegate", bytes_received);
+  RecordNetworkBytesReceivedOS();

[sclittle, 2016/09/14 21:28:13]

Is it OK for performance to call this so often? Note that OnNetworkBytesReceived
is called whenever a chunk of a response is received, so e.g. if a large
resource is being downloaded, OnNetworkBytesReceived could be called a bunch of
times.

[tbansal1, 2016/09/15 17:46:04]

Good catch. Fixed.

+}
+
+void DataUseMeasurement::OnNetworkBytesSent(const net::URLRequest& request,
+                                            int64_t bytes_sent) {
+  UMA_HISTOGRAM_COUNTS("DataUse.BytesSent.Delegate", bytes_sent);
+  RecordNetworkBytesSentOS();
+}
+
 void DataUseMeasurement::OnCompleted(const net::URLRequest& request,
                                      bool started) {
   // TODO(amohammadkhan): Verify that there is no double recording in data use
   // of redirected requests.
   ReportDataUseUMA(request);
 }
 
 void DataUseMeasurement::ReportDataUseUMA(
     const net::URLRequest& request) const {
   // Counts rely on URLRequest::GetTotalReceivedBytes() and
@@ skipping 96 matching lines @@
       "DataUse.MessageSize." + DataUseUserData::GetServiceNameAsString(service),
       message_size);
   if (message_size > 0) {
     IncreaseSparseHistogramByValue(
         GetHistogramName("DataUse.MessageSize.AllServices", dir,
                          is_connection_cellular),
         service, message_size);
   }
 }
 
+void DataUseMeasurement::RecordNetworkBytesReceivedOS() {

[sclittle, 2016/09/14 21:28:13]

Is there a timing issue here? E.g., suppose there's a whole bunch of data use
that happens at around the same time. Chrome would call into traffic stats
multiple times as it processes the received bytes, but traffic stats would
return the same value for each of these times. So all of those bytes would be
attributed to one of the chunks of Chrome bytes. Is this a problem?

[tbansal1, 2016/09/15 17:46:04]

No, because I am not attributing traffic stats bytes to Chrome bytes. They are
recorded in completely separate histograms.

+#if defined(OS_ANDROID)
+  int64_t bytes = 0;
+  if (net::android::traffic_stats::GetCurrentUidRxBytes(&bytes)) {
+    if (rx_bytes_os_ != 0) {
+      DCHECK_GE(bytes, rx_bytes_os_);

[sclittle, 2016/09/14 21:28:13]

Are you sure you want to crash if this condition doesn't hold?

[tbansal1, 2016/09/15 17:46:04]

Yes, android provides guarantee that this is always increasing.
https://developer.android.com/reference/android/net/TrafficStats.html#getTota...

So, it shouldn't trip on DCHECK.

+      UMA_HISTOGRAM_COUNTS("DataUse.BytesReceived.OS", bytes - rx_bytes_os_);
+    }
+    rx_bytes_os_ = bytes;
+  }
+#endif
+}
+
+void DataUseMeasurement::RecordNetworkBytesSentOS() {
+#if defined(OS_ANDROID)
+  int64_t bytes = 0;
+  if (net::android::traffic_stats::GetCurrentUidTxBytes(&bytes)) {
+    if (tx_bytes_os_ != 0) {
+      DCHECK_GE(bytes, tx_bytes_os_);
+      UMA_HISTOGRAM_COUNTS("DataUse.BytesSent.OS", bytes - tx_bytes_os_);
+    }
+    tx_bytes_os_ = bytes;
+  }
+#endif
+}
+
 }  // namespace data_use_measurement