VideoFrameReceiver: Remove unused scaled_buffers param.

Autumn cleaning...
As of [1], all code paths set it to {}, so we can delete it.

Follow-up CLs will continue to follow the trail of {} and delete the
scaled buffers parameters of other interfaces.

[1] https://chromium-review.googlesource.com/c/chromium/src/+/4886802

Bug: chromium:1440075
Change-Id: I144ae4e92e8cdb9f48f6ac7b87223cae5b7df769
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4892398
Reviewed-by: Mark Foltz <mfoltz@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Ahmed Fakhry <afakhry@chromium.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@chromium.org>
Commit-Queue: Henrik Boström <hbos@chromium.org>
Reviewed-by: Markus Handell <handellm@google.com>
Reviewed-by: Wei Lee <wtlee@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1206352}

ash/capture_mode/fake_camera_device.cc

@@ -295,7 +295,7 @@ class FakeCameraDevice::Subscription
   void OnFrameReadyInBuffer(
       video_capture::mojom::ReadyFrameInBufferPtr buffer) {
     DCHECK(is_active_ && !is_suspended_);
-    subscriber_->OnFrameReadyInBuffer(std::move(buffer), {});
+    subscriber_->OnFrameReadyInBuffer(std::move(buffer));
   }
 
   void OnFrameDropped() {

chromeos/crosapi/mojom/video_capture.mojom

@@ -140,6 +140,10 @@ interface VideoFrameHandler {
 
   OnNewBuffer@0(int32 buffer_id, VideoBufferHandle buffer_handle);
 
+  // `scaled_buffers` is always an empty list, it is only present for backwards
+  // compat reasons.
+  // TODO(https://crbug.com/1440075): Migrate away from this method and delete
+  // it in favor of a version that does not take `scaled_buffers`.
   OnFrameReadyInBuffer@1(ReadyFrameInBuffer buffer,
                          array<ReadyFrameInBuffer> scaled_buffers);
 

components/capture_mode/camera_video_frame_handler.cc

@@ -604,17 +604,9 @@ void CameraVideoFrameHandler::OnFrameAccessHandlerReady(
 }
 
 void CameraVideoFrameHandler::OnFrameReadyInBuffer(
-    video_capture::mojom::ReadyFrameInBufferPtr buffer,
+    video_capture::mojom::ReadyFrameInBufferPtr buffer) {
-    std::vector<video_capture::mojom::ReadyFrameInBufferPtr> scaled_buffers) {
   CHECK(video_frame_access_handler_remote_);
 
-  // Ignore scaled buffers for now.
-  for (auto& scaled_buffer : scaled_buffers) {
-    video_frame_access_handler_remote_->OnFinishedConsumingBuffer(
-        scaled_buffer->buffer_id);
-  }
-  scaled_buffers.clear();
-
   const int buffer_id = buffer->buffer_id;
 
   if (!active_) {

components/capture_mode/camera_video_frame_handler.h

@@ -121,9 +121,7 @@ class CAPTURE_MODE_EXPORT CameraVideoFrameHandler
       mojo::PendingRemote<video_capture::mojom::VideoFrameAccessHandler>
           pending_frame_access_handler) override;
   void OnFrameReadyInBuffer(
-      video_capture::mojom::ReadyFrameInBufferPtr buffer,
+      video_capture::mojom::ReadyFrameInBufferPtr buffer) override;
-      std::vector<video_capture::mojom::ReadyFrameInBufferPtr> scaled_buffers)
-      override;
   void OnBufferRetired(int buffer_id) override;
   void OnError(media::VideoCaptureError error) override;
   void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

components/mirroring/browser/single_client_video_capture_host.cc

@@ -215,8 +215,7 @@ void SingleClientVideoCaptureHost::OnNewBuffer(
 }
 
 void SingleClientVideoCaptureHost::OnFrameReadyInBuffer(
-    media::ReadyFrameInBuffer frame,
+    media::ReadyFrameInBuffer frame) {
-    std::vector<media::ReadyFrameInBuffer> scaled_frames) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(3) << __func__ << ": buffer_id=" << frame.buffer_id;
   DCHECK(observer_);

components/mirroring/browser/single_client_video_capture_host.h

@@ -82,9 +82,7 @@ class SingleClientVideoCaptureHost final
   void OnCaptureConfigurationChanged() override;
   void OnNewBuffer(int buffer_id,
                    media::mojom::VideoBufferHandlePtr buffer_handle) override;
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) override;
-      media::ReadyFrameInBuffer frame,
-      std::vector<media::ReadyFrameInBuffer> scaled_frames) override;
   void OnBufferRetired(int buffer_id) override;
   void OnError(media::VideoCaptureError error) override;
   void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

components/mirroring/browser/single_client_video_capture_host_unittest.cc

@@ -273,11 +273,9 @@ class SingleClientVideoCaptureHostTest : public ::testing::Test {
     base::RunLoop run_loop;
     EXPECT_CALL(*consumer_, OnBufferReadyCall(buffer_context_id))
         .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
-    frame_receiver_->OnFrameReadyInBuffer(
+    frame_receiver_->OnFrameReadyInBuffer(media::ReadyFrameInBuffer(
-        media::ReadyFrameInBuffer(buffer_id, feedback_id,
+        buffer_id, feedback_id, std::make_unique<StubReadWritePermission>(),
-                                  std::make_unique<StubReadWritePermission>(),
+        GetVideoFrameInfo()));
-                                  GetVideoFrameInfo()),
-        {});
     run_loop.Run();
   }
 

content/browser/media/capture/fake_video_capture_stack.cc

