Start recording background video watch time.

content/browser/media/media_internals_unittest.cc

Index: content/browser/media/media_internals_unittest.cc
diff --git a/content/browser/media/media_internals_unittest.cc b/content/browser/media/media_internals_unittest.cc
index f5edac520882387d2d88a0774cd0ef79724936f7..643695f8ac1fa3139f1694ead6238125c0234913 100644
--- a/content/browser/media/media_internals_unittest.cc
+++ b/content/browser/media/media_internals_unittest.cc
@@ -12,10 +12,16 @@
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/histogram_tester.h"
+#include "base/test/test_message_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/channel_layout.h"
+#include "media/base/media_log.h"
+#include "media/blink/watch_time_reporter.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 
@@ -29,8 +35,7 @@ const char kTestDeviceID[] = "test-device-id";
 class MediaInternalsTestBase {
  public:
   MediaInternalsTestBase()
-    : media_internals_(content::MediaInternals::GetInstance()) {
-  }
+      : media_internals_(content::MediaInternals::GetInstance()) {}
   virtual ~MediaInternalsTestBase() {}
 
  protected:
@@ -305,9 +310,133 @@ TEST_P(MediaInternalsAudioLogTest, AudioLogCreateClose) {
 }
 
 INSTANTIATE_TEST_CASE_P(
-    MediaInternalsAudioLogTest, MediaInternalsAudioLogTest, testing::Values(
-        media::AudioLogFactory::AUDIO_INPUT_CONTROLLER,
-        media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER,
-        media::AudioLogFactory::AUDIO_OUTPUT_STREAM));
+    MediaInternalsAudioLogTest,
+    MediaInternalsAudioLogTest,
+    testing::Values(media::AudioLogFactory::AUDIO_INPUT_CONTROLLER,
+                    media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER,
+                    media::AudioLogFactory::AUDIO_OUTPUT_STREAM));
+
+class DirectMediaLog : public media::MediaLog {
+ public:
+  explicit DirectMediaLog(int render_process_id)
+      : render_process_id_(render_process_id),
+        internals_(content::MediaInternals::GetInstance()) {}
+
+  void AddEvent(std::unique_ptr<media::MediaLogEvent> event) override {
+    std::vector<media::MediaLogEvent> events(1, *event);
+    internals_->OnMediaEvents(render_process_id_, events);
+  }
+
+ private:
+  ~DirectMediaLog() override {}
+
+  const int render_process_id_;
+  MediaInternals* const internals_;
+
+  DISALLOW_COPY_AND_ASSIGN(DirectMediaLog);
+};
+
+class MediaInternalsWatchTimeTest : public testing::Test,
+                                    public MediaInternalsTestBase {
+ public:
+  MediaInternalsWatchTimeTest()
+      : media_log_(new DirectMediaLog(0)),
+        watch_time_keys_(media::MediaLog::GetWatchTimeKeys()),
+        watch_time_power_keys_(media::MediaLog::GetWatchTimePowerKeys()) {}
+
+  void Initialize(bool has_audio,
+                  bool has_video,
+                  bool is_mse,
+                  bool is_encrypted) {
+    wtr_.reset(new media::WatchTimeReporter(
+        has_audio, has_video, is_mse, is_encrypted, true, media_log_,
+        gfx::Size(800, 600),
+        base::Bind(&MediaInternalsWatchTimeTest::GetCurrentMediaTime,
+                   base::Unretained(this))));
+    wtr_->set_reporting_interval_for_testing();
+  }
+
+  void CycleReportingTimer() {

[sandersd (OOO until July 31), 2017/03/31 20:51:06]

Seems like a misleading name since no timer is involved.

[DaleCurtis, 2017/04/01 00:51:35]

Renamed to CycleWatchTimeReporter().

+    base::RunLoop run_loop;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  void ExpectWatchTime(const std::vector<base::StringPiece>& keys,
+                       base::TimeDelta value) {
+    for (auto key : watch_time_keys_) {
+      auto it = std::find(keys.begin(), keys.end(), key);
+      if (it == keys.end()) {
+        histogram_tester_.ExpectTotalCount(key.as_string(), 0);
+      } else {
+        histogram_tester_.ExpectUniqueSample(key.as_string(),
+                                             value.InMilliseconds(), 1);
+      }
+    }
+  }
+
+  MOCK_METHOD0(GetCurrentMediaTime, base::TimeDelta());
+
+ protected:
+  scoped_refptr<DirectMediaLog> media_log_;
+  base::HistogramTester histogram_tester_;
+  std::unique_ptr<media::WatchTimeReporter> wtr_;
+  const base::flat_set<base::StringPiece> watch_time_keys_;
+  const base::flat_set<base::StringPiece> watch_time_power_keys_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaInternalsWatchTimeTest);
+};
+
+TEST_F(MediaInternalsWatchTimeTest, BasicAudio) {
+  constexpr base::TimeDelta kWatchTimeEarly = base::TimeDelta::FromSeconds(5);
+  constexpr base::TimeDelta kWatchTimeLate = base::TimeDelta::FromSeconds(10);
+  EXPECT_CALL(*this, GetCurrentMediaTime())
+      .WillOnce(testing::Return(base::TimeDelta()))
+      .WillOnce(testing::Return(kWatchTimeEarly))
+      .WillRepeatedly(testing::Return(kWatchTimeLate));
+  Initialize(true, false, true, true);
+  wtr_->OnPlaying();
+
+  // No log should have been generated yet since the message loop has not had
+  // any chance to pump.
+  CycleReportingTimer();
+  ExpectWatchTime({}, base::TimeDelta());
+
+  CycleReportingTimer();
+  wtr_.reset();
+
+  ExpectWatchTime(
+      {media::MediaLog::kWatchTimeAudioAll, media::MediaLog::kWatchTimeAudioMse,
+       media::MediaLog::kWatchTimeAudioEme, media::MediaLog::kWatchTimeAudioAc,
+       media::MediaLog::kWatchTimeAudioEmbeddedExperience},
+      kWatchTimeLate);
+}
+
+TEST_F(MediaInternalsWatchTimeTest, BasicVideo) {
+  constexpr base::TimeDelta kWatchTimeEarly = base::TimeDelta::FromSeconds(5);
+  constexpr base::TimeDelta kWatchTimeLate = base::TimeDelta::FromSeconds(10);
+  EXPECT_CALL(*this, GetCurrentMediaTime())
+      .WillOnce(testing::Return(base::TimeDelta()))
+      .WillOnce(testing::Return(kWatchTimeEarly))
+      .WillRepeatedly(testing::Return(kWatchTimeLate));
+  Initialize(true, true, false, true);
+  wtr_->OnPlaying();
+
+  // No log should have been generated yet since the message loop has not had
+  // any chance to pump.
+  CycleReportingTimer();
+  ExpectWatchTime({}, base::TimeDelta());
+
+  CycleReportingTimer();
+  wtr_.reset();
+
+  ExpectWatchTime({media::MediaLog::kWatchTimeAudioVideoAll,
+                   media::MediaLog::kWatchTimeAudioVideoSrc,
+                   media::MediaLog::kWatchTimeAudioVideoEme,
+                   media::MediaLog::kWatchTimeAudioVideoAc,
+                   media::MediaLog::kWatchTimeAudioVideoEmbeddedExperience},
+                  kWatchTimeLate);
+}
 
 }  // namespace content