Record the time since Chromium is in background for background data use

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"
@@ skipping 29 matching lines @@
 // histogram by |value|. Conventional UMA histograms are not used because |name|
 // is not static.
 void IncreaseSparseHistogramByValue(const std::string& name,
                                     int64_t sample,
                                     int64_t value) {
   base::HistogramBase* histogram = base::SparseHistogram::FactoryGet(
       name, base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->AddCount(sample, value);
 }
 
+void IncreaseTimeHistogramByValue(const std::string& name,
+                                  const base::TimeDelta& sample,
+                                  int64_t value) {
+  base::HistogramBase* histogram_pointer = base::Histogram::FactoryTimeGet(
+      name,
+      base::TimeDelta::FromMilliseconds(1),  // Minimum sample
+      base::TimeDelta::FromHours(1),         // Maximum sample
+      50,                                    // Bucket count.
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  histogram_pointer->AddCount(sample.InMilliseconds(), value);
+}
+
 }  // 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)))),
       rx_bytes_os_(0),
       tx_bytes_os_(0),
-      bytes_transferred_since_last_traffic_stats_query_(0)
+      bytes_transferred_since_last_traffic_stats_query_(0),
+      first_read_after_background_(false)
 #endif
 {
 }
 
 DataUseMeasurement::~DataUseMeasurement(){};
 
 void DataUseMeasurement::OnBeforeURLRequest(net::URLRequest* request) {
   DataUseUserData* data_use_user_data = reinterpret_cast<DataUseUserData*>(
       request->GetUserData(DataUseUserData::kUserDataKey));
   if (!data_use_user_data) {
@@ skipping 31 matching lines @@
 void DataUseMeasurement::OnCompleted(const net::URLRequest& request,
                                      bool started) {
   // TODO(amohammadkhan): Verify that there is no double recording in data use
   // of redirected requests.
   UpdateDataUsePrefs(request);
 #if defined(OS_ANDROID)
   MaybeRecordNetworkBytesOS();
 #endif
 }
 
-void DataUseMeasurement::ReportDataUseUMA(
-    const net::URLRequest& request,
-    TrafficDirection dir,
-    int64_t bytes) const {
+void DataUseMeasurement::ReportDataUseUMA(const net::URLRequest& request,
+                                          TrafficDirection dir,
+                                          int64_t bytes) {
   bool is_user_traffic = IsUserInitiatedRequest(request);
   bool is_connection_cellular =
       net::NetworkChangeNotifier::IsConnectionCellular(
           net::NetworkChangeNotifier::GetConnectionType());
 
   DataUseUserData* attached_service_data = static_cast<DataUseUserData*>(
       request.GetUserData(DataUseUserData::kUserDataKey));
   DataUseUserData::ServiceName service_name = DataUseUserData::NOT_TAGGED;
   DataUseUserData::AppState old_app_state = DataUseUserData::FOREGROUND;
   DataUseUserData::AppState new_app_state = DataUseUserData::UNKNOWN;
@@ skipping 11 matching lines @@
   RecordUMAHistogramCount(
       GetHistogramName(is_user_traffic ? "DataUse.TrafficSize.User"
                                        : "DataUse.TrafficSize.System",
                        dir, new_app_state, is_connection_cellular),
       bytes);
 
   if (!is_user_traffic) {
     ReportDataUsageServices(service_name, dir, new_app_state,
                             is_connection_cellular, bytes);
   }
+#if defined(OS_ANDROID)
+  if (dir == DOWNSTREAM && CurrentAppState() == DataUseUserData::BACKGROUND) {
+    const base::TimeDelta time_since_background =
+        base::TimeTicks::Now() - last_app_background_time_;

[Not at Google. Contact bengr, 2016/10/14 23:10:57]

DCHECK(!last_app_background_time_.is_null());

[Raj, 2016/10/15 19:36:14]

Done.

+    IncreaseTimeHistogramByValue(
+        is_user_traffic ? "DataUse.BackgroundDownstreamBytes.User"
+                        : "DataUse.BackgroundDownstreamBytes.System",
+        time_since_background, bytes);
+    if (first_read_after_background_) {
+      first_read_after_background_ = false;
+      UMA_HISTOGRAM_LONG_TIMES(
+          is_user_traffic ? "DataUse.BackgroundDownstreamFirstRead.User"
+                          : "DataUse.BackgroundDownstreamFirstRead.System",
+          time_since_background);
+    }
+  }
+#endif
 }
 
 void DataUseMeasurement::UpdateDataUsePrefs(
     const net::URLRequest& request) const {
   bool is_connection_cellular =
       net::NetworkChangeNotifier::IsConnectionCellular(
           net::NetworkChangeNotifier::GetConnectionType());
 
   DataUseUserData* attached_service_data = static_cast<DataUseUserData*>(
       request.GetUserData(DataUseUserData::kUserDataKey));
@@ skipping 51 matching lines @@
           ? "Unknown"
           : (app_state == DataUseUserData::FOREGROUND ? "Foreground"
                                                       : "Background"),
       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)
+  if (app_state_ != base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES) {
+    last_app_background_time_ = base::TimeTicks::Now();
+    first_read_after_background_ = true;
     MaybeRecordNetworkBytesOS();
+  } else {
+    last_app_background_time_ = base::TimeTicks();
+  }
 }
 
 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.
   static const int64_t kMinDelegateBytes = 25000;
 
   if (bytes_transferred_since_last_traffic_stats_query_ < kMinDelegateBytes &&
       CurrentAppState() == DataUseUserData::FOREGROUND) {
@@ skipping 33 matching lines @@
       message_size);
   if (message_size > 0) {
     IncreaseSparseHistogramByValue(
         GetHistogramName("DataUse.MessageSize.AllServices", dir, app_state,
                          is_connection_cellular),
         service, message_size);
   }
 }
 
 }  // namespace data_use_measurement