#include "content/renderer/media/android/renderer_media_player_manager.h"
-#include "base/bind.h"
-#include "base/message_loop/message_loop.h"
-#include "content/common/media/cdm_messages.h"
#include "content/common/media/media_player_messages_android.h"
#include "content/public/common/renderer_preferences.h"
-#include "content/renderer/media/android/proxy_media_keys.h"
#include "content/renderer/media/android/renderer_media_player_manager.h"
#include "content/renderer/media/android/webmediaplayer_android.h"
+#include "content/renderer/media/crypto/renderer_cdm_manager.h"
#include "content/renderer/render_view_impl.h"
#include "ui/gfx/rect_f.h"
namespace content {
-// Maximum sizes for various EME API parameters. These are checks to prevent
-// unnecessarily large messages from being passed around, and the sizes
-// are somewhat arbitrary as the EME spec doesn't specify any limits.
-const size_t kMaxWebSessionIdLength = 512;
-const size_t kMaxSessionMessageLength = 10240; // 10 KB
-
-RendererMediaPlayerManager::RendererMediaPlayerManager(RenderView* render_view)
- : RenderViewObserver(render_view),
+RendererMediaPlayerManager::RendererMediaPlayerManager(
+ RenderFrame* render_frame)
+ : RenderFrameObserver(render_frame),
next_media_player_id_(0),
fullscreen_frame_(NULL),
- pending_fullscreen_frame_(NULL) {}
+ pending_fullscreen_frame_(NULL) {
+}
RendererMediaPlayerManager::~RendererMediaPlayerManager() {
- std::map<int, WebMediaPlayerAndroid*>::iterator player_it;
- for (player_it = media_players_.begin();
- player_it != media_players_.end(); ++player_it) {
- WebMediaPlayerAndroid* player = player_it->second;
- player->Detach();
- }
-
- Send(new MediaPlayerHostMsg_DestroyAllMediaPlayers(routing_id()));
+ DCHECK(media_players_.empty())
+ << "RendererMediaPlayerManager is owned by RenderFrameImpl and is "
+ "destroyed only after all media players are destroyed.";
}
bool RendererMediaPlayerManager::OnMessageReceived(const IPC::Message& msg) {
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidExitFullscreen, OnDidExitFullscreen)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPlay, OnPlayerPlay)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPause, OnPlayerPause)
- IPC_MESSAGE_HANDLER(CdmMsg_SessionCreated, OnSessionCreated)
- IPC_MESSAGE_HANDLER(CdmMsg_SessionMessage, OnSessionMessage)
- IPC_MESSAGE_HANDLER(CdmMsg_SessionReady, OnSessionReady)
- IPC_MESSAGE_HANDLER(CdmMsg_SessionClosed, OnSessionClosed)
- IPC_MESSAGE_HANDLER(CdmMsg_SessionError, OnSessionError)
+ IPC_MESSAGE_HANDLER(MediaPlayerMsg_RemoteRouteAvailabilityChanged,
+ OnRemoteRouteAvailabilityChanged)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
+void RendererMediaPlayerManager::WasHidden() {
+ ReleaseVideoResources();
+}
+
void RendererMediaPlayerManager::Initialize(
MediaPlayerHostMsg_Initialize_Type type,
int player_id,
const GURL& url,
const GURL& first_party_for_cookies,
- int demuxer_client_id) {
- Send(new MediaPlayerHostMsg_Initialize(
- routing_id(), type, player_id, url, first_party_for_cookies,
- demuxer_client_id));
+ int demuxer_client_id,
+ const GURL& frame_url,
+ bool allow_credentials) {
+ MediaPlayerHostMsg_Initialize_Params media_player_params;
+ media_player_params.type = type;
+ media_player_params.player_id = player_id;
+ media_player_params.demuxer_client_id = demuxer_client_id;
+ media_player_params.url = url;
+ media_player_params.first_party_for_cookies = first_party_for_cookies;
+ media_player_params.frame_url = frame_url;
+ media_player_params.allow_credentials = allow_credentials;
+
+ Send(new MediaPlayerHostMsg_Initialize(routing_id(), media_player_params));
}
void RendererMediaPlayerManager::Start(int player_id) {
Send(new MediaPlayerHostMsg_DestroyMediaPlayer(routing_id(), player_id));
}
+void RendererMediaPlayerManager::RequestRemotePlayback(int player_id) {
+ Send(new MediaPlayerHostMsg_RequestRemotePlayback(routing_id(), player_id));
+}
+
+void RendererMediaPlayerManager::RequestRemotePlaybackControl(int player_id) {
+ Send(new MediaPlayerHostMsg_RequestRemotePlaybackControl(routing_id(),
+ player_id));
+}
+
void RendererMediaPlayerManager::OnMediaMetadataChanged(
int player_id,
base::TimeDelta duration,
player->OnVideoSizeChanged(width, height);
}
-void RendererMediaPlayerManager::OnTimeUpdate(int player_id,
- base::TimeDelta current_time) {
+void RendererMediaPlayerManager::OnTimeUpdate(
+ int player_id,
+ base::TimeDelta current_timestamp,
+ base::TimeTicks current_time_ticks) {
WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
if (player)
- player->OnTimeUpdate(current_time);
+ player->OnTimeUpdate(current_timestamp, current_time_ticks);
}
void RendererMediaPlayerManager::OnMediaPlayerReleased(int player_id) {
player->OnRequestFullscreen();
}
+void RendererMediaPlayerManager::OnRemoteRouteAvailabilityChanged(
+ int player_id,
+ bool routes_available) {
+ WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
+ if (player)
+ player->OnRemoteRouteAvailabilityChanged(routes_available);
+}
+
void RendererMediaPlayerManager::EnterFullscreen(int player_id,
blink::WebFrame* frame) {
pending_fullscreen_frame_ = frame;
void RendererMediaPlayerManager::ExitFullscreen(int player_id) {
pending_fullscreen_frame_ = NULL;
+ fullscreen_frame_ = NULL;
Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
}
void RendererMediaPlayerManager::SetCdm(int player_id, int cdm_id) {
- if (cdm_id == kInvalidCdmId)
- return;
- Send(new MediaPlayerHostMsg_SetCdm(routing_id(), player_id, cdm_id));
-}
-
-void RendererMediaPlayerManager::InitializeCdm(int cdm_id,
- ProxyMediaKeys* media_keys,
- const std::string& key_system,
- const GURL& security_origin) {
- DCHECK_NE(cdm_id, kInvalidCdmId);
- RegisterMediaKeys(cdm_id, media_keys);
- Send(new CdmHostMsg_InitializeCdm(
- routing_id(), cdm_id, key_system, security_origin));
-}
-
-void RendererMediaPlayerManager::CreateSession(
- int cdm_id,
- uint32 session_id,
- CdmHostMsg_CreateSession_ContentType content_type,
- const std::vector<uint8>& init_data) {
- DCHECK(GetMediaKeys(cdm_id)) << "|cdm_id| not registered.";
- Send(new CdmHostMsg_CreateSession(
- routing_id(), cdm_id, session_id, content_type, init_data));
-}
-
-void RendererMediaPlayerManager::UpdateSession(
- int cdm_id,
- uint32 session_id,
- const std::vector<uint8>& response) {
- DCHECK(GetMediaKeys(cdm_id)) << "|cdm_id| not registered.";
- Send(
- new CdmHostMsg_UpdateSession(routing_id(), cdm_id, session_id, response));
-}
-
-void RendererMediaPlayerManager::ReleaseSession(int cdm_id, uint32 session_id) {
- DCHECK(GetMediaKeys(cdm_id)) << "|cdm_id| not registered.";
- Send(new CdmHostMsg_ReleaseSession(routing_id(), cdm_id, session_id));
-}
-
-void RendererMediaPlayerManager::DestroyCdm(int cdm_id) {
- DCHECK(GetMediaKeys(cdm_id)) << "|cdm_id| not registered.";
- Send(new CdmHostMsg_DestroyCdm(routing_id(), cdm_id));
- media_keys_.erase(cdm_id);
-}
-
-void RendererMediaPlayerManager::OnSessionCreated(
- int cdm_id,
- uint32 session_id,
- const std::string& web_session_id) {
- if (web_session_id.length() > kMaxWebSessionIdLength) {
- OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+ if (cdm_id == media::MediaKeys::kInvalidCdmId) {
+ NOTREACHED();
return;
}
-
- ProxyMediaKeys* media_keys = GetMediaKeys(cdm_id);
- if (media_keys)
- media_keys->OnSessionCreated(session_id, web_session_id);
-}
-
-void RendererMediaPlayerManager::OnSessionMessage(
- int cdm_id,
- uint32 session_id,
- const std::vector<uint8>& message,
- const GURL& destination_url) {
- if (message.size() > kMaxSessionMessageLength) {
- OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
- return;
- }
-
- ProxyMediaKeys* media_keys = GetMediaKeys(cdm_id);
- if (media_keys)
- media_keys->OnSessionMessage(session_id, message, destination_url.spec());
-}
-
-void RendererMediaPlayerManager::OnSessionReady(int cdm_id, uint32 session_id) {
- ProxyMediaKeys* media_keys = GetMediaKeys(cdm_id);
- if (media_keys)
- media_keys->OnSessionReady(session_id);
-}
-
-void RendererMediaPlayerManager::OnSessionClosed(int cdm_id,
- uint32 session_id) {
- ProxyMediaKeys* media_keys = GetMediaKeys(cdm_id);
- if (media_keys)
- media_keys->OnSessionClosed(session_id);
-}
-
-void RendererMediaPlayerManager::OnSessionError(
- int cdm_id,
- uint32 session_id,
- media::MediaKeys::KeyError error_code,
- uint32 system_code) {
- ProxyMediaKeys* media_keys = GetMediaKeys(cdm_id);
- if (media_keys)
- media_keys->OnSessionError(session_id, error_code, system_code);
+ Send(new MediaPlayerHostMsg_SetCdm(routing_id(), player_id, cdm_id));
}
int RendererMediaPlayerManager::RegisterMediaPlayer(
media_players_.erase(player_id);
}
-void RendererMediaPlayerManager::RegisterMediaKeys(int cdm_id,
- ProxyMediaKeys* media_keys) {
- // Only allowed to register once.
- DCHECK(media_keys_.find(cdm_id) == media_keys_.end());
-
- media_keys_[cdm_id] = media_keys;
-}
-
void RendererMediaPlayerManager::ReleaseVideoResources() {
std::map<int, WebMediaPlayerAndroid*>::iterator player_it;
- for (player_it = media_players_.begin();
- player_it != media_players_.end(); ++player_it) {
+ for (player_it = media_players_.begin(); player_it != media_players_.end();
+ ++player_it) {
WebMediaPlayerAndroid* player = player_it->second;
// Do not release if an audio track is still playing
return NULL;
}
-ProxyMediaKeys* RendererMediaPlayerManager::GetMediaKeys(int cdm_id) {
- std::map<int, ProxyMediaKeys*>::iterator iter = media_keys_.find(cdm_id);
- return (iter != media_keys_.end()) ? iter->second : NULL;
-}
-
bool RendererMediaPlayerManager::CanEnterFullscreen(blink::WebFrame* frame) {
return (!fullscreen_frame_ && !pending_fullscreen_frame_)
|| ShouldEnterFullscreen(frame);
bool
RendererMediaPlayerManager::ShouldUseVideoOverlayForEmbeddedEncryptedVideo() {
- const RendererPreferences& prefs = static_cast<RenderViewImpl*>(
- render_view())->renderer_preferences();
+ const RendererPreferences& prefs = static_cast<RenderFrameImpl*>(
+ render_frame())->render_view()->renderer_preferences();
return prefs.use_video_overlay_for_embedded_encrypted_video;
}
#endif // defined(VIDEO_HOLE)
projects / platform / framework / web / crosswalk.git / blobdiff