@@ -216,9 +216,7 @@ class FakeVideoCaptureStackReceiver final : public media::VideoFrameReceiver {
     return mapped_frame;
   }
 
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) override {
-      media::ReadyFrameInBuffer frame,
-      std::vector<media::ReadyFrameInBuffer> scaled_frames) override {
     DCHECK_CALLED_ON_VALID_SEQUENCE(capture_stack_sequence_checker_);
 
     // Unretained is safe since we own the thread to which we're posting.

content/browser/media/capture/frame_sink_video_capture_device.cc

@@ -499,14 +499,12 @@ void FrameSinkVideoCaptureDevice::OnFrameCaptured(
   // passing the shared memory buffer handle and then notifying it that a new
   // frame is ready to be read from the buffer.
   receiver_->OnNewBuffer(buffer_id, std::move(data));
-  receiver_->OnFrameReadyInBuffer(
+  receiver_->OnFrameReadyInBuffer(media::ReadyFrameInBuffer(
-      media::ReadyFrameInBuffer(
+      buffer_id, buffer_id,
-          buffer_id, buffer_id,
+      std::make_unique<media::ScopedFrameDoneHelper>(base::BindOnce(
-          std::make_unique<media::ScopedFrameDoneHelper>(base::BindOnce(
+          &FrameSinkVideoCaptureDevice::OnFramePropagationComplete,
-              &FrameSinkVideoCaptureDevice::OnFramePropagationComplete,
+          weak_factory_.GetWeakPtr(), buffer_id)),
-              weak_factory_.GetWeakPtr(), buffer_id)),
+      std::move(info)));
-          std::move(info)),
-      {});
 }
 
 void FrameSinkVideoCaptureDevice::OnNewCropVersion(uint32_t crop_version) {

content/browser/media/capture/frame_sink_video_capture_device_unittest.cc

@@ -195,9 +195,7 @@ class MockVideoFrameReceiver : public media::VideoFrameReceiver {
   MOCK_METHOD2(MockOnNewBuffer,
                void(int buffer_id,
                     media::mojom::VideoBufferHandle* buffer_handle));
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) final {
-      media::ReadyFrameInBuffer frame,
-      std::vector<media::ReadyFrameInBuffer> scaled_frames) final {
     DCHECK_ON_DEVICE_THREAD();
     feedback_ids_[frame.buffer_id] = frame.frame_feedback_id;
     auto* const raw_pointer_to_permission = frame.buffer_read_permission.get();

content/browser/media/capture/receiver_media_to_crosapi_adapter.cc

@@ -35,14 +35,8 @@ void ReceiverMediaToCrosapiAdapter::OnNewBuffer(
 
 void ReceiverMediaToCrosapiAdapter::OnFrameReadyInBuffer(
     crosapi::mojom::ReadyFrameInBufferPtr buffer,
-    std::vector<crosapi::mojom::ReadyFrameInBufferPtr> scaled_buffers) {
+    std::vector<crosapi::mojom::ReadyFrameInBufferPtr> /*scaled_buffers*/) {
-  std::vector<media::ReadyFrameInBuffer> media_scaled_buffers;
+  handler_->OnFrameReadyInBuffer(ConvertToMediaReadyFrame(std::move(buffer)));
-  for (auto& b : scaled_buffers) {
-    media_scaled_buffers.push_back(ConvertToMediaReadyFrame(std::move(b)));
-  }
-
-  handler_->OnFrameReadyInBuffer(ConvertToMediaReadyFrame(std::move(buffer)),
-                                 std::move(media_scaled_buffers));
 }
 
 void ReceiverMediaToCrosapiAdapter::OnBufferRetired(int buffer_id) {

content/browser/renderer_host/media/video_capture_controller.cc

@@ -422,8 +422,7 @@ void VideoCaptureController::OnNewBuffer(
 }
 
 void VideoCaptureController::OnFrameReadyInBuffer(
-    media::ReadyFrameInBuffer frame,
+    media::ReadyFrameInBuffer frame) {
-    std::vector<media::ReadyFrameInBuffer> scaled_frames) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_NE(frame.buffer_id, media::VideoCaptureBufferPool::kInvalidId);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("video_and_image_capture"),
@@ -436,42 +435,20 @@ void VideoCaptureController::OnFrameReadyInBuffer(
       frame.buffer_id, frame.frame_feedback_id, std::move(frame.frame_info),
       &frame_context);
 
-  std::vector<BufferContext*> scaled_frame_contexts;
-  scaled_frame_contexts.reserve(scaled_frames.size());
-  std::vector<ReadyBuffer> scaled_frame_ready_buffers;
-  scaled_frame_ready_buffers.reserve(scaled_frames.size());
-  for (auto& scaled_frame : scaled_frames) {
-    BufferContext* scaled_frame_context;
-    scaled_frame_ready_buffers.push_back(MakeReadyBufferAndSetContextFeedbackId(
-        scaled_frame.buffer_id, scaled_frame.frame_feedback_id,
-        std::move(scaled_frame.frame_info), &scaled_frame_context));
-    scaled_frame_contexts.push_back(scaled_frame_context);
-  }
-
   if (state_ != blink::VIDEO_CAPTURE_STATE_ERROR) {
     // Inform all active clients of the frames.
     for (const auto& client : controller_clients_) {
       if (client->session_closed || client->paused)
         continue;
       MakeClientUseBufferContext(frame_context, client.get());
-      for (auto* scaled_frame_context : scaled_frame_contexts) {
-        MakeClientUseBufferContext(scaled_frame_context, client.get());
-      }
       client->event_handler->OnBufferReady(client->controller_id,
-                                           frame_ready_buffer,
+                                           frame_ready_buffer, {});
-                                           scaled_frame_ready_buffers);
     }
     // Transfer buffer read permissions to any contexts that now have consumers.
     if (frame_context->HasConsumers()) {
       frame_context->set_read_permission(
           std::move(frame.buffer_read_permission));
     }
-    for (size_t i = 0; i < scaled_frames.size(); ++i) {
-      if (!scaled_frame_contexts[i]->HasConsumers())
-        continue;
-      scaled_frame_contexts[i]->set_read_permission(
-          std::move(scaled_frames[i].buffer_read_permission));
-    }
   }
 
   if (!has_received_frames_) {

content/browser/renderer_host/media/video_capture_controller.h

@@ -111,9 +111,7 @@ class CONTENT_EXPORT VideoCaptureController
   void OnCaptureConfigurationChanged() override;
   void OnNewBuffer(int32_t buffer_id,
                    media::mojom::VideoBufferHandlePtr buffer_handle) override;
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) override;
-      media::ReadyFrameInBuffer frame,
-      std::vector<media::ReadyFrameInBuffer> scaled_frames) override;
   void OnBufferRetired(int buffer_id) override;
   void OnError(media::VideoCaptureError error) override;
   void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

content/browser/renderer_host/media/video_capture_controller_unittest.cc

@@ -84,9 +84,7 @@ class MockVideoCaptureControllerEventHandler
                void(const VideoCaptureControllerID&, int buffer_id));
   MOCK_METHOD2(DoBufferDestroyed,
                void(const VideoCaptureControllerID&, int buffer_id));
-  MOCK_METHOD2(DoBufferReady,
+  MOCK_METHOD1(DoBufferReady, void(ControllerIDAndSize buffer));
-               void(ControllerIDAndSize buffer,
-                    std::vector<ControllerIDAndSize> scaled_buffers));
   MOCK_METHOD1(OnCaptureConfigurationChanged,
                void(const VideoCaptureControllerID&));
   MOCK_METHOD1(OnFrameWithEmptyRegionCapture,
@@ -121,12 +119,7 @@ class MockVideoCaptureControllerEventHandler
     EXPECT_EQ(expected_pixel_format_, buffer.frame_info->pixel_format);
     EXPECT_EQ(expected_color_space_, buffer.frame_info->color_space);
     EXPECT_TRUE(buffer.frame_info->metadata.reference_time.has_value());
-    std::vector<ControllerIDAndSize> scaled_frames;
+    DoBufferReady(ControllerIDAndSize(id, buffer.frame_info->coded_size));
-    for (const auto& scaled_buffer : scaled_buffers) {
-      scaled_frames.emplace_back(id, scaled_buffer.frame_info->coded_size);
-    }
-    DoBufferReady(ControllerIDAndSize(id, buffer.frame_info->coded_size),
-                  std::move(scaled_frames));
     if (enable_auto_return_buffer_on_buffer_ready_) {
       base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
           FROM_HERE, base::BindOnce(&VideoCaptureController::ReturnBuffer,
@@ -415,26 +408,20 @@ TEST_P(VideoCaptureControllerTest, NormalCaptureMultipleClients) {
   {
     InSequence s;
     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_1, _));
-    EXPECT_CALL(*client_a_,
+    EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
-                DoBufferReady(ControllerIDAndSize(client_a_route_1,
+                                client_a_route_1, device_format.frame_size)));
-                                                  device_format.frame_size),
-                              std::vector<ControllerIDAndSize>()));
   }
   {
     InSequence s;
     EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1, _));
