BrowserMediaPlayerManager manages MediaKeys objects.

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"
 #include "content/browser/media/android/browser_demuxer_android.h"
 #include "content/browser/media/android/media_resource_getter_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_view_android.h"
 #include "content/common/media/cdm_messages.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/android/external_video_surface_container.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.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_drm_bridge.h"
+#include "media/base/android/cdm_factory.h"
 #include "media/base/android/media_player_bridge.h"
 #include "media/base/android/media_source_player.h"
 #include "media/base/media_switches.h"
 
-using media::MediaDrmBridge;
+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.
 const int kMediaPlayerThreshold = 1;
@@ skipping 292 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;
 }
 
-MediaDrmBridge* BrowserMediaPlayerManager::GetDrmBridge(int cdm_id) {
-  for (ScopedVector<MediaDrmBridge>::iterator it = drm_bridges_.begin();
-      it != drm_bridges_.end(); ++it) {
-    if ((*it)->cdm_id() == cdm_id)
-      return *it;
-  }
-  return NULL;
+MediaKeys* 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();
-  drm_bridges_.clear();
+  STLDeleteValues(&cdm_map_);
   if (fullscreen_player_id_ != -1) {
     video_view_.reset();
     fullscreen_player_id_ = -1;
   }
 }
 
 void BrowserMediaPlayerManager::RequestFullScreen(int player_id) {
   if (fullscreen_player_id_ == player_id)
     return;
 
@@ skipping 20 matching lines @@
     uint32 session_id,
     const std::string& web_session_id) {
   Send(new CdmMsg_SessionCreated(
       routing_id(), cdm_id, session_id, web_session_id));
 }
 
 void BrowserMediaPlayerManager::OnSessionMessage(
     int cdm_id,
     uint32 session_id,
     const std::vector<uint8>& message,
-    const GURL& destination_url) {
+    const std::string& destination_url) {
+  GURL destination_gurl(destination_url);
+  if (!destination_gurl.is_valid() && !destination_gurl.is_empty()) {
+    DLOG(WARNING) << "SessionMessage destination_url is invalid : "
+                  << destination_gurl.possibly_invalid_spec();
+    destination_gurl = GURL::EmptyGURL();  // Replace invalid destination_url.
+  }
+
   Send(new CdmMsg_SessionMessage(
-      routing_id(), cdm_id, session_id, message, destination_url));
+      routing_id(), cdm_id, session_id, message, destination_gurl));

[damienv1, 2014/05/12 23:14:26]

destination_gurl will be updated to a string once the renderer side is updated,
right ?

[ddorwin, 2014/05/13 00:59:38]

Why would we move away from GURL? Especially for IPCs, we should use GURLs.

[xhwang, 2014/05/14 16:42:06]

See above. Added TODO to use GURL as much as we can.

[xhwang, 2014/05/14 16:42:06]

ditto

 }
 
 void BrowserMediaPlayerManager::OnSessionReady(int cdm_id, uint32 session_id) {
   Send(new CdmMsg_SessionReady(routing_id(), cdm_id, session_id));
 }
 
 void BrowserMediaPlayerManager::OnSessionClosed(int cdm_id, uint32 session_id) {
   Send(new CdmMsg_SessionClosed(routing_id(), cdm_id, session_id));
 }
 
@@ skipping 174 matching lines @@
   RemovePlayer(player_id);
   if (fullscreen_player_id_ == player_id)
     fullscreen_player_id_ = -1;
 }
 
 void BrowserMediaPlayerManager::OnInitializeCdm(int cdm_id,
                                                 const std::string& key_system,
                                                 const GURL& security_origin) {
   if (key_system.size() > kMaxKeySystemLength) {
     // This failure will be discovered and reported by OnCreateSession()
-    // as GetDrmBridge() will return null.
+    // as GetCdm() will return null.
     NOTREACHED() << "Invalid key system: " << key_system;
     return;
   }
 
-  if (!MediaDrmBridge::IsKeySystemSupported(key_system)) {
-    NOTREACHED() << "Unsupported key system: " << key_system;
-    return;
-  }
-
-  AddDrmBridge(cdm_id, key_system, security_origin);
+  AddCdm(cdm_id, key_system, security_origin);
 }
 
 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();
