Record the data use by content type

components/data_use_measurement/core/data_use_measurement_unittest.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 <memory>
 #include <string>
 
 #include "base/macros.h"
@@ skipping 11 matching lines @@
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/application_status_listener.h"
 #endif
 
 namespace data_use_measurement {
 
-class UserRequestUserDataForTesting : public base::SupportsUserData::Data,
-                                      public URLRequestClassifier {
+class TestURLRequestClassifier : public base::SupportsUserData::Data,
+                                 public URLRequestClassifier {
  public:
   static const void* const kUserDataKey;
 
+  TestURLRequestClassifier() : content_type_(DataUseUserData::OTHER) {}
+
   bool IsUserRequest(const net::URLRequest& request) const override {
     return request.GetUserData(kUserDataKey) != nullptr;
   }
 
   static void MarkAsUserRequest(net::URLRequest* request) {
-    request->SetUserData(kUserDataKey, new UserRequestUserDataForTesting());
+    request->SetUserData(kUserDataKey, new TestURLRequestClassifier());
   }
+
+  DataUseUserData::DataUseContentType GetContentType(
+      const net::URLRequest& request,
+      const net::HttpResponseHeaders& response_headers) const override {
+    return content_type_;
+  }
+
+  void set_content_type(DataUseUserData::DataUseContentType content_type) {
+    content_type_ = content_type;
+  }
+
+ private:
+  DataUseUserData::DataUseContentType content_type_;
 };
 
 class TestDataUseAscriber : public DataUseAscriber {
  public:
   TestDataUseAscriber() {}
 
   DataUseRecorder* GetOrCreateDataUseRecorder(
       net::URLRequest* request) override {
     return &recorder_;
   }
 
   DataUseRecorder* GetDataUseRecorder(const net::URLRequest& request) override {
     return &recorder_;
   }
 
   std::unique_ptr<URLRequestClassifier> CreateURLRequestClassifier()
       const override {
     return nullptr;
   }
 
   void SetTabVisibility(bool visible) { recorder_.set_is_visible(visible); }
 
  private:
   DataUseRecorder recorder_;
 };
 
 // The more usual initialization of kUserDataKey would be along the lines of
-//     const void* const UserRequestUserDataForTesting::kUserDataKey =
-//         &UserRequestUserDataForTesting::kUserDataKey;
+//     const void* const TestURLRequestClassifier::kUserDataKey =
+//         &TestURLRequestClassifier::kUserDataKey;
 // but lld's identical constant folding then folds that with
 // DataUseUserData::kUserDataKey which is initialized like that as well, and
-// then UserRequestUserDataForTesting::IsUserRequest() starts classifying
-// service requests as user requests.  To work around this, make
-// UserRequestUserDataForTesting::kUserDataKey point to an arbitrary integer
+// then TestURLRequestClassifier::IsUserRequest() starts classifying service
+// requests as user requests.  To work around this, make
+// TestURLRequestClassifier::kUserDataKey point to an arbitrary integer
 // instead.
 // TODO(thakis): If we changed lld to only ICF over code and not over data,
 // we could undo this again.
 const int kICFBuster = 12345634;
 
 // static
-const void* const UserRequestUserDataForTesting::kUserDataKey = &kICFBuster;
+const void* const TestURLRequestClassifier::kUserDataKey = &kICFBuster;
 
 class DataUseMeasurementTest : public testing::Test {
  public:
   DataUseMeasurementTest()
-      : data_use_measurement_(
-            base::MakeUnique<UserRequestUserDataForTesting>(),
+      : url_request_classifier_(new TestURLRequestClassifier()),
+        data_use_measurement_(
+            std::unique_ptr<URLRequestClassifier>(url_request_classifier_),
             base::Bind(&DataUseMeasurementTest::FakeDataUseforwarder,
                        base::Unretained(this)),
             &ascriber_) {
     // During the test it is expected to not have cellular connection.
     DCHECK(!net::NetworkChangeNotifier::IsConnectionCellular(
         net::NetworkChangeNotifier::GetConnectionType()));
   }
 
   // Creates a test request.
   enum RequestKind { kServiceRequest, kUserRequest };
   std::unique_ptr<net::URLRequest> CreateTestRequest(
       RequestKind is_user_request) {
     net::TestDelegate test_delegate;
     InitializeContext();
     net::MockRead reads[] = {net::MockRead("HTTP/1.1 200 OK\r\n"
                                            "Content-Length: 12\r\n\r\n"),
                              net::MockRead("Test Content")};
     net::StaticSocketDataProvider socket_data(reads, arraysize(reads), nullptr,
                                               0);
     socket_factory_->AddSocketDataProvider(&socket_data);
 
     std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
         GURL("http://foo.com"), net::DEFAULT_PRIORITY, &test_delegate));
     if (is_user_request == kUserRequest) {
-      UserRequestUserDataForTesting::MarkAsUserRequest(request.get());
+      TestURLRequestClassifier::MarkAsUserRequest(request.get());
     } else {
       request->SetUserData(
           data_use_measurement::DataUseUserData::kUserDataKey,
           new data_use_measurement::DataUseUserData(
               data_use_measurement::DataUseUserData::SUGGESTIONS,
               data_use_measurement_.CurrentAppState()));
     }
 
     request->Start();
     base::RunLoop().RunUntilIdle();
@@ skipping 61 matching lines @@
 
   void FakeDataUseforwarder(const std::string& service_name,
                             int message_size,
                             bool is_celllular) {
     is_data_use_forwarder_called_ = true;
   }
 
   base::MessageLoopForIO loop_;
 
   TestDataUseAscriber ascriber_;
+  TestURLRequestClassifier* url_request_classifier_;
   DataUseMeasurement data_use_measurement_;
 
   std::unique_ptr<net::MockClientSocketFactory> socket_factory_;
   std::unique_ptr<net::TestURLRequestContext> context_;
   const std::string kConnectionType = "NotCellular";
   bool is_data_use_forwarder_called_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(DataUseMeasurementTest);
 };
 
@@ skipping 200 matching lines @@
   // access changes to BACKGROUND.
   data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
   data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
   data_use_measurement_.OnNetworkBytesSent(*request, 100);
 
   histogram_tester.ExpectTotalCount(
       "DataUse.AppTabState.Upstream.AppBackground", 1);
   histogram_tester.ExpectTotalCount(
       "DataUse.AppTabState.Downstream.AppBackground", 1);
 }
+
+TEST_F(DataUseMeasurementTest, ContentType) {
+  net::HttpResponseHeaders response_headers(std::string());
+  {
+    base::HistogramTester histogram_tester;
+    std::unique_ptr<net::URLRequest> request = CreateTestRequest(kUserRequest);
+    data_use_measurement_.OnBeforeURLRequest(request.get());
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+    histogram_tester.ExpectUniqueSample("DataUse.ContentType.UserTraffic",
+                                        DataUseUserData::OTHER, 1000);
+  }
+
+  {
+    base::HistogramTester histogram_tester;
+    std::unique_ptr<net::URLRequest> request =
+        CreateTestRequest(kServiceRequest);
+    data_use_measurement_.OnBeforeURLRequest(request.get());
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+    histogram_tester.ExpectUniqueSample("DataUse.ContentType.Services",
+                                        DataUseUserData::OTHER, 1000);
+  }
+
+  // Video request in foreground.
+  {
+    base::HistogramTester histogram_tester;
+    std::unique_ptr<net::URLRequest> request = CreateTestRequest(kUserRequest);
+
+    ascriber_.SetTabVisibility(true);
+    url_request_classifier_->set_content_type(DataUseUserData::VIDEO);
+    data_use_measurement_.OnBeforeURLRequest(request.get());
+    data_use_measurement_.OnHeadersReceived(request.get(), nullptr);
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+
+    histogram_tester.ExpectUniqueSample("DataUse.ContentType.UserTraffic",
+                                        DataUseUserData::VIDEO, 1000);
+  }
+
+  // Audio request from background tab.
+  {
+    base::HistogramTester histogram_tester;
+    std::unique_ptr<net::URLRequest> request = CreateTestRequest(kUserRequest);
+    ascriber_.SetTabVisibility(false);
+    url_request_classifier_->set_content_type(DataUseUserData::AUDIO);
+    data_use_measurement_.OnBeforeURLRequest(request.get());
+    data_use_measurement_.OnHeadersReceived(request.get(), nullptr);
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+
+    histogram_tester.ExpectUniqueSample("DataUse.ContentType.UserTraffic",
+                                        DataUseUserData::AUDIO_TABBACKGROUND,
+                                        1000);
+  }
+
+  // Video request from background app.
+  {
+    base::HistogramTester histogram_tester;
+    std::unique_ptr<net::URLRequest> request = CreateTestRequest(kUserRequest);
+    url_request_classifier_->set_content_type(DataUseUserData::VIDEO);
+    data_use_measurement()->OnApplicationStateChangeForTesting(
+        base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES);
+    ascriber_.SetTabVisibility(false);
+    data_use_measurement_.OnBeforeURLRequest(request.get());
+    data_use_measurement_.OnHeadersReceived(request.get(), nullptr);
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+
+    histogram_tester.ExpectUniqueSample("DataUse.ContentType.UserTraffic",
+                                        DataUseUserData::VIDEO_APPBACKGROUND,
+                                        1000);
+  }
+}
+
 #endif
 
 }  // namespace data_use_measurement