Separate RendererCdmManager from RendererMediaPlayerManager.

content/renderer/media/android/renderer_media_player_manager.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #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(
     RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       next_media_player_id_(0),
       fullscreen_frame_(NULL),
       pending_fullscreen_frame_(NULL) {
 }
 
 RendererMediaPlayerManager::~RendererMediaPlayerManager() {
   std::map<int, WebMediaPlayerAndroid*>::iterator player_it;
@@ skipping 27 matching lines @@
                         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(MediaPlayerMsg_PauseVideo, OnPauseVideo)
-    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_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RendererMediaPlayerManager::Initialize(
     MediaPlayerHostMsg_Initialize_Type type,
     int player_id,
     const GURL& url,
     const GURL& first_party_for_cookies,
@@ skipping 156 matching lines @@
   Send(new MediaPlayerHostMsg_EnterFullscreen(routing_id(), player_id));
 }
 
 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)
+  if (cdm_id == RendererCdmManager::kInvalidCdmId) {
+    NOTREACHED();
     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);
-    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);
-}
-
-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);
-}
-
 int RendererMediaPlayerManager::RegisterMediaPlayer(
     WebMediaPlayerAndroid* player) {
   media_players_[next_media_player_id_] = player;
   return next_media_player_id_++;
 }
 
 void RendererMediaPlayerManager::UnregisterMediaPlayer(int player_id) {
   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) {
     WebMediaPlayerAndroid* player = player_it->second;
 
     // Do not release if an audio track is still playing
     if (player && (player->paused() || player->hasVideo()))
       player->ReleaseMediaResources();
   }
 }
 
 WebMediaPlayerAndroid* RendererMediaPlayerManager::GetMediaPlayer(
     int player_id) {
   std::map<int, WebMediaPlayerAndroid*>::iterator iter =
       media_players_.find(player_id);
   if (iter != media_players_.end())
     return iter->second;
   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);
 }
 
 void RendererMediaPlayerManager::DidEnterFullscreen(blink::WebFrame* frame) {
   pending_fullscreen_frame_ = NULL;
   fullscreen_frame_ = frame;
 }
 
@@ skipping 46 matching lines @@
 
 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