-    EXPECT_CALL(*client_b_,
+    EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
-                DoBufferReady(ControllerIDAndSize(client_b_route_1,
+                                client_b_route_1, device_format.frame_size)));
-                                                  device_format.frame_size),
-                              std::vector<ControllerIDAndSize>()));
   }
   {
     InSequence s;
     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2, _));
-    EXPECT_CALL(*client_a_,
+    EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
-                DoBufferReady(ControllerIDAndSize(client_a_route_2,
+                                client_a_route_2, device_format.frame_size)));
-                                                  device_format.frame_size),
-                              std::vector<ControllerIDAndSize>()));
   }
   client_a_->feedback_.resource_utilization = 0.5;
   client_b_->feedback_.resource_utilization = -1.0;
@@ -484,18 +471,12 @@ TEST_P(VideoCaptureControllerTest, NormalCaptureMultipleClients) {
                                            arbitrary_timestamp_);
 
   // The frame should be delivered to the clients in any order.
-  EXPECT_CALL(*client_a_,
+  EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
-              DoBufferReady(ControllerIDAndSize(client_a_route_1,
+                              client_a_route_1, device_format.frame_size)));
-                                                device_format.frame_size),
+  EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
-                            std::vector<ControllerIDAndSize>()));
+                              client_b_route_1, device_format.frame_size)));
-  EXPECT_CALL(*client_b_,
+  EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
-              DoBufferReady(ControllerIDAndSize(client_b_route_1,
+                              client_a_route_2, device_format.frame_size)));
-                                                device_format.frame_size),
-                            std::vector<ControllerIDAndSize>()));
-  EXPECT_CALL(*client_a_,
-              DoBufferReady(ControllerIDAndSize(client_a_route_2,
-                                                device_format.frame_size),
-                            std::vector<ControllerIDAndSize>()));
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
@@ -534,31 +515,23 @@ TEST_P(VideoCaptureControllerTest, NormalCaptureMultipleClients) {
   // the old clients only |kPoolSize - 1|.
   EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_2, _))
       .Times(kPoolSize);
-  EXPECT_CALL(*client_b_,
+  EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
-              DoBufferReady(ControllerIDAndSize(client_b_route_2,
+                              client_b_route_2, device_format.frame_size)))
-                                                device_format.frame_size),
-                            std::vector<ControllerIDAndSize>()))
       .Times(kPoolSize);
   EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_1, _))
       .Times(kPoolSize - 1);
-  EXPECT_CALL(*client_a_,
+  EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
-              DoBufferReady(ControllerIDAndSize(client_a_route_1,
+                              client_a_route_1, device_format.frame_size)))
-                                                device_format.frame_size),
-                            std::vector<ControllerIDAndSize>()))
       .Times(kPoolSize);
   EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2, _))
       .Times(kPoolSize - 1);
-  EXPECT_CALL(*client_a_,
+  EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
-              DoBufferReady(ControllerIDAndSize(client_a_route_2,
+                              client_a_route_2, device_format.frame_size)))
-                                                device_format.frame_size),
-                            std::vector<ControllerIDAndSize>()))
       .Times(kPoolSize);
   EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1, _))
       .Times(kPoolSize - 1);
-  EXPECT_CALL(*client_b_,
+  EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
-              DoBufferReady(ControllerIDAndSize(client_b_route_1,
+                              client_b_route_1, device_format.frame_size)))
-                                                device_format.frame_size),
-                            std::vector<ControllerIDAndSize>()))
       .Times(kPoolSize);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
@@ -602,10 +575,8 @@ TEST_P(VideoCaptureControllerTest, NormalCaptureMultipleClients) {
                                            arbitrary_timestamp_);
   // B2 is the only client left, and is the only one that should
   // get the buffer.
-  EXPECT_CALL(*client_b_,
+  EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
-              DoBufferReady(ControllerIDAndSize(client_b_route_2,
+                              client_b_route_2, device_format.frame_size)))
-                                                device_format.frame_size),
-                            std::vector<ControllerIDAndSize>()))
       .Times(2);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
@@ -762,10 +733,8 @@ TEST_F(VideoCaptureControllerTest, FrameFeedbackIsReportedForSequenceOfFrames) {
 
     client_a_->feedback_ = stub_consumer_feedback;
 
-    EXPECT_CALL(*client_a_,
+    EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
-                DoBufferReady(
+                                route_id, arbitrary_format.frame_size)))
-                    ControllerIDAndSize(route_id, arbitrary_format.frame_size),
-                    std::vector<ControllerIDAndSize>()))
         .Times(1);
     EXPECT_CALL(*mock_launched_device_,
                 OnUtilizationReport(stub_consumer_feedback))
@@ -823,7 +792,7 @@ TEST_F(VideoCaptureControllerTest,
     EXPECT_CALL(*client_a_, DoBufferCreated(_, _))
         .Times(1)
         .WillOnce(SaveArg<1>(&buffer_id_reported_to_client));
-    EXPECT_CALL(*client_a_, DoBufferReady(_, _)).Times(1);
+    EXPECT_CALL(*client_a_, DoBufferReady(_)).Times(1);
   }
   EXPECT_CALL(*client_a_, DoBufferDestroyed(_, _)).Times(0);
   SendStubFrameToDeviceClient(arbitrary_format_, arbitrary_color_space_);
@@ -854,7 +823,7 @@ TEST_F(VideoCaptureControllerTest,
     EXPECT_CALL(*client_a_, DoBufferCreated(_, _))
         .Times(1)
         .WillOnce(SaveArg<1>(&buffer_id_reported_to_client));
-    EXPECT_CALL(*client_a_, DoBufferReady(_, _)).Times(1);
+    EXPECT_CALL(*client_a_, DoBufferReady(_)).Times(1);
   }
   SendStubFrameToDeviceClient(arbitrary_format_, arbitrary_color_space_);
   base::RunLoop().RunUntilIdle();
