BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

7 files changed, 118 insertions, 121 deletions

diff --git a/chromium/components/viz/service/frame_sinks/compositor_frame_sink_support.cc b/chromium/components/viz/service/frame_sinks/compositor_frame_sink_support.cc
index dc602776aad..bb23f23c193 100644
--- a/chromium/components/viz/service/frame_sinks/compositor_frame_sink_support.cc
+++ b/chromium/components/viz/service/frame_sinks/compositor_frame_sink_support.cc
@@ -11,6 +11,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "components/viz/common/frame_sinks/begin_frame_source.h"
 #include "components/viz/common/quads/compositor_frame.h"
 #include "components/viz/common/resources/bitmap_allocation.h"
@@ -46,6 +47,20 @@ void RecordShouldSendBeginFrame(SendBeginFrameResult result) {
       "Compositing.CompositorFrameSinkSupport.ShouldSendBeginFrame", result);
 }
 
+void AdjustPresentationFeedback(gfx::PresentationFeedback* feedback,
+                                base::TimeTicks swap_start) {
+  // Swap start to end breakdown is always reported if ready timestamp is
+  // available. The other timestamps are adjusted to assume 0 delay in those
+  // stages if the breakdown is not available.
+  if (feedback->ready_timestamp.is_null())
+    return;
+
+  feedback->available_timestamp =
+      std::max(feedback->available_timestamp, swap_start);
+  feedback->latch_timestamp =
+      std::max(feedback->latch_timestamp, feedback->ready_timestamp);
+}
+
 }  // namespace
 
 CompositorFrameSinkSupport::CompositorFrameSinkSupport(
@@ -623,6 +638,8 @@ void CompositorFrameSinkSupport::DidPresentCompositorFrame(
   details.draw_start_timestamp = draw_start_timestamp;
   details.swap_timings = swap_timings;
   details.presentation_feedback = feedback;
+  AdjustPresentationFeedback(&details.presentation_feedback,
+                             swap_timings.swap_start);
   pending_received_frame_times_.erase(received_frame_timestamp);
 
   // We should only ever get one PresentationFeedback per frame_token.
diff --git a/chromium/components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc b/chromium/components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc
index 04968717787..dacc55a238f 100644
--- a/chromium/components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc
+++ b/chromium/components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
+#include "build/build_config.h"
 #include "components/viz/common/frame_sinks/copy_output_request.h"
 #include "components/viz/common/frame_sinks/copy_output_result.h"
 #include "components/viz/common/quads/compositor_frame.h"
@@ -22,18 +23,19 @@
 #include "components/viz/test/fake_external_begin_frame_source.h"
 #include "components/viz/test/fake_surface_observer.h"
 #include "components/viz/test/mock_compositor_frame_sink_client.h"
+#include "components/viz/test/viz_test_suite.h"
 #include "services/viz/privileged/mojom/compositing/frame_sink_manager.mojom.h"
 #include "services/viz/public/mojom/compositing/compositor_frame_sink.mojom.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2.h"
 
-using testing::UnorderedElementsAre;
-using testing::IsEmpty;
-using testing::SizeIs;
-using testing::Invoke;
 using testing::_;
 using testing::Eq;
+using testing::Invoke;
+using testing::IsEmpty;
+using testing::SizeIs;
+using testing::UnorderedElementsAre;
 
 namespace viz {
 namespace {
@@ -645,13 +647,17 @@ TEST_F(CompositorFrameSinkSupportTest, ProhibitsUnprivilegedCopyRequests) {
       false /* not root frame sink */);
 
   bool did_receive_aborted_copy_result = false;
+  base::RunLoop aborted_copy_run_loop;
   auto request = std::make_unique<CopyOutputRequest>(
       CopyOutputRequest::ResultFormat::RGBA_BITMAP,
       base::BindOnce(
-          [](bool* got_nothing, std::unique_ptr<CopyOutputResult> result) {
+          [](bool* got_nothing, base::OnceClosure finished,
+             std::unique_ptr<CopyOutputResult> result) {
             *got_nothing = result->IsEmpty();
+            std::move(finished).Run();
           },
-          &did_receive_aborted_copy_result));
+          &did_receive_aborted_copy_result,
+          aborted_copy_run_loop.QuitClosure()));
 
   auto frame = MakeDefaultCompositorFrame();
   ResourceId frame_resource_ids[] = {1, 2, 3};
@@ -660,6 +666,7 @@ TEST_F(CompositorFrameSinkSupportTest, ProhibitsUnprivilegedCopyRequests) {
 
   EXPECT_FALSE(SubmitCompositorFrameWithCopyRequest(std::move(frame),
                                                     std::move(request)));
+  aborted_copy_run_loop.Run();
   EXPECT_TRUE(did_receive_aborted_copy_result);
 
   // All the resources in the rejected frame should have been returned.
@@ -778,8 +785,10 @@ TEST_F(CompositorFrameSinkSupportTest, EvictOlderSurfaces) {
 }
 
 void CopyRequestTestCallback(bool* called,
+                             base::OnceClosure finished,
                              std::unique_ptr<CopyOutputResult> result) {
   *called = true;
+  std::move(finished).Run();
 }
 
 TEST_F(CompositorFrameSinkSupportTest, DuplicateCopyRequest) {
@@ -796,9 +805,11 @@ TEST_F(CompositorFrameSinkSupportTest, DuplicateCopyRequest) {
   }
 
   bool called1 = false;
+  base::RunLoop called1_run_loop;
   auto request = std::make_unique<CopyOutputRequest>(
       CopyOutputRequest::ResultFormat::RGBA_BITMAP,
-      base::BindOnce(&CopyRequestTestCallback, &called1));
+      base::BindOnce(&CopyRequestTestCallback, &called1,
+                     called1_run_loop.QuitClosure()));
   request->set_source(kArbitrarySourceId1);
 
   support_->RequestCopyOfOutput(local_surface_id_, std::move(request));
@@ -806,9 +817,11 @@ TEST_F(CompositorFrameSinkSupportTest, DuplicateCopyRequest) {
   EXPECT_FALSE(called1);
 
   bool called2 = false;
+  base::RunLoop called2_run_loop;
   request = std::make_unique<CopyOutputRequest>(
       CopyOutputRequest::ResultFormat::RGBA_BITMAP,
-      base::BindOnce(&CopyRequestTestCallback, &called2));
+      base::BindOnce(&CopyRequestTestCallback, &called2,
+                     called2_run_loop.QuitClosure()));
   request->set_source(kArbitrarySourceId2);
 
   support_->RequestCopyOfOutput(local_surface_id_, std::move(request));
@@ -818,14 +831,17 @@ TEST_F(CompositorFrameSinkSupportTest, DuplicateCopyRequest) {
   EXPECT_FALSE(called2);
 
   bool called3 = false;
+  base::RunLoop called3_run_loop;
   request = std::make_unique<CopyOutputRequest>(
       CopyOutputRequest::ResultFormat::RGBA_BITMAP,
-      base::BindOnce(&CopyRequestTestCallback, &called3));
+      base::BindOnce(&CopyRequestTestCallback, &called3,
+                     called3_run_loop.QuitClosure()));
   request->set_source(kArbitrarySourceId1);
 
   support_->RequestCopyOfOutput(local_surface_id_, std::move(request));
   GetSurfaceForId(surface_id)->TakeCopyOutputRequestsFromClient();
   // Two callbacks are from source1, so the first should be called.
+  called1_run_loop.Run();
   EXPECT_TRUE(called1);
   EXPECT_FALSE(called2);
   EXPECT_FALSE(called3);
@@ -834,6 +850,8 @@ TEST_F(CompositorFrameSinkSupportTest, DuplicateCopyRequest) {
   ExpireAllTemporaryReferences();
   local_surface_id_ = LocalSurfaceId();
   manager_.surface_manager()->GarbageCollectSurfaces();
+  called2_run_loop.Run();
+  called3_run_loop.Run();
   EXPECT_TRUE(called1);
   EXPECT_TRUE(called2);
   EXPECT_TRUE(called3);
@@ -1437,5 +1455,4 @@ TEST_F(CompositorFrameSinkSupportTest, ThrottleUnresponsiveClient) {
 
   support->SetNeedsBeginFrame(false);
 }
-
 }  // namespace viz
diff --git a/chromium/components/viz/service/frame_sinks/frame_sink_manager_impl.h b/chromium/components/viz/service/frame_sinks/frame_sink_manager_impl.h
index f7623ec4869..80767529f3c 100644
--- a/chromium/components/viz/service/frame_sinks/frame_sink_manager_impl.h
+++ b/chromium/components/viz/service/frame_sinks/frame_sink_manager_impl.h
@@ -12,10 +12,10 @@
 #include <vector>
 
 #include "base/callback_helpers.h"
+#include "base/check.h"
 #include "base/containers/flat_map.h"
 #include "base/containers/flat_set.h"
 #include "base/containers/unique_ptr_adapters.h"
-#include "base/logging.h"
 #include "base/macros.h"
 #include "base/optional.h"
 #include "base/single_thread_task_runner.h"
diff --git a/chromium/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc b/chromium/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc
index c2b189e0e66..675e05a76a7 100644
--- a/chromium/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc
+++ b/chromium/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc
@@ -64,7 +64,7 @@ RootCompositorFrameSinkImpl::Create(
   bool hw_support_for_multiple_refresh_rates = false;
   bool wants_vsync_updates = false;
 
-  if (params->external_begin_frame_controller.is_pending()) {
+  if (params->external_begin_frame_controller) {
     auto owned_external_begin_frame_source_mojo =
         std::make_unique<ExternalBeginFrameSourceMojo>(
             frame_sink_manager,
diff --git a/chromium/components/viz/service/frame_sinks/video_capture/frame_sink_video_capturer_impl.cc b/chromium/components/viz/service/frame_sinks/video_capture/frame_sink_video_capturer_impl.cc
index 08338b4153b..037d3cbea16 100644
--- a/chromium/components/viz/service/frame_sinks/video_capture/frame_sink_video_capturer_impl.cc
+++ b/chromium/components/viz/service/frame_sinks/video_capture/frame_sink_video_capturer_impl.cc
@@ -15,6 +15,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
@@ -521,29 +522,20 @@ void FrameSinkVideoCapturerImpl::MaybeCaptureFrame(
   // metadata, and notify the oracle.
   const int64_t capture_frame_number = next_capture_frame_number_++;
   VideoFrameMetadata* const metadata = frame->metadata();
-  metadata->SetTimeTicks(VideoFrameMetadata::CAPTURE_BEGIN_TIME,
-                         clock_->NowTicks());
-  metadata->SetInteger(VideoFrameMetadata::CAPTURE_COUNTER,
-                       capture_frame_number);
-  metadata->SetTimeDelta(VideoFrameMetadata::FRAME_DURATION,
-                         oracle_->estimated_frame_duration());
-  metadata->SetDouble(VideoFrameMetadata::FRAME_RATE,
-                      1.0 / oracle_->min_capture_period().InSecondsF());
-  metadata->SetTimeTicks(VideoFrameMetadata::REFERENCE_TIME, event_time);
-  metadata->SetDouble(VideoFrameMetadata::DEVICE_SCALE_FACTOR,
-                      frame_metadata.device_scale_factor);
-  metadata->SetDouble(VideoFrameMetadata::PAGE_SCALE_FACTOR,
-                      frame_metadata.page_scale_factor);
-  metadata->SetDouble(VideoFrameMetadata::ROOT_SCROLL_OFFSET_X,
-                      frame_metadata.root_scroll_offset.x());
-  metadata->SetDouble(VideoFrameMetadata::ROOT_SCROLL_OFFSET_Y,
-                      frame_metadata.root_scroll_offset.y());
+  metadata->capture_begin_time = clock_->NowTicks();
+  metadata->capture_counter = capture_frame_number;
+  metadata->frame_duration = oracle_->estimated_frame_duration();
+  metadata->frame_rate = 1.0 / oracle_->min_capture_period().InSecondsF();
+  metadata->reference_time = event_time;
+  metadata->device_scale_factor = frame_metadata.device_scale_factor;
+  metadata->page_scale_factor = frame_metadata.page_scale_factor;
+  metadata->root_scroll_offset_x = frame_metadata.root_scroll_offset.x();
+  metadata->root_scroll_offset_y = frame_metadata.root_scroll_offset.y();
   if (frame_metadata.top_controls_visible_height.has_value()) {
     last_top_controls_visible_height_ =
         *frame_metadata.top_controls_visible_height;
   }
-  metadata->SetDouble(VideoFrameMetadata::TOP_CONTROLS_VISIBLE_HEIGHT,
-                      last_top_controls_visible_height_);
+  metadata->top_controls_visible_height = last_top_controls_visible_height_;
 
   oracle_->RecordCapture(utilization);
   TRACE_EVENT_ASYNC_BEGIN2("gpu.capture", "Capture", oracle_frame_number,
@@ -578,8 +570,8 @@ void FrameSinkVideoCapturerImpl::MaybeCaptureFrame(
     if (pixel_format_ == media::PIXEL_FORMAT_I420)
       update_rect = ExpandRectToI420SubsampleBoundaries(update_rect);
   }
-  metadata->SetRect(media::VideoFrameMetadata::CAPTURE_UPDATE_RECT,
-                    update_rect);
+  metadata->capture_update_rect = update_rect;
+
   // Extreme edge-case: If somehow the source size is so tiny that the content
   // region becomes empty, just deliver a frame filled with black.
   if (content_rect.IsEmpty()) {
@@ -639,6 +631,7 @@ void FrameSinkVideoCapturerImpl::MaybeCaptureFrame(
                      VideoCaptureOverlay::MakeCombinedRenderer(
                          GetOverlaysInOrder(), content_rect, frame->format()),
                      std::move(frame), base::TimeTicks::Now())));
+  request->set_result_task_runner(base::SequencedTaskRunnerHandle::Get());
   request->set_source(copy_request_source_);
   request->set_area(gfx::Rect(source_size));
   request->SetScaleRatio(
@@ -803,10 +796,8 @@ void FrameSinkVideoCapturerImpl::OnFrameReadyForDelivery(
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_GE(capture_frame_number, next_delivery_frame_number_);
 
-  if (frame) {
-    frame->metadata()->SetTimeTicks(VideoFrameMetadata::CAPTURE_END_TIME,
-                                    clock_->NowTicks());
-  }
+  if (frame)
+    frame->metadata()->capture_end_time = clock_->NowTicks();
 
   // Ensure frames are delivered in-order by using a min-heap, and only
   // deliver the next frame(s) in-sequence when they are found at the top.
@@ -871,7 +862,7 @@ void FrameSinkVideoCapturerImpl::MaybeDeliverFrame(
   // the consumer.
   media::mojom::VideoFrameInfoPtr info = media::mojom::VideoFrameInfo::New();
   info->timestamp = frame->timestamp();
-  info->metadata = frame->metadata()->GetInternalValues().Clone();
+  info->metadata = *(frame->metadata());
   info->pixel_format = frame->format();
   info->coded_size = frame->coded_size();
   info->visible_rect = frame->visible_rect();
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 11b9327289f..21ef53a9b01 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
@@ -58,20 +58,16 @@ bool CompareVarsInCompositorFrameMetadata(
     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;
+  auto dsf = frame.metadata()->device_scale_factor;
+  auto psf = frame.metadata()->page_scale_factor;
+  auto rso_x = frame.metadata()->root_scroll_offset_x;
+  auto rso_y = frame.metadata()->root_scroll_offset_y;
+
+  bool valid = dsf.has_value() && psf.has_value() && rso_x.has_value() &&
+               rso_y.has_value();
+
+  return valid && *dsf == device_scale_factor && *psf == page_scale_factor &&
+         gfx::Vector2dF(*rso_x, *rso_y) == root_scroll_offset;
 }
 
 // Dummy frame sink ID.
@@ -107,7 +103,11 @@ struct YUVColor {
 
 // Forces any pending Mojo method calls between the capturer and consumer to be
 // made.
-void PropagateMojoTasks() {
+void PropagateMojoTasks(
+    scoped_refptr<base::TestMockTimeTaskRunner> runner = nullptr) {
+  if (runner) {
+    runner->RunUntilIdle();
+  }
   base::RunLoop().RunUntilIdle();
 }
 
@@ -171,7 +171,7 @@ class MockConsumer : public mojom::FrameSinkVideoConsumer {
             const_cast<uint8_t*>(static_cast<const uint8_t*>(mapping.memory())),
             mapping.size(), info->timestamp);
     ASSERT_TRUE(frame);
-    frame->metadata()->MergeInternalValuesFrom(info->metadata);
+    frame->set_metadata(info->metadata);
     if (info->color_space.has_value())
       frame->set_color_space(info->color_space.value());
 
@@ -288,7 +288,11 @@ class FakeCapturableFrameSink : public CapturableFrameSink {
   void SendCopyOutputResult(int offset) {
     auto it = results_.begin() + offset;
     std::move(*it).Run();
-    PropagateMojoTasks();
+    PropagateMojoTasks(task_runner_);
+  }
+
+  void set_task_runner(scoped_refptr<base::TestMockTimeTaskRunner> runner) {
+    task_runner_ = std::move(runner);
   }
 
  private:
@@ -296,6 +300,7 @@ class FakeCapturableFrameSink : public CapturableFrameSink {
   YUVColor color_ = {0xde, 0xad, 0xbf};
   SizeSet size_set_;
   CompositorFrameMetadata metadata_;
+  scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
 
   std::vector<base::OnceClosure> results_;
 };
@@ -393,6 +398,10 @@ class FrameSinkVideoCapturerTest : public testing::Test {
     start_time_ = task_runner_->NowTicks();
     capturer_->clock_ = task_runner_->GetMockTickClock();
 
+    // Ensure any posted tasks for CopyOutputResults will be handled when
+    // PropagateMojoTasks() is called
+    frame_sink_.set_task_runner(task_runner_);
+
     // Replace the retry timer with one that uses this test's fake clock and
     // task runner.
     capturer_->refresh_frame_retry_timer_.emplace(
@@ -642,26 +651,15 @@ TEST_F(FrameSinkVideoCapturerTest, CapturesCompositedFrames) {
     EXPECT_LT(last_timestamp, frame->timestamp());
     last_timestamp = frame->timestamp();
     const VideoFrameMetadata* metadata = frame->metadata();
-    base::TimeTicks capture_begin_time;
-    EXPECT_TRUE(metadata->GetTimeTicks(VideoFrameMetadata::CAPTURE_BEGIN_TIME,
-                                       &capture_begin_time));
-    EXPECT_EQ(expected_capture_begin_time, capture_begin_time);
-    base::TimeTicks capture_end_time;
-    EXPECT_TRUE(metadata->GetTimeTicks(VideoFrameMetadata::CAPTURE_END_TIME,
-                                       &capture_end_time));
-    EXPECT_EQ(expected_capture_end_time, capture_end_time);
+    EXPECT_EQ(expected_capture_begin_time, *metadata->capture_begin_time);
+    EXPECT_EQ(expected_capture_end_time, *metadata->capture_end_time);
     EXPECT_EQ(gfx::ColorSpace::CreateREC709(), frame->ColorSpace());
-    EXPECT_TRUE(metadata->HasKey(VideoFrameMetadata::FRAME_DURATION));
-    // FRAME_DURATION is an estimate computed by the VideoCaptureOracle, so it
+    // frame_duration is an estimate computed by the VideoCaptureOracle, so it
     // its exact value is not being checked here.
-    double frame_rate = 0.0;
-    EXPECT_TRUE(
-        metadata->GetDouble(VideoFrameMetadata::FRAME_RATE, &frame_rate));
-    EXPECT_NEAR(media::limits::kMaxFramesPerSecond, frame_rate, 0.001);
-    base::TimeTicks reference_time;
-    EXPECT_TRUE(metadata->GetTimeTicks(VideoFrameMetadata::REFERENCE_TIME,
-                                       &reference_time));
-    EXPECT_EQ(expected_reference_time, reference_time);
+    EXPECT_TRUE(metadata->frame_duration.has_value());
+    EXPECT_NEAR(media::limits::kMaxFramesPerSecond, *metadata->frame_rate,
+                0.001);
+    EXPECT_EQ(expected_reference_time, *metadata->reference_time);
 
     // Notify the capturer that the consumer is done with the frame.
     consumer.SendDoneNotification(i);
@@ -1150,14 +1148,10 @@ TEST_F(FrameSinkVideoCapturerTest, DeliversUpdateRectAndCaptureCounter) {
   EXPECT_EQ(expected_frames_count, consumer.num_frames_received());
   {
     auto received_frame = consumer.TakeFrame(cur_frame_index);
-    gfx::Rect received_update_rect;
-    int received_capture_counter = 0;
-    ASSERT_TRUE(received_frame->metadata()->GetInteger(
-        media::VideoFrameMetadata::CAPTURE_COUNTER, &received_capture_counter));
-    ASSERT_TRUE(received_frame->metadata()->GetRect(
-        media::VideoFrameMetadata::CAPTURE_UPDATE_RECT, &received_update_rect));
-    EXPECT_EQ(gfx::Rect(size_set().capture_size), received_update_rect);
-    previous_capture_counter_received = received_capture_counter;
+    EXPECT_EQ(gfx::Rect(size_set().capture_size),
+              received_frame->metadata()->capture_update_rect);
+    previous_capture_counter_received =
+        *received_frame->metadata()->capture_counter;
   }
   consumer.SendDoneNotification(cur_frame_index);
 
@@ -1184,13 +1178,9 @@ TEST_F(FrameSinkVideoCapturerTest, DeliversUpdateRectAndCaptureCounter) {
   EXPECT_EQ(expected_frames_count, consumer.num_frames_received());
   {
     auto received_frame = consumer.TakeFrame(++cur_frame_index);
-    int received_capture_counter = 0;
-    gfx::Rect received_update_rect;
-    ASSERT_TRUE(received_frame->metadata()->GetInteger(
-        media::VideoFrameMetadata::CAPTURE_COUNTER, &received_capture_counter));
-    ASSERT_TRUE(received_frame->metadata()->GetRect(
-        media::VideoFrameMetadata::CAPTURE_UPDATE_RECT, &received_update_rect));
-    EXPECT_EQ(expected_frame_update_rect, received_update_rect);
+    int received_capture_counter = *received_frame->metadata()->capture_counter;
+    EXPECT_EQ(expected_frame_update_rect,
+              *received_frame->metadata()->capture_update_rect);
     EXPECT_EQ(previous_capture_counter_received + 1, received_capture_counter);
     previous_capture_counter_received = received_capture_counter;
   }
@@ -1206,13 +1196,8 @@ TEST_F(FrameSinkVideoCapturerTest, DeliversUpdateRectAndCaptureCounter) {
   EXPECT_EQ(expected_frames_count, consumer.num_frames_received());
   {
     auto received_frame = consumer.TakeFrame(++cur_frame_index);
-    int received_capture_counter = 0;
-    gfx::Rect received_update_rect;
-    ASSERT_TRUE(received_frame->metadata()->GetInteger(
-        media::VideoFrameMetadata::CAPTURE_COUNTER, &received_capture_counter));
-    ASSERT_TRUE(received_frame->metadata()->GetRect(
-        media::VideoFrameMetadata::CAPTURE_UPDATE_RECT, &received_update_rect));
-    EXPECT_TRUE(received_update_rect.IsEmpty());
+    int received_capture_counter = *received_frame->metadata()->capture_counter;
+    EXPECT_TRUE(received_frame->metadata()->capture_update_rect->IsEmpty());
     EXPECT_EQ(previous_capture_counter_received + 1, received_capture_counter);
     previous_capture_counter_received = received_capture_counter;
   }
@@ -1229,13 +1214,9 @@ TEST_F(FrameSinkVideoCapturerTest, DeliversUpdateRectAndCaptureCounter) {
   EXPECT_EQ(expected_frames_count, consumer.num_frames_received());
   {
     auto received_frame = consumer.TakeFrame(++cur_frame_index);
-    int received_capture_counter = 0;
-    gfx::Rect received_update_rect;
-    ASSERT_TRUE(received_frame->metadata()->GetInteger(
-        media::VideoFrameMetadata::CAPTURE_COUNTER, &received_capture_counter));
-    ASSERT_TRUE(received_frame->metadata()->GetRect(
-        media::VideoFrameMetadata::CAPTURE_UPDATE_RECT, &received_update_rect));
-    EXPECT_EQ(gfx::Rect(size_set().capture_size), received_update_rect);
+    int received_capture_counter = *received_frame->metadata()->capture_counter;
+    EXPECT_EQ(gfx::Rect(size_set().capture_size),
+              *received_frame->metadata()->capture_update_rect);
     EXPECT_EQ(previous_capture_counter_received + 1, received_capture_counter);
     previous_capture_counter_received = received_capture_counter;
   }
@@ -1252,13 +1233,9 @@ TEST_F(FrameSinkVideoCapturerTest, DeliversUpdateRectAndCaptureCounter) {
   EXPECT_EQ(expected_frames_count, consumer.num_frames_received());
   {
     auto received_frame = consumer.TakeFrame(++cur_frame_index);
-    int received_capture_counter = 0;
-    gfx::Rect received_update_rect;
-    ASSERT_TRUE(received_frame->metadata()->GetInteger(
-        media::VideoFrameMetadata::CAPTURE_COUNTER, &received_capture_counter));
-    ASSERT_TRUE(received_frame->metadata()->GetRect(
-        media::VideoFrameMetadata::CAPTURE_UPDATE_RECT, &received_update_rect));
-    EXPECT_EQ(gfx::Rect(size_set().capture_size), received_update_rect);
+    int received_capture_counter = *received_frame->metadata()->capture_counter;
+    EXPECT_EQ(gfx::Rect(size_set().capture_size),
+              *received_frame->metadata()->capture_update_rect);
     EXPECT_EQ(previous_capture_counter_received + 1, received_capture_counter);
     previous_capture_counter_received = received_capture_counter;
   }
@@ -1286,14 +1263,10 @@ TEST_F(FrameSinkVideoCapturerTest, CaptureCounterSkipsWhenFramesAreDropped) {
   EXPECT_EQ(expected_frames_count, consumer.num_frames_received());
   {
     auto received_frame = consumer.TakeFrame(cur_receive_frame_index);
-    int received_capture_counter = 0;
-    gfx::Rect received_update_rect;
-    ASSERT_TRUE(received_frame->metadata()->GetInteger(
-        media::VideoFrameMetadata::CAPTURE_COUNTER, &received_capture_counter));
-    ASSERT_TRUE(received_frame->metadata()->GetRect(
-        media::VideoFrameMetadata::CAPTURE_UPDATE_RECT, &received_update_rect));
-    EXPECT_EQ(gfx::Rect(size_set().capture_size), received_update_rect);
-    previous_capture_counter_received = received_capture_counter;
+    EXPECT_EQ(gfx::Rect(size_set().capture_size),
+              *received_frame->metadata()->capture_update_rect);
+    previous_capture_counter_received =
+        *received_frame->metadata()->capture_counter;
   }
   consumer.SendDoneNotification(cur_receive_frame_index);
 
@@ -1318,10 +1291,8 @@ TEST_F(FrameSinkVideoCapturerTest, CaptureCounterSkipsWhenFramesAreDropped) {
   EXPECT_EQ(expected_frames_count, consumer.num_frames_received());
   {
     auto received_frame = consumer.TakeFrame(++cur_receive_frame_index);
-    int received_capture_counter = 0;
-    ASSERT_TRUE(received_frame->metadata()->GetInteger(
-        media::VideoFrameMetadata::CAPTURE_COUNTER, &received_capture_counter));
-    EXPECT_NE(previous_capture_counter_received + 1, received_capture_counter);
+    EXPECT_NE(previous_capture_counter_received + 1,
+              *received_frame->metadata()->capture_counter);
   }
   StopCapture();
 }
diff --git a/chromium/components/viz/service/frame_sinks/video_capture/interprocess_frame_pool.cc b/chromium/components/viz/service/frame_sinks/video_capture/interprocess_frame_pool.cc
index 04d16521310..419d97d9f39 100644
--- a/chromium/components/viz/service/frame_sinks/video_capture/interprocess_frame_pool.cc
+++ b/chromium/components/viz/service/frame_sinks/video_capture/interprocess_frame_pool.cc
@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/logging.h"
 
 using media::VideoFrame;
 using media::VideoPixelFormat;