0

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}
This commit is contained in:
Henrik Boström
2023-10-06 12:57:22 +00:00
committed by Chromium LUCI CQ
parent 20027f320b
commit 2dc4742a86
37 changed files with 109 additions and 359 deletions

@@ -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() {

@@ -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);

@@ -604,17 +604,9 @@ void CameraVideoFrameHandler::OnFrameAccessHandlerReady(
}
void CameraVideoFrameHandler::OnFrameReadyInBuffer(
video_capture::mojom::ReadyFrameInBufferPtr buffer,
std::vector<video_capture::mojom::ReadyFrameInBufferPtr> scaled_buffers) {
video_capture::mojom::ReadyFrameInBufferPtr buffer) {
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_) {

@@ -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,
std::vector<video_capture::mojom::ReadyFrameInBufferPtr> scaled_buffers)
override;
video_capture::mojom::ReadyFrameInBufferPtr buffer) override;
void OnBufferRetired(int buffer_id) override;
void OnError(media::VideoCaptureError error) override;
void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

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

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

@@ -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(
media::ReadyFrameInBuffer(buffer_id, feedback_id,
std::make_unique<StubReadWritePermission>(),
GetVideoFrameInfo()),
{});
frame_receiver_->OnFrameReadyInBuffer(media::ReadyFrameInBuffer(
buffer_id, feedback_id, std::make_unique<StubReadWritePermission>(),
GetVideoFrameInfo()));
run_loop.Run();
}

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

@@ -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(
media::ReadyFrameInBuffer(
buffer_id, buffer_id,
std::make_unique<media::ScopedFrameDoneHelper>(base::BindOnce(
&FrameSinkVideoCaptureDevice::OnFramePropagationComplete,
weak_factory_.GetWeakPtr(), buffer_id)),
std::move(info)),
{});
receiver_->OnFrameReadyInBuffer(media::ReadyFrameInBuffer(
buffer_id, buffer_id,
std::make_unique<media::ScopedFrameDoneHelper>(base::BindOnce(
&FrameSinkVideoCaptureDevice::OnFramePropagationComplete,
weak_factory_.GetWeakPtr(), buffer_id)),
std::move(info)));
}
void FrameSinkVideoCaptureDevice::OnNewCropVersion(uint32_t crop_version) {

@@ -195,9 +195,7 @@ class MockVideoFrameReceiver : public media::VideoFrameReceiver {
MOCK_METHOD2(MockOnNewBuffer,
void(int buffer_id,
media::mojom::VideoBufferHandle* buffer_handle));
void OnFrameReadyInBuffer(
media::ReadyFrameInBuffer frame,
std::vector<media::ReadyFrameInBuffer> scaled_frames) final {
void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) 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();

@@ -35,14 +35,8 @@ void ReceiverMediaToCrosapiAdapter::OnNewBuffer(
void ReceiverMediaToCrosapiAdapter::OnFrameReadyInBuffer(
crosapi::mojom::ReadyFrameInBufferPtr buffer,
std::vector<crosapi::mojom::ReadyFrameInBufferPtr> scaled_buffers) {
std::vector<media::ReadyFrameInBuffer> media_scaled_buffers;
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));
std::vector<crosapi::mojom::ReadyFrameInBufferPtr> /*scaled_buffers*/) {
handler_->OnFrameReadyInBuffer(ConvertToMediaReadyFrame(std::move(buffer)));
}
void ReceiverMediaToCrosapiAdapter::OnBufferRetired(int buffer_id) {

@@ -422,8 +422,7 @@ void VideoCaptureController::OnNewBuffer(
}
void VideoCaptureController::OnFrameReadyInBuffer(
media::ReadyFrameInBuffer frame,
std::vector<media::ReadyFrameInBuffer> scaled_frames) {
media::ReadyFrameInBuffer frame) {
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,
scaled_frame_ready_buffers);
frame_ready_buffer, {});
}
// 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_) {

