Add PlayerTracker and BrowserCdm interfaces.

content/browser/media/android/browser_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/browser/media/android/browser_media_player_manager.h"
 
 #include "base/android/scoped_java_ref.h"
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "content/browser/android/content_view_core_impl.h"
@@ skipping 10 matching lines @@
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/android/media_player_bridge.h"
 #include "media/base/android/media_source_player.h"
-#include "media/base/cdm_factory.h"
+#include "media/base/browser_cdm.h"
+#include "media/base/browser_cdm_factory.h"
 #include "media/base/media_switches.h"
 
+using media::BrowserCdm;
 using media::MediaKeys;
 using media::MediaPlayerAndroid;
 using media::MediaPlayerBridge;
 using media::MediaPlayerManager;
 using media::MediaSourcePlayer;
 
 namespace content {
 
 // Threshold on the number of media players per renderer before we start
 // attempting to release inactive media players.
@@ skipping 266 matching lines @@
 
 MediaPlayerAndroid* BrowserMediaPlayerManager::GetPlayer(int player_id) {
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id)
       return *it;
   }
   return NULL;
 }
 
-MediaKeys* BrowserMediaPlayerManager::GetCdm(int cdm_id) {
+BrowserCdm* BrowserMediaPlayerManager::GetCdm(int cdm_id) {
   CdmMap::const_iterator iter = cdm_map_.find(cdm_id);
   return (iter == cdm_map_.end()) ? NULL : iter->second;
 }
 
 void BrowserMediaPlayerManager::DestroyAllMediaPlayers() {
   players_.clear();
   STLDeleteValues(&cdm_map_);
   if (fullscreen_player_id_ != -1) {
     video_view_.reset();
     fullscreen_player_id_ = -1;
@@ skipping 38 matching lines @@
 }
 
 void BrowserMediaPlayerManager::OnSessionReady(int cdm_id, uint32 session_id) {
   Send(new CdmMsg_SessionReady(RoutingID(), cdm_id, session_id));
 }
 
 void BrowserMediaPlayerManager::OnSessionClosed(int cdm_id, uint32 session_id) {
   Send(new CdmMsg_SessionClosed(RoutingID(), cdm_id, session_id));
 }
 
-void BrowserMediaPlayerManager::OnSessionError(
-    int cdm_id,
-    uint32 session_id,
-    media::MediaKeys::KeyError error_code,
-    uint32 system_code) {
+void BrowserMediaPlayerManager::OnSessionError(int cdm_id,
+                                               uint32 session_id,
+                                               MediaKeys::KeyError error_code,

[ddorwin, 2014/05/30 20:50:05]

When BrowserCdm no longer inherits from MediaKeys, we'll need a duplicate of the
error (to become Exception) enum.

[xhwang, 2014/06/02 20:11:43]

Shall we put those errors in a common place? e.g. meida/base/cdm_common.h?

[ddorwin, 2014/06/02 20:20:29]

Maybe. That's how jrummel has them in the Blink CL.

+                                               uint32 system_code) {
   Send(new CdmMsg_SessionError(
       RoutingID(), cdm_id, session_id, error_code, system_code));
 }
 
 #if defined(VIDEO_HOLE)
 void BrowserMediaPlayerManager::AttachExternalVideoSurface(int player_id,
                                                            jobject surface) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player) {
     player->SetVideoSurface(
@@ skipping 175 matching lines @@
 }
 
 void BrowserMediaPlayerManager::OnCreateSession(
     int cdm_id,
     uint32 session_id,
     CdmHostMsg_CreateSession_ContentType content_type,
     const std::vector<uint8>& init_data) {
   if (init_data.size() > kMaxInitDataLength) {
     LOG(WARNING) << "InitData for ID: " << cdm_id
                  << " too long: " << init_data.size();
-    OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(cdm_id, session_id, MediaKeys::kUnknownError, 0);
     return;
   }
 
   // Convert the session content type into a MIME type. "audio" and "video"
   // don't matter, so using "video" for the MIME type.
   // Ref:
   // https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-media.html#dom-createsession
   std::string mime_type;
   switch (content_type) {
     case CREATE_SESSION_TYPE_WEBM:
       mime_type = "video/webm";
       break;
     case CREATE_SESSION_TYPE_MP4:
       mime_type = "video/mp4";
       break;
     default:
       NOTREACHED();
       return;
   }
 
   if (CommandLine::ForCurrentProcess()
       ->HasSwitch(switches::kDisableInfobarForProtectedMediaIdentifier)) {
     CreateSessionIfPermitted(cdm_id, session_id, mime_type, init_data, true);
     return;
   }
 
-  MediaKeys* cdm = GetCdm(cdm_id);
+  BrowserCdm* cdm = GetCdm(cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM for ID " << cdm_id << " found";
-    OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(cdm_id, session_id, MediaKeys::kUnknownError, 0);
     return;
   }
 
   BrowserContext* context =
       web_contents()->GetRenderProcessHost()->GetBrowserContext();
 
   std::map<int, GURL>::const_iterator iter =
       cdm_security_origin_map_.find(cdm_id);
   if (iter == cdm_security_origin_map_.end()) {
     NOTREACHED();
-    OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(cdm_id, session_id, MediaKeys::kUnknownError, 0);
     return;
   }
 
   context->RequestProtectedMediaIdentifierPermission(
       web_contents()->GetRenderProcessHost()->GetID(),
       web_contents()->GetRenderViewHost()->GetRoutingID(),
       iter->second,
       base::Bind(&BrowserMediaPlayerManager::CreateSessionIfPermitted,
                  weak_ptr_factory_.GetWeakPtr(),
                  cdm_id,
                  session_id,
                  mime_type,
                  init_data));
 }
 
 void BrowserMediaPlayerManager::OnUpdateSession(
     int cdm_id,
     uint32 session_id,
     const std::vector<uint8>& response) {
-  MediaKeys* cdm = GetCdm(cdm_id);
+  BrowserCdm* cdm = GetCdm(cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM for ID " << cdm_id << " found";
-    OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(cdm_id, session_id, MediaKeys::kUnknownError, 0);
     return;
   }
 
   if (response.size() > kMaxSessionResponseLength) {
     LOG(WARNING) << "Response for ID " << cdm_id
                  << " is too long: " << response.size();
-    OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(cdm_id, session_id, MediaKeys::kUnknownError, 0);
     return;
   }
 
   cdm->UpdateSession(session_id, &response[0], response.size());
-
-  CdmToPlayerMap::const_iterator iter = cdm_to_player_map_.find(cdm_id);
-  if (iter == cdm_to_player_map_.end())
-    return;
-
-  int player_id = iter->second;
-  MediaPlayerAndroid* player = GetPlayer(player_id);
-  if (player)
-    player->OnKeyAdded();
 }
 
 void BrowserMediaPlayerManager::OnReleaseSession(int cdm_id,
                                                  uint32 session_id) {
-  MediaKeys* cdm = GetCdm(cdm_id);
+  BrowserCdm* cdm = GetCdm(cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM for ID " << cdm_id << " found";
-    OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(cdm_id, session_id, MediaKeys::kUnknownError, 0);
     return;
   }
 
   cdm->ReleaseSession(session_id);
 }
 
 void BrowserMediaPlayerManager::OnDestroyCdm(int cdm_id) {
-  MediaKeys* cdm = GetCdm(cdm_id);
+  BrowserCdm* cdm = GetCdm(cdm_id);
   if (!cdm)
     return;
 
   CancelAllPendingSessionCreations(cdm_id);
   RemoveCdm(cdm_id);
 }
 
 void BrowserMediaPlayerManager::CancelAllPendingSessionCreations(int cdm_id) {
   BrowserContext* context =
       web_contents()->GetRenderProcessHost()->GetBrowserContext();
@@ skipping 14 matching lines @@
 
 void BrowserMediaPlayerManager::RemovePlayer(int player_id) {
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     MediaPlayerAndroid* player = *it;
     if (player->player_id() == player_id) {
       players_.erase(it);
       break;
     }
   }
-
-  for (CdmToPlayerMap::iterator it = cdm_to_player_map_.begin();
-       it != cdm_to_player_map_.end();
-       ++it) {
-    if (it->second == player_id) {
-      cdm_to_player_map_.erase(it);
-      break;
-    }
-  }
 }
 
 scoped_ptr<media::MediaPlayerAndroid> BrowserMediaPlayerManager::SwapPlayer(
       int player_id, media::MediaPlayerAndroid* player) {
   media::MediaPlayerAndroid* previous_player = NULL;
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
       previous_player = *it;
       players_.weak_erase(it);
       players_.push_back(player);
       break;
     }
   }
   return scoped_ptr<media::MediaPlayerAndroid>(previous_player);
 }
 
 void BrowserMediaPlayerManager::AddCdm(int cdm_id,
                                        const std::string& key_system,
                                        const GURL& security_origin) {
   DCHECK(!GetCdm(cdm_id));
   base::WeakPtr<BrowserMediaPlayerManager> weak_this =
       weak_ptr_factory_.GetWeakPtr();
 
-  scoped_ptr<MediaKeys> cdm(media::CreateBrowserCdm(
+  const int& id = cdm_id;

[ddorwin, 2014/05/30 20:50:05]

nit: I think we usually just copy the value. The compiler should handle this.

This is also odd since cdm_id could change, changing the value of id.

[xhwang, 2014/06/02 20:11:43]

Done.

+  scoped_ptr<BrowserCdm> cdm(media::CreateBrowserCdm(
       key_system,
-      base::Bind(
-          &BrowserMediaPlayerManager::OnSessionCreated, weak_this, cdm_id),
-      base::Bind(
-          &BrowserMediaPlayerManager::OnSessionMessage, weak_this, cdm_id),
-      base::Bind(
-          &BrowserMediaPlayerManager::OnSessionReady, weak_this, cdm_id),
-      base::Bind(
-          &BrowserMediaPlayerManager::OnSessionClosed, weak_this, cdm_id),
-      base::Bind(
-          &BrowserMediaPlayerManager::OnSessionError, weak_this, cdm_id)));
+      base::Bind(&BrowserMediaPlayerManager::OnSessionCreated, weak_this, id),
+      base::Bind(&BrowserMediaPlayerManager::OnSessionMessage, weak_this, id),
+      base::Bind(&BrowserMediaPlayerManager::OnSessionReady, weak_this, id),
+      base::Bind(&BrowserMediaPlayerManager::OnSessionClosed, weak_this, id),
+      base::Bind(&BrowserMediaPlayerManager::OnSessionError, weak_this, id)));
 
   if (!cdm) {
     // This failure will be discovered and reported by OnCreateSession()
     // as GetCdm() will return null.
     DVLOG(1) << "failed to create CDM.";
     return;
   }
 
   cdm_map_[cdm_id] = cdm.release();
   cdm_security_origin_map_[cdm_id] = security_origin;
 }
 
 void BrowserMediaPlayerManager::RemoveCdm(int cdm_id) {
   // TODO(xhwang): Detach CDM from the player it's set to. In prefixed
   // EME implementation the current code is fine because we always destroy the
   // player before we destroy the DrmBridge. This will not always be the case
   // in unprefixed EME implementation.
   CdmMap::iterator iter = cdm_map_.find(cdm_id);
   if (iter != cdm_map_.end()) {
     delete iter->second;
     cdm_map_.erase(iter);
   }
-  cdm_to_player_map_.erase(cdm_id);
   cdm_security_origin_map_.erase(cdm_id);
 }
 
 void BrowserMediaPlayerManager::OnSetCdm(int player_id, int cdm_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
-  MediaKeys* cdm = GetCdm(cdm_id);
+  BrowserCdm* cdm = GetCdm(cdm_id);
+  // Currently we do not support detaching CDM from a player.

[ddorwin, 2014/05/30 20:50:05]

Is this prevented by Blink? If so, DCHECK()? If not, we're not reporting a
failure.

[xhwang, 2014/06/02 20:11:43]

This is prevented by the WMPA. Added NOT_REACHED.

   if (!cdm || !player) {
     DVLOG(1) << "Cannot set CDM on the specified player.";
     return;
   }
 
   // TODO(qinmin): add the logic to decide whether we should create the
   // fullscreen surface for EME lv1.
   player->SetCdm(cdm);
-  // Do now support setting one CDM on multiple players.
-
-  if (ContainsKey(cdm_to_player_map_, cdm_id)) {
-    DVLOG(1) << "CDM is already set on another player.";
-    return;
-  }
-
-  cdm_to_player_map_[cdm_id] = player_id;
 }
 
 int BrowserMediaPlayerManager::RoutingID() {
   return render_frame_host_->GetRoutingID();
 }
 
 bool BrowserMediaPlayerManager::Send(IPC::Message* msg) {
   return render_frame_host_->Send(msg);
 }
 
 void BrowserMediaPlayerManager::CreateSessionIfPermitted(
     int cdm_id,
     uint32 session_id,
     const std::string& content_type,
     const std::vector<uint8>& init_data,
     bool permitted) {
   if (!permitted) {
-    OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(cdm_id, session_id, MediaKeys::kUnknownError, 0);
     return;
   }
 
-  MediaKeys* cdm = GetCdm(cdm_id);
+  BrowserCdm* cdm = GetCdm(cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM for ID: " << cdm_id << " found";
-    OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
+    OnSessionError(cdm_id, session_id, MediaKeys::kUnknownError, 0);
     return;
   }
 
   // This could fail, in which case a SessionError will be fired.
   cdm->CreateSession(session_id, content_type, &init_data[0], init_data.size());
 }
 
 void BrowserMediaPlayerManager::ReleaseFullscreenPlayer(
     MediaPlayerAndroid* player) {
     player->Release();
@@ skipping 31 matching lines @@
 #if defined(VIDEO_HOLE)
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player && player->IsSurfaceInUse())
     return;
   if (external_video_surface_container_)
     external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
 #endif  // defined(VIDEO_HOLE)
 }
 
 }  // namespace content