Start recording background video watch time.

media/blink/watch_time_reporter_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 <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/run_loop.h"
 #include "base/test/test_message_loop.h"
 #include "media/base/mock_media_log.h"
 #include "media/blink/watch_time_reporter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 constexpr gfx::Size kSizeJustRight = gfx::Size(201, 201);
 
 #define EXPECT_WATCH_TIME(key, value)                                      \
   do {                                                                     \
     EXPECT_CALL(                                                           \
         *media_log_,                                                       \
         OnWatchTimeUpdate(has_video_ ? MediaLog::kWatchTimeAudioVideo##key \
                                      : MediaLog::kWatchTimeAudio##key,     \
                           value))                                          \
         .RetiresOnSaturation();                                            \
   } while (0)
 
+#define EXPECT_BACKGROUND_WATCH_TIME(key, value)                           \
+  do {                                                                     \
+    DCHECK(has_video_);                                                    \
+    EXPECT_CALL(*media_log_,                                               \
+                OnWatchTimeUpdate(                                         \
+                    MediaLog::kWatchTimeAudioVideoBackground##key, value)) \
+        .RetiresOnSaturation();                                            \
+  } while (0)
+
 #define EXPECT_WATCH_TIME_FINALIZED() \
   EXPECT_CALL(*media_log_, OnWatchTimeFinalized()).RetiresOnSaturation();
 
 #define EXPECT_POWER_WATCH_TIME_FINALIZED() \
   EXPECT_CALL(*media_log_, OnPowerWatchTimeFinalized()).RetiresOnSaturation();
 
 class WatchTimeReporterTest : public testing::TestWithParam<bool> {
  public:
   WatchTimeReporterTest()
       : has_video_(GetParam()),
@@ skipping 93 matching lines @@
     kStartOnBattery = 16,
 
     // Indicates an extra start event may be generated during test execution.
     kFinalizeInterleavedStartEvent = 32,
   };
 
   template <int TestFlags = 0, typename HysteresisTestCallback>
   void RunHysteresisTest(HysteresisTestCallback test_callback_func) {
     Initialize(true, false, false, kSizeJustRight);
 
+    // Disable background reporting for the hysteresis tests.
+    wtr_->background_reporter_.reset();
+
     // Setup all current time expectations first since they need to use the
     // InSequence macro for ease of use, but we don't want the watch time
     // expectations to be in sequence (or expectations would depend on sorted
     // order of histogram names).
     constexpr base::TimeDelta kWatchTime1 = base::TimeDelta::FromSeconds(10);
     constexpr base::TimeDelta kWatchTime2 = base::TimeDelta::FromSeconds(12);
     constexpr base::TimeDelta kWatchTime3 = base::TimeDelta::FromSeconds(15);
     constexpr base::TimeDelta kWatchTime4 = base::TimeDelta::FromSeconds(30);
     {
       testing::InSequence s;
@@ skipping 157 matching lines @@
   EXPECT_WATCH_TIME(Ac, kWatchTimeLate);
   EXPECT_WATCH_TIME(All, kWatchTimeLate);
   EXPECT_WATCH_TIME(Eme, kWatchTimeLate);
   EXPECT_WATCH_TIME(Mse, kWatchTimeLate);
   CycleReportingTimer();
 }
 
 // Tests that basic reporting for the all category works.
 TEST_P(WatchTimeReporterTest, WatchTimeReporterShownHidden) {
   constexpr base::TimeDelta kWatchTimeEarly = base::TimeDelta::FromSeconds(8);
-  constexpr base::TimeDelta kWatchTimeLate = base::TimeDelta::FromSeconds(10);
+  constexpr base::TimeDelta kWatchTimeLate = base::TimeDelta::FromSeconds(25);
   EXPECT_CALL(*this, GetCurrentMediaTime())
       .WillOnce(testing::Return(base::TimeDelta()))
       .WillOnce(testing::Return(kWatchTimeEarly))
+      .WillOnce(testing::Return(kWatchTimeEarly))
       .WillRepeatedly(testing::Return(kWatchTimeLate));
   Initialize(true, true, true, kSizeJustRight);
   wtr_->OnPlaying();
   EXPECT_TRUE(IsMonitoring());
 
   // If we have video, this will halt watch time collection, if only audio it
-  // will do nothing. Consume the expectation if audio only.
+  // will do nothing. Consume the expectations if audio only.
   wtr_->OnHidden();
-  if (!has_video_)
+  if (!has_video_) {
     GetCurrentMediaTime();
+    GetCurrentMediaTime();
+  } else {
+    const base::TimeDelta kExpectedWatchTime = kWatchTimeLate - kWatchTimeEarly;
+    EXPECT_BACKGROUND_WATCH_TIME(Ac, kExpectedWatchTime);
+    EXPECT_BACKGROUND_WATCH_TIME(All, kExpectedWatchTime);
+    EXPECT_BACKGROUND_WATCH_TIME(Eme, kExpectedWatchTime);
+    EXPECT_BACKGROUND_WATCH_TIME(Mse, kExpectedWatchTime);
+    EXPECT_WATCH_TIME_FINALIZED();
+  }
 
   const base::TimeDelta kExpectedWatchTime =
       has_video_ ? kWatchTimeEarly : kWatchTimeLate;
   EXPECT_WATCH_TIME(Ac, kExpectedWatchTime);
   EXPECT_WATCH_TIME(All, kExpectedWatchTime);
   EXPECT_WATCH_TIME(Eme, kExpectedWatchTime);
   EXPECT_WATCH_TIME(Mse, kExpectedWatchTime);
   EXPECT_WATCH_TIME_FINALIZED();
   wtr_.reset();
 }
@@ skipping 260 matching lines @@
           });
     }
   }
 }
 
 INSTANTIATE_TEST_CASE_P(WatchTimeReporterTest,
                         WatchTimeReporterTest,
                         testing::Values(true, false));
 
 }  // namespace media