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 static const size_t kEmeDestinationUrlMaximum = 2048;  // 2 KB
  21
  22 namespace content {
  23
  24 RendererMediaPlayerManager::RendererMediaPlayerManager(RenderView* render_view)
  25     : RenderViewObserver(render_view),
  26       next_media_player_id_(0),
  27       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::ReleaseResources(int player_id) {
 110   Send(new MediaPlayerHostMsg_Release(routing_id(), player_id));
 111 }
 112
 113 void RendererMediaPlayerManager::DestroyPlayer(int player_id) {
 114   Send(new MediaPlayerHostMsg_DestroyMediaPlayer(routing_id(), player_id));
 115 }
 116
 117 void RendererMediaPlayerManager::OnMediaMetadataChanged(
 118     int player_id,
 119     base::TimeDelta duration,
 120     int width,
 121     int height,
 122     bool success) {
 123   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 124   if (player)
 125     player->OnMediaMetadataChanged(duration, width, height, success);
 126 }
 127
 128 void RendererMediaPlayerManager::OnMediaPlaybackCompleted(int player_id) {
 129   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 130   if (player)
 131     player->OnPlaybackComplete();
 132 }
 133
 134 void RendererMediaPlayerManager::OnMediaBufferingUpdate(int player_id,
 135                                                         int percent) {
 136   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 137   if (player)
 138     player->OnBufferingUpdate(percent);
 139 }
 140
 141 void RendererMediaPlayerManager::OnSeekRequest(
 142     int player_id,
 143     const base::TimeDelta& time_to_seek) {
 144   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 145   if (player)
 146     player->OnSeekRequest(time_to_seek);
 147 }
 148
 149 void RendererMediaPlayerManager::OnSeekCompleted(
 150     int player_id,
 151     const base::TimeDelta& current_time) {
 152   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 153   if (player)
 154     player->OnSeekComplete(current_time);
 155 }
 156
 157 void RendererMediaPlayerManager::OnMediaError(int player_id, int error) {
 158   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 159   if (player)
 160     player->OnMediaError(error);
 161 }
 162
 163 void RendererMediaPlayerManager::OnVideoSizeChanged(int player_id,
 164                                                     int width,
 165                                                     int height) {
 166   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 167   if (player)
 168     player->OnVideoSizeChanged(width, height);
 169 }
 170
 171 void RendererMediaPlayerManager::OnTimeUpdate(int player_id,
 172                                               base::TimeDelta current_time) {
 173   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 174   if (player)
 175     player->OnTimeUpdate(current_time);
 176 }
 177
 178 void RendererMediaPlayerManager::OnMediaPlayerReleased(int player_id) {
 179   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 180   if (player)
 181     player->OnPlayerReleased();
 182 }
 183
 184 void RendererMediaPlayerManager::OnConnectedToRemoteDevice(int player_id) {
 185   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 186   if (player)
 187     player->OnConnectedToRemoteDevice();
 188 }
 189
 190 void RendererMediaPlayerManager::OnDisconnectedFromRemoteDevice(int player_id) {
 191   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 192   if (player)
 193     player->OnDisconnectedFromRemoteDevice();
 194 }
 195
 196 void RendererMediaPlayerManager::OnDidEnterFullscreen(int player_id) {
 197   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 198   if (player)
 199     player->OnDidEnterFullscreen();
 200 }
 201
 202 void RendererMediaPlayerManager::OnDidExitFullscreen(int player_id) {
 203   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 204   if (player)
 205     player->OnDidExitFullscreen();
 206 }
 207
 208 void RendererMediaPlayerManager::OnPlayerPlay(int player_id) {
 209   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 210   if (player)
 211     player->OnMediaPlayerPlay();
 212 }
 213
 214 void RendererMediaPlayerManager::OnPlayerPause(int player_id) {
 215   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 216   if (player)
 217     player->OnMediaPlayerPause();
 218 }
 219
 220 void RendererMediaPlayerManager::OnRequestFullscreen(int player_id) {
 221   WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
 222   if (player)
 223     player->OnRequestFullscreen();
 224 }
 225
 226 void RendererMediaPlayerManager::EnterFullscreen(int player_id) {
 227   Send(new MediaPlayerHostMsg_EnterFullscreen(routing_id(), player_id));
 228 }
 229
 230 void RendererMediaPlayerManager::ExitFullscreen(int player_id) {
 231   Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
 232 }
 233
 234 void RendererMediaPlayerManager::InitializeCDM(int media_keys_id,
 235                                                ProxyMediaKeys* media_keys,
 236                                                const std::vector<uint8>& uuid,
 237                                                const GURL& frame_url) {
 238   RegisterMediaKeys(media_keys_id, media_keys);
 239   Send(new MediaKeysHostMsg_InitializeCDM(
 240       routing_id(), media_keys_id, uuid, frame_url));
 241 }
 242
 243 void RendererMediaPlayerManager::CreateSession(
 244     int media_keys_id,
 245     uint32 session_id,
 246     const std::string& type,
 247     const std::vector<uint8>& init_data) {
 248   Send(new MediaKeysHostMsg_CreateSession(
 249       routing_id(), media_keys_id, session_id, type, init_data));
 250 }
 251
 252 void RendererMediaPlayerManager::UpdateSession(
 253     int media_keys_id,
 254     uint32 session_id,
 255     const std::vector<uint8>& response) {
 256   Send(new MediaKeysHostMsg_UpdateSession(
 257       routing_id(), media_keys_id, session_id, response));
 258 }
 259
 260 void RendererMediaPlayerManager::ReleaseSession(int media_keys_id,
 261                                                 uint32 session_id) {
 262   Send(new MediaKeysHostMsg_ReleaseSession(
 263       routing_id(), media_keys_id, session_id));
 264 }
 265
 266 void RendererMediaPlayerManager::CancelAllPendingSessionCreations(
 267     int media_keys_id) {
 268   Send(new MediaKeysHostMsg_CancelAllPendingSessionCreations(
 269       routing_id(), media_keys_id));
 270 }
 271
 272 void RendererMediaPlayerManager::OnSessionCreated(
 273     int media_keys_id,
 274     uint32 session_id,
 275     const std::string& web_session_id) {
 276   if (web_session_id.length() > kEmeWebSessionIdMaximum) {
 277     OnSessionError(
 278         media_keys_id, session_id, media::MediaKeys::kUnknownError, 0);
 279     return;
 280   }
 281
 282   ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
 283   if (media_keys)
 284     media_keys->OnSessionCreated(session_id, web_session_id);
 285 }
 286
 287 void RendererMediaPlayerManager::OnSessionMessage(
 288     int media_keys_id,
 289     uint32 session_id,
 290     const std::vector<uint8>& message,
 291     const std::string& destination_url) {
 292   if (message.size() > kEmeMessageMaximum) {
 293     OnSessionError(
 294         media_keys_id, session_id, media::MediaKeys::kUnknownError, 0);
 295     return;
 296   }
 297   if (destination_url.length() > kEmeDestinationUrlMaximum) {
 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);
 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_ || IsInFullscreen(frame);
 385 }
 386
 387 void RendererMediaPlayerManager::DidEnterFullscreen(blink::WebFrame* frame) {
 388   fullscreen_frame_ = frame;
 389 }
 390
 391 void RendererMediaPlayerManager::DidExitFullscreen() {
 392   fullscreen_frame_ = NULL;
 393 }
 394
 395 bool RendererMediaPlayerManager::IsInFullscreen(blink::WebFrame* frame) {
 396   return fullscreen_frame_ == frame;
 397 }
 398
 399 #if defined(VIDEO_HOLE)
 400 void RendererMediaPlayerManager::RequestExternalSurface(
 401     int player_id,
 402     const gfx::RectF& geometry) {
 403   Send(new MediaPlayerHostMsg_NotifyExternalSurface(
 404       routing_id(), player_id, true, geometry));
 405 }
 406
 407 void RendererMediaPlayerManager::DidCommitCompositorFrame() {
 408   std::map<int, gfx::RectF> geometry_change;
 409   RetrieveGeometryChanges(&geometry_change);
 410   for (std::map<int, gfx::RectF>::iterator it = geometry_change.begin();
 411        it != geometry_change.end();
 412        ++it) {
 413     Send(new MediaPlayerHostMsg_NotifyExternalSurface(
 414         routing_id(), it->first, false, it->second));
 415   }
 416 }
 417
 418 void RendererMediaPlayerManager::RetrieveGeometryChanges(
 419     std::map<int, gfx::RectF>* changes) {
 420   DCHECK(changes->empty());
 421   for (std::map<int, WebMediaPlayerAndroid*>::iterator player_it =
 422            media_players_.begin();
 423        player_it != media_players_.end();
 424        ++player_it) {
 425     WebMediaPlayerAndroid* player = player_it->second;
 426
 427     if (player && player->hasVideo()) {
 428       gfx::RectF rect;
 429       if (player->RetrieveGeometryChange(&rect)) {
 430         (*changes)[player_it->first] = rect;
 431       }
 432     }
 433   }
 434 }
 435 #endif  // defined(VIDEO_HOLE)
 436
 437 }  // namespace content