@@ -894,7 +863,7 @@ TEST_F(VideoCaptureControllerTest,
     EXPECT_CALL(*client_a_, DoBufferCreated(_, _))
         .Times(1)
         .WillOnce(SaveArg<1>(&first_buffer_id));
-    EXPECT_CALL(*client_a_, DoBufferReady(_, _)).Times(1);
+    EXPECT_CALL(*client_a_, DoBufferReady(_)).Times(1);
   }
   SendStubFrameToDeviceClient(arbitrary_format_, arbitrary_color_space_);
   base::RunLoop().RunUntilIdle();
@@ -916,7 +885,7 @@ TEST_F(VideoCaptureControllerTest,
     EXPECT_CALL(*client_a_, DoBufferCreated(_, _))
         .Times(1)
         .WillOnce(SaveArg<1>(&second_buffer_id));
-    EXPECT_CALL(*client_a_, DoBufferReady(_, _)).Times(1);
+    EXPECT_CALL(*client_a_, DoBufferReady(_)).Times(1);
   }
   SendStubFrameToDeviceClient(arbitrary_format_, arbitrary_color_space_);
   base::RunLoop().RunUntilIdle();
@@ -1020,7 +989,7 @@ TEST_F(VideoCaptureControllerTest, DeviceClientWithColorSpace) {
     EXPECT_CALL(*client_a_, DoBufferCreated(_, _))
         .Times(1)
         .WillOnce(SaveArg<1>(&buffer_id_reported_to_client));
-    EXPECT_CALL(*client_a_, DoBufferReady(_, _)).Times(1);
+    EXPECT_CALL(*client_a_, DoBufferReady(_)).Times(1);
   }
   EXPECT_CALL(*client_a_, DoBufferDestroyed(_, _)).Times(0);
   SendStubFrameToDeviceClient(requested_params.requested_format,

media/capture/video/chromeos/video_capture_jpeg_decoder.h

@@ -25,9 +25,7 @@ class CAPTURE_EXPORT VideoCaptureJpegDecoder {
                    // decode error.
   };
 
-  using DecodeDoneCB =
+  using DecodeDoneCB = base::RepeatingCallback<void(ReadyFrameInBuffer)>;
-      base::RepeatingCallback<void(ReadyFrameInBuffer,
-                                   std::vector<ReadyFrameInBuffer>)>;
 
   virtual ~VideoCaptureJpegDecoder() {}
 

media/capture/video/chromeos/video_capture_jpeg_decoder_impl.cc

@@ -142,8 +142,7 @@ void VideoCaptureJpegDecoderImpl::DecodeCapturedData(
         decode_done_cb_,
         ReadyFrameInBuffer(out_buffer.id, out_buffer.frame_feedback_id,
                            std::move(out_buffer.access_permission),
-                           std::move(out_frame_info)),
+                           std::move(out_frame_info)));
-        std::vector<ReadyFrameInBuffer>());
   }
 
   // base::Unretained is safe because |decoder_| is deleted on

media/capture/video/mock_video_frame_receiver.h

@@ -39,9 +39,7 @@ class MockVideoFrameReceiver : public VideoFrameReceiver {
     MockOnNewBufferHandle(buffer_id);
   }
 
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(ReadyFrameInBuffer frame) override {
-      ReadyFrameInBuffer frame,
-      std::vector<ReadyFrameInBuffer> scaled_frames) override {
     MockOnFrameReadyInBuffer(frame.buffer_id, &frame.buffer_read_permission,
                              frame.frame_info->coded_size);
   }

media/capture/video/video_capture_device_client.cc

@@ -496,7 +496,7 @@ void VideoCaptureDeviceClient::OnIncomingCapturedExternalBuffer(
                 "trakcer failed.";
     return;
   }
-  receiver_->OnFrameReadyInBuffer(std::move(ready_frame), {});
+  receiver_->OnFrameReadyInBuffer(std::move(ready_frame));
 }
 
 VideoCaptureDevice::Client::ReserveResult
