EME: Update MediaKeySystemConfiguration defaults; require non-empty capabilities

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 104 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&);
 
+    // Generate deprecation warning and log UseCounter if configuration does
+    // not have at least one of 'audioCapabilities' and 'videoCapabilities'
+    // non-empty.
+    // TODO(jrummell): Remove once this is enforced.
+    // See http://crbug.com/616233.
+    void checkCapabilitiesProvided(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;
-        if (config.hasInitDataTypes()) {
-            webConfig.hasInitDataTypes = true;
-            webConfig.initDataTypes = convertInitDataTypes(config.initDataTypes());
-        }
-        if (config.hasAudioCapabilities()) {
-            webConfig.hasAudioCapabilities = true;
-            webConfig.audioCapabilities = convertCapabilities(config.audioCapabilities());
-        }
-        if (config.hasVideoCapabilities()) {
-            webConfig.hasVideoCapabilities = true;
-            webConfig.videoCapabilities = convertCapabilities(config.videoCapabilities());
-        }
+
+        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);

[foolip, 2016/09/23 08:18:39]

I can't find where the "If video capabilities is null, return NotSupported" bit
of the spec is implemented, does it already reject?

[jrummell, 2016/09/29 20:40:02]

Most of the steps are done in media/blink/key_system_config_selector.cc, see
line 652 in this CL. It has a TODO to check it once we require it.

+
         DCHECK(config.hasDistinctiveIdentifier());
         webConfig.distinctiveIdentifier = convertMediaKeysRequirement(config.distinctiveIdentifier());
+
         DCHECK(config.hasPersistentState());
         webConfig.persistentState = convertMediaKeysRequirement(config.persistentState());
+
         if (config.hasSessionTypes()) {
             webConfig.hasSessionTypes = true;
             webConfig.sessionTypes = convertSessionTypes(config.sessionTypes());
         }
+
         // If |label| is not present, it will be a null string.
         webConfig.label = config.label();
         m_supportedConfigurations[i] = webConfig;
     }
 
     checkVideoCapabilityRobustness();
 }
 
 void MediaKeySystemAccessInitializer::requestSucceeded(WebContentDecryptionModuleAccess* access)
 {
@@ skipping 12 matching lines @@
 void MediaKeySystemAccessInitializer::checkVideoCapabilityRobustness() const
 {
     // Only check for widevine key system.
     if (keySystem() != "com.widevine.alpha")
         return;
 
     bool hasVideoCapabilities = false;
     bool hasEmptyRobustness = false;
 
     for (const auto& config : m_supportedConfigurations) {
-        if (!config.hasVideoCapabilities)
-            continue;
-
-        hasVideoCapabilities = true;
-
         for (const auto& capability : config.videoCapabilities) {
+            hasVideoCapabilities = true;
             if (capability.robustness.isEmpty()) {
                 hasEmptyRobustness = true;
                 break;
             }
         }
 
         if (hasEmptyRobustness)
             break;
     }
 
@@ skipping 11 matching lines @@
 
 void MediaKeySystemAccessInitializer::checkEmptyCodecs(const WebMediaKeySystemConfiguration& config)
 {
     // This is only checking for empty codecs in the selected configuration,
     // as apps may pass container only contentType strings for compatibility
     // with other implementations.
     // This will only check that all returned capabilities do not contain
     // codecs. This avoids alerting on configurations that will continue
     // to succeed in the future once strict checking is enforced.
     bool areAllAudioCodecsEmpty = false;
-    if (config.hasAudioCapabilities && !config.audioCapabilities.isEmpty()) {
+    if (!config.audioCapabilities.isEmpty()) {
         areAllAudioCodecsEmpty = std::find_if(config.audioCapabilities.begin(), config.audioCapabilities.end(), AreCodecsSpecified)
             == config.audioCapabilities.end();
     }
 
     bool areAllVideoCodecsEmpty = false;
-    if (config.hasVideoCapabilities && !config.videoCapabilities.isEmpty()) {
+    if (!config.videoCapabilities.isEmpty()) {
         areAllVideoCodecsEmpty = std::find_if(config.videoCapabilities.begin(), config.videoCapabilities.end(), AreCodecsSpecified)
             == config.videoCapabilities.end();
     }
 
     if (areAllAudioCodecsEmpty || areAllVideoCodecsEmpty) {
         Deprecation::countDeprecation(m_resolver->getExecutionContext(), UseCounter::EncryptedMediaAllSelectedContentTypesMissingCodecs);
     } else {
         UseCounter::count(m_resolver->getExecutionContext(), UseCounter::EncryptedMediaAllSelectedContentTypesHaveCodecs);
     }
 }
 
+void MediaKeySystemAccessInitializer::checkCapabilitiesProvided(const WebMediaKeySystemConfiguration& config)
+{
+    bool atLeastOneAudioCapability = config.audioCapabilities.size() > 0;
+    bool atLeastOneVideoCapability = config.videoCapabilities.size() > 0;
+
+    if (atLeastOneAudioCapability || atLeastOneVideoCapability) {
+        UseCounter::count(m_resolver->getExecutionContext(), UseCounter::EncryptedMediaCapabilityProvided);
+    } else {
+        Deprecation::countDeprecation(m_resolver->getExecutionContext(), UseCounter::EncryptedMediaCapabilityNotProvided);

[foolip, 2016/09/23 08:18:39]

Optional nit: refactor so that the deprecation is exactly where the promise
would be rejected with NotSupported. It'd be more obviously like what the spec
if handled in MediaKeySystemAccess::getConfiguration, working with the generated
MediaKeySystemConfiguration instead of the WebMediaKeySystemConfiguration it
populates.

(Then the "removal" CL would be a one-liner replacing the reprecation by a
rejection.)

[jrummell, 2016/09/29 20:40:02]

I wish :). Most of the checks happen outside of blink, where we know more about
what is supported by the key system.

+    }
+}
+
 } // namespace
 
 ScriptPromise NavigatorRequestMediaKeySystemAccess::requestMediaKeySystemAccess(
     ScriptState* scriptState,
     Navigator& navigator,
     const String& keySystem,
     const HeapVector<MediaKeySystemConfiguration>& supportedConfigurations)
 {
     DVLOG(3) << __func__;
 
     // From https://w3c.github.io/encrypted-media/#requestMediaKeySystemAccess
     // When this method is invoked, the user agent must run the following steps:
     // 1. If keySystem is an empty string, return a promise rejected with a
     //    new DOMException whose name is InvalidAccessError.
     if (keySystem.isEmpty()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidAccessError, "The keySystem parameter is empty."));
     }
 
     // 2. If supportedConfigurations was provided and is empty, return a
     //    promise rejected with a new DOMException whose name is
     //    InvalidAccessError.
     if (!supportedConfigurations.size()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidAccessError, "The supportedConfigurations parameter is empty."));
     }
 
