Encrypted Media: Confine UUID code to MediaDrmBridge.

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/command_line.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"
@@ skipping 15 matching lines @@
 #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::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.
-static const int kMediaPlayerThreshold = 1;
+const int kMediaPlayerThreshold = 1;
 
-// Maximum sizes for various EME message parameters. These are checks to
-// prevent unnecessarily large messages from being passed around, and the sizes
-// are somewhat arbitrary as the EME specification doesn't specify any limits.
-static const size_t kEmeUuidSize = 16;
-static const size_t kEmeInitDataMaximum = 64 * 1024;  // 64 KB
-static const size_t kEmeResponseMaximum = 64 * 1024;  // 64 KB
-
-namespace content {
+// Maximum lengths for various EME API parameters. These are checks to
+// prevent unnecessarily large parameters from being passed around, and the
+// lengths are somewhat arbitrary as the EME spec doesn't specify any limits.
+const size_t kMaxInitDataLength = 64 * 1024;  // 64 KB
+const size_t kMaxSessionResponseLength = 64 * 1024;  // 64 KB
+const size_t kMaxKeySystemLength = 256;
 
 static BrowserMediaPlayerManager::Factory g_factory = NULL;
 
 // static
 void BrowserMediaPlayerManager::RegisterFactory(Factory factory) {
   g_factory = factory;
 }
 
 // static
 BrowserMediaPlayerManager* BrowserMediaPlayerManager::Create(
@@ skipping 508 matching lines @@
     fullscreen_player_is_released_ = true;
 }
 
 void BrowserMediaPlayerManager::OnDestroyPlayer(int player_id) {
   RemovePlayer(player_id);
   if (fullscreen_player_id_ == player_id)
     fullscreen_player_id_ = -1;
 }
 
 void BrowserMediaPlayerManager::OnInitializeCdm(int cdm_id,
-                                                const std::vector<uint8>& uuid,
+                                                const std::string& key_system,
                                                 const GURL& frame_url) {
-  if (uuid.size() != kEmeUuidSize) {
+  if (key_system.size() > kMaxKeySystemLength) {
     // This failure will be discovered and reported by OnCreateSession()
     // as GetDrmBridge() will return null.
-    NOTREACHED() << "Invalid UUID for ID: " << cdm_id;
+    NOTREACHED() << "Invalid key system: " << key_system;
     return;
   }
 
-  AddDrmBridge(cdm_id, uuid, frame_url);
+  if (!MediaDrmBridge::IsKeySystemSupportedWithType(key_system, "")) {
+    NOTREACHED() << "Unsupported key system: " << key_system;
+    return;
+  }
+
+  AddDrmBridge(cdm_id, key_system, frame_url);
   // In EME v0.1b MediaKeys lives in the media element. So the |cdm_id|
   // is the same as the |player_id|.
   OnSetMediaKeys(cdm_id, cdm_id);
 }
 
 void BrowserMediaPlayerManager::OnCreateSession(
     int cdm_id,
     uint32 session_id,
     CdmHostMsg_CreateSession_ContentType content_type,
     const std::vector<uint8>& init_data) {
-  if (init_data.size() > kEmeInitDataMaximum) {
+  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);
     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
@@ skipping 48 matching lines @@
     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";
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  if (response.size() > kEmeResponseMaximum) {
+  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());
   // In EME v0.1b MediaKeys lives in the media element. So the |cdm_id|
   // is the same as the |player_id|.
   // TODO(xhwang): Separate |cdm_id| and |player_id|.
@@ skipping 68 matching lines @@
         Send(new MediaPlayerMsg_DisconnectedFromRemoteDevice(
             routing_id(), player->player_id()));
       }
       break;
     }
   }
   return scoped_ptr<media::MediaPlayerAndroid>(previous_player);
 }
 
 void BrowserMediaPlayerManager::AddDrmBridge(int cdm_id,
-                                             const std::vector<uint8>& uuid,
+                                             const std::string& key_system,
                                              const GURL& frame_url) {
   DCHECK(!GetDrmBridge(cdm_id));
 
   scoped_ptr<MediaDrmBridge> drm_bridge(
-      MediaDrmBridge::Create(cdm_id, uuid, frame_url, this));
+      MediaDrmBridge::Create(cdm_id, key_system, frame_url, this));
   if (!drm_bridge) {
     // This failure will be discovered and reported by OnCreateSession()
     // as GetDrmBridge() will return null.
     DVLOG(1) << "failed to create drm bridge.";
     return;
   }
 
   // TODO(xhwang/ddorwin): Pass the security level from key system.
   MediaDrmBridge::SecurityLevel security_level =
       MediaDrmBridge::SECURITY_LEVEL_3;
@@ skipping 109 matching lines @@
   if (player && player->IsSurfaceInUse())
     return;
   ExternalVideoSurfaceContainer* surface_container =
       ExternalVideoSurfaceContainer::FromWebContents(web_contents_);
   if (surface_container)
     surface_container->ReleaseExternalVideoSurface(player_id);
 #endif  // defined(VIDEO_HOLE)
 }
 
 }  // namespace content