Fix foregound vs background data use measurement

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 "components/data_use_measurement/core/data_use_user_data.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
 
@@ skipping 38 matching lines @@
                      base::Unretained(this)))),
       rx_bytes_os_(0),
       tx_bytes_os_(0),
       bytes_transferred_since_last_traffic_stats_query_(0)
 #endif
 {
 }
 
 DataUseMeasurement::~DataUseMeasurement(){};
 
+void DataUseMeasurement::OnBeforeURLRequest(net::URLRequest* request) {
+  DataUseUserData* data_use_user_data = reinterpret_cast<DataUseUserData*>(

[Not at Google. Contact bengr, 2016/09/26 18:40:19]

Is there a reason for reinterpret_cast here? Could this be a static_cast?

+      request->GetUserData(DataUseUserData::kUserDataKey));
+  if (!data_use_user_data) {
+    data_use_user_data = new DataUseUserData(
+        DataUseUserData::ServiceName::NOT_TAGGED, CurrentAppState());
+    request->SetUserData(DataUseUserData::kUserDataKey, data_use_user_data);
+  }
+}
+
 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)
@@ skipping 26 matching lines @@
   // network layer overhead, TLS overhead, and DNS.
   // TODO(amohammadkhan): Make these measured bytes more in line with number of
   // bytes in lower levels.
   int64_t total_upload_bytes = request.GetTotalSentBytes();
   int64_t total_received_bytes = request.GetTotalReceivedBytes();
   bool is_user_traffic = IsUserInitiatedRequest(request);
 
   bool is_connection_cellular =
       net::NetworkChangeNotifier::IsConnectionCellular(
           net::NetworkChangeNotifier::GetConnectionType());
-  RecordUMAHistogramCount(
-      GetHistogramName(is_user_traffic ? "DataUse.TrafficSize.User"
-                                       : "DataUse.TrafficSize.System",
-                       UPSTREAM, is_connection_cellular),
-      total_upload_bytes);
-  RecordUMAHistogramCount(
-      GetHistogramName(is_user_traffic ? "DataUse.TrafficSize.User"
-                                       : "DataUse.TrafficSize.System",
-                       DOWNSTREAM, is_connection_cellular),
-      total_received_bytes);
 
   DataUseUserData* attached_service_data = reinterpret_cast<DataUseUserData*>(
       request.GetUserData(DataUseUserData::kUserDataKey));
   DataUseUserData::ServiceName service_name =
       attached_service_data ? attached_service_data->service_name()
                             : DataUseUserData::NOT_TAGGED;
+  bool started_in_foreground =
+      attached_service_data
+          ? attached_service_data->app_state() == DataUseUserData::FOREGROUND
+          : CurrentAppState() == DataUseUserData::FOREGROUND;
+
+  RecordUMAHistogramCount(
+      GetHistogramName(is_user_traffic ? "DataUse.TrafficSize.User"
+                                       : "DataUse.TrafficSize.System",
+                       UPSTREAM, started_in_foreground, is_connection_cellular),
+      total_upload_bytes);
+  RecordUMAHistogramCount(
+      GetHistogramName(is_user_traffic ? "DataUse.TrafficSize.User"
+                                       : "DataUse.TrafficSize.System",
+                       DOWNSTREAM, started_in_foreground,
+                       is_connection_cellular),
+      total_received_bytes);
+
   if (!is_user_traffic) {
-    ReportDataUsageServices(service_name, UPSTREAM, is_connection_cellular,
-                            total_upload_bytes);
-    ReportDataUsageServices(service_name, DOWNSTREAM, is_connection_cellular,
-                            total_received_bytes);
+    ReportDataUsageServices(service_name, UPSTREAM, started_in_foreground,
+                            is_connection_cellular, total_upload_bytes);
+    ReportDataUsageServices(service_name, DOWNSTREAM, started_in_foreground,
+                            is_connection_cellular, total_received_bytes);
   }
 
   // Update data use prefs for cellular connections.
   if (!metrics_data_use_forwarder_.is_null()) {
     metrics_data_use_forwarder_.Run(
         attached_service_data->GetServiceNameAsString(service_name),
         total_upload_bytes + total_received_bytes, is_connection_cellular);
   }
 }
 
@@ skipping 11 matching lines @@
   return content::ResourceRequestInfo::ForRequest(&request) != nullptr;
 }
 
 #if defined(OS_ANDROID)
 void DataUseMeasurement::OnApplicationStateChangeForTesting(
     base::android::ApplicationState application_state) {
   app_state_ = application_state;
 }
 #endif
 
-DataUseMeasurement::AppState DataUseMeasurement::CurrentAppState() const {
+DataUseUserData::AppState DataUseMeasurement::CurrentAppState() const {
 #if defined(OS_ANDROID)
   if (app_state_ != base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES)
-    return BACKGROUND;
+    return DataUseUserData::BACKGROUND;
 #endif
   // If the OS is not Android, all the requests are considered Foreground.
-  return FOREGROUND;
+  return DataUseUserData::FOREGROUND;
 }
 
 std::string DataUseMeasurement::GetHistogramName(
     const char* prefix,
     TrafficDirection dir,
+    bool started_in_foreground,
     bool is_connection_cellular) const {
-  AppState app_state = CurrentAppState();
   return base::StringPrintf(
       "%s.%s.%s.%s", prefix, dir == UPSTREAM ? "Upstream" : "Downstream",
-      app_state == BACKGROUND ? "Background" : "Foreground",
+      started_in_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)
     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.
   static const int64_t kMinDelegateBytes = 25000;
 
   if (bytes_transferred_since_last_traffic_stats_query_ < kMinDelegateBytes &&
-      CurrentAppState() == FOREGROUND) {
+      CurrentAppState() == DataUseUserData::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 started_in_foreground,
     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),
+                         started_in_foreground, is_connection_cellular),
         service, message_size);
   }
 }
 
 }  // namespace data_use_measurement