Record the data use by content type

components/data_use_measurement/core/data_use_network_delegate_unittest.cc

 // Copyright 2016 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_network_delegate.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "components/data_use_measurement/core/data_use_ascriber.h"
 #include "components/data_use_measurement/core/url_request_classifier.h"
 #include "components/metrics/data_use_tracker.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace data_use_measurement {
 
 namespace {
 
-class UserRequestUserDataForTesting : public base::SupportsUserData::Data,
-                                      public URLRequestClassifier {
+class TestURLRequestClassifier : public base::SupportsUserData::Data,
+                                 public URLRequestClassifier {
  public:
   static const void* const kUserDataKey;
 
   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 DataUseUserData::OTHER;
   }
 };
 
 class TestDataUseAscriber : public DataUseAscriber {
  public:
   TestDataUseAscriber() {}
 
   DataUseRecorder* GetOrCreateDataUseRecorder(
       net::URLRequest* request) override {
     return nullptr;
   }
   DataUseRecorder* GetDataUseRecorder(const net::URLRequest& request) override {
     return nullptr;
   }
 
   std::unique_ptr<URLRequestClassifier> CreateURLRequestClassifier()
       const override {
     return nullptr;
   }
 };
 
 // static
-const void* const UserRequestUserDataForTesting::kUserDataKey =
-    &UserRequestUserDataForTesting::kUserDataKey;
+const void* const TestURLRequestClassifier::kUserDataKey =
+    &TestURLRequestClassifier::kUserDataKey;
 
 // This function requests a URL, and makes it return a known response. If
 // |from_user| is true, it attaches a ResourceRequestInfo to the URLRequest,
 // because requests from users have this info. If |from_user| is false, the
 // request is presumed to be from a service, and the service name is set in the
 // request's user data. (As an example suggestions service tag is attached). if
 // |redirect| is true, it adds necessary socket data to have it follow redirect
 // before getting the final response.
 std::unique_ptr<net::URLRequest> RequestURL(
     net::URLRequestContext* context,
@@ skipping 16 matching lines @@
   };
   net::StaticSocketDataProvider response_socket_data_provider(
       response_mock_reads, arraysize(response_mock_reads), nullptr, 0);
   socket_factory->AddSocketDataProvider(&response_socket_data_provider);
   net::TestDelegate test_delegate;
   test_delegate.set_quit_on_complete(true);
   std::unique_ptr<net::URLRequest> request(context->CreateRequest(
       GURL("http://example.com"), net::DEFAULT_PRIORITY, &test_delegate));
 
   if (from_user) {
-    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::DataUseUserData::FOREGROUND));
   }
   request->Start();
   base::RunLoop().RunUntilIdle();
   return request;
 }
 
 class DataUseNetworkDelegateTest : public testing::Test {
  public:
   DataUseNetworkDelegateTest()
       : context_(true),
-        data_use_network_delegate_(
-            base::MakeUnique<net::TestNetworkDelegate>(),
-            &test_data_use_ascriber_,
-            base::MakeUnique<UserRequestUserDataForTesting>(),
-            metrics::UpdateUsagePrefCallbackType()) {
+        data_use_network_delegate_(base::MakeUnique<net::TestNetworkDelegate>(),
+                                   &test_data_use_ascriber_,
+                                   base::MakeUnique<TestURLRequestClassifier>(),
+                                   metrics::UpdateUsagePrefCallbackType()) {
     context_.set_client_socket_factory(&mock_socket_factory_);
     context_.set_network_delegate(&data_use_network_delegate_);
     context_.Init();
   }
 
   net::TestURLRequestContext* context() { return &context_; }
   net::MockClientSocketFactory* socket_factory() {
     return &mock_socket_factory_;
   }
 
@@ skipping 101 matching lines @@
   histogram_tester.ExpectTotalCount(
       "DataUse.TrafficSize.System.Downstream.Foreground.NotCellular", 0);
   histogram_tester.ExpectTotalCount(
       "DataUse.TrafficSize.System.Upstream.Foreground.NotCellular", 0);
   histogram_tester.ExpectTotalCount("DataUse.MessageSize.Suggestions", 0);
 }
 
 }  // namespace
 
 }  // namespace data_use_measurement