@@ -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(
media::ReadyFrameInBuffer frame,
std::vector<media::ReadyFrameInBuffer> scaled_frames) override;
void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) override;
void OnBufferRetired(int buffer_id) override;
void OnError(media::VideoCaptureError error) override;
void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

@@ -84,9 +84,7 @@ class MockVideoCaptureControllerEventHandler
void(const VideoCaptureControllerID&, int buffer_id));
MOCK_METHOD2(DoBufferDestroyed,
void(const VideoCaptureControllerID&, int buffer_id));
MOCK_METHOD2(DoBufferReady,
void(ControllerIDAndSize buffer,
std::vector<ControllerIDAndSize> scaled_buffers));
MOCK_METHOD1(DoBufferReady, void(ControllerIDAndSize buffer));
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;
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));
DoBufferReady(ControllerIDAndSize(id, buffer.frame_info->coded_size));
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_,
DoBufferReady(ControllerIDAndSize(client_a_route_1,
device_format.frame_size),
std::vector<ControllerIDAndSize>()));
EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
client_a_route_1, device_format.frame_size)));
}
{
InSequence s;
EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1, _));
EXPECT_CALL(*client_b_,
DoBufferReady(ControllerIDAndSize(client_b_route_1,
device_format.frame_size),
std::vector<ControllerIDAndSize>()));
EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
client_b_route_1, device_format.frame_size)));
}
{
InSequence s;
EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2, _));
EXPECT_CALL(*client_a_,
DoBufferReady(ControllerIDAndSize(client_a_route_2,
device_format.frame_size),
std::vector<ControllerIDAndSize>()));
EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
client_a_route_2, device_format.frame_size)));
}
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_,
DoBufferReady(ControllerIDAndSize(client_a_route_1,
device_format.frame_size),
std::vector<ControllerIDAndSize>()));
EXPECT_CALL(*client_b_,
DoBufferReady(ControllerIDAndSize(client_b_route_1,
device_format.frame_size),
std::vector<ControllerIDAndSize>()));
EXPECT_CALL(*client_a_,
DoBufferReady(ControllerIDAndSize(client_a_route_2,
device_format.frame_size),
std::vector<ControllerIDAndSize>()));
EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
client_a_route_1, device_format.frame_size)));
EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
client_b_route_1, device_format.frame_size)));
EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
client_a_route_2, device_format.frame_size)));
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_,
DoBufferReady(ControllerIDAndSize(client_b_route_2,
device_format.frame_size),
std::vector<ControllerIDAndSize>()))
EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
client_b_route_2, device_format.frame_size)))
.Times(kPoolSize);
EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_1, _))
.Times(kPoolSize - 1);
EXPECT_CALL(*client_a_,
DoBufferReady(ControllerIDAndSize(client_a_route_1,
device_format.frame_size),
std::vector<ControllerIDAndSize>()))
EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
client_a_route_1, device_format.frame_size)))
.Times(kPoolSize);
EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2, _))
.Times(kPoolSize - 1);
EXPECT_CALL(*client_a_,
DoBufferReady(ControllerIDAndSize(client_a_route_2,
device_format.frame_size),
std::vector<ControllerIDAndSize>()))
EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
client_a_route_2, device_format.frame_size)))
.Times(kPoolSize);
EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1, _))
.Times(kPoolSize - 1);
EXPECT_CALL(*client_b_,
DoBufferReady(ControllerIDAndSize(client_b_route_1,
device_format.frame_size),
std::vector<ControllerIDAndSize>()))
EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
client_b_route_1, device_format.frame_size)))
.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_,
DoBufferReady(ControllerIDAndSize(client_b_route_2,
device_format.frame_size),
std::vector<ControllerIDAndSize>()))
EXPECT_CALL(*client_b_, DoBufferReady(ControllerIDAndSize(
client_b_route_2, device_format.frame_size)))
.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_,
DoBufferReady(
ControllerIDAndSize(route_id, arbitrary_format.frame_size),
std::vector<ControllerIDAndSize>()))
EXPECT_CALL(*client_a_, DoBufferReady(ControllerIDAndSize(
route_id, arbitrary_format.frame_size)))
.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,

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