@@ -675,13 +675,11 @@ void VideoCaptureDeviceClient::OnIncomingCapturedBufferExt(
   info->is_premapped = buffer.is_premapped;
 
   buffer_pool_->HoldForConsumers(buffer.id, 1);
-  receiver_->OnFrameReadyInBuffer(
+  receiver_->OnFrameReadyInBuffer(ReadyFrameInBuffer(
-      ReadyFrameInBuffer(
+      buffer.id, buffer.frame_feedback_id,
-          buffer.id, buffer.frame_feedback_id,
+      std::make_unique<ScopedBufferPoolReservation<ConsumerReleaseTraits>>(
-          std::make_unique<ScopedBufferPoolReservation<ConsumerReleaseTraits>>(
+          buffer_pool_, buffer.id),
-              buffer_pool_, buffer.id),
+      std::move(info)));
-          std::move(info)),
-      {});
 }
 
 void VideoCaptureDeviceClient::OnError(VideoCaptureError error,

media/capture/video/video_frame_receiver.h

@@ -5,6 +5,8 @@
 #ifndef MEDIA_CAPTURE_VIDEO_VIDEO_FRAME_RECEIVER_H_
 #define MEDIA_CAPTURE_VIDEO_VIDEO_FRAME_RECEIVER_H_
 
+#include <memory>
+
 #include "base/functional/callback_helpers.h"
 #include "media/capture/capture_export.h"
 #include "media/capture/mojom/video_capture_buffer.mojom.h"
@@ -77,9 +79,7 @@ class CAPTURE_EXPORT VideoFrameReceiver {
   // the buffer. The producer guarantees that the buffer and its contents stay
   // alive and unchanged until VideoFrameReceiver releases the given
   // |buffer_read_permission|.
-  virtual void OnFrameReadyInBuffer(
+  virtual void OnFrameReadyInBuffer(ReadyFrameInBuffer frame) = 0;
-      ReadyFrameInBuffer frame,
-      std::vector<ReadyFrameInBuffer> scaled_frames) = 0;
 
   // Tells the VideoFrameReceiver that the producer is no longer going to use
   // the buffer with id |buffer_id| for frame delivery. This may be called even

media/capture/video/video_frame_receiver_on_task_runner.cc

@@ -34,12 +34,10 @@ void VideoFrameReceiverOnTaskRunner::OnNewBuffer(
 }
 
 void VideoFrameReceiverOnTaskRunner::OnFrameReadyInBuffer(
-    ReadyFrameInBuffer frame,
+    ReadyFrameInBuffer frame) {
-    std::vector<ReadyFrameInBuffer> scaled_frames) {
   task_runner_->PostTask(
-      FROM_HERE,
+      FROM_HERE, base::BindOnce(&VideoFrameReceiver::OnFrameReadyInBuffer,
-      base::BindOnce(&VideoFrameReceiver::OnFrameReadyInBuffer, receiver_,
+                                receiver_, std::move(frame)));
-                     std::move(frame), std::move(scaled_frames)));
 }
 
 void VideoFrameReceiverOnTaskRunner::OnBufferRetired(int buffer_id) {

media/capture/video/video_frame_receiver_on_task_runner.h

@@ -26,9 +26,7 @@ class CAPTURE_EXPORT VideoFrameReceiverOnTaskRunner
   void OnCaptureConfigurationChanged() override;
   void OnNewBuffer(int32_t buffer_id,
                    media::mojom::VideoBufferHandlePtr buffer_handle) override;
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(ReadyFrameInBuffer frame) override;
-      ReadyFrameInBuffer frame,
-      std::vector<ReadyFrameInBuffer> scaled_frames) override;
   void OnBufferRetired(int buffer_id) override;
   void OnError(VideoCaptureError error) override;
   void OnFrameDropped(VideoCaptureFrameDropReason reason) override;

services/video_capture/ash/video_frame_handler_ash.cc

@@ -161,20 +161,12 @@ void VideoFrameHandlerAsh::OnFrameAccessHandlerReady(
 }
 
 void VideoFrameHandlerAsh::OnFrameReadyInBuffer(
-    video_capture::mojom::ReadyFrameInBufferPtr buffer,
+    video_capture::mojom::ReadyFrameInBufferPtr buffer) {
-    std::vector<video_capture::mojom::ReadyFrameInBufferPtr> scaled_buffers) {
   DCHECK(frame_access_handler_remote_);
   crosapi::mojom::ReadyFrameInBufferPtr crosapi_buffer =
       ToCrosapiBuffer(std::move(buffer), frame_access_handler_remote_);
-  std::vector<crosapi::mojom::ReadyFrameInBufferPtr> crosapi_scaled_buffers;
-  crosapi_scaled_buffers.reserve(scaled_buffers.size());
-  for (auto& b : scaled_buffers) {
-    crosapi_scaled_buffers.push_back(
-        ToCrosapiBuffer(std::move(b), frame_access_handler_remote_));
-  }
 
-  proxy_->OnFrameReadyInBuffer(std::move(crosapi_buffer),
+  proxy_->OnFrameReadyInBuffer(std::move(crosapi_buffer), {});
-                               std::move(crosapi_scaled_buffers));
 }
 
 void VideoFrameHandlerAsh::OnBufferRetired(int buffer_id) {

services/video_capture/ash/video_frame_handler_ash.h

@@ -5,8 +5,6 @@
 #ifndef SERVICES_VIDEO_CAPTURE_ASH_VIDEO_FRAME_HANDLER_ASH_H_
 #define SERVICES_VIDEO_CAPTURE_ASH_VIDEO_FRAME_HANDLER_ASH_H_
 
-#include <vector>
-
 #include "chromeos/crosapi/mojom/video_capture.mojom.h"
 #include "media/capture/mojom/video_capture_buffer.mojom.h"
 #include "media/capture/mojom/video_capture_types.mojom.h"
@@ -66,9 +64,7 @@ class VideoFrameHandlerAsh : public video_capture::mojom::VideoFrameHandler {
       mojo::PendingRemote<video_capture::mojom::VideoFrameAccessHandler>
           pending_frame_access_handler) override;
   void OnFrameReadyInBuffer(
-      video_capture::mojom::ReadyFrameInBufferPtr buffer,
+      video_capture::mojom::ReadyFrameInBufferPtr buffer) override;
-      std::vector<video_capture::mojom::ReadyFrameInBufferPtr> scaled_buffers)
-      override;
   void OnBufferRetired(int buffer_id) override;
   void OnError(media::VideoCaptureError error) override;
   void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

services/video_capture/broadcasting_receiver.cc

@@ -263,8 +263,7 @@ void BroadcastingReceiver::OnNewBuffer(
 }
 
 void BroadcastingReceiver::OnFrameReadyInBuffer(
-    media::ReadyFrameInBuffer frame,
+    media::ReadyFrameInBuffer frame) {
-    std::vector<media::ReadyFrameInBuffer> scaled_frames) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   bool has_consumers = false;
   for (auto& client : clients_) {
@@ -286,17 +285,6 @@ void BroadcastingReceiver::OnFrameReadyInBuffer(
       std::make_pair(buffer_context->buffer_context_id(),
                      std::move(frame.buffer_read_permission)));
   DCHECK(result.second);
-  std::vector<BufferContext*> scaled_buffer_contexts;
-  scaled_buffer_contexts.reserve(scaled_frames.size());
-  for (auto& scaled_frame : scaled_frames) {
-    it = FindUnretiredBufferContextFromBufferId(scaled_frame.buffer_id);
-    CHECK(it != buffer_contexts_.end());
-    result = scoped_access_permissions_by_buffer_context_id_.insert(
-        std::make_pair(it->buffer_context_id(),
-                       std::move(scaled_frame.buffer_read_permission)));
-    DCHECK(result.second);
-    scaled_buffer_contexts.push_back(&(*it));
-  }
   // Broadcast to all clients.
   for (auto& client : clients_) {
     if (client.second.is_suspended())
@@ -321,17 +309,7 @@ void BroadcastingReceiver::OnFrameReadyInBuffer(
         buffer_context->buffer_context_id(), frame.frame_feedback_id,
         frame.frame_info.Clone());
 
-    std::vector<mojom::ReadyFrameInBufferPtr> scaled_ready_buffers;
+    client.second.client()->OnFrameReadyInBuffer(std::move(ready_buffer));
-    scaled_ready_buffers.reserve(scaled_frames.size());
-    for (size_t i = 0; i < scaled_frames.size(); ++i) {
-      scaled_buffer_contexts[i]->IncreaseConsumerCount();
-      scaled_ready_buffers.push_back(mojom::ReadyFrameInBuffer::New(
-          scaled_buffer_contexts[i]->buffer_context_id(),
-          scaled_frames[i].frame_feedback_id,
-          scaled_frames[i].frame_info.Clone()));
-    }
-    client.second.client()->OnFrameReadyInBuffer(
-        std::move(ready_buffer), std::move(scaled_ready_buffers));
   }
 }
 

services/video_capture/broadcasting_receiver.h

@@ -79,9 +79,7 @@ class BroadcastingReceiver : public media::VideoFrameReceiver {
   void OnCaptureConfigurationChanged() override;
   void OnNewBuffer(int32_t buffer_id,
                    media::mojom::VideoBufferHandlePtr buffer_handle) override;
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) override;
-      media::ReadyFrameInBuffer frame,
-      std::vector<media::ReadyFrameInBuffer> scaled_frames) override;
   void OnBufferRetired(int32_t buffer_id) override;
   void OnError(media::VideoCaptureError error) override;
   void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

