Record the tab state during data use

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"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "build/build_config.h"
+#include "components/data_use_measurement/core/data_use_ascriber.h"
+#include "components/data_use_measurement/core/data_use_recorder.h"
 #include "components/data_use_measurement/core/url_request_classifier.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/request_priority.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"
 
 #if defined(OS_ANDROID)
 #include "base/android/application_status_listener.h"
 #endif
 
 namespace data_use_measurement {
 
 class UserRequestUserDataForTesting : 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());
   }
 };
 
+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;
 // 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
 // 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;
 
 class DataUseMeasurementTest : public testing::Test {
  public:
   DataUseMeasurementTest()
       : data_use_measurement_(
             base::MakeUnique<UserRequestUserDataForTesting>(),
             base::Bind(&DataUseMeasurementTest::FakeDataUseforwarder,
-                       base::Unretained(this))) {
+                       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;
@@ skipping 81 matching lines @@
     context_->Init();
   }
 
   void FakeDataUseforwarder(const std::string& service_name,
                             int message_size,
                             bool is_celllular) {
     is_data_use_forwarder_called_ = true;
   }
 
   base::MessageLoopForIO loop_;
+
+  TestDataUseAscriber ascriber_;
   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);
 };
 
 // This test function tests recording of data use information in UMA histogram
 // when packet is originated from user or services when the app is in the
@@ skipping 156 matching lines @@
     data_use_measurement_.OnNetworkBytesSent(*request, 100);
     data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
     data_use_measurement_.OnNetworkBytesSent(*request, 200);
     data_use_measurement_.OnNetworkBytesReceived(*request, 2000);
     histogram_tester.ExpectTotalCount(
         "DataUse.BackgroundToDataRecievedPerByte.User", 0);
     histogram_tester.ExpectTotalCount(
         "DataUse.BackgroundToFirstDownstream.User", 0);
   }
 }
+
+TEST_F(DataUseMeasurementTest, AppTabState) {
+  base::HistogramTester histogram_tester;
+  std::unique_ptr<net::URLRequest> request = CreateTestRequest(kUserRequest);
+
+  // App in foreground, Tab in background.
+  data_use_measurement_.OnBeforeURLRequest(request.get());
+  data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+  data_use_measurement_.OnNetworkBytesSent(*request, 100);
+
+  histogram_tester.ExpectTotalCount(
+      "DataUse.AppTabState.Upstream.AppForeground.TabBackground", 1);
+  histogram_tester.ExpectTotalCount(
+      "DataUse.AppTabState.Downstream.AppForeground.TabBackground", 1);
+
+  // App and Tab in foreground.
+  ascriber_.SetTabVisibility(true);
+  data_use_measurement_.OnBeforeURLRequest(request.get());
+  data_use_measurement_.OnNetworkBytesReceived(*request, 1000);
+  data_use_measurement_.OnNetworkBytesSent(*request, 100);
+
+  histogram_tester.ExpectTotalCount(
+      "DataUse.AppTabState.Upstream.AppForeground.TabForeground", 1);
+  histogram_tester.ExpectTotalCount(
+      "DataUse.AppTabState.Downstream.AppForeground.TabForeground", 1);
+
+  // App and Tab in background.
+  data_use_measurement()->OnApplicationStateChangeForTesting(
+      base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES);
+  ascriber_.SetTabVisibility(false);
+  data_use_measurement_.OnBeforeURLRequest(request.get());
+  // First network access changes the app state to UNKNOWN and the next nextwork
+  // 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);
+}
 #endif
 
 }  // namespace data_use_measurement