Support needed to measure user and service traffic in Chrome.

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 <string>
+
+#include "base/hash.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
+#include "base/strings/stringprintf.h"
+#include "components/data_use_measurement/content/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/url_request/url_request.h"
+
+#if defined(OS_ANDROID)
+#include "base/android/application_status_listener.h"
+#endif
+
+namespace data_use_measurement {
+
+// Records the occurrence of |sample| in |name| histogram. Conventional UMA
+// histograms are not used because the |name| is not static.
+void UMAHistogramRecorder(const std::string& name, int64_t sample) {

[sclittle, 2015/08/21 23:55:34]

Name this function more like a verb, e.g. RecordUMAHistogramCount or something

[amohammadkhan, 2015/08/24 23:18:47]

Done.

+  base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
+      name,
+      1,       // Minimum sample size.
+      5000000, // Maximum sample size. Should cover most of the requests.

[sclittle, 2015/08/21 23:55:34]

Why just 5 MB? Lots of fetches are more than 5 MB.

[amohammadkhan, 2015/08/24 23:18:48]

I agree with you. What do you think is the good number here? My main concern was
that I wasn't sure what would happen to histogram's precision if I make this
number very large as there is limited number of buckets?

[sclittle, 2015/08/24 23:59:34]

After discussing offline, it seems like the service requests are typically on
the order of kilobytes, so it should be fine to make this 1000000.

[amohammadkhan, 2015/08/26 22:28:41]

Done.

+      50,      // Bucket count.
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  histogram_pointer->Add(sample);                        \

[sclittle, 2015/08/21 23:55:34]

remove backslash

[amohammadkhan, 2015/08/24 23:18:47]

It is very odd that I don't see the backslash in my code(but I see it here too),
maybe it is because of an error happened during one of my cl uploads. It gave me
an error after cl upload and an erroneous cl was uploaded here. So I deleted it
and I uploaded another version after making some changes. Maybe one of my
commits is missing somehow! (Or maybe I have edited it later and I don't
remember, if it exists in my next CL upload, I'll try to fix it)

+}
+
+// This function increases the value of |sample| bucket in |name| sparse
+// histogram by |value|. Conventional UMA histograms are not used because the
+// |name| is not static.
+void SparseHistogramWithValue(const std::string& name, int64_t sample,

[sclittle, 2015/08/21 23:55:34]

Put these helper functions that aren't part of the class into an anonymous
namespace, also name this function like a verb

[amohammadkhan, 2015/08/24 23:18:47]

Done.

+                                            int64_t value)
+{
+    base::HistogramBase* histogram = base::SparseHistogram::FactoryGet(
+        name, base::HistogramBase::kUmaTargetedHistogramFlag);
+    histogram->AddCount(sample, value);
+}
+
+DataUseMeasurement::DataUseMeasurement()
+#if defined(OS_ANDROID)
+  :app_state_(base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES),
+   app_listener_ (base::Bind(&DataUseMeasurement::OnApplicationStateChange,
+                             base::Unretained(this)))
+#endif
+{}
+
+void DataUseMeasurement::ReportDataUseUMA(const net::URLRequest* request) {
+  bool user_traffic_flag = false;
+
+  const content::ResourceRequestInfo* info =
+      content::ResourceRequestInfo::ForRequest(request);
+  // Having |info| is the sign of a request for a web content from user. For now
+  // we could add a condition to check ProcessType in info is
+  // content::PROCESS_TYPE_RENDERER, but it won't be compatible with upcoming
+  // PlzNavigate architecture. So just existence of |info| is verified, and the
+  // current check should be compatible with upcoming changes in PlzNavigate.
+  if (info) {
+    user_traffic_flag = true;
+  }
+
+  // These number won't be the number of bytes handed to the kernel because
+  // session layer framing and compression is not being accounted for.
+  // TODO(amohammadkhan): Make these measured bytes more in line with number of
+  // bytes in lower levels.
+  int64_t request_body_bytes = 0;
+  int64_t request_header_bytes = 0;
+  int64_t total_upload_bytes = 0;
+  if (request->has_upload())
+    request_body_bytes = request->get_upload()->size();
+  net::HttpRequestHeaders request_headers;
+  if (request->GetFullRequestHeaders(&request_headers))
+    request_header_bytes = request_headers.ToString().length();
+  total_upload_bytes = request_body_bytes + request_header_bytes;
+  int64_t total_received_bytes = request->GetTotalReceivedBytes();
+
+  ReportDataUsageURLRequest(user_traffic_flag ? USER_TRAFFIC : SERVICE_TRAFFIC,
+                            UPLOAD, total_upload_bytes);
+  ReportDataUsageURLRequest(user_traffic_flag ? USER_TRAFFIC : SERVICE_TRAFFIC,
+                            DOWNLOAD, total_received_bytes);
+  DataUseUserData* sData = reinterpret_cast<DataUseUserData*>(

[sclittle, 2015/08/21 23:55:34]

Please be more descriptive than "sData", maybe "ServiceData" or something?

[amohammadkhan, 2015/08/24 23:18:47]

Done.

+      request->GetUserData(DataUseUserData::kUserDataKey));
+
+  if (sData) {
+    ReportDataUsage(sData->service_name(), UPLOAD, total_upload_bytes);
+    ReportDataUsage(sData->service_name(), DOWNLOAD, total_received_bytes);
+  }
+}
+
+#if defined(OS_ANDROID)
+void DataUseMeasurement::OnApplicationStateChange(
+    base::android::ApplicationState application_state) {
+  app_state_ = application_state;
+}
+#endif
+
+DataUseMeasurement::AppState DataUseMeasurement::CurrentAppState() {
+#if defined(OS_ANDROID)
+  if (app_state_ == base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES)

[sclittle, 2015/08/21 23:55:34]

Reorganize this function to be like

#if defined(OS_ANDROID)
if (app_state_ != base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES)
  return BACKGROUND;
#endif

return FOREGROUND;

or something such that there's only one "return FOREGROUND;".

[amohammadkhan, 2015/08/24 23:18:47]

Done.

+    return FOREGROUND;
+  else
+    return BACKGROUND;
+#endif
+  // If the OS is not Android, all the requests are considered Foreground.
+  return FOREGROUND;
+}
+
+DataUseMeasurement::ConnectionType DataUseMeasurement::CurrentConnectionType() {
+  if (net::NetworkChangeNotifier::IsConnectionCellular(
+          net::NetworkChangeNotifier::GetConnectionType())) {
+    return CELLULAR;
+  }
+  return NOT_CELLULAR;
+}
+
+std::string DataUseMeasurement::DimensionMaker(TrafficDirection dir) {
+  AppState app_state = CurrentAppState();
+  ConnectionType conn_type = CurrentConnectionType();
+  return base::StringPrintf(
+      ".%s.%s.%s", dir == UPLOAD ? "Upload" : "Download",
+      app_state == BACKGROUND ? "Background" : "Foreground",
+      conn_type == NOT_CELLULAR ? "NotCellular" : "Cellular");
+}
+
+void DataUseMeasurement::ReportDataUsage(const std::string& service_name,
+                                         TrafficDirection dir,
+                                         int64_t message_size) {
+  std::string serviceHistogramName = "DataUse.Service." + service_name;
+  std::string combinedHistogramName = "DataUse.Services" + DimensionMaker(dir);
+  UMAHistogramRecorder(serviceHistogramName, message_size);
+  if (message_size > 0) {
+    SparseHistogramWithValue(combinedHistogramName, base::Hash(service_name),

[sclittle, 2015/08/21 23:55:34]

Instead of hashing the service name, which is dependent on the implementation of
base::Hash and isn't guaranteed to be the same for all platforms/compliers, just
have an enum in data_use_user_data.h or something of all the data types.

[amohammadkhan, 2015/08/24 23:18:48]

Done.

+                             message_size);
+  }
+}
+
+void DataUseMeasurement::ReportDataUsageURLRequest(
+    ChromeTrafficType service_type,
+    TrafficDirection dir,
+    int64_t message_size) {
+  std::string histogram_name = base::StringPrintf(
+      "DataUse.%s%s", service_type == USER_TRAFFIC ? "User" : "NotUser",
+      DimensionMaker(dir).c_str());
+  UMAHistogramRecorder(histogram_name, message_size);
+}
+
+} // data_use_measurement namespace