0

Disable Live Caption for muted audio on low media engagament sites

This CL disables Live Caption for muted audio on low media engagement
sites. See go/disabling-live-caption-for-muted-ads for rationale.

Bug: 362557377
Change-Id: I7196bb254d41fb067bd4f4e238764a0bcd57fba9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5818394
Reviewed-by: David Song <wintermelons@google.com>
Commit-Queue: Evan Liu <evliu@google.com>
Reviewed-by: Frank Liberato <liberato@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1353119}
This commit is contained in:
Evan Liu
2024-09-10 03:02:05 +00:00
committed by Chromium LUCI CQ
parent e3e40e0101
commit 96ce493225
30 changed files with 130 additions and 86 deletions

@ -208,8 +208,8 @@ void CastAudioRenderer::SetPreservesPitch(bool preverves_pitch) {
NOTIMPLEMENTED();
}
void CastAudioRenderer::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
void CastAudioRenderer::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
NOTIMPLEMENTED();
}

@ -85,8 +85,8 @@ class CastAudioRenderer
void SetVolume(float volume) override;
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint) override;
void SetPreservesPitch(bool preserves_pitch) override;
void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) override;
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) override;
// ::media::TimeSource implementation:
void StartTicking() override;

@ -341,8 +341,9 @@ void WebEngineAudioRenderer::SetPreservesPitch(bool preserves_pitch) {
NOTIMPLEMENTED();
}
void WebEngineAudioRenderer::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
void WebEngineAudioRenderer::
SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
// WebEngine does not use this signal. This is currently only used by the Live
// Caption feature.
NOTIMPLEMENTED_LOG_ONCE();

@ -52,8 +52,8 @@ class WEB_ENGINE_EXPORT WebEngineAudioRenderer final
void SetVolume(float volume) override;
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint) override;
void SetPreservesPitch(bool preserves_pitch) override;
void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) override;
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) override;
// TimeSource implementation.
void StartTicking() override;

@ -73,9 +73,9 @@ class MEDIA_EXPORT AudioRenderer {
virtual void SetPreservesPitch(bool preserves_pitch) = 0;
// Sets a flag indicating whether the audio stream was played with user
// activation.
virtual void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) = 0;
// activation and high media engagement.
virtual void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) = 0;
};
} // namespace media

@ -125,7 +125,8 @@ class MockPipeline : public Pipeline {
MOCK_METHOD1(SetVolume, void(float));
MOCK_METHOD1(SetLatencyHint, void(std::optional<base::TimeDelta>));
MOCK_METHOD1(SetPreservesPitch, void(bool));
MOCK_METHOD1(SetWasPlayedWithUserActivation, void(bool));
MOCK_METHOD1(SetWasPlayedWithUserActivationAndHighMediaEngagement,
void(bool));
// TODO(sandersd): These should probably have setters too.
MOCK_CONST_METHOD0(GetMediaTime, base::TimeDelta());
@ -500,7 +501,8 @@ class MockAudioRenderer : public AudioRenderer {
MOCK_METHOD1(SetLatencyHint,
void(std::optional<base::TimeDelta> latency_hint));
MOCK_METHOD1(SetPreservesPitch, void(bool));
MOCK_METHOD1(SetWasPlayedWithUserActivation, void(bool));
MOCK_METHOD1(SetWasPlayedWithUserActivationAndHighMediaEngagement,
void(bool));
};
class MockRenderer : public Renderer {
@ -524,7 +526,8 @@ class MockRenderer : public Renderer {
PipelineStatusCallback& init_cb));
MOCK_METHOD1(SetLatencyHint, void(std::optional<base::TimeDelta>));
MOCK_METHOD1(SetPreservesPitch, void(bool));
MOCK_METHOD1(SetWasPlayedWithUserActivation, void(bool));
MOCK_METHOD1(SetWasPlayedWithUserActivationAndHighMediaEngagement,
void(bool));
void Flush(base::OnceClosure flush_cb) override { OnFlush(flush_cb); }
MOCK_METHOD1(OnFlush, void(base::OnceClosure& flush_cb));
MOCK_METHOD1(StartPlayingFrom, void(base::TimeDelta timestamp));

@ -233,8 +233,8 @@ class MEDIA_EXPORT Pipeline {
// Sets a flag indicating whether the audio stream was played with user
// activation.
virtual void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) = 0;
virtual void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) = 0;
// Returns the current media playback time, which progresses from 0 until
// GetMediaDuration().

