BASELINE: Update Chromium to 65.0.3525.40

Also imports missing submodules

Change-Id: I36901b7c6a325cda3d2c10cedb2186c25af3b79b
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

1 files changed, 335 insertions, 65 deletions

diff --git a/chromium/media/mojo/services/watch_time_recorder_unittest.cc b/chromium/media/mojo/services/watch_time_recorder_unittest.cc
index 666b2246a2a..771d8e2c3fe 100644
--- a/chromium/media/mojo/services/watch_time_recorder_unittest.cc
+++ b/chromium/media/mojo/services/watch_time_recorder_unittest.cc
@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/hash.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
@@ -15,6 +16,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/ukm/test_ukm_recorder.h"
 #include "media/base/watch_time_keys.h"
+#include "media/mojo/services/media_metrics_provider.h"
 #include "services/metrics/public/cpp/ukm_builders.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -42,24 +44,32 @@ class WatchTimeRecorderTest : public testing::Test {
         smooth_keys_({kRebuffersCountAudioSrc, kRebuffersCountAudioMse,
                       kRebuffersCountAudioEme, kRebuffersCountAudioVideoSrc,
                       kRebuffersCountAudioVideoMse,
-                      kRebuffersCountAudioVideoEme}) {
+                      kRebuffersCountAudioVideoEme}),
+        discard_keys_({kDiscardedWatchTimeAudioSrc, kDiscardedWatchTimeAudioMse,
+                       kDiscardedWatchTimeAudioEme,
+                       kDiscardedWatchTimeAudioVideoSrc,
+                       kDiscardedWatchTimeAudioVideoMse,
+                       kDiscardedWatchTimeAudioVideoEme}) {
     ResetMetricRecorders();
-    WatchTimeRecorder::CreateWatchTimeRecorderProvider(
-        mojo::MakeRequest(&provider_));
+    MediaMetricsProvider::Create(nullptr, mojo::MakeRequest(&provider_));
   }
 
   ~WatchTimeRecorderTest() override { base::RunLoop().RunUntilIdle(); }
 