services/video_capture/broadcasting_receiver_unittest.cc

@@ -92,8 +92,7 @@ TEST_F(
   broadcaster_.OnFrameReadyInBuffer(
       media::ReadyFrameInBuffer(kArbitraryBufferId, kArbitraryFrameFeedbackId,
                                 std::make_unique<StubReadWritePermission>(),
-                                media::mojom::VideoFrameInfo::New()),
+                                media::mojom::VideoFrameInfo::New()));
-      {});
 
   // mock_video_frame_handler_1_ finishes consuming immediately.
   // mock_video_frame_handler_2_ continues consuming.
@@ -151,8 +150,7 @@ TEST_F(BroadcastingReceiverTest,
   broadcaster_.OnFrameReadyInBuffer(
       media::ReadyFrameInBuffer(kArbitraryBufferId, kArbitraryFrameFeedbackId,
                                 std::make_unique<StubReadWritePermission>(),
-                                media::mojom::VideoFrameInfo::New()),
+                                media::mojom::VideoFrameInfo::New()));
-      {});
 
   // Because the clients are suspended, frames are automatically released.
   base::RunLoop().RunUntilIdle();
@@ -165,8 +163,7 @@ TEST_F(BroadcastingReceiverTest,
   broadcaster_.OnFrameReadyInBuffer(
       media::ReadyFrameInBuffer(kArbitraryBufferId, kArbitraryFrameFeedbackId,
                                 std::make_unique<StubReadWritePermission>(),
-                                media::mojom::VideoFrameInfo::New()),
+                                media::mojom::VideoFrameInfo::New()));
-      {});
 
   // This time the buffer is not released automatically.
   base::RunLoop().RunUntilIdle();
@@ -180,66 +177,6 @@ TEST_F(BroadcastingReceiverTest,
   DCHECK_EQ(HoldBufferContextSize(), 0u);
 }
 
-TEST_F(BroadcastingReceiverTest, ForwardsScaledFrames) {
-  const int kBufferId = 10;
-  const int kScaledBufferId = 11;
-
-  mock_video_frame_handler_1_->HoldAccessPermissions();
-
-  media::mojom::VideoBufferHandlePtr buffer_handle =
-      media::mojom::VideoBufferHandle::NewUnsafeShmemRegion(
-          base::UnsafeSharedMemoryRegion::Create(kArbitraryDummyBufferSize));
-  broadcaster_.OnNewBuffer(kBufferId, std::move(buffer_handle));
-
-  media::mojom::VideoBufferHandlePtr scaled_buffer_handle =
-      media::mojom::VideoBufferHandle::NewUnsafeShmemRegion(
-          base::UnsafeSharedMemoryRegion::Create(kArbitraryDummyBufferSize));
-  broadcaster_.OnNewBuffer(kScaledBufferId, std::move(scaled_buffer_handle));
-
-  // Suspend the second client so that the first client alone controls buffer
-  // access.
-  broadcaster_.SuspendClient(client_id_2_);
-
-  base::RunLoop on_buffer_ready;
-  EXPECT_CALL(*mock_video_frame_handler_1_, DoOnFrameReadyInBuffer(_, _, _))
-      .WillOnce(
-          InvokeWithoutArgs([&on_buffer_ready]() { on_buffer_ready.Quit(); }));
-
-  media::ReadyFrameInBuffer ready_buffer =
-      media::ReadyFrameInBuffer(kBufferId, kArbitraryFrameFeedbackId,
-                                std::make_unique<StubReadWritePermission>(),
-                                media::mojom::VideoFrameInfo::New());
-
-  std::vector<media::ReadyFrameInBuffer> scaled_ready_buffers;
-  scaled_ready_buffers.emplace_back(kScaledBufferId, kArbitraryFrameFeedbackId,
-                                    std::make_unique<StubReadWritePermission>(),
-                                    media::mojom::VideoFrameInfo::New());
-
-  broadcaster_.OnFrameReadyInBuffer(std::move(ready_buffer),
-                                    std::move(scaled_ready_buffers));
-  on_buffer_ready.Run();
-  DCHECK_EQ(HoldBufferContextSize(), 2u);
-
-  // Releasing the handler's buffers releases both frame and scaled frame.
-  mock_video_frame_handler_1_->ReleaseAccessedFrames();
-  base::RunLoop().RunUntilIdle();
-  DCHECK_EQ(HoldBufferContextSize(), 0u);
-
-  // Scaled buffers also get retired.
-  base::RunLoop on_both_buffers_retired;
-  size_t num_buffers_retired = 0u;
-  EXPECT_CALL(*mock_video_frame_handler_1_, DoOnBufferRetired(_))
-      .WillRepeatedly(
-          InvokeWithoutArgs([&on_both_buffers_retired, &num_buffers_retired]() {
-            ++num_buffers_retired;
-            if (num_buffers_retired == 2u)
-              on_both_buffers_retired.Quit();
-          }));
-  broadcaster_.OnBufferRetired(kBufferId);
-  broadcaster_.OnBufferRetired(kScaledBufferId);
-  on_both_buffers_retired.Run();
-}
-
 TEST_F(BroadcastingReceiverTest, AccessPermissionsSurviveStop) {
   // For simplicitly, we only care about the first client in this test.
   broadcaster_.SuspendClient(client_id_2_);
@@ -254,8 +191,7 @@ TEST_F(BroadcastingReceiverTest, AccessPermissionsSurviveStop) {
   broadcaster_.OnFrameReadyInBuffer(
       media::ReadyFrameInBuffer(kArbitraryBufferId, kArbitraryFrameFeedbackId,
                                 std::make_unique<StubReadWritePermission>(),
-                                media::mojom::VideoFrameInfo::New()),
+                                media::mojom::VideoFrameInfo::New()));
-      {});
   base::RunLoop().RunUntilIdle();
 
   // The first frame has not been released yet.
@@ -279,12 +215,10 @@ TEST_F(BroadcastingReceiverTest, AccessPermissionsSurviveStop) {
   broadcaster_.OnNewBuffer(kArbitraryBufferId + 1, std::move(buffer_handle2));
   EXPECT_CALL(*mock_video_frame_handler_1_, DoOnFrameReadyInBuffer(_, _, _))
       .Times(1);
-  broadcaster_.OnFrameReadyInBuffer(
+  broadcaster_.OnFrameReadyInBuffer(media::ReadyFrameInBuffer(
-      media::ReadyFrameInBuffer(kArbitraryBufferId + 1,
+      kArbitraryBufferId + 1, kArbitraryFrameFeedbackId + 1,
-                                kArbitraryFrameFeedbackId + 1,
+      std::make_unique<StubReadWritePermission>(),
-                                std::make_unique<StubReadWritePermission>(),
+      media::mojom::VideoFrameInfo::New()));
-                                media::mojom::VideoFrameInfo::New()),
-      {});
   base::RunLoop().RunUntilIdle();
 
   // Neither frame has been released.

services/video_capture/gpu_memory_buffer_virtual_device_mojo_adapter.cc

@@ -70,10 +70,8 @@ void GpuMemoryBufferVirtualDeviceMojoAdapter::OnFrameReadyInBuffer(
             video_frame_handler_, frame_access_handler_remote_);
     video_frame_handler_has_forwarder_ = true;
   }
