src/content/renderer/media/android/renderer_media_player_manager.cc

   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.
   4
   5 #include "content/renderer/media/android/renderer_media_player_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "content/common/media/media_player_messages_android.h"
  10 #include "content/renderer/media/android/proxy_media_keys.h"
  11 #include "content/renderer/media/android/renderer_media_player_manager.h"
  12 #include "content/renderer/media/android/webmediaplayer_android.h"
  13 #include "ui/gfx/rect_f.h"
  14
  15 // Maximum sizes for various EME message parameters. These are checks to
  16 // prevent unnecessarily large messages from being passed around, and the sizes
  17 // are somewhat arbitrary as the EME specification doesn't specify any limits.
  18 static const size_t kEmeWebSessionIdMaximum = 512;
  19 static const size_t kEmeMessageMaximum = 10240;  // 10 KB
  20
  21 namespace content {
  22
  23 RendererMediaPlayerManager::RendererMediaPlayerManager(RenderView* render_view)
  24     : RenderViewObserver(render_view),
  25       next_media_player_id_(0),
  26       fullscreen_frame_(NULL),
  27       pending_fullscreen_frame_(NULL) {}
  28
  29 RendererMediaPlayerManager::~RendererMediaPlayerManager() {
  30   std::map<int, WebMediaPlayerAndroid*>::iterator player_it;
  31   for (player_it = media_players_.begin();
  32       player_it != media_players_.end(); ++player_it) {
  33     WebMediaPlayerAndroid* player = player_it->second;
  34     player->Detach();
  35   }
  36
  37   Send(new MediaPlayerHostMsg_DestroyAllMediaPlayers(routing_id()));
  38 }
  39
  40 bool RendererMediaPlayerManager::OnMessageReceived(const IPC::Message& msg) {
  41   bool handled = true;
  42   IPC_BEGIN_MESSAGE_MAP(RendererMediaPlayerManager, msg)
  43     IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaMetadataChanged,
  44                         OnMediaMetadataChanged)
  45     IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaPlaybackCompleted,
  46                         OnMediaPlaybackCompleted)
  47     IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaBufferingUpdate,
  48                         OnMediaBufferingUpdate)
  49     IPC_MESSAGE_HANDLER(MediaPlayerMsg_SeekRequest, OnSeekRequest)
  50     IPC_MESSAGE_HANDLER(MediaPlayerMsg_SeekCompleted, OnSeekCompleted)
  51     IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaError, OnMediaError)
  52     IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaVideoSizeChanged,
  53                         OnVideoSizeChanged)
  54     IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaTimeUpdate, OnTimeUpdate)
  55     IPC_MESSAGE_HANDLER(MediaPlayerMsg_MediaPlayerReleased,
  56                         OnMediaPlayerReleased)
  57     IPC_MESSAGE_HANDLER(MediaPlayerMsg_ConnectedToRemoteDevice,
  58                         OnConnectedToRemoteDevice)
  59     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DisconnectedFromRemoteDevice,
  60                         OnDisconnectedFromRemoteDevice)
  61     IPC_MESSAGE_HANDLER(MediaPlayerMsg_RequestFullscreen,
  62                         OnRequestFullscreen)
  63     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidEnterFullscreen, OnDidEnterFullscreen)
  64     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidExitFullscreen, OnDidExitFullscreen)
  65     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPlay, OnPlayerPlay)
  66     IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPause, OnPlayerPause)
  67     IPC_MESSAGE_HANDLER(MediaKeysMsg_SessionCreated, OnSessionCreated)
  68     IPC_MESSAGE_HANDLER(MediaKeysMsg_SessionMessage, OnSessionMessage)
  69     IPC_MESSAGE_HANDLER(MediaKeysMsg_SessionReady, OnSessionReady)
  70     IPC_MESSAGE_HANDLER(MediaKeysMsg_SessionClosed, OnSessionClosed)
  71     IPC_MESSAGE_HANDLER(MediaKeysMsg_SessionError, OnSessionError)
  72   IPC_MESSAGE_UNHANDLED(handled = false)
  73   IPC_END_MESSAGE_MAP()
  74   return handled;
  75 }
  76
  77 void RendererMediaPlayerManager::Initialize(
  78     MediaPlayerHostMsg_Initialize_Type type,
  79     int player_id,
  80     const GURL& url,
  81     const GURL& first_party_for_cookies,
  82     int demuxer_client_id) {
  83   Send(new MediaPlayerHostMsg_Initialize(
  84       routing_id(), type, player_id, url, first_party_for_cookies,
  85       demuxer_client_id));
  86 }
  87
  88 void RendererMediaPlayerManager::Start(int player_id) {
  89   Send(new MediaPlayerHostMsg_Start(routing_id(), player_id));
  90 }
  91
  92 void RendererMediaPlayerManager::Pause(
  93     int player_id,
  94     bool is_media_related_action) {
  95   Send(new MediaPlayerHostMsg_Pause(
  96       routing_id(), player_id, is_media_related_action));
  97 }
  98
  99 void RendererMediaPlayerManager::Seek(
 100     int player_id,
 101     const base::TimeDelta& time) {
 102   Send(new MediaPlayerHostMsg_Seek(routing_id(), player_id, time));
 103 }
 104
 105 void RendererMediaPlayerManager::SetVolume(int player_id, double volume) {
 106   Send(new MediaPlayerHostMsg_SetVolume(routing_id(), player_id, volume));
 107 }
 108
 109 void RendererMediaPlayerManager::SetPoster(int player_id, const GURL& poster) {
 110   Send(new MediaPlayerHostMsg_SetPoster(routing_id(), player_id, poster));
 111 }
 112
 113 void RendererMediaPlayerManager::ReleaseResources(int player_id) {
 114   Send(new MediaPlayerHostMsg_Release(routing_id(), player_id));
 115 }
 116
 117 void RendererMediaPlayerManager::DestroyPlayer(int player_id) {
 118   Send(new MediaPlayerHostMsg_DestroyMediaPlayer(routing_id(), player_id));
 119 }
 120
 121 void RendererMediaPlayerManager::OnMediaMetadataChanged(
 122     int player_id,
 123     base::TimeDelta duration,
 124     int width,
 125     int height,
 126     bool success) {
 127   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 128   if (player)
 129     player->OnMediaMetadataChanged(duration, width, height, success);
 130 }
 131
 132 void RendererMediaPlayerManager::OnMediaPlaybackCompleted(int player_id) {
 133   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 134   if (player)
 135     player->OnPlaybackComplete();
 136 }
 137
 138 void RendererMediaPlayerManager::OnMediaBufferingUpdate(int player_id,
 139                                                         int percent) {
 140   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 141   if (player)
 142     player->OnBufferingUpdate(percent);
 143 }
 144
 145 void RendererMediaPlayerManager::OnSeekRequest(
 146     int player_id,
 147     const base::TimeDelta& time_to_seek) {
 148   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 149   if (player)
 150     player->OnSeekRequest(time_to_seek);
 151 }
 152
 153 void RendererMediaPlayerManager::OnSeekCompleted(
 154     int player_id,
 155     const base::TimeDelta& current_time) {
 156   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 157   if (player)
 158     player->OnSeekComplete(current_time);
 159 }
 160
 161 void RendererMediaPlayerManager::OnMediaError(int player_id, int error) {
 162   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 163   if (player)
 164     player->OnMediaError(error);
 165 }
 166
 167 void RendererMediaPlayerManager::OnVideoSizeChanged(int player_id,
 168                                                     int width,
 169                                                     int height) {
 170   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 171   if (player)
 172     player->OnVideoSizeChanged(width, height);
 173 }
 174
 175 void RendererMediaPlayerManager::OnTimeUpdate(int player_id,
 176                                               base::TimeDelta current_time) {
 177   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 178   if (player)
 179     player->OnTimeUpdate(current_time);
 180 }
 181
 182 void RendererMediaPlayerManager::OnMediaPlayerReleased(int player_id) {
 183   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 184   if (player)
 185     player->OnPlayerReleased();
 186 }
 187
 188 void RendererMediaPlayerManager::OnConnectedToRemoteDevice(int player_id) {
 189   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 190   if (player)
 191     player->OnConnectedToRemoteDevice();
 192 }
 193
 194 void RendererMediaPlayerManager::OnDisconnectedFromRemoteDevice(int player_id) {
 195   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 196   if (player)
 197     player->OnDisconnectedFromRemoteDevice();
 198 }
 199
 200 void RendererMediaPlayerManager::OnDidEnterFullscreen(int player_id) {
 201   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 202   if (player)
 203     player->OnDidEnterFullscreen();
 204 }
 205
 206 void RendererMediaPlayerManager::OnDidExitFullscreen(int player_id) {
 207   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 208   if (player)
 209     player->OnDidExitFullscreen();
 210 }
 211
 212 void RendererMediaPlayerManager::OnPlayerPlay(int player_id) {
 213   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 214   if (player)
 215     player->OnMediaPlayerPlay();
 216 }
 217
 218 void RendererMediaPlayerManager::OnPlayerPause(int player_id) {
 219   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 220   if (player)
 221     player->OnMediaPlayerPause();
 222 }
 223
 224 void RendererMediaPlayerManager::OnRequestFullscreen(int player_id) {
 225   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 226   if (player)
 227     player->OnRequestFullscreen();
 228 }
 229
 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));
 234 }
 235
 236 void RendererMediaPlayerManager::ExitFullscreen(int player_id) {
 237   pending_fullscreen_frame_ = NULL;
 238   Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
 239 }
 240
 241 void RendererMediaPlayerManager::InitializeCDM(int media_keys_id,
 242                                                ProxyMediaKeys* media_keys,
 243                                                const std::vector<uint8>& uuid,
 244                                                const GURL& frame_url) {
 245   RegisterMediaKeys(media_keys_id, media_keys);
 246   Send(new MediaKeysHostMsg_InitializeCDM(
 247       routing_id(), media_keys_id, uuid, frame_url));
 248 }
 249
 250 void RendererMediaPlayerManager::CreateSession(
 251     int media_keys_id,
 252     uint32 session_id,
 253     MediaKeysHostMsg_CreateSession_Type type,
 254     const std::vector<uint8>& init_data) {
 255   Send(new MediaKeysHostMsg_CreateSession(
 256       routing_id(), media_keys_id, session_id, type, init_data));
 257 }
 258
 259 void RendererMediaPlayerManager::UpdateSession(
 260     int media_keys_id,
 261     uint32 session_id,
 262     const std::vector<uint8>& response) {
 263   Send(new MediaKeysHostMsg_UpdateSession(
 264       routing_id(), media_keys_id, session_id, response));
 265 }
 266
 267 void RendererMediaPlayerManager::ReleaseSession(int media_keys_id,
 268                                                 uint32 session_id) {
 269   Send(new MediaKeysHostMsg_ReleaseSession(
 270       routing_id(), media_keys_id, session_id));
 271 }
 272
 273 void RendererMediaPlayerManager::DestroyCdm(int media_keys_id) {
 274   Send(new MediaKeysHostMsg_DestroyCdm(routing_id(), media_keys_id));
 275 }
 276
 277 void RendererMediaPlayerManager::OnSessionCreated(
 278     int media_keys_id,
 279     uint32 session_id,
 280     const std::string& web_session_id) {
 281   if (web_session_id.length() > kEmeWebSessionIdMaximum) {
 282     OnSessionError(
 283         media_keys_id, session_id, media::MediaKeys::kUnknownError, 0);
 284     return;
 285   }
 286
 287   ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
 288   if (media_keys)
 289     media_keys->OnSessionCreated(session_id, web_session_id);
 290 }
 291
 292 void RendererMediaPlayerManager::OnSessionMessage(
 293     int media_keys_id,
 294     uint32 session_id,
 295     const std::vector<uint8>& message,
 296     const GURL& destination_url) {
 297   if (message.size() > kEmeMessageMaximum) {
 298     OnSessionError(
 299         media_keys_id, session_id, media::MediaKeys::kUnknownError, 0);
 300     return;
 301   }
 302
 303   ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
 304   if (media_keys)
 305     media_keys->OnSessionMessage(session_id, message, destination_url.spec());
 306 }
 307
 308 void RendererMediaPlayerManager::OnSessionReady(int media_keys_id,
 309                                                 uint32 session_id) {
 310   ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
 311   if (media_keys)
 312     media_keys->OnSessionReady(session_id);
 313 }
 314
 315 void RendererMediaPlayerManager::OnSessionClosed(int media_keys_id,
 316                                                  uint32 session_id) {
 317   ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
 318   if (media_keys)
 319     media_keys->OnSessionClosed(session_id);
 320 }
 321
 322 void RendererMediaPlayerManager::OnSessionError(
 323     int media_keys_id,
 324     uint32 session_id,
 325     media::MediaKeys::KeyError error_code,
 326     int system_code) {
 327   ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
 328   if (media_keys)
 329     media_keys->OnSessionError(session_id, error_code, system_code);
 330 }
 331
 332 int RendererMediaPlayerManager::RegisterMediaPlayer(
 333     WebMediaPlayerAndroid* player) {
 334   media_players_[next_media_player_id_] = player;
 335   return next_media_player_id_++;
 336 }
 337
 338 void RendererMediaPlayerManager::UnregisterMediaPlayer(int player_id) {
 339   media_players_.erase(player_id);
 340   media_keys_.erase(player_id);
 341 }
 342
 343 void RendererMediaPlayerManager::RegisterMediaKeys(int media_keys_id,
 344                                                    ProxyMediaKeys* media_keys) {
 345   // WebMediaPlayerAndroid must have already been registered for
 346   // |media_keys_id|. For now |media_keys_id| is the same as player_id
 347   // used in other methods.
 348   DCHECK(media_players_.find(media_keys_id) != media_players_.end());
 349
 350   // Only allowed to register once.
 351   DCHECK(media_keys_.find(media_keys_id) == media_keys_.end());
 352
 353   media_keys_[media_keys_id] = media_keys;
 354 }
 355
 356 void RendererMediaPlayerManager::ReleaseVideoResources() {
 357   std::map<int, WebMediaPlayerAndroid*>::iterator player_it;
 358   for (player_it = media_players_.begin();
 359       player_it != media_players_.end(); ++player_it) {
 360     WebMediaPlayerAndroid* player = player_it->second;
 361
 362     // Do not release if an audio track is still playing
 363     if (player && (player->paused() || player->hasVideo()))
 364       player->ReleaseMediaResources();
 365   }
 366 }
 367
 368 WebMediaPlayerAndroid* RendererMediaPlayerManager::GetMediaPlayer(
 369     int player_id) {
 370   std::map<int, WebMediaPlayerAndroid*>::iterator iter =
 371       media_players_.find(player_id);
 372   if (iter != media_players_.end())
 373     return iter->second;
 374   return NULL;
 375 }
 376
 377 ProxyMediaKeys* RendererMediaPlayerManager::GetMediaKeys(int media_keys_id) {
 378   std::map<int, ProxyMediaKeys*>::iterator iter =
 379       media_keys_.find(media_keys_id);
 380   return (iter != media_keys_.end()) ? iter->second : NULL;
 381 }
 382
 383 bool RendererMediaPlayerManager::CanEnterFullscreen(blink::WebFrame* frame) {
 384   return (!fullscreen_frame_ && !pending_fullscreen_frame_)
 385       || ShouldEnterFullscreen(frame);
 386 }
 387
 388 void RendererMediaPlayerManager::DidEnterFullscreen(blink::WebFrame* frame) {
 389   pending_fullscreen_frame_ = NULL;
 390   fullscreen_frame_ = frame;
 391 }
 392
 393 void RendererMediaPlayerManager::DidExitFullscreen() {
 394   fullscreen_frame_ = NULL;
 395 }
 396
 397 bool RendererMediaPlayerManager::IsInFullscreen(blink::WebFrame* frame) {
 398   return fullscreen_frame_ == frame;
 399 }
 400
 401 bool RendererMediaPlayerManager::ShouldEnterFullscreen(blink::WebFrame* frame) {
 402   return fullscreen_frame_ == frame || pending_fullscreen_frame_ == frame;
 403 }
 404
 405 #if defined(VIDEO_HOLE)
 406 void RendererMediaPlayerManager::RequestExternalSurface(
 407     int player_id,
 408     const gfx::RectF& geometry) {
 409   Send(new MediaPlayerHostMsg_NotifyExternalSurface(
 410       routing_id(), player_id, true, geometry));
 411 }
 412
 413 void RendererMediaPlayerManager::DidCommitCompositorFrame() {
 414   std::map<int, gfx::RectF> geometry_change;
 415   RetrieveGeometryChanges(&geometry_change);
 416   for (std::map<int, gfx::RectF>::iterator it = geometry_change.begin();
 417        it != geometry_change.end();
 418        ++it) {
 419     Send(new MediaPlayerHostMsg_NotifyExternalSurface(
 420         routing_id(), it->first, false, it->second));
 421   }
 422 }
 423
 424 void RendererMediaPlayerManager::RetrieveGeometryChanges(
 425     std::map<int, gfx::RectF>* changes) {
 426   DCHECK(changes->empty());
 427   for (std::map<int, WebMediaPlayerAndroid*>::iterator player_it =
 428            media_players_.begin();
 429        player_it != media_players_.end();
 430        ++player_it) {
 431     WebMediaPlayerAndroid* player = player_it->second;
 432
 433     if (player && player->hasVideo()) {
 434       if (player->UpdateBoundaryRectangle())
 435         (*changes)[player_it->first] = player->GetBoundaryRectangle();
 436     }
 437   }
 438 }
 439 #endif  // defined(VIDEO_HOLE)
 440
 441 }  // namespace content