#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/media_player_messages_android.h"
-#include "content/renderer/media/android/proxy_media_keys.h"
+#include "content/public/common/renderer_preferences.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 {
-RendererMediaPlayerManager::RendererMediaPlayerManager(RenderView* render_view)
- : RenderViewObserver(render_view),
+RendererMediaPlayerManager::RendererMediaPlayerManager(
+ RenderFrame* render_frame)
+ : RenderFrameObserver(render_frame),
next_media_player_id_(0),
- fullscreen_frame_(NULL) {}
+ 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) {
OnConnectedToRemoteDevice)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DisconnectedFromRemoteDevice,
OnDisconnectedFromRemoteDevice)
+ IPC_MESSAGE_HANDLER(MediaPlayerMsg_RequestFullscreen,
+ OnRequestFullscreen)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidEnterFullscreen, OnDidEnterFullscreen)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidExitFullscreen, OnDidExitFullscreen)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPlay, OnPlayerPlay)
IPC_MESSAGE_HANDLER(MediaPlayerMsg_DidMediaPlayerPause, OnPlayerPause)
- IPC_MESSAGE_HANDLER(MediaKeysMsg_KeyAdded, OnKeyAdded)
- IPC_MESSAGE_HANDLER(MediaKeysMsg_KeyError, OnKeyError)
- IPC_MESSAGE_HANDLER(MediaKeysMsg_KeyMessage, OnKeyMessage)
+ IPC_MESSAGE_HANDLER(MediaPlayerMsg_PauseVideo, OnPauseVideo)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
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_SetVolume(routing_id(), player_id, volume));
}
+void RendererMediaPlayerManager::SetPoster(int player_id, const GURL& poster) {
+ Send(new MediaPlayerHostMsg_SetPoster(routing_id(), player_id, poster));
+}
+
void RendererMediaPlayerManager::ReleaseResources(int player_id) {
Send(new MediaPlayerHostMsg_Release(routing_id(), player_id));
}
player->OnPlayerReleased();
}
-void RendererMediaPlayerManager::OnConnectedToRemoteDevice(int player_id) {
+void RendererMediaPlayerManager::OnConnectedToRemoteDevice(int player_id,
+ const std::string& remote_playback_message) {
WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
if (player)
- player->OnConnectedToRemoteDevice();
+ player->OnConnectedToRemoteDevice(remote_playback_message);
}
void RendererMediaPlayerManager::OnDisconnectedFromRemoteDevice(int player_id) {
player->OnMediaPlayerPause();
}
-void RendererMediaPlayerManager::EnterFullscreen(int player_id) {
- Send(new MediaPlayerHostMsg_EnterFullscreen(routing_id(), player_id));
-}
-
-void RendererMediaPlayerManager::ExitFullscreen(int player_id) {
- Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
-}
-
-void RendererMediaPlayerManager::InitializeCDM(int media_keys_id,
- ProxyMediaKeys* media_keys,
- const std::vector<uint8>& uuid,
- const GURL& frame_url) {
- RegisterMediaKeys(media_keys_id, media_keys);
- Send(new MediaKeysHostMsg_InitializeCDM(
- routing_id(), media_keys_id, uuid, frame_url));
-}
-
-void RendererMediaPlayerManager::GenerateKeyRequest(
- int media_keys_id,
- const std::string& type,
- const std::vector<uint8>& init_data) {
- Send(new MediaKeysHostMsg_GenerateKeyRequest(
- routing_id(), media_keys_id, type, init_data));
-}
-
-void RendererMediaPlayerManager::AddKey(int media_keys_id,
- const std::vector<uint8>& key,
- const std::vector<uint8>& init_data,
- const std::string& session_id) {
- Send(new MediaKeysHostMsg_AddKey(
- routing_id(), media_keys_id, key, init_data, session_id));
+void RendererMediaPlayerManager::OnRequestFullscreen(int player_id) {
+ WebMediaPlayerAndroid* player = GetMediaPlayer(player_id);
+ if (player)
+ player->OnRequestFullscreen();
}
-void RendererMediaPlayerManager::CancelKeyRequest(
- int media_keys_id,
- const std::string& session_id) {
- Send(new MediaKeysHostMsg_CancelKeyRequest(
- routing_id(), media_keys_id, session_id));
+void RendererMediaPlayerManager::OnPauseVideo() {
+ ReleaseVideoResources();
}
-void RendererMediaPlayerManager::OnKeyAdded(int media_keys_id,
- const std::string& session_id) {
- ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
- if (media_keys)
- media_keys->OnKeyAdded(session_id);
+void RendererMediaPlayerManager::EnterFullscreen(int player_id,
+ blink::WebFrame* frame) {
+ pending_fullscreen_frame_ = frame;
+ Send(new MediaPlayerHostMsg_EnterFullscreen(routing_id(), player_id));
}
-void RendererMediaPlayerManager::OnKeyError(
- int media_keys_id,
- const std::string& session_id,
- media::MediaKeys::KeyError error_code,
- int system_code) {
- ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
- if (media_keys)
- media_keys->OnKeyError(session_id, error_code, system_code);
+void RendererMediaPlayerManager::ExitFullscreen(int player_id) {
+ pending_fullscreen_frame_ = NULL;
+ fullscreen_frame_ = NULL;
+ Send(new MediaPlayerHostMsg_ExitFullscreen(routing_id(), player_id));
}
-void RendererMediaPlayerManager::OnKeyMessage(
- int media_keys_id,
- const std::string& session_id,
- const std::vector<uint8>& message,
- const std::string& destination_url) {
- ProxyMediaKeys* media_keys = GetMediaKeys(media_keys_id);
- if (media_keys)
- media_keys->OnKeyMessage(session_id, message, destination_url);
+void RendererMediaPlayerManager::SetCdm(int player_id, int cdm_id) {
+ if (cdm_id == RendererCdmManager::kInvalidCdmId) {
+ NOTREACHED();
+ return;
+ }
+ Send(new MediaPlayerHostMsg_SetCdm(routing_id(), player_id, cdm_id));
}
int RendererMediaPlayerManager::RegisterMediaPlayer(
void RendererMediaPlayerManager::UnregisterMediaPlayer(int player_id) {
media_players_.erase(player_id);
- media_keys_.erase(player_id);
-}
-
-void RendererMediaPlayerManager::RegisterMediaKeys(int media_keys_id,
- ProxyMediaKeys* media_keys) {
- // WebMediaPlayerAndroid must have already been registered for
- // |media_keys_id|. For now |media_keys_id| is the same as player_id
- // used in other methods.
- DCHECK(media_players_.find(media_keys_id) != media_players_.end());
-
- // Only allowed to register once.
- DCHECK(media_keys_.find(media_keys_id) == media_keys_.end());
-
- media_keys_[media_keys_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 media_keys_id) {
- std::map<int, ProxyMediaKeys*>::iterator iter =
- media_keys_.find(media_keys_id);
- return (iter != media_keys_.end()) ? iter->second : NULL;
-}
-
-bool RendererMediaPlayerManager::CanEnterFullscreen(WebKit::WebFrame* frame) {
- return !fullscreen_frame_ || IsInFullscreen(frame);
+bool RendererMediaPlayerManager::CanEnterFullscreen(blink::WebFrame* frame) {
+ return (!fullscreen_frame_ && !pending_fullscreen_frame_)
+ || ShouldEnterFullscreen(frame);
}
-void RendererMediaPlayerManager::DidEnterFullscreen(WebKit::WebFrame* frame) {
+void RendererMediaPlayerManager::DidEnterFullscreen(blink::WebFrame* frame) {
+ pending_fullscreen_frame_ = NULL;
fullscreen_frame_ = frame;
}
fullscreen_frame_ = NULL;
}
-bool RendererMediaPlayerManager::IsInFullscreen(WebKit::WebFrame* frame) {
+bool RendererMediaPlayerManager::IsInFullscreen(blink::WebFrame* frame) {
return fullscreen_frame_ == frame;
}
-#if defined(GOOGLE_TV)
+bool RendererMediaPlayerManager::ShouldEnterFullscreen(blink::WebFrame* frame) {
+ return fullscreen_frame_ == frame || pending_fullscreen_frame_ == frame;
+}
+
+#if defined(VIDEO_HOLE)
void RendererMediaPlayerManager::RequestExternalSurface(
int player_id,
const gfx::RectF& geometry) {
WebMediaPlayerAndroid* player = player_it->second;
if (player && player->hasVideo()) {
- gfx::RectF rect;
- if (player->RetrieveGeometryChange(&rect)) {
- (*changes)[player_it->first] = rect;
- }
+ if (player->UpdateBoundaryRectangle())
+ (*changes)[player_it->first] = player->GetBoundaryRectangle();
}
}
}
-#endif
+
+bool
+RendererMediaPlayerManager::ShouldUseVideoOverlayForEmbeddedEncryptedVideo() {
+ 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)
} // namespace content
projects / platform / framework / web / crosswalk.git / blobdiff