chromium/content/browser/media/session/mock_media_session_player_observer.cc

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/media/session/mock_media_session_player_observer.h"
#include "content/public/browser/render_frame_host.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace content {

MockMediaSessionPlayerObserver::MockMediaSessionPlayerObserver(
    RenderFrameHost* render_frame_host,
    media::MediaContentType media_content_type)
    : … { … }

MockMediaSessionPlayerObserver::MockMediaSessionPlayerObserver(
    media::MediaContentType media_content_type)
    : … { … }

MockMediaSessionPlayerObserver::~MockMediaSessionPlayerObserver() = default;

void MockMediaSessionPlayerObserver::OnSuspend(int player_id) { … }

void MockMediaSessionPlayerObserver::OnResume(int player_id) { … }

void MockMediaSessionPlayerObserver::OnSeekForward(int player_id,
                                                   base::TimeDelta seek_time) { … }

void MockMediaSessionPlayerObserver::OnSeekBackward(int player_id,
                                                    base::TimeDelta seek_time) { … }

void MockMediaSessionPlayerObserver::OnSeekTo(int player_id,
                                              base::TimeDelta seek_time) { … }

void MockMediaSessionPlayerObserver::OnSetVolumeMultiplier(
    int player_id,
    double volume_multiplier) { … }

void MockMediaSessionPlayerObserver::OnEnterPictureInPicture(int player_id) { … }

void MockMediaSessionPlayerObserver::OnSetAudioSinkId(
    int player_id,
    const std::string& raw_device_id) { … }

void MockMediaSessionPlayerObserver::OnSetMute(int player_id, bool mute) { … }

void MockMediaSessionPlayerObserver::OnRequestMediaRemoting(int player_id) { … }

void MockMediaSessionPlayerObserver::OnRequestVisibility(
    int player_id,
    RequestVisibilityCallback request_visibility_callback) { … }

std::optional<media_session::MediaPosition>
MockMediaSessionPlayerObserver::GetPosition(int player_id) const { … }

bool MockMediaSessionPlayerObserver::IsPictureInPictureAvailable(
    int player_id) const { … }

bool MockMediaSessionPlayerObserver::HasSufficientlyVisibleVideo(
    int player_id) const { … }

RenderFrameHost* MockMediaSessionPlayerObserver::render_frame_host() const { … }

int MockMediaSessionPlayerObserver::StartNewPlayer() { … }

bool MockMediaSessionPlayerObserver::IsPlaying(size_t player_id) { … }

double MockMediaSessionPlayerObserver::GetVolumeMultiplier(size_t player_id) { … }

void MockMediaSessionPlayerObserver::SetAudioSinkId(size_t player_id,
                                                    std::string sink_id) { … }

void MockMediaSessionPlayerObserver::SetPlaying(size_t player_id,
                                                bool playing) { … }

void MockMediaSessionPlayerObserver::SetPosition(
    size_t player_id,
    media_session::MediaPosition& position) { … }

void MockMediaSessionPlayerObserver::SetHasSufficientlyVisibleVideo(
    size_t player_id,
    bool has_sufficiently_visible_video) { … }

int MockMediaSessionPlayerObserver::received_suspend_calls() const { … }

int MockMediaSessionPlayerObserver::received_resume_calls() const { … }

int MockMediaSessionPlayerObserver::received_seek_forward_calls() const { … }

int MockMediaSessionPlayerObserver::received_seek_backward_calls() const { … }

int MockMediaSessionPlayerObserver::received_seek_to_calls() const { … }

int MockMediaSessionPlayerObserver::received_enter_picture_in_picture_calls()
    const { … }

int MockMediaSessionPlayerObserver::received_exit_picture_in_picture_calls()
    const { … }

int MockMediaSessionPlayerObserver::received_set_audio_sink_id_calls() const { … }

int MockMediaSessionPlayerObserver::received_request_visibility_calls() const { … }

bool MockMediaSessionPlayerObserver::HasAudio(int player_id) const { … }

bool MockMediaSessionPlayerObserver::HasVideo(int player_id) const { … }

bool MockMediaSessionPlayerObserver::IsPaused(int player_id) const { … }

std::string MockMediaSessionPlayerObserver::GetAudioOutputSinkId(
    int player_id) const { … }

bool MockMediaSessionPlayerObserver::SupportsAudioOutputDeviceSwitching(
    int player_id) const { … }

media::MediaContentType MockMediaSessionPlayerObserver::GetMediaContentType()
    const { … }

void MockMediaSessionPlayerObserver::SetMediaContentType(
    media::MediaContentType media_content_type) { … }

MockMediaSessionPlayerObserver::MockPlayer::MockPlayer(bool is_playing,
                                                       double volume_multiplier)
    : … { … }

MockMediaSessionPlayerObserver::MockPlayer::~MockPlayer() = default;

MockMediaSessionPlayerObserver::MockPlayer::MockPlayer(const MockPlayer&) =
    default;

}  // namespace content