Add an IPC to return the platform supported key-system names in Android.

media/base/android/media_drm_bridge.cc

 // Copyright (c) 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 "media/base/android/media_drm_bridge.h"
 
 #include <algorithm>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_array.h"
@@ skipping 55 matching lines @@
     0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
     0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED };
 
 typedef std::vector<uint8> UUID;
 
 class KeySystemUuidManager {
  public:
   KeySystemUuidManager();
   UUID GetUUID(const std::string& key_system);
   void AddMapping(const std::string& key_system, const UUID& uuid);
+  std::vector<std::string> GetPlatformKeySystemNames();
 
  private:
   typedef base::hash_map<std::string, UUID> KeySystemUuidMap;
 
   KeySystemUuidMap key_system_uuid_map_;
 
   DISALLOW_COPY_AND_ASSIGN(KeySystemUuidManager);
 };
 
 KeySystemUuidManager::KeySystemUuidManager() {
@@ skipping 12 matching lines @@
 void KeySystemUuidManager::AddMapping(const std::string& key_system,
                                       const UUID& uuid) {
   KeySystemUuidMap::iterator it = key_system_uuid_map_.find(key_system);
   DCHECK(it == key_system_uuid_map_.end())
       << "Shouldn't overwrite an existing key system.";
   if (it != key_system_uuid_map_.end())
     return;
   key_system_uuid_map_[key_system] = uuid;
 }
 
+std::vector<std::string> KeySystemUuidManager::GetPlatformKeySystemNames() {
+  std::vector<std::string> key_systems;
+  for (KeySystemUuidMap::iterator it = key_system_uuid_map_.begin();
+       it != key_system_uuid_map_.end(); ++it) {
+    // Rule out the key system handled by Chrome explicitly.
+    if (it->first.compare(kWidevineKeySystem) != 0)

[xhwang, 2014/06/11 23:12:28]

Can you just do 
it->first != kWidevineKeySystem ?

[ycheo (away), 2014/06/12 02:02:45]

Done.

+      key_systems.push_back(it->first);
+  }
+  return key_systems;
+}
+
 base::LazyInstance<KeySystemUuidManager>::Leaky g_key_system_uuid_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 // Tries to find a PSSH box whose "SystemId" is |uuid| in |data|, parses the
 // "Data" of the box and put it in |pssh_data|. Returns true if such a box is
 // found and successfully parsed. Returns false otherwise.
 // Notes:
 // 1, If multiple PSSH boxes are found,the "Data" of the first matching PSSH box
 // will be set in |pssh_data|.
 // 2, Only PSSH and TENC boxes are allowed in |data|. TENC boxes are skipped.
@@ skipping 139 matching lines @@
     return false;
 
   scoped_ptr<MediaDrmBridge> media_drm_bridge =
       MediaDrmBridge::CreateSessionless(key_system);
   if (!media_drm_bridge)
     return false;
 
   return media_drm_bridge->SetSecurityLevel(security_level);
 }
 
-//static
+// static
 void MediaDrmBridge::AddKeySystemUuidMapping(const std::string& key_system,
                                              const std::vector<uint8>& uuid) {
   g_key_system_uuid_manager.Get().AddMapping(key_system, uuid);
 }
 
 // static
+std::vector<std::string> MediaDrmBridge::GetPlatformKeySystemNames() {
+  return g_key_system_uuid_manager.Get().GetPlatformKeySystemNames();
+}
+
+// static
 bool MediaDrmBridge::IsKeySystemSupported(const std::string& key_system) {
   DCHECK(!key_system.empty());
   return IsKeySystemSupportedWithTypeImpl(key_system, "");
 }
 
 // static
 bool MediaDrmBridge::IsKeySystemSupportedWithType(
     const std::string& key_system,
     const std::string& container_mime_type) {
   DCHECK(!key_system.empty() && !container_mime_type.empty());
@@ skipping 258 matching lines @@
   JNIEnv* env = AttachCurrentThread();
   Java_MediaDrmBridge_resetDeviceCredentials(env, j_media_drm_.obj());
 }
 
 void MediaDrmBridge::OnResetDeviceCredentialsCompleted(
     JNIEnv* env, jobject, bool success) {
   base::ResetAndReturn(&reset_credentials_cb_).Run(success);
 }
 
 }  // namespace media