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 46 matching lines @@
   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(latency.InMilliseconds(), count);
 }
 #endif
 
+// Data use broken by content type. This enum must remain synchronized
+// with the enum of the same name in metrics/histograms/histograms.xml.
+enum DataUseContenType {

[RyanSturm, 2016/12/20 19:37:52]

nit: This seems duplicative. Maybe you could consolidate
DataUseUserData::ContentType and DataUseContenType.

If you change AUDIO_TABFOREGROUND to just AUDIO, you could return AUDIO from
GetContentType and in GetDataUseContentType you could leave it as AUDIO or
chagne it to AUDIO_TABBACKGROUND or AUDIO_APPBACKGROUND.

I'm sure there are other ways to consolidate them as well, but we are basically
defining two more content types on top of content::ResourceType.

If you think this way is clearer though, you can keep it, as it really costs the
user nothing.

[Raj, 2016/12/22 18:44:38]

Done.

+  MAIN_FRAME_HTML = 0,
+  NON_MAIN_FRAME_HTML,
+  CSS,
+  IMAGE,
+  JAVASCRIPT,
+  FONT,
+  AUDIO_APPBACKGROUND,
+  AUDIO_TABBACKGROUND,
+  AUDIO_TABFOREGROUND,
+  VIDEO_APPBACKGROUND,
+  VIDEO_TABBACKGROUND,
+  VIDEO_TABFOREGROUND,
+  OTHER,
+  TYPE_MAX,
+};
+
+DataUseContenType GetDataUseContentType(
+    DataUseUserData::ContentType content_type,
+    bool is_app_foreground,
+    bool is_tab_visible) {
+  switch (content_type) {
+    case DataUseUserData::ContentType::MAIN_FRAME_HTML:
+      return MAIN_FRAME_HTML;
+    case DataUseUserData::ContentType::NON_MAIN_FRAME_HTML:
+      return NON_MAIN_FRAME_HTML;
+    case DataUseUserData::ContentType::CSS:
+      return CSS;
+    case DataUseUserData::ContentType::IMAGE:
+      return IMAGE;
+    case DataUseUserData::ContentType::FONT:
+      return FONT;
+    case DataUseUserData::ContentType::AUDIO:
+      return !is_app_foreground
+                 ? AUDIO_APPBACKGROUND
+                 : (is_tab_visible ? AUDIO_TABFOREGROUND : AUDIO_TABBACKGROUND);
+    case DataUseUserData::ContentType::VIDEO:
+      return !is_app_foreground
+                 ? VIDEO_APPBACKGROUND
+                 : (is_tab_visible ? VIDEO_TABFOREGROUND : VIDEO_TABBACKGROUND);
+    case DataUseUserData::ContentType::OTHER:
+      return OTHER;
+    default:
+      NOTREACHED();
+  }
+  return OTHER;
+}
+
 }  // namespace
 
 DataUseMeasurement::DataUseMeasurement(
     std::unique_ptr<URLRequestClassifier> url_request_classifier,
     const metrics::UpdateUsagePrefCallbackType& metrics_data_use_forwarder,
     DataUseAscriber* ascriber)
     : url_request_classifier_(std::move(url_request_classifier)),
       metrics_data_use_forwarder_(metrics_data_use_forwarder),
       ascriber_(ascriber)
 #if defined(OS_ANDROID)
@@ skipping 35 matching lines @@
 }
 
 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(),

[RyanSturm, 2016/12/20 19:37:52]

nit: I just noticed now that these are sort of strange in the sense that a
URLRequest could start in background and finish in foreground and be marked as
foreground (or vice versa). Maybe you should open a bug to resolve that later if
you agree that it is an issue. 

[Raj, 2016/12/22 18:44:37]

Yes. That case is handled as follows.
These UMA are recorded on every NetworkBytes Sent/Received with the current
app/tab state. So if a URLRequest started in FG and moved to BG, part of the
bytes will be logged as FG and remaining as BG.

To explain in more detatil, data use is logged in 3 app states - FG, BG,
UNKNOWN. Unknown indicates FG->BG or BG->FG transitions.

[RyanSturm, 2016/12/22 20:00:42]

Awesome. Sounds like good enough granularity (FG->BG->FG in between calls to
NetworkBytesReceived is probably fine to treat as FG).

Can you add a comment with a similar explanation near if (old_app_state ==
CurrentAppState()) . When I first read that line, I misread it an missed the
subtlety of the tri-state machine.

+                               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::ContentType content_type,
+    bool is_user_traffic,
+    DataUseUserData::AppState app_state,
+    bool is_tab_visible,
+    int64_t bytes) {
+  DataUseContenType data_use_content_type = GetDataUseContentType(
+      content_type, app_state == DataUseUserData::FOREGROUND, is_tab_visible);
+  if (is_user_traffic) {
+    UMA_HISTOGRAM_ENUMERATION("DataUse.ContentType.UserTraffic",
+                              data_use_content_type,
+                              DataUseContenType::TYPE_MAX);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("DataUse.ContentType.Services",
+                              data_use_content_type,
+                              DataUseContenType::TYPE_MAX);
+  }
+}
+
 }  // namespace data_use_measurement