-  video_frame_handler_->OnFrameReadyInBuffer(
+  video_frame_handler_->OnFrameReadyInBuffer(mojom::ReadyFrameInBuffer::New(
-      mojom::ReadyFrameInBuffer::New(buffer_id, 0 /* frame_feedback_id */,
+      buffer_id, 0 /* frame_feedback_id */, std::move(frame_info)));
-                                     std::move(frame_info)),
-      {});
 }
 
 void GpuMemoryBufferVirtualDeviceMojoAdapter::OnBufferRetired(int buffer_id) {

services/video_capture/lacros/video_frame_handler_proxy_lacros.cc

@@ -126,7 +126,7 @@ void VideoFrameHandlerProxyLacros::OnNewBuffer(
 
 void VideoFrameHandlerProxyLacros::OnFrameReadyInBuffer(
     crosapi::mojom::ReadyFrameInBufferPtr buffer,
-    std::vector<crosapi::mojom::ReadyFrameInBufferPtr> scaled_buffers) {
+    std::vector<crosapi::mojom::ReadyFrameInBufferPtr> /*scaled_buffers*/) {
   if (handler_.is_bound()) {
     if (!access_permission_proxy_map_) {
       access_permission_proxy_map_ = new AccessPermissionProxyMap();
@@ -142,25 +142,11 @@ void VideoFrameHandlerProxyLacros::OnFrameReadyInBuffer(
         buffer->buffer_id, std::move(buffer->access_permission));
     mojom::ReadyFrameInBufferPtr video_capture_buffer =
         ToVideoCaptureBuffer(std::move(buffer));
-    std::vector<mojom::ReadyFrameInBufferPtr> video_capture_scaled_buffers;
-    for (auto& b : scaled_buffers) {
-      access_permission_proxy_map_->InsertAccessPermission(
-          b->buffer_id, std::move(b->access_permission));
-      video_capture_scaled_buffers.push_back(
-          ToVideoCaptureBuffer(std::move(b)));
-    }
 
-    handler_->OnFrameReadyInBuffer(std::move(video_capture_buffer),
+    handler_->OnFrameReadyInBuffer(std::move(video_capture_buffer));
-                                   std::move(video_capture_scaled_buffers));
   } else if (handler_in_process_) {
-    std::vector<media::ReadyFrameInBuffer> media_scaled_buffers;
-    for (auto& b : scaled_buffers) {
-      media_scaled_buffers.push_back(ConvertToMediaReadyFrame(std::move(b)));
-    }
-
     handler_in_process_->OnFrameReadyInBuffer(
-        ConvertToMediaReadyFrame(std::move(buffer)),
+        ConvertToMediaReadyFrame(std::move(buffer)));
-        std::move(media_scaled_buffers));
   }
 }
 

services/video_capture/public/cpp/mock_video_frame_handler.cc

@@ -48,12 +48,8 @@ void MockVideoFrameHandler::OnFrameAccessHandlerReady(
 }
 
 void MockVideoFrameHandler::OnFrameReadyInBuffer(
-    mojom::ReadyFrameInBufferPtr buffer,
+    mojom::ReadyFrameInBufferPtr buffer) {
-    std::vector<mojom::ReadyFrameInBufferPtr> scaled_buffers) {
   accessed_frame_ids_.push_back(buffer->buffer_id);
-  for (auto& scaled_buffer : scaled_buffers) {
-    accessed_frame_ids_.push_back(scaled_buffer->buffer_id);
-  }
   DoOnFrameReadyInBuffer(buffer->buffer_id, buffer->frame_feedback_id,
                          &buffer->frame_info);
   if (!should_store_access_permissions_) {

services/video_capture/public/cpp/mock_video_frame_handler.h

@@ -32,9 +32,7 @@ class MockVideoFrameHandler : public mojom::VideoFrameHandler {
   void OnFrameAccessHandlerReady(
       mojo::PendingRemote<video_capture::mojom::VideoFrameAccessHandler>
           frame_access_handler_proxy) override;
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(mojom::ReadyFrameInBufferPtr buffer) override;
-      mojom::ReadyFrameInBufferPtr buffer,
-      std::vector<mojom::ReadyFrameInBufferPtr> scaled_buffers) override;
   void OnBufferRetired(int32_t buffer_id) override;
 
   MOCK_METHOD0(OnCaptureConfigurationChanged, void());

services/video_capture/public/cpp/receiver_media_to_mojo_adapter.cc

@@ -45,8 +45,7 @@ void ReceiverMediaToMojoAdapter::OnFrameAccessHandlerReady(
 }
 
 void ReceiverMediaToMojoAdapter::OnFrameReadyInBuffer(
-    mojom::ReadyFrameInBufferPtr buffer,
+    mojom::ReadyFrameInBufferPtr buffer) {
-    std::vector<mojom::ReadyFrameInBufferPtr> scaled_buffers) {
   DCHECK(frame_access_handler_);
 
   media::ReadyFrameInBuffer media_buffer(
@@ -56,18 +55,7 @@ void ReceiverMediaToMojoAdapter::OnFrameReadyInBuffer(
                          buffer->buffer_id)),
       std::move(buffer->frame_info));
 
-  std::vector<media::ReadyFrameInBuffer> media_scaled_buffers;
+  receiver_->OnFrameReadyInBuffer(std::move(media_buffer));
-  media_scaled_buffers.reserve(scaled_buffers.size());
-  for (auto& scaled_buffer : scaled_buffers) {
-    media_scaled_buffers.emplace_back(
-        scaled_buffer->buffer_id, scaled_buffer->frame_feedback_id,
-        std::make_unique<media::ScopedFrameDoneHelper>(
-            base::BindOnce(&OnFramePropagationComplete, frame_access_handler_,
-                           scaled_buffer->buffer_id)),
-        std::move(scaled_buffer->frame_info));
-  }
-  receiver_->OnFrameReadyInBuffer(std::move(media_buffer),
-                                  std::move(media_scaled_buffers));
 }
 
 void ReceiverMediaToMojoAdapter::OnBufferRetired(int32_t buffer_id) {

services/video_capture/public/cpp/receiver_media_to_mojo_adapter.h

@@ -27,9 +27,7 @@ class ReceiverMediaToMojoAdapter : public mojom::VideoFrameHandler {
   void OnFrameAccessHandlerReady(
       mojo::PendingRemote<video_capture::mojom::VideoFrameAccessHandler>
           pending_frame_access_handler) override;
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(mojom::ReadyFrameInBufferPtr buffer) override;
-      mojom::ReadyFrameInBufferPtr buffer,
-      std::vector<mojom::ReadyFrameInBufferPtr> scaled_buffers) override;
   void OnBufferRetired(int32_t buffer_id) override;
   void OnError(media::VideoCaptureError error) override;
   void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

services/video_capture/public/cpp/receiver_mojo_to_media_adapter.cc

@@ -30,8 +30,7 @@ void ReceiverMojoToMediaAdapter::OnNewBuffer(
 }
 
 void ReceiverMojoToMediaAdapter::OnFrameReadyInBuffer(
-    media::ReadyFrameInBuffer frame,
+    media::ReadyFrameInBuffer frame) {
-    std::vector<media::ReadyFrameInBuffer> scaled_frames) {
   if (!scoped_access_permission_map_) {
     scoped_access_permission_map_ =
         ScopedAccessPermissionMap::CreateMapAndSendVideoFrameAccessHandlerReady(
@@ -42,18 +41,7 @@ void ReceiverMojoToMediaAdapter::OnFrameReadyInBuffer(
   mojom::ReadyFrameInBufferPtr mojom_frame = mojom::ReadyFrameInBuffer::New(
       frame.buffer_id, frame.frame_feedback_id, std::move(frame.frame_info));
 
-  std::vector<mojom::ReadyFrameInBufferPtr> mojom_scaled_frames;
+  video_frame_handler_->OnFrameReadyInBuffer(std::move(mojom_frame));
-  mojom_scaled_frames.reserve(scaled_frames.size());
-  for (auto& scaled_frame : scaled_frames) {
-    scoped_access_permission_map_->InsertAccessPermission(
-        scaled_frame.buffer_id, std::move(scaled_frame.buffer_read_permission));
-    mojom_scaled_frames.push_back(mojom::ReadyFrameInBuffer::New(
-        scaled_frame.buffer_id, scaled_frame.frame_feedback_id,
-        std::move(scaled_frame.frame_info)));
-  }
-
-  video_frame_handler_->OnFrameReadyInBuffer(std::move(mojom_frame),
-                                             std::move(mojom_scaled_frames));
 }
 
 void ReceiverMojoToMediaAdapter::OnBufferRetired(int buffer_id) {

services/video_capture/public/cpp/receiver_mojo_to_media_adapter.h

@@ -26,9 +26,7 @@ class ReceiverMojoToMediaAdapter : public media::VideoFrameReceiver {
   void OnCaptureConfigurationChanged() override;
   void OnNewBuffer(int buffer_id,
                    media::mojom::VideoBufferHandlePtr buffer_handle) override;
-  void OnFrameReadyInBuffer(
+  void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) override;
-      media::ReadyFrameInBuffer frame,
-      std::vector<media::ReadyFrameInBuffer> scaled_frames) override;
   void OnBufferRetired(int buffer_id) override;
   void OnError(media::VideoCaptureError error) override;
   void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

services/video_capture/public/mojom/video_frame_handler.mojom

@@ -51,13 +51,11 @@ interface VideoFrameHandler {
   OnFrameAccessHandlerReady(
       pending_remote<VideoFrameAccessHandler> frame_access_handler);
 
-  // Indicates that a new frame is ready for consumption and optionally a set of
+  // Indicates that a new frame is ready for consumption. The producer
-  // scaled down versions of that frame. The producer guarantees that the
+  // guarantees that the buffer and its contents stay alive and unchanged until
-  // buffer(s) and their contents stay alive and unchanged until
+  // VideoFrameHandler releases the buffer using |frame_access_handler|'s
-  // VideoFrameHandler releases the buffers using |frame_access_handler|'s
   // OnFinishedConsumingBuffer().
-  OnFrameReadyInBuffer(ReadyFrameInBuffer buffer,
+  OnFrameReadyInBuffer(ReadyFrameInBuffer buffer);
-                       array<ReadyFrameInBuffer> scaled_buffers);
 
   // Indicates that the producer is no longer going to use the buffer with id
   // |buffer_id| for frame delivery. This may be called even while the handler

services/video_capture/shared_memory_virtual_device_mojo_adapter.cc

@@ -136,10 +136,8 @@ void SharedMemoryVirtualDeviceMojoAdapter::OnFrameReadyInBuffer(
         buffer_pool_, buffer_id);
     scoped_access_permission_map_->InsertAccessPermission(
         buffer_id, std::move(access_permission));
-    video_frame_handler_->OnFrameReadyInBuffer(
+    video_frame_handler_->OnFrameReadyInBuffer(mojom::ReadyFrameInBuffer::New(
-        mojom::ReadyFrameInBuffer::New(buffer_id, 0 /* frame_feedback_id */,
+        buffer_id, 0 /* frame_feedback_id */, std::move(frame_info)));
-                                       std::move(frame_info)),
-        {});
   } else if (video_frame_handler_in_process_) {
     buffer_pool_->HoldForConsumers(buffer_id, 1 /* num_clients */);
     video_frame_handler_in_process_->OnFrameReadyInBuffer(
@@ -147,8 +145,7 @@ void SharedMemoryVirtualDeviceMojoAdapter::OnFrameReadyInBuffer(
             buffer_id, 0 /* frame_feedback_id */,
             std::make_unique<media::ScopedBufferPoolReservation<
                 media::ConsumerReleaseTraits>>(buffer_pool_, buffer_id),
-            std::move(frame_info)),
+            std::move(frame_info)));
-        {});
   }
   buffer_pool_->RelinquishProducerReservation(buffer_id);
 }

services/video_capture/texture_virtual_device_mojo_adapter.cc

@@ -94,18 +94,15 @@ void TextureVirtualDeviceMojoAdapter::OnFrameReadyInBuffer(
       video_frame_handler_has_forwarder_ = true;
     }
 
-    video_frame_handler_->OnFrameReadyInBuffer(
+    video_frame_handler_->OnFrameReadyInBuffer(mojom::ReadyFrameInBuffer::New(
-        mojom::ReadyFrameInBuffer::New(buffer_id, 0 /* frame_feedback_id */,
+        buffer_id, 0 /* frame_feedback_id */, std::move(frame_info)));
-                                       std::move(frame_info)),
-        {});
   } else if (video_frame_handler_in_process_) {
     video_frame_handler_has_forwarder_ = true;
     video_frame_handler_in_process_->OnFrameReadyInBuffer(
         media::ReadyFrameInBuffer(buffer_id, 0 /* frame_feedback_id */,
                                   std::make_unique<ScopedBufferPoolReservation>(
                                       frame_access_handler_remote_, buffer_id),
-                                  std::move(frame_info)),
+                                  std::move(frame_info)));
-        {});
   }
 }