Record the data use by content type

components/data_use_measurement/core/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/core/data_use_measurement.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
@@ skipping 90 matching lines @@
         domain_reliability::DomainReliabilityUploader::
             OriginatedFromDomainReliability(*request)) {
       // Detect if the request originated from DomainReliability.
       // DataUseUserData::AttachToFetcher() cannot be called from domain
       // reliability, since it sets userdata on URLFetcher for its purposes.
       service_name = DataUseUserData::ServiceName::NOT_TAGGED;
     }
 
     data_use_user_data = new DataUseUserData(service_name, CurrentAppState());
     request->SetUserData(DataUseUserData::kUserDataKey, data_use_user_data);
+  } else {
+    data_use_user_data->set_app_state(CurrentAppState());
   }
 }
 
 void DataUseMeasurement::OnBeforeRedirect(const net::URLRequest& request,
                                           const GURL& new_location) {
   // Recording data use of request on redirects.
   // TODO(rajendrant): May not be needed when http://crbug/651957 is fixed.
   UpdateDataUsePrefs(request);
   ReportServicesMessageSizeUMA(request);
 }
 
+void DataUseMeasurement::OnHeadersReceived(
+    net::URLRequest* request,
+    const net::HttpResponseHeaders* response_headers) {
+  DataUseUserData* data_use_user_data = reinterpret_cast<DataUseUserData*>(
+      request->GetUserData(DataUseUserData::kUserDataKey));
+  if (data_use_user_data) {
+    data_use_user_data->set_content_type(
+        url_request_classifier_->GetContentType(*request, *response_headers));
+  }
+}
+
 void DataUseMeasurement::OnNetworkBytesReceived(const net::URLRequest& request,
                                                 int64_t bytes_received) {
   UMA_HISTOGRAM_COUNTS("DataUse.BytesReceived.Delegate", bytes_received);
   ReportDataUseUMA(request, DOWNSTREAM, bytes_received);
 #if defined(OS_ANDROID)
   bytes_transferred_since_last_traffic_stats_query_ += bytes_received;
 #endif
 }
 
 void DataUseMeasurement::OnNetworkBytesSent(const net::URLRequest& request,
@@ skipping 57 matching lines @@
     if (no_reads_since_background_) {
       no_reads_since_background_ = false;
       IncrementLatencyHistogramByCount(
           is_user_traffic ? "DataUse.BackgroundToFirstDownstream.User"
                           : "DataUse.BackgroundToFirstDownstream.System",
           time_since_background, 1);
     }
   }
 #endif
 
+  bool is_tab_visible = false;
+
   if (is_user_traffic) {
     const DataUseRecorder* recorder = ascriber_->GetDataUseRecorder(request);
     if (recorder) {
+      is_tab_visible = recorder->is_visible();
       RecordTabStateHistogram(dir, new_app_state, recorder->is_visible(),
                               bytes);
     }
   }
+  if (attached_service_data && dir == DOWNSTREAM &&
+      new_app_state != DataUseUserData::UNKNOWN) {
+    RecordContentTypeHistogram(attached_service_data->content_type(),
+                               is_user_traffic, new_app_state, is_tab_visible,
+                               bytes);
+  }
 }
 
 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 140 matching lines @@
   if (app_state == DataUseUserData::BACKGROUND) {
     histogram_name.append("AppBackground");
   } else if (is_tab_visible) {
     histogram_name.append("AppForeground.TabForeground");
   } else {
     histogram_name.append("AppForeground.TabBackground");
   }
   RecordUMAHistogramCount(histogram_name, bytes);
 }
 
+void DataUseMeasurement::RecordContentTypeHistogram(
+    DataUseUserData::DataUseContentType content_type,
+    bool is_user_traffic,
+    DataUseUserData::AppState app_state,
+    bool is_tab_visible,
+    int64_t bytes) {
+  if (content_type == DataUseUserData::AUDIO) {
+    content_type = app_state != DataUseUserData::FOREGROUND
+                       ? DataUseUserData::AUDIO_APPBACKGROUND
+                       : (!is_tab_visible ? DataUseUserData::AUDIO_TABBACKGROUND
+                                          : DataUseUserData::AUDIO);
+  } else if (content_type == DataUseUserData::VIDEO) {
+    content_type = app_state != DataUseUserData::FOREGROUND
+                       ? DataUseUserData::VIDEO_APPBACKGROUND
+                       : (!is_tab_visible ? DataUseUserData::VIDEO_TABBACKGROUND
+                                          : DataUseUserData::VIDEO);
+  }
+  if (is_user_traffic) {
+    STATIC_HISTOGRAM_POINTER_BLOCK(

[Mark P, 2016/12/22 21:40:29]

Please use the standard UMA macro UMA_HISTOGRAM_ENUMERATION unless you have a
reason not to.  It doesn't appear you have a reason to avoid it here.

[Raj, 2016/12/22 23:14:37]

Added comments. UMA_HISTOGRAM_ENUMERATION cannot be used, since the histogram is
incremented 'byte' number of times.

+        "DataUse.ContentType.UserTraffic", AddCount(content_type, bytes),
+        base::LinearHistogram::FactoryGet(
+            "DataUse.ContentType.UserTraffic", 1, DataUseUserData::TYPE_MAX,
+            DataUseUserData::TYPE_MAX + 1,
+            base::HistogramBase::kUmaTargetedHistogramFlag));
+  } else {
+    STATIC_HISTOGRAM_POINTER_BLOCK(
+        "DataUse.ContentType.Services", AddCount(content_type, bytes),
+        base::LinearHistogram::FactoryGet(
+            "DataUse.ContentType.Services", 1, DataUseUserData::TYPE_MAX,
+            DataUseUserData::TYPE_MAX + 1,
+            base::HistogramBase::kUmaTargetedHistogramFlag));
+  }
+}
+
 }  // namespace data_use_measurement