@ -92,7 +92,8 @@ class PipelineImpl::RendererWrapper final : public DemuxerHost,
void SetVolume(float volume);
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint);
void SetPreservesPitch(bool preserves_pitch);
void SetWasPlayedWithUserActivation(bool was_played_with_user_activation);
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement);
base::TimeDelta GetMediaTime() const;
Ranges<base::TimeDelta> GetBufferedTimeRanges() const;
bool DidLoadingProgress();
@ -236,7 +237,7 @@ class PipelineImpl::RendererWrapper final : public DemuxerHost,
// By default, apply pitch adjustments.
bool preserves_pitch_ = true;
bool was_played_with_user_activation_ = false;
bool was_played_with_user_activation_and_high_media_engagement_ = false;
// Lock used to serialize |shared_state_|.
// TODO(crbug.com/41419817): Add GUARDED_BY annotations.
@ -544,14 +545,17 @@ void PipelineImpl::RendererWrapper::SetPreservesPitch(bool preserves_pitch) {
shared_state_.renderer->SetPreservesPitch(preserves_pitch_);
}
void PipelineImpl::RendererWrapper::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
void PipelineImpl::RendererWrapper::
SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
was_played_with_user_activation_ = was_played_with_user_activation;
was_played_with_user_activation_and_high_media_engagement_ =
was_played_with_user_activation_and_high_media_engagement;
if (shared_state_.renderer) {
shared_state_.renderer->SetWasPlayedWithUserActivation(
was_played_with_user_activation_);
shared_state_.renderer
->SetWasPlayedWithUserActivationAndHighMediaEngagement(
was_played_with_user_activation_and_high_media_engagement_);
}
}
@ -1190,8 +1194,8 @@ void PipelineImpl::RendererWrapper::InitializeRenderer(
// power by avoiding initialization of audio output until necessary.
shared_state_.renderer->SetVolume(volume_);
shared_state_.renderer->SetWasPlayedWithUserActivation(
was_played_with_user_activation_);
shared_state_.renderer->SetWasPlayedWithUserActivationAndHighMediaEngagement(
was_played_with_user_activation_and_high_media_engagement_);
// Initialize Renderer and report timeout UMA.
std::string uma_name = "Media.InitializeRendererTimeout";
@ -1527,15 +1531,17 @@ void PipelineImpl::SetPreservesPitch(bool preserves_pitch) {
preserves_pitch));
}
void PipelineImpl::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
void PipelineImpl::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
DCHECK(thread_checker_.CalledOnValidThread());
media_task_runner_->PostTask(
FROM_HERE,
base::BindOnce(&RendererWrapper::SetWasPlayedWithUserActivation,
base::Unretained(renderer_wrapper_.get()),
was_played_with_user_activation));
base::BindOnce(
&RendererWrapper::
SetWasPlayedWithUserActivationAndHighMediaEngagement,
base::Unretained(renderer_wrapper_.get()),
was_played_with_user_activation_and_high_media_engagement));
}
base::TimeDelta PipelineImpl::GetMediaTime() const {

@ -111,8 +111,8 @@ class MEDIA_EXPORT PipelineImpl : public Pipeline {
void SetVolume(float volume) override;
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint) override;
void SetPreservesPitch(bool preserves_pitch) override;
void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) override;
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) override;
base::TimeDelta GetMediaTime() const override;
Ranges<base::TimeDelta> GetBufferedTimeRanges() const override;
base::TimeDelta GetMediaDuration() const override;

