1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_MEDIA_FLINGING_RENDERER_H_
#define CONTENT_BROWSER_MEDIA_FLINGING_RENDERER_H_
#include "base/functional/callback.h"
#include "base/memory/raw_ptr.h"
#include "content/common/content_export.h"
#include "media/base/flinging_controller.h"
#include "media/base/media_resource.h"
#include "media/base/media_status_observer.h"
#include "media/base/renderer.h"
#include "media/base/renderer_client.h"
#include "media/mojo/mojom/renderer_extensions.mojom.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "url/gurl.h"
namespace content {
class FlingingRendererTest;
class RenderFrameHost;
// FlingingRenderer adapts from the media::Renderer interface to the
// MediaController interface. The MediaController is used to issue simple media
// playback commands. In this case, the media we are controlling should be an
// already existing RemotingCastSession, which should have been initiated by a
// blink::RemotePlayback object, using the PresentationService.
class CONTENT_EXPORT FlingingRenderer : public media::Renderer,
media::MediaStatusObserver {
public:
using ClientExtension = media::mojom::FlingingRendererClientExtension;
// Helper method to create a FlingingRenderer from an already existing
// presentation ID.
// Returns nullptr if there was an error getting the MediaControllor for the
// given presentation ID.
static std::unique_ptr<FlingingRenderer> Create(
RenderFrameHost* render_frame_host,
const std::string& presentation_id,
mojo::PendingRemote<ClientExtension> client_extension);
FlingingRenderer(const FlingingRenderer&) = delete;
FlingingRenderer& operator=(const FlingingRenderer&) = delete;
~FlingingRenderer() override;
// media::Renderer implementation
void Initialize(media::MediaResource* media_resource,
media::RendererClient* client,
media::PipelineStatusCallback init_cb) override;
void SetLatencyHint(std::optional<base::TimeDelta> latency_hint) override;
void Flush(base::OnceClosure flush_cb) override;
void StartPlayingFrom(base::TimeDelta time) override;
void SetPlaybackRate(double playback_rate) override;
void SetVolume(float volume) override;
base::TimeDelta GetMediaTime() override;
media::RendererType GetRendererType() override;
// media::MediaStatusObserver implementation.
void OnMediaStatusUpdated(const media::MediaStatus& status) override;
private:
friend class FlingingRendererTest;
using PlayState = media::MediaStatus::State;
explicit FlingingRenderer(
std::unique_ptr<media::FlingingController> controller,
mojo::PendingRemote<ClientExtension> client_extension);
void SetExpectedPlayState(PlayState state);
// The play state that we expect the remote device to reach.
// Updated whenever WMPI sends play/pause commands.
PlayState expected_play_state_ = PlayState::kUnknown;
// True when the remote device has reached the expected play state.
// False when it is transitioning.
bool play_state_is_stable_ = false;
// The last "stable" play state received from the cast device.
// Only updated when |play_state_is_stable_| is true.
PlayState last_play_state_received_ = PlayState::kUnknown;
raw_ptr<media::RendererClient> client_;
mojo::Remote<ClientExtension> client_extension_;
std::unique_ptr<media::FlingingController> controller_;
};
} // namespace content
#endif // CONTENT_BROWSER_MEDIA_FLINGING_RENDERER_H_
|
