1 files changed, 117 insertions, 3 deletions
diff --git a/chromium/components/viz/service/frame_sinks/video_capture/frame_sink_video_capturer_impl_unittest.cc b/chromium/components/viz/service/frame_sinks/video_capture/frame_sink_video_capturer_impl_unittest.cc
index e5efebcfac0..babe29ca1b1 100644
--- a/chromium/components/viz/service/frame_sinks/video_capture/frame_sink_video_capturer_impl_unittest.cc
+++ b/chromium/components/viz/service/frame_sinks/video_capture/frame_sink_video_capturer_impl_unittest.cc
@@ -39,6 +39,29 @@ using testing::Return;
 namespace viz {
 namespace {
 
+// Returns true if |frame|'s device scale factor, page scale factor and root
+// scroll offset are equal to the expected values.
+bool CompareVarsInCompositorFrameMetadata(
+    const VideoFrame& frame,
+    float device_scale_factor,
+    float page_scale_factor,
+    const gfx::Vector2dF& root_scroll_offset) {
+  double dsf, psf, rso_x, rso_y;
+  bool valid = true;
+
+  valid &= frame.metadata()->GetDouble(
+      media::VideoFrameMetadata::DEVICE_SCALE_FACTOR, &dsf);
+  valid &= frame.metadata()->GetDouble(
+      media::VideoFrameMetadata::PAGE_SCALE_FACTOR, &psf);
+  valid &= frame.metadata()->GetDouble(
+      media::VideoFrameMetadata::ROOT_SCROLL_OFFSET_X, &rso_x);
+  valid &= frame.metadata()->GetDouble(
+      media::VideoFrameMetadata::ROOT_SCROLL_OFFSET_Y, &rso_y);
+
+  return valid && dsf == device_scale_factor && psf == page_scale_factor &&
+         gfx::Vector2dF(rso_x, rso_y) == root_scroll_offset;
+}
+
 // Dummy frame sink ID.
 constexpr FrameSinkId kFrameSinkId = FrameSinkId(1, 1);
 
@@ -52,6 +75,10 @@ constexpr gfx::Size kSourceSize = gfx::Size(100, 100);
 // The size of the VideoFrames produced by the capturer.
 constexpr gfx::Size kCaptureSize = gfx::Size(32, 18);
 
+constexpr float kDefaultDeviceScaleFactor = 1.f;
+constexpr float kDefaultPageScaleFactor = 1.f;
+constexpr gfx::Vector2dF kDefaultRootScrollOffset = gfx::Vector2dF(0, 0);
+
 // The location of the letterboxed content within each VideoFrame. All pixels
 // outside of this region should be black.
 constexpr gfx::Rect kContentRect = gfx::Rect(6, 0, 18, 18);
@@ -182,6 +209,12 @@ class SolidColorI420Result : public CopyOutputResult {
 
 class FakeCapturableFrameSink : public CapturableFrameSink {
  public:
+  FakeCapturableFrameSink() {
+    metadata_.root_scroll_offset = kDefaultRootScrollOffset;
+    metadata_.page_scale_factor = kDefaultPageScaleFactor;
+    metadata_.device_scale_factor = kDefaultDeviceScaleFactor;
+  }
+
   Client* attached_client() const { return client_; }
 
   void AttachCaptureClient(Client* client) override {
@@ -216,6 +249,14 @@ class FakeCapturableFrameSink : public CapturableFrameSink {
         std::move(request), std::move(result)));
   }
 
+  const CompositorFrameMetadata* GetLastActivatedFrameMetadata() override {
+    return &metadata_;
+  }
+
+  void set_metadata(const CompositorFrameMetadata& metadata) {
+    metadata_ = metadata.Clone();
+  }
+
   void SetCopyOutputColor(YUVColor color) { color_ = color; }
 
   int num_copy_results() const { return results_.size(); }
@@ -229,6 +270,7 @@ class FakeCapturableFrameSink : public CapturableFrameSink {
  private:
   CapturableFrameSink::Client* client_ = nullptr;
   YUVColor color_ = {0xde, 0xad, 0xbf};
+  CompositorFrameMetadata metadata_;
 
   std::vector<base::OnceClosure> results_;
 };
@@ -335,9 +377,20 @@ class FrameSinkVideoCapturerTest : public testing::Test {
     task_runner_->FastForwardBy(GetNextVsync() - task_runner_->NowTicks());
   }
 
-  void NotifyFrameDamaged() {
+  void NotifyFrameDamaged(
+      float device_scale_factor = kDefaultDeviceScaleFactor,
+      float page_scale_factor = kDefaultPageScaleFactor,
+      gfx::Vector2dF root_scroll_offset = kDefaultRootScrollOffset) {
+    CompositorFrameMetadata metadata;
+
+    metadata.device_scale_factor = device_scale_factor;
+    metadata.page_scale_factor = page_scale_factor;
+    metadata.root_scroll_offset = root_scroll_offset;
+
+    frame_sink_.set_metadata(metadata);
+
     capturer_.OnFrameDamaged(kSourceSize, gfx::Rect(kSourceSize),
-                             GetNextVsync());
+                             GetNextVsync(), metadata);
   }
 
   void NotifyTargetWentAway() {
@@ -363,7 +416,7 @@ class FrameSinkVideoCapturerTest : public testing::Test {
 };
 
 // Tests that the capturer attaches to a frame sink immediately, in the case
-// where the frame sink was already known by the manger.
+// where the frame sink was already known by the manager.
 TEST_F(FrameSinkVideoCapturerTest, ResolvesTargetImmediately) {
   EXPECT_CALL(frame_sink_manager_, FindCapturableFrameSink(kFrameSinkId))
       .WillRepeatedly(Return(&frame_sink_));
@@ -857,4 +910,65 @@ TEST_F(FrameSinkVideoCapturerTest, EventuallySendsARefreshFrame) {
   StopCapture();
 }
 
+// Tests that CompositorFrameMetadata variables (|device_scale_factor|,
+// |page_scale_factor| and |root_scroll_offset|) are sent along with each frame,
+// and refreshes cause variables of the cached CompositorFrameMetadata
+// (|last_frame_metadata|) to be used.
+TEST_F(FrameSinkVideoCapturerTest, CompositorFrameMetadataReachesConsumer) {
+  EXPECT_CALL(frame_sink_manager_, FindCapturableFrameSink(kFrameSinkId))
+      .WillRepeatedly(Return(&frame_sink_));
+  capturer_.ChangeTarget(kFrameSinkId);
+
+  MockConsumer consumer;
+  // Initial refresh frame for starting capture, plus later refresh.
+  const int num_refresh_frames = 2;
+  const int num_update_frames = 1;
+  EXPECT_CALL(consumer, OnFrameCapturedMock(_, _, _))
+      .Times(num_refresh_frames + num_update_frames);
+  EXPECT_CALL(consumer, OnTargetLost(_)).Times(0);
+  EXPECT_CALL(consumer, OnStopped()).Times(1);
+  StartCapture(&consumer);
+
+  // With the start, an immediate refresh occurred. Simulate a copy result.
+  // Expect to see the refresh frame delivered to the consumer, along with
+  // default metadata values.
+  int cur_frame_index = 0, expected_frames_count = 1;
+  frame_sink_.SendCopyOutputResult(cur_frame_index);
+  EXPECT_EQ(expected_frames_count, consumer.num_frames_received());
+  EXPECT_TRUE(CompareVarsInCompositorFrameMetadata(
+      *(consumer.TakeFrame(cur_frame_index)), kDefaultDeviceScaleFactor,
+      kDefaultPageScaleFactor, kDefaultRootScrollOffset));
+  consumer.SendDoneNotification(cur_frame_index);
+
+  // The metadata used to signal a frame damage and verify that it reaches the
+  // consumer.
+  const float kNewDeviceScaleFactor = 3.5;
+  const float kNewPageScaleFactor = 1.5;
+  const gfx::Vector2dF kNewRootScrollOffset = gfx::Vector2dF(100, 200);
+
+  // Notify frame damage with new metadata, and expect that the refresh frame
+  // is delivered to the consumer with this new metadata.
+  AdvanceClockToNextVsync();
+  NotifyFrameDamaged(kNewDeviceScaleFactor, kNewPageScaleFactor,
+                     kNewRootScrollOffset);
+  frame_sink_.SendCopyOutputResult(++cur_frame_index);
+  EXPECT_EQ(++expected_frames_count, consumer.num_frames_received());
+  EXPECT_TRUE(CompareVarsInCompositorFrameMetadata(
+      *(consumer.TakeFrame(cur_frame_index)), kNewDeviceScaleFactor,
+      kNewPageScaleFactor, kNewRootScrollOffset));
+  consumer.SendDoneNotification(cur_frame_index);
+
+  // Request a refresh frame. Because the refresh request was made just after
+  // the last frame capture, the refresh retry timer should be started.
+  // Expect that the refresh frame is delivered to the consumer with the same
+  // metadata from the previous frame.
+  capturer_.RequestRefreshFrame();
+  AdvanceClockForRefreshTimer();
+  EXPECT_EQ(++expected_frames_count, consumer.num_frames_received());
+  EXPECT_TRUE(CompareVarsInCompositorFrameMetadata(
+      *(consumer.TakeFrame(++cur_frame_index)), kNewDeviceScaleFactor,
+      kNewPageScaleFactor, kNewRootScrollOffset));
+  StopCapture();
+}
+
 }  // namespace viz