Expand test coverage of VideoPlaybackRoughnessReporter

1. Testing that VideoRendererAlgorithm sets frame duration
   metadata

2. Testing VideoFrameSubmitter correctly calls
   VideoPlaybackRoughnessReporter

This is a follow-up CL for the 2 previous CLs related to the
same bug.

Bug: 1042111
Change-Id: I47bb5804549dacb9e613ab40f0859cc618e489c7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2107174Reviewed-by: Stephen Chenney <schenney@chromium.org>
Reviewed-by: Frank Liberato <liberato@chromium.org>
Commit-Queue: Eugene Zemtsov <eugene@chromium.org>
Cr-Commit-Position: refs/heads/master@{#751155}

media/filters/video_renderer_algorithm_unittest.cc

@@ -1623,4 +1623,36 @@ TEST_F(VideoRendererAlgorithmTest, UsesFrameDuration) {
             base::TimeTicks() + kLongDuration + tg.interval(1) * 3);
 }
 
+// Check that VideoRendererAlgorithm correctly sets WALLCLOCK_FRAME_DURATION
+// for each frame.
+TEST_F(VideoRendererAlgorithmTest, WallClockDurationMetadataSet) {
+  int playback_rate = 4;
+  int frame_count = 10;
+  TickGenerator tg(tick_clock_->NowTicks(), 25);
+
+  time_source_.SetPlaybackRate(playback_rate);
+  auto intended_duration = tg.interval(1) / playback_rate;
+
+  for (int i = 0; i < frame_count; i++) {
+    auto frame = CreateFrame(tg.interval(i));
+    frame->metadata()->SetTimeDelta(VideoFrameMetadata::FRAME_DURATION,
+                                    tg.interval(1));
+    algorithm_.EnqueueFrame(frame);
+  }
+
+  for (int i = 0; i < frame_count; i++) {
+    size_t frames_dropped = 0;
+    auto frame = RenderAndStep(&tg, &frames_dropped);
+
+    SCOPED_TRACE(base::StringPrintf("Frame #%d", i));
+    base::TimeDelta wallclock_duration;
+    EXPECT_TRUE(frame->metadata()->GetTimeDelta(
+        media::VideoFrameMetadata::WALLCLOCK_FRAME_DURATION,
+        &wallclock_duration));
+
+    EXPECT_EQ(wallclock_duration, intended_duration);
+    EXPECT_EQ(algorithm_.average_frame_duration(), intended_duration);
+  }
+}
+
 }  // namespace media

third_party/blink/renderer/platform/BUILD.gn

@@ -1984,6 +1984,7 @@ jumbo_source_set("blink_platform_unittests_sources") {
     "//ui/gfx",
     "//ui/gfx/geometry",
     "//ui/gfx/geometry/mojom:test_interfaces_blink",
+    "//ui/gfx/mojom:test_interfaces_blink",
     "//url",
     "//url/mojom:test_url_mojom_gurl_blink",
   ]

third_party/blink/renderer/platform/graphics/video_frame_submitter_test.cc

@@ -12,10 +12,12 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/read_only_shared_memory_region.h"
+#include "base/test/bind_test_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/task_environment.h"
 #include "base/time/time.h"
 #include "cc/layers/video_frame_provider.h"
+#include "cc/metrics/video_playback_roughness_reporter.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/task_runner_provider.h"
@@ -37,6 +39,7 @@
 
 using testing::_;
 using testing::AnyNumber;
+using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
 
@@ -955,4 +958,66 @@ TEST_F(VideoFrameSubmitterTest, ZeroSizedFramesAreNotSubmitted) {
   task_environment_.RunUntilIdle();
 }
 
+// Check that given enough frames with wallclock duration and enough
+// presentation feedback data, VideoFrameSubmitter will call the video roughness
+// reporting callback.
+TEST_F(VideoFrameSubmitterTest, ProcessTimingDetails) {
+  int fps = 24;
+  int reports = 0;
+  base::TimeDelta frame_duration = base::TimeDelta::FromSecondsD(1.0 / fps);
+  int frames_to_run =
+      (fps / 2) *
+      (cc::VideoPlaybackRoughnessReporter::kMinWindowsBeforeSubmit + 1);
+  WTF::HashMap<uint32_t, viz::mojom::blink::FrameTimingDetailsPtr>
+      timing_details;
+
+  MakeSubmitter(
+      base::BindLambdaForTesting([&](int frames, base::TimeDelta duration,
+                                     double roughness) { reports++; }));
+  EXPECT_CALL(*sink_, SetNeedsBeginFrame(true));
+  submitter_->StartRendering();
+  task_environment_.RunUntilIdle();
+  EXPECT_TRUE(IsRendering());
+
+  auto sink_submit = [&](const viz::LocalSurfaceId&,
+                         viz::CompositorFrame* frame) {
+    auto token = frame->metadata.frame_token;
+    viz::mojom::blink::FrameTimingDetailsPtr details =
+        viz::mojom::blink::FrameTimingDetails::New();
+    details->presentation_feedback =
+        gfx::mojom::blink::PresentationFeedback::New();
+    details->presentation_feedback->timestamp =
+        base::TimeTicks() + frame_duration * token;
+    timing_details.clear();
+    timing_details.Set(token, std::move(details));
+  };
+
+  EXPECT_CALL(*video_frame_provider_, UpdateCurrentFrame)
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*video_frame_provider_, PutCurrentFrame).Times(AnyNumber());
+  EXPECT_CALL(*sink_, DoSubmitCompositorFrame)
+      .WillRepeatedly(Invoke(sink_submit));
+  EXPECT_CALL(*resource_provider_, AppendQuads).Times(AnyNumber());
+  EXPECT_CALL(*resource_provider_, PrepareSendToParent).Times(AnyNumber());
+  EXPECT_CALL(*resource_provider_, ReleaseFrameResources).Times(AnyNumber());
+
+  for (int i = 0; i < frames_to_run; i++) {
+    auto frame = media::VideoFrame::CreateFrame(
+        media::PIXEL_FORMAT_YV12, gfx::Size(8, 8), gfx::Rect(gfx::Size(8, 8)),
+        gfx::Size(8, 8), i * frame_duration);
+    frame->metadata()->SetTimeDelta(
+        media::VideoFrameMetadata::WALLCLOCK_FRAME_DURATION, frame_duration);
+    EXPECT_CALL(*video_frame_provider_, GetCurrentFrame())
+        .WillRepeatedly(Return(frame));
+
+    auto args = begin_frame_source_->CreateBeginFrameArgs(BEGINFRAME_FROM_HERE,
+                                                          now_src_.get());
+    submitter_->OnBeginFrame(args, std::move(timing_details));
+    task_environment_.RunUntilIdle();
+    AckSubmittedFrame();
+  }
+  submitter_->StopRendering();
+  EXPECT_EQ(reports, 1);
+}
+
 }  // namespace blink