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),
+      bytes_transferred_since_last_traffic_stats_query_(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);
+#if defined(OS_ANDROID)
+  bytes_transferred_since_last_traffic_stats_query_ += bytes_received;
+  MaybeRecordNetworkBytesOS();
+#endif
+}
+
+void DataUseMeasurement::OnNetworkBytesSent(const net::URLRequest& request,
+                                            int64_t bytes_sent) {
+  UMA_HISTOGRAM_COUNTS("DataUse.BytesSent.Delegate", bytes_sent);
+#if defined(OS_ANDROID)
+  bytes_transferred_since_last_traffic_stats_query_ += bytes_sent;
+  MaybeRecordNetworkBytesOS();
+#endif
+}
+
 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 77 matching lines @@
   return base::StringPrintf(
       "%s.%s.%s.%s", prefix, dir == UPSTREAM ? "Upstream" : "Downstream",
       app_state == BACKGROUND ? "Background" : "Foreground",
       is_connection_cellular ? "Cellular" : "NotCellular");
 }
 
 #if defined(OS_ANDROID)
 void DataUseMeasurement::OnApplicationStateChange(
     base::android::ApplicationState application_state) {
   app_state_ = application_state;
+  if (app_state_ != base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES)
+    MaybeRecordNetworkBytesOS();
+}
+
+void DataUseMeasurement::MaybeRecordNetworkBytesOS() {
+  // Minimum number of bytes that should be reported by the network delegate
+  // before Android's TrafficStats API is queried (if Chrome is not in
+  // background). This reduces the overhead of repeatedly calling the API.

[sclittle, 2016/09/20 20:54:13]

I'm not sure 10k is much different here. If the user's on a fast connection then
this could be equivalent to calling into TrafficStats on every response chunk.

An alternative could be to have a timer here to call into traffic stats only
every so often.

An even easier approach might be to just call the TrafficStats-querying code
from OnComplete in the network delegate, since you're not too concerned with
timing anyways here.

[tbansal1, 2016/09/21 17:38:42]

Done.

+  static const int64_t kMaxDelegateBytes = 10000;

[sclittle, 2016/09/20 20:54:13]

nit: Should this be called kMinDelegateBytes, to match the comment above?

[tbansal1, 2016/09/21 17:38:42]

Obsolete.

+  if (bytes_transferred_since_last_traffic_stats_query_ < kMaxDelegateBytes &&
+      CurrentAppState() == FOREGROUND) {
+    return;
+  }
+  bytes_transferred_since_last_traffic_stats_query_ = 0;
+  int64_t bytes = 0;
+  // Query Android traffic stats directly instead of registering with the
+  // DataUseAggregator since the latter does not provide notifications for
+  // the incognito traffic.
+  if (net::android::traffic_stats::GetCurrentUidRxBytes(&bytes)) {
+    if (rx_bytes_os_ != 0) {
+      DCHECK_GE(bytes, rx_bytes_os_);
+      UMA_HISTOGRAM_COUNTS("DataUse.BytesReceived.OS", bytes - rx_bytes_os_);
+    }
+    rx_bytes_os_ = bytes;
+  }
+
+  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
 
 void DataUseMeasurement::ReportDataUsageServices(
     DataUseUserData::ServiceName service,
     TrafficDirection dir,
     bool is_connection_cellular,
     int64_t message_size) const {
   RecordUMAHistogramCount(
       "DataUse.MessageSize." + DataUseUserData::GetServiceNameAsString(service),
       message_size);
   if (message_size > 0) {
     IncreaseSparseHistogramByValue(
         GetHistogramName("DataUse.MessageSize.AllServices", dir,
                          is_connection_cellular),
         service, message_size);
   }
 }
 
 }  // namespace data_use_measurement