@@ -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::vector<ReadyFrameInBuffer>());
std::move(out_frame_info)));
}
// base::Unretained is safe because |decoder_| is deleted on

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

@@ -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(
ReadyFrameInBuffer(
buffer.id, buffer.frame_feedback_id,
std::make_unique<ScopedBufferPoolReservation<ConsumerReleaseTraits>>(
buffer_pool_, buffer.id),
std::move(info)),
{});
receiver_->OnFrameReadyInBuffer(ReadyFrameInBuffer(
buffer.id, buffer.frame_feedback_id,
std::make_unique<ScopedBufferPoolReservation<ConsumerReleaseTraits>>(
buffer_pool_, buffer.id),
std::move(info)));
}
void VideoCaptureDeviceClient::OnError(VideoCaptureError error,

@@ -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(
ReadyFrameInBuffer frame,
std::vector<ReadyFrameInBuffer> scaled_frames) = 0;
virtual void OnFrameReadyInBuffer(ReadyFrameInBuffer frame) = 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

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

@@ -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(
ReadyFrameInBuffer frame,
std::vector<ReadyFrameInBuffer> scaled_frames) override;
void OnFrameReadyInBuffer(ReadyFrameInBuffer frame) override;
void OnBufferRetired(int buffer_id) override;
void OnError(VideoCaptureError error) override;
void OnFrameDropped(VideoCaptureFrameDropReason reason) override;

@@ -161,20 +161,12 @@ void VideoFrameHandlerAsh::OnFrameAccessHandlerReady(
}
void VideoFrameHandlerAsh::OnFrameReadyInBuffer(
video_capture::mojom::ReadyFrameInBufferPtr buffer,
std::vector<video_capture::mojom::ReadyFrameInBufferPtr> scaled_buffers) {
video_capture::mojom::ReadyFrameInBufferPtr buffer) {
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),
std::move(crosapi_scaled_buffers));
proxy_->OnFrameReadyInBuffer(std::move(crosapi_buffer), {});
}
void VideoFrameHandlerAsh::OnBufferRetired(int buffer_id) {

@@ -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,
std::vector<video_capture::mojom::ReadyFrameInBufferPtr> scaled_buffers)
override;
video_capture::mojom::ReadyFrameInBufferPtr buffer) override;
void OnBufferRetired(int buffer_id) override;
void OnError(media::VideoCaptureError error) override;
void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

@@ -263,8 +263,7 @@ void BroadcastingReceiver::OnNewBuffer(
}
void BroadcastingReceiver::OnFrameReadyInBuffer(
media::ReadyFrameInBuffer frame,
std::vector<media::ReadyFrameInBuffer> scaled_frames) {
media::ReadyFrameInBuffer frame) {
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;
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));
client.second.client()->OnFrameReadyInBuffer(std::move(ready_buffer));
}
}

@@ -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(
media::ReadyFrameInBuffer frame,
std::vector<media::ReadyFrameInBuffer> scaled_frames) override;
void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) override;
void OnBufferRetired(int32_t buffer_id) override;
void OnError(media::VideoCaptureError error) override;
void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

@@ -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(
media::ReadyFrameInBuffer(kArbitraryBufferId + 1,
kArbitraryFrameFeedbackId + 1,
std::make_unique<StubReadWritePermission>(),
media::mojom::VideoFrameInfo::New()),
{});
broadcaster_.OnFrameReadyInBuffer(media::ReadyFrameInBuffer(
kArbitraryBufferId + 1, kArbitraryFrameFeedbackId + 1,
std::make_unique<StubReadWritePermission>(),
media::mojom::VideoFrameInfo::New()));
base::RunLoop().RunUntilIdle();
// Neither frame has been released.

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