@ -185,7 +185,8 @@ class PipelineImplTest : public ::testing::Test {
void SetRendererPostStartExpectations() {
EXPECT_CALL(*renderer_, SetPlaybackRate(0.0));
EXPECT_CALL(*renderer_, SetVolume(1.0f));
EXPECT_CALL(*renderer_, SetWasPlayedWithUserActivation(false));
EXPECT_CALL(*renderer_,
SetWasPlayedWithUserActivationAndHighMediaEngagement(false));
EXPECT_CALL(*renderer_, StartPlayingFrom(start_time_))
.WillOnce(SetBufferingState(&renderer_client_, BUFFERING_HAVE_ENOUGH,
BUFFERING_CHANGE_REASON_UNKNOWN));
@ -312,7 +313,8 @@ class PipelineImplTest : public ::testing::Test {
.WillOnce(RunOnceCallback<1>(PIPELINE_OK));
EXPECT_CALL(*renderer_, SetPlaybackRate(_));
EXPECT_CALL(*renderer_, SetVolume(_));
EXPECT_CALL(*renderer_, SetWasPlayedWithUserActivation(false));
EXPECT_CALL(*renderer_,
SetWasPlayedWithUserActivationAndHighMediaEngagement(false));
EXPECT_CALL(*renderer_, StartPlayingFrom(seek_time))
.WillOnce(SetBufferingState(&renderer_client_, BUFFERING_HAVE_ENOUGH,
BUFFERING_CHANGE_REASON_UNKNOWN));
@ -648,7 +650,8 @@ TEST_F(PipelineImplTest, SetVolumeDuringStartup) {
// The audio renderer should receive two calls to SetVolume().
float expected = 0.5f;
EXPECT_CALL(*renderer_, SetVolume(expected)).Times(2);
EXPECT_CALL(*renderer_, SetWasPlayedWithUserActivation(false));
EXPECT_CALL(*renderer_,
SetWasPlayedWithUserActivationAndHighMediaEngagement(false));
EXPECT_CALL(callbacks_, OnStart(HasStatusCode(PIPELINE_OK)));
EXPECT_CALL(callbacks_, OnMetadata(_))
.WillOnce(RunOnceClosure(base::BindOnce(&PipelineImpl::SetVolume,
@ -1053,7 +1056,8 @@ class PipelineTeardownTest : public PipelineImplTest {
CreateVideoStream();
SetDemuxerExpectations(base::Seconds(3000));
EXPECT_CALL(*renderer_, SetVolume(1.0f));
EXPECT_CALL(*renderer_, SetWasPlayedWithUserActivation(false));
EXPECT_CALL(*renderer_,
SetWasPlayedWithUserActivationAndHighMediaEngagement(false));
if (state == kInitRenderer) {
if (stop_or_error == kStop) {

@ -63,8 +63,8 @@ void Renderer::SetPreservesPitch(bool preserves_pitch) {
// Not supported by most renderers.
}
void Renderer::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
void Renderer::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
// Not supported by most renderers.
}

@ -83,8 +83,8 @@ class MEDIA_EXPORT Renderer {
// Sets a flag indicating whether the audio stream was played with user
// activation.
virtual void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation);
virtual void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement);
// The following functions must be called after Initialize().

@ -399,9 +399,10 @@ void PipelineController::SetPreservesPitch(bool preserves_pitch) {
pipeline_->SetPreservesPitch(preserves_pitch);
}
void PipelineController::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
pipeline_->SetWasPlayedWithUserActivation(was_played_with_user_activation);
void PipelineController::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
pipeline_->SetWasPlayedWithUserActivationAndHighMediaEngagement(
was_played_with_user_activation_and_high_media_engagement);
}
base::TimeDelta PipelineController::GetMediaTime() const {

@ -139,7 +139,8 @@ class MEDIA_EXPORT PipelineController {
void SetVolume(float volume);
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint);
void SetPreservesPitch(bool preserves_pitch);
void SetWasPlayedWithUserActivation(bool was_played_with_user_activation);
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement);
base::TimeDelta GetMediaTime() const;
Ranges<base::TimeDelta> GetBufferedTimeRanges() const;
base::TimeDelta GetMediaDuration() const;

@ -865,10 +865,11 @@ void AudioRendererImpl::SetPreservesPitch(bool preserves_pitch) {
algorithm_->SetPreservesPitch(preserves_pitch);
}
void AudioRendererImpl::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
void AudioRendererImpl::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
base::AutoLock auto_lock(lock_);
was_played_with_user_activation_ = was_played_with_user_activation;
was_played_with_user_activation_and_high_media_engagement_ =
was_played_with_user_activation_and_high_media_engagement;
}
void AudioRendererImpl::OnSuspend() {
@ -1067,7 +1068,8 @@ bool AudioRendererImpl::HandleDecodedBuffer_Locked(
// Do not transcribe muted streams initiated by autoplay if the stream was
// never unmuted.
if (transcribe_audio_callback_ &&
(was_played_with_user_activation_ || was_unmuted_)) {
(was_played_with_user_activation_and_high_media_engagement_ ||
was_unmuted_)) {
transcribe_audio_callback_.Run(buffer);
}
#endif

@ -108,8 +108,8 @@ class MEDIA_EXPORT AudioRendererImpl
void SetVolume(float volume) override;
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint) override;
void SetPreservesPitch(bool preserves_pitch) override;
void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) override;
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) override;
// base::PowerSuspendObserver implementation.
void OnSuspend() override;
@ -338,7 +338,7 @@ class MEDIA_EXPORT AudioRendererImpl
// make pitch adjustments at playbacks other than 1.0.
bool preserves_pitch_ = true;
bool was_played_with_user_activation_ = false;
bool was_played_with_user_activation_and_high_media_engagement_ = false;
// Simple state tracking variable.
State state_;

@ -1915,7 +1915,7 @@ TEST_F(AudioRendererImplTest,
TEST_F(AudioRendererImplTest,
TranscribeAudioCallback_Muted_WithUserActivation) {
EnableSpeechRecognition();
renderer_->SetWasPlayedWithUserActivation(true);
renderer_->SetWasPlayedWithUserActivationAndHighMediaEngagement(true);
EXPECT_CALL(*this, SetOnReadyCallback(_));
Initialize();

@ -116,9 +116,10 @@ void DecryptingRenderer::SetPreservesPitch(bool preserves_pitch) {
renderer_->SetPreservesPitch(preserves_pitch);
}
void DecryptingRenderer::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
renderer_->SetWasPlayedWithUserActivation(was_played_with_user_activation);
void DecryptingRenderer::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
renderer_->SetWasPlayedWithUserActivationAndHighMediaEngagement(
was_played_with_user_activation_and_high_media_engagement);
}
void DecryptingRenderer::Flush(base::OnceClosure flush_cb) {

@ -53,8 +53,8 @@ class MEDIA_EXPORT DecryptingRenderer : public Renderer {
void SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb) override;
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint) override;
void SetPreservesPitch(bool preserves_pitch) override;
void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) override;
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) override;
void Flush(base::OnceClosure flush_cb) override;
void StartPlayingFrom(base::TimeDelta time) override;

@ -203,14 +203,14 @@ void RendererImpl::SetPreservesPitch(bool preserves_pitch) {
audio_renderer_->SetPreservesPitch(preserves_pitch);
}
void RendererImpl::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
void RendererImpl::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
DVLOG(1) << __func__;
DCHECK(task_runner_->RunsTasksInCurrentSequence());
if (audio_renderer_)
audio_renderer_->SetWasPlayedWithUserActivation(
was_played_with_user_activation);
audio_renderer_->SetWasPlayedWithUserActivationAndHighMediaEngagement(
was_played_with_user_activation_and_high_media_engagement);
}
void RendererImpl::Flush(base::OnceClosure flush_cb) {

@ -59,8 +59,8 @@ class MEDIA_EXPORT RendererImpl final : public Renderer {
void SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb) final;
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint) final;
void SetPreservesPitch(bool preserves_pitch) final;
void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) final;
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) final;
void Flush(base::OnceClosure flush_cb) final;
void StartPlayingFrom(base::TimeDelta time) final;
void SetPlaybackRate(double playback_rate) final;

@ -159,9 +159,9 @@ class WebMediaPlayer {
virtual void SetPreservesPitch(bool preserves_pitch) = 0;
// Sets a flag indicating whether the audio stream was played with user
// activation.
virtual void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) = 0;
// activation and high media engagement.
virtual void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) = 0;
// Sets a flag indicating whether media playback should be paused when the
// the iframe is hidden.

