forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
webmediaplayer_params.h
207 lines (168 loc) · 7.25 KB
/
webmediaplayer_params.h
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MEDIA_BLINK_WEBMEDIAPLAYER_PARAMS_H_
#define MEDIA_BLINK_WEBMEDIAPLAYER_PARAMS_H_
#include <stdint.h>
#include "base/callback.h"
#include "base/feature_list.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "cc/layers/surface_layer.h"
#include "components/viz/common/gpu/context_provider.h"
#include "media/base/media_log.h"
#include "media/base/media_observer.h"
#include "media/base/media_switches.h"
#include "media/base/routing_token_callback.h"
#include "media/blink/media_blink_export.h"
#include "media/mojo/interfaces/media_metrics_provider.mojom.h"
#include "third_party/blink/public/platform/web_media_player.h"
#include "third_party/blink/public/platform/web_video_frame_submitter.h"
namespace base {
class SingleThreadTaskRunner;
class TaskRunner;
}
namespace blink {
class WebContentDecryptionModule;
class WebSurfaceLayerBridge;
class WebSurfaceLayerBridgeObserver;
} // namespace blink
namespace media {
using CreateSurfaceLayerBridgeCB =
base::OnceCallback<std::unique_ptr<blink::WebSurfaceLayerBridge>(
blink::WebSurfaceLayerBridgeObserver*,
cc::UpdateSubmissionStateCB)>;
class SwitchableAudioRendererSink;
// Holds parameters for constructing WebMediaPlayerImpl without having
// to plumb arguments through various abstraction layers.
class MEDIA_BLINK_EXPORT WebMediaPlayerParams {
public:
// Returns true if load will deferred. False if it will run immediately.
using DeferLoadCB = base::RepeatingCallback<bool(base::OnceClosure)>;
// Callback to obtain the media ContextProvider.
// Requires being called on the media thread.
// The argument callback is also called on the media thread as a reply.
using ContextProviderCB =
base::Callback<void(base::Callback<void(viz::ContextProvider*)>)>;
// Callback to tell V8 about the amount of memory used by the WebMediaPlayer
// instance. The input parameter is the delta in bytes since the last call to
// AdjustAllocatedMemoryCB and the return value is the total number of bytes
// used by objects external to V8. Note: this value includes things that are
// not the WebMediaPlayer!
typedef base::Callback<int64_t(int64_t)> AdjustAllocatedMemoryCB;
// |defer_load_cb|, |audio_renderer_sink|, |compositor_task_runner|, and
// |context_3d_cb| may be null.
WebMediaPlayerParams(
std::unique_ptr<MediaLog> media_log,
const DeferLoadCB& defer_load_cb,
const scoped_refptr<SwitchableAudioRendererSink>& audio_renderer_sink,
const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
const scoped_refptr<base::TaskRunner>& worker_task_runner,
const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
const scoped_refptr<base::SingleThreadTaskRunner>&
video_frame_compositor_task_runner,
const AdjustAllocatedMemoryCB& adjust_allocated_memory_cb,
blink::WebContentDecryptionModule* initial_cdm,
RequestRoutingTokenCallback request_routing_token_cb,
base::WeakPtr<MediaObserver> media_observer,
bool enable_instant_source_buffer_gc,
bool embedded_media_experience_enabled,
mojom::MediaMetricsProviderPtr metrics_provider,
CreateSurfaceLayerBridgeCB bridge_callback,
scoped_refptr<viz::ContextProvider> context_provider,
blink::WebMediaPlayer::SurfaceLayerMode use_surface_layer_for_video,
bool is_background_suspend_enabled,
bool is_background_video_play_enabled,
bool is_background_video_track_optimization_supported);
~WebMediaPlayerParams();
DeferLoadCB defer_load_cb() const { return defer_load_cb_; }
const scoped_refptr<SwitchableAudioRendererSink>& audio_renderer_sink()
const {
return audio_renderer_sink_;
}
std::unique_ptr<MediaLog> take_media_log() { return std::move(media_log_); }
mojom::MediaMetricsProviderPtr take_metrics_provider() {
return std::move(metrics_provider_);
}
const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner() const {
return media_task_runner_;
}
const scoped_refptr<base::TaskRunner> worker_task_runner() const {
return worker_task_runner_;
}
const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner()
const {
return compositor_task_runner_;
}
const scoped_refptr<base::SingleThreadTaskRunner>&
video_frame_compositor_task_runner() const {
return video_frame_compositor_task_runner_;
}
blink::WebContentDecryptionModule* initial_cdm() const {
return initial_cdm_;
}
AdjustAllocatedMemoryCB adjust_allocated_memory_cb() const {
return adjust_allocated_memory_cb_;
}
base::WeakPtr<MediaObserver> media_observer() const {
return media_observer_;
}
bool enable_instant_source_buffer_gc() const {
return enable_instant_source_buffer_gc_;
}
bool embedded_media_experience_enabled() const {
return embedded_media_experience_enabled_;
}
RequestRoutingTokenCallback request_routing_token_cb() {
return request_routing_token_cb_;
}
CreateSurfaceLayerBridgeCB create_bridge_callback() {
return std::move(create_bridge_callback_);
}
scoped_refptr<viz::ContextProvider> context_provider() {
return context_provider_;
}
blink::WebMediaPlayer::SurfaceLayerMode use_surface_layer_for_video() const {
return use_surface_layer_for_video_;
}
bool IsBackgroundSuspendEnabled() const {
return is_background_suspend_enabled_;
}
bool IsBackgroundVideoPlaybackEnabled() const {
return is_background_video_playback_enabled_;
}
bool IsBackgroundVideoTrackOptimizationSupported() const {
return is_background_video_track_optimization_supported_;
}
private:
DeferLoadCB defer_load_cb_;
scoped_refptr<SwitchableAudioRendererSink> audio_renderer_sink_;
std::unique_ptr<MediaLog> media_log_;
scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
scoped_refptr<base::TaskRunner> worker_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
scoped_refptr<base::SingleThreadTaskRunner>
video_frame_compositor_task_runner_;
AdjustAllocatedMemoryCB adjust_allocated_memory_cb_;
blink::WebContentDecryptionModule* initial_cdm_;
RequestRoutingTokenCallback request_routing_token_cb_;
base::WeakPtr<MediaObserver> media_observer_;
bool enable_instant_source_buffer_gc_;
const bool embedded_media_experience_enabled_;
mojom::MediaMetricsProviderPtr metrics_provider_;
CreateSurfaceLayerBridgeCB create_bridge_callback_;
scoped_refptr<viz::ContextProvider> context_provider_;
blink::WebMediaPlayer::SurfaceLayerMode use_surface_layer_for_video_;
// Whether the renderer should automatically suspend media playback in
// background tabs.
bool is_background_suspend_enabled_ = false;
// Whether the renderer is allowed to play video in background tabs.
bool is_background_video_playback_enabled_ = true;
// Whether background video optimization is supported on current platform.
bool is_background_video_track_optimization_supported_ = true;
DISALLOW_IMPLICIT_CONSTRUCTORS(WebMediaPlayerParams);
};
} // namespace media
#endif // MEDIA_BLINK_WEBMEDIAPLAYER_PARAMS_H_