@@ skipping 17 matching lines @@
       NOTREACHED();
       return;
   }
 
   if (CommandLine::ForCurrentProcess()
       ->HasSwitch(switches::kDisableInfobarForProtectedMediaIdentifier)) {
     CreateSessionIfPermitted(cdm_id, session_id, mime_type, init_data, true);
     return;
   }
 
-  MediaDrmBridge* drm_bridge = GetDrmBridge(cdm_id);
-  if (!drm_bridge) {
-    DLOG(WARNING) << "No MediaDrmBridge for ID: " << cdm_id << " found";
+  MediaKeys* cdm = GetCdm(cdm_id);
+  if (!cdm) {
+    DLOG(WARNING) << "No CDMs for ID: " << cdm_id << " found";

[ddorwin, 2014/05/13 00:59:38]

nit: s/CDMs/CDM/
nit: remove colon or move "found" before "for"

[xhwang, 2014/05/14 16:42:06]

Done.

     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   BrowserContext* context =
       web_contents()->GetRenderProcessHost()->GetBrowserContext();
 
+  DCHECK(ContainsKey(security_origin_map_, cdm_id));

[ddorwin, 2014/05/13 00:59:38]

If this fails, we crash at 658. Since this is the browser and it could be
attacked by the renderer, we should fail gracefully.

[xhwang, 2014/05/14 16:42:06]

Done.

+
   context->RequestProtectedMediaIdentifierPermission(
       web_contents()->GetRenderProcessHost()->GetID(),
       web_contents()->GetRenderViewHost()->GetRoutingID(),
       static_cast<int>(session_id),
       cdm_id,
-      drm_bridge->security_origin(),
+      security_origin_map_[cdm_id],
       base::Bind(&BrowserMediaPlayerManager::CreateSessionIfPermitted,
                  weak_ptr_factory_.GetWeakPtr(),
                  cdm_id,
                  session_id,
                  mime_type,
                  init_data));

[damienv1, 2014/05/12 21:37:53]

All this part seems to be an internal detail of the implementation of
MediaKeys::CreateSession.
And this would remove the need for a security_origin_map_ (the security_origin
should be an internal detail of the MediaKeys implementation).

[xhwang, 2014/05/12 21:58:44]

Well, I agree that the security origin should and the user permission prompt
should be an implementation detail of the MediaKeys. But to do that, we need to
pass the security origin in CreateCdm(). Also, we need some other plumbing so
that MediaDrmBridge can request protected media identifier permission. Maybe
pass a RequestPermissionCB() in CreateCdm(). I don't know what's the best way to
do that yet. How about a TODO?

[ddorwin, 2014/05/13 00:59:38]

When and whether to check permissions is CDM-specific, but it is likely to occur
around createSession(), so it might make sense to include this in the general
framework. The individual implementation would then decide what to do.

It appears this is what would happen at 653. The BrowserContext implementation
will decide what to do and call the callback. We _could_ make it more explicit
about this request being related to session creation, but I don't think we have
use cases for that currently.

[xhwang, 2014/05/14 16:42:06]

I can think of it in both ways. What if on some platform, createsession doesn't
involve a protected-media-identifier? Then even this call is generic and can be
platform specific, the function name doesn't make sense anymore. Maybe we can
rename it as something like "RequestCreateSessionPermission". Or maybe we can
move all of these to MediaDrmBridge.

Anyway, I feel this is low priority and don't want to involve this in the
current refactoring work. WDYT?

 }
 
 void BrowserMediaPlayerManager::OnUpdateSession(
     int cdm_id,
     uint32 session_id,
     const std::vector<uint8>& response) {
-  MediaDrmBridge* drm_bridge = GetDrmBridge(cdm_id);
-  if (!drm_bridge) {
-    DLOG(WARNING) << "No MediaDrmBridge for ID: " << cdm_id << " found";
+  MediaKeys* cdm = GetCdm(cdm_id);
+  if (!cdm) {
+    DLOG(WARNING) << "No CDM for ID: " << cdm_id << " found";

[ddorwin, 2014/05/13 00:59:38]

ditto

[xhwang, 2014/05/14 16:42:06]

Done.

     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   if (response.size() > kMaxSessionResponseLength) {
     LOG(WARNING) << "Response for ID: " << cdm_id
                  << " too long: " << response.size();
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  drm_bridge->UpdateSession(session_id, &response[0], response.size());
+  cdm->UpdateSession(session_id, &response[0], response.size());
 
-  DrmBridgePlayerMap::const_iterator iter = drm_bridge_player_map_.find(cdm_id);
-  if (iter == drm_bridge_player_map_.end())
+  CdmToPlayerMap::const_iterator iter = cdm_to_player_map_.find(cdm_id);
+  if (iter == cdm_to_player_map_.end())

[damienv1, 2014/05/12 21:37:53]

I don't think that's the right way: we shouldn't need this cdm_to_player_map_:
1) The BrowserMediaPlayerManager should not have to remember the CDM to player
association.
2) When we call SetCdm on the player, the player should register itself to the
MediaKey object to listen to some CDM events.
Then the CDM will invoke this callback.

[xhwang, 2014/05/12 21:58:44]

Agreed. Since this is from the old code and we'll have a new event to notify
"new key added". I'd like to do this in a later CL.

[xhwang, 2014/05/14 16:42:06]

I filed a bug (http://crbug.com/373327) and added a TODO.

     return;
 
   int player_id = iter->second;
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->OnKeyAdded();
 }
 
 void BrowserMediaPlayerManager::OnReleaseSession(int cdm_id,
                                                  uint32 session_id) {
-  MediaDrmBridge* drm_bridge = GetDrmBridge(cdm_id);
-  if (!drm_bridge) {
-    DLOG(WARNING) << "No MediaDrmBridge for ID: " << cdm_id << " found";
+  MediaKeys* cdm = GetCdm(cdm_id);
+  if (!cdm) {
+    DLOG(WARNING) << "No MediaKeys for ID: " << cdm_id << " found";

[ddorwin, 2014/05/13 00:59:38]

ditto

[xhwang, 2014/05/14 16:42:06]

Done.

     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  drm_bridge->ReleaseSession(session_id);
+  cdm->ReleaseSession(session_id);
 }
 
 void BrowserMediaPlayerManager::OnDestroyCdm(int cdm_id) {
-  MediaDrmBridge* drm_bridge = GetDrmBridge(cdm_id);
-  if (!drm_bridge) return;
+  MediaKeys* cdm = GetCdm(cdm_id);
+  if (!cdm) return;
 
   CancelAllPendingSessionCreations(cdm_id);
-  RemoveDrmBridge(cdm_id);
+  RemoveCdm(cdm_id);
 }
 
 void BrowserMediaPlayerManager::CancelAllPendingSessionCreations(int cdm_id) {
   BrowserContext* context =
       web_contents()->GetRenderProcessHost()->GetBrowserContext();
   context->CancelProtectedMediaIdentifierPermissionRequests(cdm_id);
 }
 
 void BrowserMediaPlayerManager::AddPlayer(MediaPlayerAndroid* player) {
   DCHECK(!GetPlayer(player->player_id()));
   players_.push_back(player);
 }
 
 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 (DrmBridgePlayerMap::iterator it = drm_bridge_player_map_.begin();
-       it != drm_bridge_player_map_.end(); ++it) {
+  for (CdmToPlayerMap::iterator it = cdm_to_player_map_.begin();
+       it != cdm_to_player_map_.end(); ++it) {
     if (it->second == player_id) {
-      drm_bridge_player_map_.erase(it);
+      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::AddDrmBridge(int cdm_id,
-                                             const std::string& key_system,
-                                             const GURL& security_origin) {
-  DCHECK(!GetDrmBridge(cdm_id));
+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<MediaDrmBridge> drm_bridge(
-      MediaDrmBridge::Create(cdm_id, key_system, security_origin, this));
-  if (!drm_bridge) {
+  scoped_ptr<MediaKeys> cdm(media::CreateCdm(
+      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)));
+
+  if (!cdm) {
     // This failure will be discovered and reported by OnCreateSession()
-    // as GetDrmBridge() will return null.
-    DVLOG(1) << "failed to create drm bridge.";
+    // as GetCdm() will return null.
+    DVLOG(1) << "failed to create CDM.";
     return;
   }
 
-  // TODO(xhwang/ddorwin): Pass the security level from key system.
-  MediaDrmBridge::SecurityLevel security_level =
-      MediaDrmBridge::SECURITY_LEVEL_3;
-  if (CommandLine::ForCurrentProcess()
-          ->HasSwitch(switches::kMediaDrmEnableNonCompositing)) {
-    security_level = MediaDrmBridge::SECURITY_LEVEL_1;
-  }
-  if (!drm_bridge->SetSecurityLevel(security_level)) {
-    DVLOG(1) << "failed to set security level " << security_level;
-    return;
-  }
-
-  drm_bridges_.push_back(drm_bridge.release());
+  cdm_map_[cdm_id] = cdm.release();
+  security_origin_map_[cdm_id] = security_origin;
 }
 
-void BrowserMediaPlayerManager::RemoveDrmBridge(int cdm_id) {
-  // TODO(xhwang): Detach DrmBridge from the player it's set to. In prefixed
+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.
-  for (ScopedVector<MediaDrmBridge>::iterator it = drm_bridges_.begin();
-      it != drm_bridges_.end(); ++it) {
-    if ((*it)->cdm_id() == cdm_id) {
-      drm_bridges_.erase(it);
-      drm_bridge_player_map_.erase(cdm_id);
-      break;
-    }
+  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);
+  security_origin_map_.erase(cdm_id);
 }
 
 void BrowserMediaPlayerManager::OnSetCdm(int player_id, int cdm_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
-  MediaDrmBridge* drm_bridge = GetDrmBridge(cdm_id);
-  if (!drm_bridge || !player) {
+  MediaKeys* cdm = GetCdm(cdm_id);
+  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->SetDrmBridge(drm_bridge);
+  player->SetCdm(cdm);
   // Do now support setting one CDM on multiple players.
-  DCHECK(drm_bridge_player_map_.find(cdm_id) == drm_bridge_player_map_.end());
-  drm_bridge_player_map_[cdm_id] = player_id;
+  DCHECK(!ContainsKey(cdm_to_player_map_, cdm_id));
+  cdm_to_player_map_[cdm_id] = player_id;
 }
 
 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);
     return;
   }
 
-  MediaDrmBridge* drm_bridge = GetDrmBridge(cdm_id);
-  if (!drm_bridge) {
-    DLOG(WARNING) << "No MediaDrmBridge for ID: " << cdm_id << " found";
+  MediaKeys* cdm = GetCdm(cdm_id);
+  if (!cdm) {
+    DLOG(WARNING) << "No CDM for ID: " << cdm_id << " found";
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   // This could fail, in which case a SessionError will be fired.
-  drm_bridge->CreateSession(
+  cdm->CreateSession(
       session_id, content_type, &init_data[0], init_data.size());
 }
 
 void BrowserMediaPlayerManager::ReleaseFullscreenPlayer(
     MediaPlayerAndroid* player) {
     player->Release();
 }
 
 void BrowserMediaPlayerManager::OnMediaResourcesRequested(int player_id) {
   int num_active_player = 0;
@@ skipping 27 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