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 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
+  // 'audioCapabilities' and 'videoCapabilities' non-empty.
+  // TODO(jrummell): Switch to deprecation message once we have data.
+  // 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);
+
     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());
+    } else {
+      // From the spec (http://w3c.github.io/encrypted-media/#idl-def-mediakeysystemconfiguration):
+      // If this member is not present when the dictionary is passed to
+      // requestMediaKeySystemAccess(), the dictionary will be treated
+      // as if this member is set to [ "temporary" ].
+      WebVector<WebEncryptedMediaSessionType> sessionTypes(
+          static_cast<size_t>(1));
+      sessionTypes[0] = WebEncryptedMediaSessionType::Temporary;
+      webConfig.sessionTypes = 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 17 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 {
+    // TODO(jrummell): Switch to deprecation message once we understand
+    // current usage. http://crbug.com/616233.
+    UseCounter::count(m_resolver->getExecutionContext(),
+                      UseCounter::EncryptedMediaCapabilityNotProvided);
+  }
+}
+
 }  // 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