Split the data use into foreground, background and unknown

components/data_use_measurement/content/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/content/data_use_measurement.h"
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
@@ skipping 20 matching lines @@
  public:
   DataUseMeasurementTest()
       : data_use_measurement_(
             base::Bind(&DataUseMeasurementTest::FakeDataUseforwarder,
                        base::Unretained(this))) {
     // During the test it is expected to not have cellular connection.
     DCHECK(!net::NetworkChangeNotifier::IsConnectionCellular(
         net::NetworkChangeNotifier::GetConnectionType()));
   }
 
-  // Sends a request and reports data use attaching either user data or service
-  // data based on |is_user_request|.
-  void SendRequest(bool is_user_request) {
+  // Creates a test request.
+  std::unique_ptr<net::URLRequest> CreateTestRequest(bool 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) {
       request->SetUserData(
           data_use_measurement::DataUseUserData::kUserDataKey,
           new data_use_measurement::DataUseUserData(
               data_use_measurement::DataUseUserData::SUGGESTIONS,
               data_use_measurement_.CurrentAppState()));
     } else {
       content::ResourceRequestInfo::AllocateForTesting(
           request.get(), content::RESOURCE_TYPE_MAIN_FRAME, nullptr, -2, -2, -2,
           true, false, true, true, false);
     }
 
     request->Start();
     base::RunLoop().RunUntilIdle();
+    return request;
+  }
 
+  // Sends a request and reports data use attaching either user data or service
+  // data based on |is_user_request|.
+  void SendRequest(bool is_user_request) {
+    std::unique_ptr<net::URLRequest> request =
+        CreateTestRequest(is_user_request);
+    data_use_measurement_.OnBeforeURLRequest(request.get());
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+    data_use_measurement_.OnNetworkBytesSent(*request, 100);
     data_use_measurement_.OnCompleted(*request, true);
   }
 
   // This function makes a user request and confirms that its effect is
   // reflected in proper histograms.
   void TestForAUserRequest(const std::string& target_dimension) {
     base::HistogramTester histogram_tester;
     SendRequest(true);
     histogram_tester.ExpectTotalCount("DataUse.TrafficSize.System.Downstream." +
                                           target_dimension + kConnectionType,
@@ skipping 23 matching lines @@
     histogram_tester.ExpectTotalCount(
         "DataUse.MessageSize.AllServices.Downstream." + target_dimension +
             kConnectionType,
         0);
   }
 
   DataUseMeasurement* data_use_measurement() { return &data_use_measurement_; }
 
   bool IsDataUseForwarderCalled() { return is_data_use_forwarder_called_; }
 
- private:
+ protected:
   void InitializeContext() {
     context_.reset(new net::TestURLRequestContext(true));
     socket_factory_.reset(new net::MockClientSocketFactory());
     context_->set_client_socket_factory(socket_factory_.get());
     context_->Init();
   }
 
   void FakeDataUseforwarder(const std::string& service_name,
                             int message_size,
                             bool is_celllular) {
@@ skipping 35 matching lines @@
   TestForAUserRequest("Background.");
 }
 #endif
 
 TEST_F(DataUseMeasurementTest, DataUseForwarderIsCalled) {
   EXPECT_FALSE(IsDataUseForwarderCalled());
   SendRequest(true);
   EXPECT_TRUE(IsDataUseForwarderCalled());
 }
 
+#if defined(OS_ANDROID)
+TEST_F(DataUseMeasurementTest, AppStateUnknown) {
+  base::HistogramTester histogram_tester;
+  std::unique_ptr<net::URLRequest> request = CreateTestRequest(false);
+  data_use_measurement_.OnBeforeURLRequest(request.get());
+
+  {
+    base::HistogramTester histogram_tester;
+    data_use_measurement()->OnApplicationStateChangeForTesting(
+        base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES);
+    data_use_measurement_.OnNetworkBytesSent(*request, 100);
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+    histogram_tester.ExpectTotalCount(
+        "DataUse.TrafficSize.User.Downstream.Foreground." + kConnectionType, 1);
+    histogram_tester.ExpectTotalCount(
+        "DataUse.TrafficSize.User.Upstream.Foreground." + kConnectionType, 1);
+  }
+
+  {
+    base::HistogramTester histogram_tester;
+    data_use_measurement()->OnApplicationStateChangeForTesting(
+        base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES);
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+    histogram_tester.ExpectTotalCount(
+        "DataUse.TrafficSize.User.Downstream.Unknown." + kConnectionType, 1);
+  }
+
+  {
+    base::HistogramTester histogram_tester;
+    data_use_measurement()->OnApplicationStateChangeForTesting(
+        base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES);
+    data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+    histogram_tester.ExpectTotalCount(
+        "DataUse.TrafficSize.User.Downstream.Background." + kConnectionType, 1);
+  }
+}
+#endif
+
 }  // namespace data_use_measurement