+  void Initialize(mojom::PlaybackPropertiesPtr properties) {
+    provider_->Initialize(properties->is_mse, true /* is_top_frame */,
+                          url::Origin::Create(GURL(kTestOrigin)));
+    provider_->AcquireWatchTimeRecorder(std::move(properties),
+                                        mojo::MakeRequest(&wtr_));
+  }
+
   void Initialize(bool has_audio,
                   bool has_video,
                   bool is_mse,
                   bool is_encrypted) {
-    provider_->AcquireWatchTimeRecorder(
-        mojom::PlaybackProperties::New(
-            kUnknownAudioCodec, kUnknownVideoCodec, has_audio, has_video,
-            is_mse, is_encrypted, false, gfx::Size(800, 600),
-            url::Origin::Create(GURL(kTestOrigin)), true /* is_top_frame */),
-        mojo::MakeRequest(&wtr_));
+    Initialize(mojom::PlaybackProperties::New(
+        kUnknownAudioCodec, kUnknownVideoCodec, has_audio, has_video, false,
+        is_mse, is_encrypted, false, gfx::Size(800, 600)));
   }
 
   void ExpectWatchTime(const std::vector<base::StringPiece>& keys,
@@ -103,14 +113,13 @@ class WatchTimeRecorderTest : public testing::Test {
     ExpectHelper(smooth_keys_, keys, count);
   }
 
+  void ExpectNoUkmWatchTime() {
+    ASSERT_EQ(0u, test_recorder_->sources_count());
+    ASSERT_EQ(0u, test_recorder_->entries_count());
+  }
+
   void ExpectUkmWatchTime(const std::vector<base::StringPiece>& keys,
                           base::TimeDelta value) {
-    if (keys.empty()) {
-      ASSERT_EQ(0u, test_recorder_->sources_count());
-      ASSERT_EQ(0u, test_recorder_->entries_count());
-      return;
-    }
-
     const auto& entries =
         test_recorder_->GetEntriesByName(UkmEntry::kEntryName);
     EXPECT_EQ(1u, entries.size());
@@ -134,13 +143,14 @@ class WatchTimeRecorderTest : public testing::Test {
 
  protected:
   base::MessageLoop message_loop_;
-  mojom::WatchTimeRecorderProviderPtr provider_;
+  mojom::MediaMetricsProviderPtr provider_;
   std::unique_ptr<base::HistogramTester> histogram_tester_;
   std::unique_ptr<ukm::TestAutoSetUkmRecorder> test_recorder_;
   mojom::WatchTimeRecorderPtr wtr_;
   const std::vector<WatchTimeKey> computation_keys_;
   const std::vector<base::StringPiece> mtbr_keys_;
   const std::vector<base::StringPiece> smooth_keys_;
+  const std::vector<base::StringPiece> discard_keys_;
 
   DISALLOW_COPY_AND_ASSIGN(WatchTimeRecorderTest);
 };
@@ -149,11 +159,7 @@ TEST_F(WatchTimeRecorderTest, TestBasicReporting) {
   constexpr base::TimeDelta kWatchTime1 = base::TimeDelta::FromSeconds(25);
   constexpr base::TimeDelta kWatchTime2 = base::TimeDelta::FromSeconds(50);
 
-  // Don't include kWatchTimeKeyMax, since we'll use that as a placeholder to
-  // ensure only the keys requested for finalize are finalized.
-  const base::StringPiece kLastKey =
-      WatchTimeKeyToString(WatchTimeKey::kWatchTimeKeyMax);
-  for (int i = 0; i < static_cast<int>(WatchTimeKey::kWatchTimeKeyMax); ++i) {
+  for (int i = 0; i <= static_cast<int>(WatchTimeKey::kWatchTimeKeyMax); ++i) {
     const WatchTimeKey key = static_cast<WatchTimeKey>(i);
     SCOPED_TRACE(WatchTimeKeyToString(key));
 
@@ -170,48 +176,119 @@ TEST_F(WatchTimeRecorderTest, TestBasicReporting) {
     wtr_->FinalizeWatchTime({key});
     base::RunLoop().RunUntilIdle();
 
-    const base::StringPiece key_str = WatchTimeKeyToString(key);
-    ExpectWatchTime({key_str}, kWatchTime2);
+    if (WatchTimeRecorder::ShouldReportUmaForTesting(key)) {
+      const base::StringPiece key_str = WatchTimeKeyToString(key);
+      ExpectWatchTime({key_str}, kWatchTime2);
+    }
 
     // These keys are only reported for a full finalize.
     ExpectMtbrTime({}, base::TimeDelta());
     ExpectZeroRebuffers({});
-    ExpectUkmWatchTime({}, base::TimeDelta());
+    ExpectNoUkmWatchTime();
 
-    // Verify our sentinel key is recorded properly at player destruction.
+    // Verify nothing else is recorded except for what we finalized above.
     ResetMetricRecorders();
     wtr_.reset();
     base::RunLoop().RunUntilIdle();
-
-    ExpectWatchTime({kLastKey}, kWatchTime1);
+    ExpectWatchTime({}, base::TimeDelta());
     ExpectMtbrTime({}, base::TimeDelta());
     ExpectZeroRebuffers({});
 
-    if (key == WatchTimeKey::kAudioAll || key == WatchTimeKey::kAudioVideoAll ||
-        key == WatchTimeKey::kAudioVideoBackgroundAll) {
-      ExpectUkmWatchTime({UkmEntry::kWatchTimeName}, kWatchTime2);
-    } else {
-      ExpectUkmWatchTime({}, base::TimeDelta());
+    switch (key) {
+      case WatchTimeKey::kAudioAll:
+      case WatchTimeKey::kAudioBackgroundAll:
+      case WatchTimeKey::kAudioVideoAll:
+      case WatchTimeKey::kAudioVideoBackgroundAll:
+      case WatchTimeKey::kVideoAll:
+      case WatchTimeKey::kVideoBackgroundAll:
+        ExpectUkmWatchTime({UkmEntry::kWatchTimeName}, kWatchTime2);
+        break;
+
+      // These keys are not reported, instead we boolean flags for each type.
+      case WatchTimeKey::kAudioMse:
+      case WatchTimeKey::kAudioEme:
+      case WatchTimeKey::kAudioSrc:
+      case WatchTimeKey::kAudioEmbeddedExperience:
+      case WatchTimeKey::kAudioBackgroundMse:
+      case WatchTimeKey::kAudioBackgroundEme:
+      case WatchTimeKey::kAudioBackgroundSrc:
+      case WatchTimeKey::kAudioBackgroundEmbeddedExperience:
+      case WatchTimeKey::kAudioVideoMse:
+      case WatchTimeKey::kAudioVideoEme:
+      case WatchTimeKey::kAudioVideoSrc:
+      case WatchTimeKey::kAudioVideoEmbeddedExperience:
+      case WatchTimeKey::kAudioVideoBackgroundMse:
+      case WatchTimeKey::kAudioVideoBackgroundEme:
+      case WatchTimeKey::kAudioVideoBackgroundSrc:
+      case WatchTimeKey::kAudioVideoBackgroundEmbeddedExperience:
+      case WatchTimeKey::kVideoMse:
+      case WatchTimeKey::kVideoEme:
+      case WatchTimeKey::kVideoSrc:
+      case WatchTimeKey::kVideoEmbeddedExperience:
+      case WatchTimeKey::kVideoBackgroundMse:
+      case WatchTimeKey::kVideoBackgroundEme:
+      case WatchTimeKey::kVideoBackgroundSrc:
+      case WatchTimeKey::kVideoBackgroundEmbeddedExperience:
+        ExpectUkmWatchTime({}, base::TimeDelta());
+        break;
+
+      // These keys roll up into the battery watch time field.
+      case WatchTimeKey::kAudioBattery:
+      case WatchTimeKey::kAudioBackgroundBattery:
+      case WatchTimeKey::kAudioVideoBattery:
+      case WatchTimeKey::kAudioVideoBackgroundBattery:
+      case WatchTimeKey::kVideoBattery:
+      case WatchTimeKey::kVideoBackgroundBattery:
+        ExpectUkmWatchTime({UkmEntry::kWatchTime_BatteryName}, kWatchTime2);
+        break;
+
+      // These keys roll up into the AC watch time field.
+      case WatchTimeKey::kAudioAc:
+      case WatchTimeKey::kAudioBackgroundAc:
+      case WatchTimeKey::kAudioVideoAc:
+      case WatchTimeKey::kAudioVideoBackgroundAc:
+      case WatchTimeKey::kVideoAc:
+      case WatchTimeKey::kVideoBackgroundAc:
+        ExpectUkmWatchTime({UkmEntry::kWatchTime_ACName}, kWatchTime2);
+        break;
+
+      case WatchTimeKey::kAudioVideoDisplayFullscreen:
+      case WatchTimeKey::kVideoDisplayFullscreen:
+        ExpectUkmWatchTime({UkmEntry::kWatchTime_DisplayFullscreenName},
+                           kWatchTime2);
+        break;
+
+      case WatchTimeKey::kAudioVideoDisplayInline:
+      case WatchTimeKey::kVideoDisplayInline:
+        ExpectUkmWatchTime({UkmEntry::kWatchTime_DisplayInlineName},
+                           kWatchTime2);
+        break;
+
+      case WatchTimeKey::kAudioVideoDisplayPictureInPicture:
+      case WatchTimeKey::kVideoDisplayPictureInPicture:
+        ExpectUkmWatchTime({UkmEntry::kWatchTime_DisplayPictureInPictureName},
+                           kWatchTime2);
+        break;
+
+      case WatchTimeKey::kAudioNativeControlsOn:
+      case WatchTimeKey::kAudioVideoNativeControlsOn:
+      case WatchTimeKey::kVideoNativeControlsOn:
+        ExpectUkmWatchTime({UkmEntry::kWatchTime_NativeControlsOnName},
+                           kWatchTime2);
+        break;
+
+      case WatchTimeKey::kAudioNativeControlsOff:
+      case WatchTimeKey::kAudioVideoNativeControlsOff:
+      case WatchTimeKey::kVideoNativeControlsOff:
+        ExpectUkmWatchTime({UkmEntry::kWatchTime_NativeControlsOffName},
+                           kWatchTime2);
+        break;
     }
 
     ResetMetricRecorders();
   }
 }
 
-TEST_F(WatchTimeRecorderTest, FinalizeWithoutWatchTime) {
-  Initialize(true, true, false, true);
-  wtr_.reset();
-  base::RunLoop().RunUntilIdle();
-
-  // No watch time should have been recorded even though a finalize event will
-  // be sent.
-  ExpectWatchTime({}, base::TimeDelta());
-  ExpectMtbrTime({}, base::TimeDelta());
-  ExpectZeroRebuffers({});
-  ExpectUkmWatchTime({}, base::TimeDelta());
-  ASSERT_EQ(0U, test_recorder_->sources_count());
-}
-
 TEST_F(WatchTimeRecorderTest, TestRebufferingMetrics) {
   Initialize(true, false, true, true);
 
@@ -237,21 +314,188 @@ TEST_F(WatchTimeRecorderTest, TestRebufferingMetrics) {
 
   ExpectMtbrTime({}, base::TimeDelta());
   ExpectZeroRebuffers(smooth_keys_);
+
+  // Now rerun the test with a small amount of watch time and ensure rebuffering
+  // isn't recorded because we haven't met the watch time requirements.
+  ResetMetricRecorders();
+  constexpr base::TimeDelta kWatchTimeShort = base::TimeDelta::FromSeconds(5);
+  for (auto key : computation_keys_)
+    wtr_->RecordWatchTime(key, kWatchTimeShort);
+  wtr_->UpdateUnderflowCount(1);
+  wtr_->UpdateUnderflowCount(2);
+  wtr_->FinalizeWatchTime({});
+  base::RunLoop().RunUntilIdle();
+
+  // Nothing should be logged since this doesn't meet requirements.
+  ExpectMtbrTime({}, base::TimeDelta());
+  for (auto key : smooth_keys_)
+    histogram_tester_->ExpectTotalCount(key.as_string(), 0);
+}
+
+TEST_F(WatchTimeRecorderTest, TestDiscardMetrics) {
+  Initialize(true, false, true, true);
+
+  constexpr base::TimeDelta kWatchTime = base::TimeDelta::FromSeconds(5);
+  for (auto key : computation_keys_)
+    wtr_->RecordWatchTime(key, kWatchTime);
+
+  // Trigger finalization of everything.
+  wtr_.reset();
+  base::RunLoop().RunUntilIdle();
+
+  // No standard watch time should be recorded because it falls below the
+  // reporting threshold.
+  ExpectWatchTime({}, base::TimeDelta());
+
+  // Verify the time was instead logged to the discard keys.
+  for (auto key : discard_keys_) {
+    histogram_tester_->ExpectUniqueSample(key.as_string(),
+                                          kWatchTime.InMilliseconds(), 1);
+  }
+
+  // UKM watch time won't be logged because we aren't sending "All" keys.
+  ExpectUkmWatchTime({}, base::TimeDelta());
 }
 
 #define EXPECT_UKM(name, value) \
   test_recorder_->ExpectEntryMetric(entry, name, value)
 #define EXPECT_NO_UKM(name) \
   EXPECT_FALSE(test_recorder_->EntryHasMetric(entry, name))
+#define EXPECT_HAS_UKM(name) \
+  EXPECT_TRUE(test_recorder_->EntryHasMetric(entry, name));
+
+TEST_F(WatchTimeRecorderTest, TestFinalizeNoDuplication) {
+  mojom::PlaybackPropertiesPtr properties =
+      mojom::PlaybackProperties::New(kCodecAAC, kCodecH264, true, true, false,
+                                     false, false, false, gfx::Size(800, 600));
+  Initialize(properties.Clone());
+
+  // Verify that UKM is reported along with the watch time.
+  constexpr base::TimeDelta kWatchTime = base::TimeDelta::FromSeconds(4);
+  wtr_->RecordWatchTime(WatchTimeKey::kAudioVideoAll, kWatchTime);
+
+  // Finalize everything. UKM is only recorded at destruction, so this should do
+  // nothing.
+  wtr_->FinalizeWatchTime({});
+  base::RunLoop().RunUntilIdle();
+
+  // No watch time should have been recorded since this is below the UMA report
+  // threshold.
+  ExpectWatchTime({}, base::TimeDelta());
+  ExpectMtbrTime({}, base::TimeDelta());
+  ExpectZeroRebuffers({});
+  ExpectNoUkmWatchTime();
+
+  const auto& empty_entries =
+      test_recorder_->GetEntriesByName(UkmEntry::kEntryName);
+  EXPECT_EQ(0u, empty_entries.size());
+
+  // Verify UKM is logged at destruction time.
+  ResetMetricRecorders();
+  wtr_.reset();
+  base::RunLoop().RunUntilIdle();
+  const auto& entries = test_recorder_->GetEntriesByName(UkmEntry::kEntryName);
+  EXPECT_EQ(1u, entries.size());
+  for (const auto* entry : entries) {
+    test_recorder_->ExpectEntrySourceHasUrl(entry, GURL(kTestOrigin));
+
+    EXPECT_UKM(UkmEntry::kIsBackgroundName, properties->is_background);
+    EXPECT_UKM(UkmEntry::kAudioCodecName, properties->audio_codec);
+    EXPECT_UKM(UkmEntry::kVideoCodecName, properties->video_codec);
+    EXPECT_UKM(UkmEntry::kHasAudioName, properties->has_audio);
+    EXPECT_UKM(UkmEntry::kHasVideoName, properties->has_video);
+    EXPECT_UKM(UkmEntry::kIsEMEName, properties->is_eme);
+    EXPECT_UKM(UkmEntry::kIsMSEName, properties->is_mse);
+    EXPECT_UKM(UkmEntry::kLastPipelineStatusName, PIPELINE_OK);
+    EXPECT_UKM(UkmEntry::kRebuffersCountName, 0);
+    EXPECT_UKM(UkmEntry::kVideoNaturalWidthName,
+               properties->natural_size.width());
+    EXPECT_UKM(UkmEntry::kVideoNaturalHeightName,
+               properties->natural_size.height());
+    EXPECT_UKM(UkmEntry::kWatchTimeName, kWatchTime.InMilliseconds());
+    EXPECT_UKM(UkmEntry::kAudioDecoderNameName, 0);
+    EXPECT_UKM(UkmEntry::kVideoDecoderNameName, 0);
+    EXPECT_HAS_UKM(UkmEntry::kPlayerIDName);
+
+    EXPECT_NO_UKM(UkmEntry::kMeanTimeBetweenRebuffersName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_ACName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_BatteryName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_NativeControlsOnName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_NativeControlsOffName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_DisplayFullscreenName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_DisplayInlineName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_DisplayPictureInPictureName);
+  }
+}
+
+TEST_F(WatchTimeRecorderTest, FinalizeWithoutWatchTime) {
+  mojom::PlaybackPropertiesPtr properties =
+      mojom::PlaybackProperties::New(kCodecAAC, kCodecH264, true, true, false,
+                                     false, false, false, gfx::Size(800, 600));
+  Initialize(properties.Clone());
+
+  // Finalize everything. UKM is only recorded at destruction, so this should do
+  // nothing.
+  wtr_->FinalizeWatchTime({});
+  base::RunLoop().RunUntilIdle();
+
+  // No watch time should have been recorded even though a finalize event will
+  // be sent, however a UKM entry with the playback properties will still be
+  // generated.
+  ExpectWatchTime({}, base::TimeDelta());
+  ExpectMtbrTime({}, base::TimeDelta());
+  ExpectZeroRebuffers({});
+  ExpectNoUkmWatchTime();
+
+  const auto& empty_entries =
+      test_recorder_->GetEntriesByName(UkmEntry::kEntryName);
+  EXPECT_EQ(0u, empty_entries.size());
+
+  // Destructing the recorder should generate a UKM report though.
+  ResetMetricRecorders();
+  wtr_.reset();
+  base::RunLoop().RunUntilIdle();
+  const auto& entries = test_recorder_->GetEntriesByName(UkmEntry::kEntryName);
+  EXPECT_EQ(1u, entries.size());
+  for (const auto* entry : entries) {
+    test_recorder_->ExpectEntrySourceHasUrl(entry, GURL(kTestOrigin));
+
+    EXPECT_UKM(UkmEntry::kIsBackgroundName, properties->is_background);
+    EXPECT_UKM(UkmEntry::kAudioCodecName, properties->audio_codec);
+    EXPECT_UKM(UkmEntry::kVideoCodecName, properties->video_codec);
+    EXPECT_UKM(UkmEntry::kHasAudioName, properties->has_audio);
+    EXPECT_UKM(UkmEntry::kHasVideoName, properties->has_video);
+    EXPECT_UKM(UkmEntry::kIsEMEName, properties->is_eme);
+    EXPECT_UKM(UkmEntry::kIsMSEName, properties->is_mse);
+    EXPECT_UKM(UkmEntry::kLastPipelineStatusName, PIPELINE_OK);
+    EXPECT_UKM(UkmEntry::kRebuffersCountName, 0);
+    EXPECT_UKM(UkmEntry::kVideoNaturalWidthName,
+               properties->natural_size.width());
+    EXPECT_UKM(UkmEntry::kVideoNaturalHeightName,
+               properties->natural_size.height());
+    EXPECT_UKM(UkmEntry::kAudioDecoderNameName, 0);
+    EXPECT_UKM(UkmEntry::kVideoDecoderNameName, 0);
+    EXPECT_HAS_UKM(UkmEntry::kPlayerIDName);
+
+    EXPECT_NO_UKM(UkmEntry::kMeanTimeBetweenRebuffersName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTimeName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_ACName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_BatteryName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_NativeControlsOnName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_NativeControlsOffName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_DisplayFullscreenName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_DisplayInlineName);
+    EXPECT_NO_UKM(UkmEntry::kWatchTime_DisplayPictureInPictureName);
+  }
+}
 
 TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideo) {
-  mojom::PlaybackPropertiesPtr properties = mojom::PlaybackProperties::New(
-      kCodecAAC, kCodecH264, true, true, false, false, false,
-      gfx::Size(800, 600), url::Origin::Create(GURL(kTestOrigin)), true);
-  provider_->AcquireWatchTimeRecorder(properties.Clone(),
-                                      mojo::MakeRequest(&wtr_));
+  mojom::PlaybackPropertiesPtr properties =
+      mojom::PlaybackProperties::New(kCodecAAC, kCodecH264, true, true, false,
+                                     false, false, false, gfx::Size(800, 600));
+  Initialize(properties.Clone());
 
-  constexpr base::TimeDelta kWatchTime = base::TimeDelta::FromSeconds(54);
+  constexpr base::TimeDelta kWatchTime = base::TimeDelta::FromSeconds(4);
   wtr_->RecordWatchTime(WatchTimeKey::kAudioVideoAll, kWatchTime);
   wtr_.reset();
   base::RunLoop().RunUntilIdle();
@@ -262,7 +506,7 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideo) {
     test_recorder_->ExpectEntrySourceHasUrl(entry, GURL(kTestOrigin));
 
     EXPECT_UKM(UkmEntry::kWatchTimeName, kWatchTime.InMilliseconds());
-    EXPECT_UKM(UkmEntry::kIsBackgroundName, false);
+    EXPECT_UKM(UkmEntry::kIsBackgroundName, properties->is_background);
     EXPECT_UKM(UkmEntry::kAudioCodecName, properties->audio_codec);
     EXPECT_UKM(UkmEntry::kVideoCodecName, properties->video_codec);
     EXPECT_UKM(UkmEntry::kHasAudioName, properties->has_audio);
@@ -275,6 +519,9 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideo) {
                properties->natural_size.width());
     EXPECT_UKM(UkmEntry::kVideoNaturalHeightName,
                properties->natural_size.height());
+    EXPECT_HAS_UKM(UkmEntry::kPlayerIDName);
+    EXPECT_UKM(UkmEntry::kAudioDecoderNameName, 0);
+    EXPECT_UKM(UkmEntry::kVideoDecoderNameName, 0);
 
     EXPECT_NO_UKM(UkmEntry::kMeanTimeBetweenRebuffersName);
     EXPECT_NO_UKM(UkmEntry::kWatchTime_ACName);
@@ -288,11 +535,10 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideo) {
 }
 
 TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideoWithExtras) {
-  mojom::PlaybackPropertiesPtr properties = mojom::PlaybackProperties::New(
-      kCodecOpus, kCodecVP9, true, true, true, true, false, gfx::Size(800, 600),
-      url::Origin::Create(GURL(kTestOrigin)), true);
-  provider_->AcquireWatchTimeRecorder(properties.Clone(),
-                                      mojo::MakeRequest(&wtr_));
+  mojom::PlaybackPropertiesPtr properties =
+      mojom::PlaybackProperties::New(kCodecOpus, kCodecVP9, true, true, false,
+                                     true, true, false, gfx::Size(800, 600));
+  Initialize(properties.Clone());
 
   constexpr base::TimeDelta kWatchTime = base::TimeDelta::FromSeconds(54);
   const base::TimeDelta kWatchTime2 = kWatchTime * 2;
@@ -316,6 +562,11 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideoWithExtras) {
   wtr_->UpdateUnderflowCount(3);
   wtr_->OnError(PIPELINE_ERROR_DECODE);
 
+  const std::string kAudioDecoderName = "MojoAudioDecoder";
+  const std::string kVideoDecoderName = "MojoVideoDecoder";
+  wtr_->SetAudioDecoderName(kAudioDecoderName);
+  wtr_->SetVideoDecoderName(kVideoDecoderName);
+
   wtr_.reset();
   base::RunLoop().RunUntilIdle();
 
@@ -338,8 +589,13 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideoWithExtras) {
                kWatchTime3.InMilliseconds());
     EXPECT_UKM(UkmEntry::kMeanTimeBetweenRebuffersName,
                kWatchTime2.InMilliseconds() / 3);
+    EXPECT_HAS_UKM(UkmEntry::kPlayerIDName);
+
+    // Values taken from .cc private enumeration (and should never change).
+    EXPECT_UKM(UkmEntry::kAudioDecoderNameName, 2);
+    EXPECT_UKM(UkmEntry::kVideoDecoderNameName, 5);
 
-    EXPECT_UKM(UkmEntry::kIsBackgroundName, false);
+    EXPECT_UKM(UkmEntry::kIsBackgroundName, properties->is_background);
     EXPECT_UKM(UkmEntry::kAudioCodecName, properties->audio_codec);
     EXPECT_UKM(UkmEntry::kVideoCodecName, properties->video_codec);
     EXPECT_UKM(UkmEntry::kHasAudioName, properties->has_audio);
@@ -356,11 +612,10 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideoWithExtras) {
 }
 
 TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideoBackground) {
-  mojom::PlaybackPropertiesPtr properties = mojom::PlaybackProperties::New(
-      kCodecAAC, kCodecH264, true, true, false, false, false,
-      gfx::Size(800, 600), url::Origin::Create(GURL(kTestOrigin)), true);
-  provider_->AcquireWatchTimeRecorder(properties.Clone(),
-                                      mojo::MakeRequest(&wtr_));
+  mojom::PlaybackPropertiesPtr properties =
+      mojom::PlaybackProperties::New(kCodecAAC, kCodecH264, true, true, true,
+                                     false, false, false, gfx::Size(800, 600));
+  Initialize(properties.Clone());
 
   constexpr base::TimeDelta kWatchTime = base::TimeDelta::FromSeconds(54);
   wtr_->RecordWatchTime(WatchTimeKey::kAudioVideoBackgroundAll, kWatchTime);
@@ -373,7 +628,7 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideoBackground) {
     test_recorder_->ExpectEntrySourceHasUrl(entry, GURL(kTestOrigin));
 
     EXPECT_UKM(UkmEntry::kWatchTimeName, kWatchTime.InMilliseconds());
-    EXPECT_UKM(UkmEntry::kIsBackgroundName, true);
+    EXPECT_UKM(UkmEntry::kIsBackgroundName, properties->is_background);
     EXPECT_UKM(UkmEntry::kAudioCodecName, properties->audio_codec);
     EXPECT_UKM(UkmEntry::kVideoCodecName, properties->video_codec);
     EXPECT_UKM(UkmEntry::kHasAudioName, properties->has_audio);
@@ -386,6 +641,9 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideoBackground) {
                properties->natural_size.width());
     EXPECT_UKM(UkmEntry::kVideoNaturalHeightName,
                properties->natural_size.height());
+    EXPECT_HAS_UKM(UkmEntry::kPlayerIDName);
+    EXPECT_UKM(UkmEntry::kAudioDecoderNameName, 0);
+    EXPECT_UKM(UkmEntry::kVideoDecoderNameName, 0);
 
     EXPECT_NO_UKM(UkmEntry::kMeanTimeBetweenRebuffersName);
     EXPECT_NO_UKM(UkmEntry::kWatchTime_ACName);
@@ -397,7 +655,19 @@ TEST_F(WatchTimeRecorderTest, BasicUkmAudioVideoBackground) {
     EXPECT_NO_UKM(UkmEntry::kWatchTime_DisplayPictureInPictureName);
   }
 }
+
 #undef EXPECT_UKM
 #undef EXPECT_NO_UKM
+#undef EXPECT_HAS_UKM
+
+TEST_F(WatchTimeRecorderTest, DISABLED_PrintExpectedDecoderNameHashes) {
+  const std::string kDecoderNames[] = {
+      "FFmpegAudioDecoder", "FFmpegVideoDecoder",     "GpuVideoDecoder",
+      "MojoVideoDecoder",   "MojoAudioDecoder",       "VpxVideoDecoder",
+      "AomVideoDecoder",    "DecryptingAudioDecoder", "DecryptingVideoDecoder"};
+  printf("%18s = 0\n", "None");
+  for (const auto& name : kDecoderNames)
+    printf("%18s = 0x%x\n", name.c_str(), base::PersistentHash(name));
+}
 
 }  // namespace media