@ -116,8 +116,8 @@ class BLINK_MODULES_EXPORT WebMediaPlayerMS
void SetVolume(double volume) override;
void SetLatencyHint(double seconds) override;
void SetPreservesPitch(bool preserves_pitch) override;
void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) override;
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) override;
void OnRequestPictureInPicture() override;
bool SetSinkId(const WebString& sink_id,
WebSetSinkIdCompleteCallback completion_callback) override;

@ -2858,8 +2858,9 @@ void HTMLMediaElement::PlayInternal() {
DVLOG(3) << "playInternal(" << *this << ")";
if (web_media_player_) {
web_media_player_->SetWasPlayedWithUserActivation(
LocalFrame::HasTransientUserActivation(GetDocument().GetFrame()));
web_media_player_->SetWasPlayedWithUserActivationAndHighMediaEngagement(
LocalFrame::HasTransientUserActivation(GetDocument().GetFrame()) &&
AutoplayPolicy::DocumentHasHighMediaEngagement(GetDocument()));
}
// Playback aborts any lazy loading.

@ -95,7 +95,8 @@ class MockWebMediaPlayer : public EmptyWebMediaPlayer {
MOCK_CONST_METHOD0(GetNetworkState, NetworkState());
MOCK_CONST_METHOD0(WouldTaintOrigin, bool());
MOCK_METHOD1(SetLatencyHint, void(double));
MOCK_METHOD1(SetWasPlayedWithUserActivation, void(bool));
MOCK_METHOD1(SetWasPlayedWithUserActivationAndHighMediaEngagement,
void(bool));
MOCK_METHOD1(EnabledAudioTracksChanged, void(const WebVector<TrackId>&));
MOCK_METHOD1(SelectedVideoTrackChanged, void(std::optional<TrackId>));
MOCK_METHOD4(
@ -1664,7 +1665,8 @@ TEST_P(HTMLMediaElementTest, PlayedWithoutUserActivation) {
SetReadyState(HTMLMediaElement::kHaveEnoughData);
test::RunPendingTasks();
EXPECT_CALL(*MockMediaPlayer(), SetWasPlayedWithUserActivation(false));
EXPECT_CALL(*MockMediaPlayer(),
SetWasPlayedWithUserActivationAndHighMediaEngagement(false));
Media()->Play();
}
@ -1679,7 +1681,25 @@ TEST_P(HTMLMediaElementTest, PlayedWithUserActivation) {
Media()->GetDocument().GetFrame(),
mojom::UserActivationNotificationType::kTest);
EXPECT_CALL(*MockMediaPlayer(), SetWasPlayedWithUserActivation(true));
EXPECT_CALL(*MockMediaPlayer(),
SetWasPlayedWithUserActivationAndHighMediaEngagement(false));
Media()->Play();
}
TEST_P(HTMLMediaElementTest, PlayedWithUserActivationAndHighMediaEngagement) {
Media()->SetSrc(SrcSchemeToURL(TestURLScheme::kHttp));
test::RunPendingTasks();
SetReadyState(HTMLMediaElement::kHaveEnoughData);
SimulateHighMediaEngagement();
test::RunPendingTasks();
LocalFrame::NotifyUserActivation(
Media()->GetDocument().GetFrame(),
mojom::UserActivationNotificationType::kTest);
EXPECT_CALL(*MockMediaPlayer(),
SetWasPlayedWithUserActivationAndHighMediaEngagement(true));
Media()->Play();
}
@ -1688,7 +1708,9 @@ TEST_P(HTMLMediaElementTest, PlayedWithUserActivationBeforeLoad) {
Media()->GetDocument().GetFrame(),
mojom::UserActivationNotificationType::kTest);
EXPECT_CALL(*MockMediaPlayer(), SetWasPlayedWithUserActivation(_)).Times(0);
EXPECT_CALL(*MockMediaPlayer(),
SetWasPlayedWithUserActivationAndHighMediaEngagement(_))
.Times(0);
Media()->Play();
}
@ -1699,7 +1721,8 @@ TEST_P(HTMLMediaElementTest, CanFreezeWithoutMediaPlayerAttached) {
SetReadyState(HTMLMediaElement::kHaveEnoughData);
test::RunPendingTasks();
EXPECT_CALL(*MockMediaPlayer(), SetWasPlayedWithUserActivation(false));
EXPECT_CALL(*MockMediaPlayer(),
SetWasPlayedWithUserActivationAndHighMediaEngagement(false));
Media()->Play();
ResetWebMediaPlayer();
@ -1720,7 +1743,8 @@ TEST_P(HTMLMediaElementTest, CanFreezeWithMediaPlayerAttached) {
SetReadyState(HTMLMediaElement::kHaveEnoughData);
test::RunPendingTasks();
EXPECT_CALL(*MockMediaPlayer(), SetWasPlayedWithUserActivation(false));
EXPECT_CALL(*MockMediaPlayer(),
SetWasPlayedWithUserActivationAndHighMediaEngagement(false));
EXPECT_CALL(*MockMediaPlayer(), OnFrozen());
Media()->Play();

@ -54,7 +54,7 @@ class MockWebMediaPlayer : public WebMediaPlayer {
void SetVolume(double) override {}
void SetLatencyHint(double) override {}
void SetPreservesPitch(bool) override {}
void SetWasPlayedWithUserActivation(bool) override {}
void SetWasPlayedWithUserActivationAndHighMediaEngagement(bool) override {}
void SetShouldPauseWhenFrameIsHidden(bool) override {}
void OnRequestPictureInPicture() override {}
WebTimeRanges Buffered() const override { return WebTimeRanges(); }

@ -917,8 +917,8 @@ void WebMediaPlayerMS::SetPreservesPitch(bool preserves_pitch) {
// and thus there should be no pitch-shifting.
}
void WebMediaPlayerMS::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {}
void WebMediaPlayerMS::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {}
void WebMediaPlayerMS::SetShouldPauseWhenFrameIsHidden(
bool should_pause_when_frame_is_hidden) {

@ -1187,11 +1187,11 @@ void WebMediaPlayerImpl::SetPreservesPitch(bool preserves_pitch) {
pipeline_controller_->SetPreservesPitch(preserves_pitch);
}
void WebMediaPlayerImpl::SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) {
void WebMediaPlayerImpl::SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) {
DCHECK(main_task_runner_->BelongsToCurrentThread());
pipeline_controller_->SetWasPlayedWithUserActivation(
was_played_with_user_activation);
pipeline_controller_->SetWasPlayedWithUserActivationAndHighMediaEngagement(
was_played_with_user_activation_and_high_media_engagement);
}
void WebMediaPlayerImpl::SetShouldPauseWhenFrameIsHidden(

@ -185,8 +185,8 @@ class PLATFORM_EXPORT WebMediaPlayerImpl
void SetVolume(double volume) override;
void SetLatencyHint(double seconds) override;
void SetPreservesPitch(bool preserves_pitch) override;
void SetWasPlayedWithUserActivation(
bool was_played_with_user_activation) override;
void SetWasPlayedWithUserActivationAndHighMediaEngagement(
bool was_played_with_user_activation_and_high_media_engagement) override;
void OnRequestPictureInPicture() override;
void OnTimeUpdate() override;
bool SetSinkId(const WebString& sink_id,

@ -34,7 +34,7 @@ class EmptyWebMediaPlayer : public WebMediaPlayer {
void SetVolume(double) override {}
void SetLatencyHint(double) override {}
void SetPreservesPitch(bool) override {}
void SetWasPlayedWithUserActivation(bool) override {}
void SetWasPlayedWithUserActivationAndHighMediaEngagement(bool) override {}
void SetShouldPauseWhenFrameIsHidden(bool) override {}
void OnRequestPictureInPicture() override {}
WebTimeRanges Buffered() const override;