@@ -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),
std::move(video_capture_scaled_buffers));
handler_->OnFrameReadyInBuffer(std::move(video_capture_buffer));
} 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)),
std::move(media_scaled_buffers));
ConvertToMediaReadyFrame(std::move(buffer)));
}
}

@@ -48,12 +48,8 @@ void MockVideoFrameHandler::OnFrameAccessHandlerReady(
}
void MockVideoFrameHandler::OnFrameReadyInBuffer(
mojom::ReadyFrameInBufferPtr buffer,
std::vector<mojom::ReadyFrameInBufferPtr> scaled_buffers) {
mojom::ReadyFrameInBufferPtr buffer) {
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_) {

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

@@ -45,8 +45,7 @@ void ReceiverMediaToMojoAdapter::OnFrameAccessHandlerReady(
}
void ReceiverMediaToMojoAdapter::OnFrameReadyInBuffer(
mojom::ReadyFrameInBufferPtr buffer,
std::vector<mojom::ReadyFrameInBufferPtr> scaled_buffers) {
mojom::ReadyFrameInBufferPtr buffer) {
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;
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));
receiver_->OnFrameReadyInBuffer(std::move(media_buffer));
}
void ReceiverMediaToMojoAdapter::OnBufferRetired(int32_t buffer_id) {

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

@@ -30,8 +30,7 @@ void ReceiverMojoToMediaAdapter::OnNewBuffer(
}
void ReceiverMojoToMediaAdapter::OnFrameReadyInBuffer(
media::ReadyFrameInBuffer frame,
std::vector<media::ReadyFrameInBuffer> scaled_frames) {
media::ReadyFrameInBuffer frame) {
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;
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));
video_frame_handler_->OnFrameReadyInBuffer(std::move(mojom_frame));
}
void ReceiverMojoToMediaAdapter::OnBufferRetired(int buffer_id) {

@@ -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(
media::ReadyFrameInBuffer frame,
std::vector<media::ReadyFrameInBuffer> scaled_frames) override;
void OnFrameReadyInBuffer(media::ReadyFrameInBuffer frame) override;
void OnBufferRetired(int buffer_id) override;
void OnError(media::VideoCaptureError error) override;
void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;

@@ -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
// scaled down versions of that frame. The producer guarantees that the
// buffer(s) and their contents stay alive and unchanged until
// VideoFrameHandler releases the buffers using |frame_access_handler|'s
// Indicates that a new frame is ready for consumption. The producer
// guarantees that the buffer and its contents stay alive and unchanged until
// VideoFrameHandler releases the buffer using |frame_access_handler|'s
// OnFinishedConsumingBuffer().
OnFrameReadyInBuffer(ReadyFrameInBuffer buffer,
array<ReadyFrameInBuffer> scaled_buffers);
OnFrameReadyInBuffer(ReadyFrameInBuffer buffer);
// 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

@@ -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(
mojom::ReadyFrameInBuffer::New(buffer_id, 0 /* frame_feedback_id */,
std::move(frame_info)),
{});
video_frame_handler_->OnFrameReadyInBuffer(mojom::ReadyFrameInBuffer::New(
buffer_id, 0 /* frame_feedback_id */, 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);
}

@@ -94,18 +94,15 @@ void TextureVirtualDeviceMojoAdapter::OnFrameReadyInBuffer(
video_frame_handler_has_forwarder_ = true;
}
video_frame_handler_->OnFrameReadyInBuffer(
mojom::ReadyFrameInBuffer::New(buffer_id, 0 /* frame_feedback_id */,
std::move(frame_info)),
{});
video_frame_handler_->OnFrameReadyInBuffer(mojom::ReadyFrameInBuffer::New(
buffer_id, 0 /* frame_feedback_id */, 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)));
}
}