Check whether the Pepper CDM is available before adding the key system.

chrome/renderer/media/chrome_key_systems.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 "chrome/renderer/media/chrome_key_systems.h"
 
 #include "base/logging.h"
+#include "chrome/common/render_messages.h"
+#include "content/public/renderer/render_thread.h"
 
 #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
 
 // The following must be after widevine_cdm_version.h.
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
 #include <gnu/libc-version.h>
 #include "base/version.h"
 #endif
 
@@ skipping 26 matching lines @@
 static void AddWidevineForCodecs(
     SupportedCodecs supported_codecs,
     std::vector<KeySystemInfo>* concrete_key_systems) {
   static const char kWidevineParentKeySystem[] = "com.widevine";
 #if defined(OS_ANDROID)
   static const uint8 kWidevineUuid[16] = {
       0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
       0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED };
 #endif
 
-#if defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
-  Version glibc_version(gnu_get_libc_version());
-  DCHECK(glibc_version.IsValid());
-  if (glibc_version.IsOlderThan(WIDEVINE_CDM_MIN_GLIBC_VERSION))
-    return;
-#endif  // defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
-
   KeySystemInfo info(kWidevineKeySystem);
 
   if (supported_codecs & WEBM_VP8_AND_VORBIS) {
     info.supported_types.push_back(std::make_pair(kAudioWebM, kVorbis));
     info.supported_types.push_back(std::make_pair(kVideoWebM, kVorbisVP8));
   }
 
 #if defined(USE_PROPRIETARY_CODECS)
   if (supported_codecs & MP4_AAC)
     info.supported_types.push_back(std::make_pair(kAudioMp4, kMp4a));
 
   if (supported_codecs & MP4_AVC1) {
     const char* video_codecs = (supported_codecs & MP4_AAC) ? kMp4aAvc1 : kAvc1;
     info.supported_types.push_back(std::make_pair(kVideoMp4, video_codecs));
   }
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
   info.parent_key_system = kWidevineParentKeySystem;
 
 #if defined(ENABLE_PEPPER_CDMS)
   info.pepper_type = kWidevineCdmPluginMimeType;
 #elif defined(OS_ANDROID)
   info.uuid.assign(kWidevineUuid, kWidevineUuid + arraysize(kWidevineUuid));
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
   concrete_key_systems->push_back(info);
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
+static bool IsPepperCdmAvailable(const std::string& pepper_type) {
+  bool is_available = false;

[scherkus (not reviewing), 2013/09/11 22:34:41]

do you want cache this value?

[ddorwin, 2013/09/16 17:17:58]

It's not really necessary. This should only happen once per renderer process
since it is invoked by KeySystems, which is a lazily-instantiated singleton.
That's a bit of implementation knowledge that this code probably shouldn't have,
but adding static values just adds complexity for no real gain. Note that this
is not called for every canPlayType() call since this code is run to _add_ key
systems. WDYT?

P.S. If we were going to cache this value, it would probably need to be at line
104.

[scherkus (not reviewing), 2013/09/16 17:42:05]

seems fine as is

+  content::RenderThread::Get()->Send(
+      new ChromeViewHostMsg_IsSupportingPluginAvailable(pepper_type,
+                                                        &is_available));
+
+  return is_available;
+}
+
 // Supported types are determined at compile time.
 static void AddPepperBasedWidevine(
     std::vector<KeySystemInfo>* concrete_key_systems) {
+#if defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
+  Version glibc_version(gnu_get_libc_version());
+  DCHECK(glibc_version.IsValid());
+  if (glibc_version.IsOlderThan(WIDEVINE_CDM_MIN_GLIBC_VERSION))
+    return;
+#endif  // defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
+
+  if (!IsPepperCdmAvailable(kWidevineCdmPluginMimeType)) {
+    DVLOG(1) << "Widevine CDM is not currently available.";
+    return;
+  }
+
   SupportedCodecs supported_codecs = WEBM_VP8_AND_VORBIS;
 
 #if defined(USE_PROPRIETARY_CODECS)
 #if defined(WIDEVINE_CDM_AAC_SUPPORT_AVAILABLE)
   supported_codecs = static_cast<SupportedCodecs>(supported_codecs | MP4_AAC);
 #endif
 #if defined(WIDEVINE_CDM_AVC1_SUPPORT_AVAILABLE)
   supported_codecs = static_cast<SupportedCodecs>(supported_codecs | MP4_AVC1);
 #endif
 #endif  // defined(USE_PROPRIETARY_CODECS)
@@ skipping 56 matching lines @@
 #endif
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
 #if defined(ENABLE_PEPPER_CDMS)
   AddPepperBasedWidevine(key_systems_info);
 #elif defined(OS_ANDROID)
   AddAndroidWidevine(key_systems_info);
 #endif
 #endif
 }