-    // 3-4. 'May Document use powerful features?' check.
+    // Note: This method should only be exposed to secure contexts as indicated
+    // by the [SecureContext] IDL attribute. Since that will break some existing
+    // sites, we simply keep track of sites that aren't secure and output a
+    // deprecation message.
     ExecutionContext* executionContext = scriptState->getExecutionContext();
     String errorMessage;
     if (executionContext->isSecureContext(errorMessage)) {
         UseCounter::count(executionContext, UseCounter::EncryptedMediaSecureOrigin);
     } else {
         Deprecation::countDeprecation(executionContext, UseCounter::EncryptedMediaInsecureOrigin);
         // TODO(ddorwin): Implement the following:
         // Reject promise with a new DOMException whose name is NotSupportedError.
     }
 
-    // 5. Let origin be the origin of document.
-    //    (Passed with the execution context in step 7.)
-
-    // 6. Let promise be a new promise.
+    // 3. Let document be the calling context's Document.
     Document* document = toDocument(executionContext);
     if (!document->page()) {
         return ScriptPromise::rejectWithDOMException(
             scriptState, DOMException::create(InvalidStateError, "The context provided is not associated with a page."));
     }
 
+    // 4. Let origin be the origin of document.
+    //    (Passed with the execution context.)
+
+    // 5. Let promise be a new promise.
     MediaKeySystemAccessInitializer* initializer = new MediaKeySystemAccessInitializer(scriptState, keySystem, supportedConfigurations);
     ScriptPromise promise = initializer->promise();
 
-    // 7. Asynchronously determine support, and if allowed, create and
+    // 6. Asynchronously determine support, and if allowed, create and
     //    initialize the MediaKeySystemAccess object.
     MediaKeysController* controller = MediaKeysController::from(document->page());
     WebEncryptedMediaClient* mediaClient = controller->encryptedMediaClient(executionContext);
     mediaClient->requestMediaKeySystemAccess(WebEncryptedMediaRequest(initializer));
 
-    // 8. Return promise.
+    // 7. Return promise.
     return promise;
 }
 
 } // namespace blink