Check whether the plugin is disabled in OnIsInternalPluginRegisteredForMimeType().

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 <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
 #include <gnu/libc-version.h>
 #include "base/version.h"
 #endif
 
 using content::KeySystemInfo;
 using content::SupportedCodecs;
 
 #if defined(ENABLE_PEPPER_CDMS)
-static bool IsPepperCdmRegistered(
+static bool IsPepperCdmAvailable(
     const std::string& pepper_type,
     std::vector<base::string16>* additional_param_names,
     std::vector<base::string16>* additional_param_values) {
-  bool is_registered = false;
+  bool is_available = false;
   content::RenderThread::Get()->Send(
-      new ChromeViewHostMsg_IsInternalPluginRegisteredForMimeType(
+      new ChromeViewHostMsg_IsInternalPluginAvailableForMimeType(
           pepper_type,
-          &is_registered,
+          &is_available,
           additional_param_names,
           additional_param_values));
 
-  return is_registered;
+  return is_available;
 }
 
 // External Clear Key (used for testing).
 static void AddExternalClearKey(
     std::vector<KeySystemInfo>* concrete_key_systems) {
   static const char kExternalClearKeyKeySystem[] =
       "org.chromium.externalclearkey";
   static const char kExternalClearKeyDecryptOnlyKeySystem[] =
       "org.chromium.externalclearkey.decryptonly";
   static const char kExternalClearKeyFileIOTestKeySystem[] =
       "org.chromium.externalclearkey.fileiotest";
   static const char kExternalClearKeyInitializeFailKeySystem[] =
       "org.chromium.externalclearkey.initializefail";
   static const char kExternalClearKeyCrashKeySystem[] =
       "org.chromium.externalclearkey.crash";
   static const char kExternalClearKeyPepperType[] =
       "application/x-ppapi-clearkey-cdm";
 
   std::vector<base::string16> additional_param_names;
   std::vector<base::string16> additional_param_values;
-  if (!IsPepperCdmRegistered(kExternalClearKeyPepperType,
-                             &additional_param_names,
-                             &additional_param_values)) {
+  if (!IsPepperCdmAvailable(kExternalClearKeyPepperType,
+                            &additional_param_names,
+                            &additional_param_values)) {
     return;
   }
 
   KeySystemInfo info(kExternalClearKeyKeySystem);
 
   info.supported_codecs = content::EME_CODEC_WEBM_ALL;
 #if defined(USE_PROPRIETARY_CODECS)
   info.supported_codecs |= content::EME_CODEC_MP4_ALL;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
@@ skipping 53 matching lines @@
     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)
 
   std::vector<base::string16> additional_param_names;
   std::vector<base::string16> additional_param_values;
-  if (!IsPepperCdmRegistered(kWidevineCdmPluginMimeType,
-                             &additional_param_names,
-                             &additional_param_values)) {
+  if (!IsPepperCdmAvailable(kWidevineCdmPluginMimeType,
+                            &additional_param_names,
+                            &additional_param_values)) {
     DVLOG(1) << "Widevine CDM is not currently available.";
     return;
   }
 
   std::vector<std::string> codecs;
   GetSupportedCodecsForPepperCdm(additional_param_names,
                                  additional_param_values,
                                  &codecs);
 
   SupportedCodecs supported_codecs = content::EME_CODEC_NONE;
@@ skipping 25 matching lines @@
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
   AddPepperBasedWidevine(key_systems_info);
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
 #if defined(OS_ANDROID)
   cdm::AddAndroidWidevine(key_systems_info);
 #endif  // defined(OS_ANDROID)
 }