1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "content/renderer/media/android/renderer_media_player_manager.h"
7 #include "content/common/media/media_player_messages_android.h"
8 #include "content/public/common/renderer_preferences.h"
9 #include "content/renderer/media/android/renderer_media_player_manager.h"
10 #include "content/renderer/media/android/webmediaplayer_android.h"
11 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
12 #include "content/renderer/render_view_impl.h"
13 #include "ui/gfx/rect_f.h"
17 RendererMediaPlayerManager::RendererMediaPlayerManager(
18 RenderFrame* render_frame)
19 : RenderFrameObserver(render_frame),
20 next_media_player_id_(0),
21 fullscreen_frame_(NULL),
22 pending_fullscreen_frame_(NULL) {
25 RendererMediaPlayerManager::~RendererMediaPlayerManager() {
26 DCHECK(media_players_.empty())
27 << "RendererMediaPlayerManager is owned by RenderFrameImpl and is "
28 "destroyed only after all media players are destroyed.";
31 bool RendererMediaPlayerManager::OnMessageReceived(const IPC::Message& msg) {
33 IPC_BEGIN_MESSAGE_MAP(RendererMediaPlayerManager, msg)
34 IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaMetadataChanged,
35 OnMediaMetadataChanged)
36 IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaPlaybackCompleted,
37 OnMediaPlaybackCompleted)
38 IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaBufferingUpdate,
39 OnMediaBufferingUpdate)
40 IPC_MESSAGE_HANDLER(MediaPlayerMsg_SeekRequest, OnSeekRequest)
41 IPC_MESSAGE_HANDLER(MediaPlayerMsg_SeekCompleted, OnSeekCompleted)
42 IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaError, OnMediaError)
43 IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaVideoSizeChanged,
45 IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaTimeUpdate, OnTimeUpdate)
46 IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaPlayerReleased,
47 OnMediaPlayerReleased)
48 IPC_MESSAGE_HANDLER(MediaPlayerMsg_ConnectedToRemoteDevice,
49 OnConnectedToRemoteDevice)
50 IPC_MESSAGE_HANDLER(MediaPlayerMsg_DisconnectedFromRemoteDevice,
51 OnDisconnectedFromRemoteDevice)
52 IPC_MESSAGE_HANDLER(MediaPlayerMsg_RequestFullscreen,
54 IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidEnterFullscreen, OnDidEnterFullscreen)
55 IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidExitFullscreen, OnDidExitFullscreen)
56 IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPlay, OnPlayerPlay)
57 IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPause, OnPlayerPause)
58 IPC_MESSAGE_HANDLER(MediaPlayerMsg_PauseVideo, OnPauseVideo)
59 IPC_MESSAGE_UNHANDLED(handled = false)
64 void RendererMediaPlayerManager::Initialize(
65 MediaPlayerHostMsg_Initialize_Type type,
68 const GURL& first_party_for_cookies,
69 int demuxer_client_id,
70 const GURL& frame_url) {
72 MediaPlayerHostMsg_Initialize_Params media_player_params;
73 media_player_params.type = type;
74 media_player_params.player_id = player_id;
75 media_player_params.demuxer_client_id = demuxer_client_id;
76 media_player_params.url = url;
77 media_player_params.first_party_for_cookies = first_party_for_cookies;
78 media_player_params.frame_url = frame_url;
80 Send(new MediaPlayerHostMsg_Initialize(routing_id(), media_player_params));
83 void RendererMediaPlayerManager::Start(int player_id) {
84 Send(new MediaPlayerHostMsg_Start(routing_id(), player_id));
87 void RendererMediaPlayerManager::Pause(
89 bool is_media_related_action) {
90 Send(new MediaPlayerHostMsg_Pause(
91 routing_id(), player_id, is_media_related_action));
94 void RendererMediaPlayerManager::Seek(
96 const base::TimeDelta& time) {
97 Send(new MediaPlayerHostMsg_Seek(routing_id(), player_id, time));
100 void RendererMediaPlayerManager::SetVolume(int player_id, double volume) {
101 Send(new MediaPlayerHostMsg_SetVolume(routing_id(), player_id, volume));
104 void RendererMediaPlayerManager::SetPoster(int player_id, const GURL& poster) {
105 Send(new MediaPlayerHostMsg_SetPoster(routing_id(), player_id, poster));
108 void RendererMediaPlayerManager::ReleaseResources(int player_id) {
109 Send(new MediaPlayerHostMsg_Release(routing_id(), player_id));
112 void RendererMediaPlayerManager::DestroyPlayer(int player_id) {
113 Send(new MediaPlayerHostMsg_DestroyMediaPlayer(routing_id(), player_id));
116 void RendererMediaPlayerManager::OnMediaMetadataChanged(
118 base::TimeDelta duration,
122 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
124 player->OnMediaMetadataChanged(duration, width, height, success);
127 void RendererMediaPlayerManager::OnMediaPlaybackCompleted(int player_id) {
128 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
130 player->OnPlaybackComplete();
133 void RendererMediaPlayerManager::OnMediaBufferingUpdate(int player_id,
135 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
137 player->OnBufferingUpdate(percent);
140 void RendererMediaPlayerManager::OnSeekRequest(
142 const base::TimeDelta& time_to_seek) {
143 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
145 player->OnSeekRequest(time_to_seek);
148 void RendererMediaPlayerManager::OnSeekCompleted(
150 const base::TimeDelta& current_time) {
151 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
153 player->OnSeekComplete(current_time);
156 void RendererMediaPlayerManager::OnMediaError(int player_id, int error) {
157 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
159 player->OnMediaError(error);
162 void RendererMediaPlayerManager::OnVideoSizeChanged(int player_id,
165 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
167 player->OnVideoSizeChanged(width, height);
170 void RendererMediaPlayerManager::OnTimeUpdate(int player_id,
171 base::TimeDelta current_time) {
172 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
174 player->OnTimeUpdate(current_time);
177 void RendererMediaPlayerManager::OnMediaPlayerReleased(int player_id) {
178 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
180 player->OnPlayerReleased();
183 void RendererMediaPlayerManager::OnConnectedToRemoteDevice(int player_id,
184 const std::string& remote_playback_message) {
185 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
187 player->OnConnectedToRemoteDevice(remote_playback_message);
190 void RendererMediaPlayerManager::OnDisconnectedFromRemoteDevice(int player_id) {
191 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
193 player->OnDisconnectedFromRemoteDevice();
196 void RendererMediaPlayerManager::OnDidEnterFullscreen(int player_id) {
197 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
199 player->OnDidEnterFullscreen();
202 void RendererMediaPlayerManager::OnDidExitFullscreen(int player_id) {
203 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
205 player->OnDidExitFullscreen();
208 void RendererMediaPlayerManager::OnPlayerPlay(int player_id) {
209 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
211 player->OnMediaPlayerPlay();
214 void RendererMediaPlayerManager::OnPlayerPause(int player_id) {
215 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
217 player->OnMediaPlayerPause();
220 void RendererMediaPlayerManager::OnRequestFullscreen(int player_id) {
221 WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
223 player->OnRequestFullscreen();
226 void RendererMediaPlayerManager::OnPauseVideo() {
227 ReleaseVideoResources();
230 void RendererMediaPlayerManager::EnterFullscreen(int player_id,
231 blink::WebFrame* frame) {
232 pending_fullscreen_frame_ = frame;
233 Send(new MediaPlayerHostMsg_EnterFullscreen(routing_id(), player_id));
236 void RendererMediaPlayerManager::ExitFullscreen(int player_id) {
237 pending_fullscreen_frame_ = NULL;
238 fullscreen_frame_ = NULL;
239 Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
242 void RendererMediaPlayerManager::SetCdm(int player_id, int cdm_id) {
243 if (cdm_id == RendererCdmManager::kInvalidCdmId) {
247 Send(new MediaPlayerHostMsg_SetCdm(routing_id(), player_id, cdm_id));
250 int RendererMediaPlayerManager::RegisterMediaPlayer(
251 WebMediaPlayerAndroid* player) {
252 media_players_[next_media_player_id_] = player;
253 return next_media_player_id_++;
256 void RendererMediaPlayerManager::UnregisterMediaPlayer(int player_id) {
257 media_players_.erase(player_id);
260 void RendererMediaPlayerManager::ReleaseVideoResources() {
261 std::map<int, WebMediaPlayerAndroid*>::iterator player_it;
262 for (player_it = media_players_.begin(); player_it != media_players_.end();
264 WebMediaPlayerAndroid* player = player_it->second;
266 // Do not release if an audio track is still playing
267 if (player && (player->paused() || player->hasVideo()))
268 player->ReleaseMediaResources();
272 WebMediaPlayerAndroid* RendererMediaPlayerManager::GetMediaPlayer(
274 std::map<int, WebMediaPlayerAndroid*>::iterator iter =
275 media_players_.find(player_id);
276 if (iter != media_players_.end())
281 bool RendererMediaPlayerManager::CanEnterFullscreen(blink::WebFrame* frame) {
282 return (!fullscreen_frame_ && !pending_fullscreen_frame_)
283 || ShouldEnterFullscreen(frame);
286 void RendererMediaPlayerManager::DidEnterFullscreen(blink::WebFrame* frame) {
287 pending_fullscreen_frame_ = NULL;
288 fullscreen_frame_ = frame;
291 void RendererMediaPlayerManager::DidExitFullscreen() {
292 fullscreen_frame_ = NULL;
295 bool RendererMediaPlayerManager::IsInFullscreen(blink::WebFrame* frame) {
296 return fullscreen_frame_ == frame;
299 bool RendererMediaPlayerManager::ShouldEnterFullscreen(blink::WebFrame* frame) {
300 return fullscreen_frame_ == frame || pending_fullscreen_frame_ == frame;
303 #if defined(VIDEO_HOLE)
304 void RendererMediaPlayerManager::RequestExternalSurface(
306 const gfx::RectF& geometry) {
307 Send(new MediaPlayerHostMsg_NotifyExternalSurface(
308 routing_id(), player_id, true, geometry));
311 void RendererMediaPlayerManager::DidCommitCompositorFrame() {
312 std::map<int, gfx::RectF> geometry_change;
313 RetrieveGeometryChanges(&geometry_change);
314 for (std::map<int, gfx::RectF>::iterator it = geometry_change.begin();
315 it != geometry_change.end();
317 Send(new MediaPlayerHostMsg_NotifyExternalSurface(
318 routing_id(), it->first, false, it->second));
322 void RendererMediaPlayerManager::RetrieveGeometryChanges(
323 std::map<int, gfx::RectF>* changes) {
324 DCHECK(changes->empty());
325 for (std::map<int, WebMediaPlayerAndroid*>::iterator player_it =
326 media_players_.begin();
327 player_it != media_players_.end();
329 WebMediaPlayerAndroid* player = player_it->second;
331 if (player && player->hasVideo()) {
332 if (player->UpdateBoundaryRectangle())
333 (*changes)[player_it->first] = player->GetBoundaryRectangle();
339 RendererMediaPlayerManager::ShouldUseVideoOverlayForEmbeddedEncryptedVideo() {
340 const RendererPreferences& prefs = static_cast<RenderFrameImpl*>(
341 render_frame())->render_view()->renderer_preferences();
342 return prefs.use_video_overlay_for_embedded_encrypted_video;
344 #endif // defined(VIDEO_HOLE)
346 } // namespace content