Start recording background video watch time.

content/browser/media/media_internals_unittest.cc

 // Copyright (c) 2011 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 "content/browser/media/media_internals.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_reader.h"
 #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"
 
 namespace {
 const int kTestComponentID = 0;
 const char kTestDeviceID[] = "test-device-id";
 
 // This class encapsulates a MediaInternals reference. It also has some useful
 // methods to receive a callback, deserialize its associated data and expect
 // integer/string values.
 class MediaInternalsTestBase {
  public:
   MediaInternalsTestBase()
-    : media_internals_(content::MediaInternals::GetInstance()) {
-  }
+      : media_internals_(content::MediaInternals::GetInstance()) {}
   virtual ~MediaInternalsTestBase() {}
 
  protected:
   // Extracts and deserializes the JSON update data; merges into |update_data_|.
   void UpdateCallbackImpl(const base::string16& update) {
     // Each update string looks like "<JavaScript Function Name>({<JSON>});"
     // or for video capabilities: "<JavaScript Function Name>([{<JSON>}]);".
     // In the second case we will be able to extract the dictionary if it is the
     // only member of the list.
     // To use the JSON reader we need to strip out the JS function name and ().
@@ skipping 254 matching lines @@
   audio_log_->OnCreated(kTestComponentID, test_params_, kTestDeviceID);
   base::RunLoop().RunUntilIdle();
   ExpectStatus("created");
 
   audio_log_->OnClosed(kTestComponentID);
   base::RunLoop().RunUntilIdle();
   ExpectStatus("closed");
 }
 
 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