EME: Check capabilities provided only on success

third_party/WebKit/Source/modules/encryptedmedia/NavigatorRequestMediaKeySystemAccess.cpp

 // Copyright 2014 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 "modules/encryptedmedia/NavigatorRequestMediaKeySystemAccess.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
@@ skipping 111 matching lines @@
   // TODO(xhwang): Remove after we handle empty robustness correctly.
   // See http://crbug.com/482277
   void checkVideoCapabilityRobustness() const;
 
   // Generate deprecation warning and log UseCounter if configuration
   // contains only container-only contentType strings.
   // TODO(jrummell): Remove once this is no longer allowed.
   // See http://crbug.com/605661.
   void checkEmptyCodecs(const WebMediaKeySystemConfiguration&);
 
-  // Log UseCounter if configuration does not have at least one of
+  // Log UseCounter if selected configuration does not have at least one of
   // 'audioCapabilities' and 'videoCapabilities' non-empty.
   // TODO(jrummell): Switch to deprecation message once we have data.
   // See http://crbug.com/616233.
-  void checkCapabilitiesProvided(const WebMediaKeySystemConfiguration&);
+  void checkCapabilities(const WebMediaKeySystemConfiguration&);
 
   Member<ScriptPromiseResolver> m_resolver;
   const String m_keySystem;
   WebVector<WebMediaKeySystemConfiguration> m_supportedConfigurations;
 };
 
 MediaKeySystemAccessInitializer::MediaKeySystemAccessInitializer(
     ScriptState* scriptState,
     const String& keySystem,
     const HeapVector<MediaKeySystemConfiguration>& supportedConfigurations)
     : m_resolver(ScriptPromiseResolver::create(scriptState)),
       m_keySystem(keySystem),
       m_supportedConfigurations(supportedConfigurations.size()) {
   for (size_t i = 0; i < supportedConfigurations.size(); ++i) {
     const MediaKeySystemConfiguration& config = supportedConfigurations[i];
     WebMediaKeySystemConfiguration webConfig;
 
     DCHECK(config.hasInitDataTypes());
     webConfig.initDataTypes = convertInitDataTypes(config.initDataTypes());
 
     DCHECK(config.hasAudioCapabilities());
     webConfig.audioCapabilities =
         convertCapabilities(config.audioCapabilities());
 
     DCHECK(config.hasVideoCapabilities());
     webConfig.videoCapabilities =
         convertCapabilities(config.videoCapabilities());
 
-    checkCapabilitiesProvided(webConfig);
-
     DCHECK(config.hasDistinctiveIdentifier());
     webConfig.distinctiveIdentifier =
         convertMediaKeysRequirement(config.distinctiveIdentifier());
 
     DCHECK(config.hasPersistentState());
     webConfig.persistentState =
         convertMediaKeysRequirement(config.persistentState());
 
     if (config.hasSessionTypes()) {
       webConfig.sessionTypes = convertSessionTypes(config.sessionTypes());
@@ skipping 12 matching lines @@
     webConfig.label = config.label();
     m_supportedConfigurations[i] = webConfig;
   }
 
   checkVideoCapabilityRobustness();
 }
 
 void MediaKeySystemAccessInitializer::requestSucceeded(
     WebContentDecryptionModuleAccess* access) {
   checkEmptyCodecs(access->getConfiguration());
+  checkCapabilities(access->getConfiguration());
 
   m_resolver->resolve(
       new MediaKeySystemAccess(m_keySystem, wrapUnique(access)));
   m_resolver.clear();
 }
 
 void MediaKeySystemAccessInitializer::requestNotSupported(
     const WebString& errorMessage) {
   m_resolver->reject(DOMException::create(NotSupportedError, errorMessage));
   m_resolver.clear();
@@ skipping 66 matching lines @@
     Deprecation::countDeprecation(
         m_resolver->getExecutionContext(),
         UseCounter::EncryptedMediaAllSelectedContentTypesMissingCodecs);
   } else {
     UseCounter::count(
         m_resolver->getExecutionContext(),
         UseCounter::EncryptedMediaAllSelectedContentTypesHaveCodecs);
   }
 }
 
-void MediaKeySystemAccessInitializer::checkCapabilitiesProvided(
+void MediaKeySystemAccessInitializer::checkCapabilities(
     const WebMediaKeySystemConfiguration& config) {
+  // This is only checking that at least one capability is provided in the
+  // selected configuration, as apps may pass empty capabilities for
+  // compatibility with other implementations.
   bool atLeastOneAudioCapability = config.audioCapabilities.size() > 0;
   bool atLeastOneVideoCapability = config.videoCapabilities.size() > 0;
 
   if (atLeastOneAudioCapability || atLeastOneVideoCapability) {
     UseCounter::count(m_resolver->getExecutionContext(),
                       UseCounter::EncryptedMediaCapabilityProvided);
   } else {
     // TODO(jrummell): Switch to deprecation message once we understand
     // current usage. http://crbug.com/616233.
     UseCounter::count(m_resolver->getExecutionContext(),
@@ skipping 70 matching lines @@
   WebEncryptedMediaClient* mediaClient =
       controller->encryptedMediaClient(executionContext);
   mediaClient->requestMediaKeySystemAccess(
       WebEncryptedMediaRequest(initializer));
 
   // 7. Return promise.
   return promise;
 }
 
 }  // namespace blink